fix: teardown xray fast fix

- Added a check in XrayController::stop() to skip the stop operation if Xray is not currently running, with a debug log for clarity.

.github/workflows/deploy.yml

@@ -88,7 +88,7 @@ jobs:
         host: 'linux'
         target: 'desktop'
         arch: 'linux_gcc_64'
-        modules: 'qtremoteobjects qt5compat qtshadertools'
+        modules: 'qtremoteobjects qt5compat qtshadertools qthttpserver qtwebsockets'
         dir: ${{ runner.temp }}
         setup-python: 'true'
         tools: 'tools_ifw'
@@ -201,7 +201,7 @@ jobs:
         host: 'windows'
         target: 'desktop'
         arch: 'win64_msvc2022_64'
-        modules: 'qtremoteobjects qt5compat qtshadertools'
+        modules: 'qtremoteobjects qt5compat qtshadertools qthttpserver qtwebsockets'
         dir: ${{ runner.temp }}
         setup-python: 'true'
         tools: 'tools_ifw'
@@ -365,7 +365,7 @@ jobs:
         version: ${{ env.QT_VERSION }}
         host: 'mac'
         target: 'desktop'
-        modules: 'qtremoteobjects qt5compat qtshadertools qtmultimedia'
+        modules: 'qtremoteobjects qt5compat qtshadertools qtmultimedia qthttpserver qtwebsockets'
         arch: 'clang_64'
         dir: ${{ runner.temp }}
         set-env: 'true'
@@ -377,7 +377,7 @@ jobs:
         version: ${{ env.QT_VERSION }}
         host: 'mac'
         target: 'ios'
-        modules: 'qtremoteobjects qt5compat qtshadertools qtmultimedia'
+        modules: 'qtremoteobjects qt5compat qtshadertools qtmultimedia qthttpserver qtwebsockets'
         dir: ${{ runner.temp }}
         setup-python: 'true'
         set-env: 'true'
@@ -506,7 +506,7 @@ jobs:
         host: 'mac'
         target: 'desktop'
         arch: 'clang_64'
-        modules: 'qtremoteobjects qt5compat qtshadertools'
+        modules: 'qtremoteobjects qt5compat qtshadertools qthttpserver qtwebsockets'
         dir: ${{ runner.temp }}
         setup-python: 'true'
         set-env: 'true'
@@ -739,7 +739,7 @@ jobs:
       ANDROID_PLATFORM: android-28
       NDK_VERSION: 27.0.11718014
       QT_VERSION: 6.10.3
-      QT_MODULES: 'qtremoteobjects qt5compat qtimageformats qtshadertools'
+      QT_MODULES: 'qtremoteobjects qt5compat qtimageformats qtshadertools qthttpserver qtwebsockets'
       PROD_AGW_PUBLIC_KEY: ${{ secrets.PROD_AGW_PUBLIC_KEY }}
       PROD_S3_ENDPOINT: ${{ secrets.PROD_S3_ENDPOINT }}
       FALLBACK_S3_ENDPOINT: ${{ secrets.FALLBACK_S3_ENDPOINT }}

.gitignore

@@ -10,7 +10,9 @@ deploy/build_64/*
 winbuild*.bat
 .cache/
 .vscode/
-
+.cursorignore
+.cursor/
+.venv/
 
 # Qt-es
 /.qmake.cache

CMakeLists.txt

@@ -4,7 +4,7 @@ set(CMAKE_CXX_STANDARD 17)
 set(CMAKE_CXX_STANDARD_REQUIRED ON)
 
 set(PROJECT AmneziaVPN)
-set(AMNEZIAVPN_VERSION 4.9.0.2)
+set(AMNEZIAVPN_VERSION 4.9.0.3)
 
 set(QT_CREATOR_SKIP_PACKAGE_MANAGER_SETUP ON CACHE BOOL "" FORCE)
 set(CMAKE_PROJECT_TOP_LEVEL_INCLUDES
@@ -28,7 +28,7 @@ string(TIMESTAMP CURRENT_DATE "%Y-%m-%d")
 set(RELEASE_DATE "${CURRENT_DATE}")
 
 set(APP_MAJOR_VERSION ${CMAKE_PROJECT_VERSION_MAJOR}.${CMAKE_PROJECT_VERSION_MINOR}.${CMAKE_PROJECT_VERSION_PATCH})
-set(APP_ANDROID_VERSION_CODE 2123)
+set(APP_ANDROID_VERSION_CODE 2126)
 
 if(${CMAKE_SYSTEM_NAME} STREQUAL "Linux")
     set(MZ_PLATFORM_NAME "linux")

client/CMakeLists.txt

@@ -14,6 +14,10 @@ set(PACKAGES
     Core5Compat Concurrent LinguistTools
 )
 
+if(NOT ANDROID AND NOT IOS)
+    list(APPEND PACKAGES HttpServer)
+endif()
+
 execute_process(
   WORKING_DIRECTORY "${CMAKE_SOURCE_DIR}"
   COMMAND git rev-parse --short HEAD
@@ -47,6 +51,10 @@ set(LIBS ${LIBS}
     Qt6::Core5Compat Qt6::Concurrent
 )
 
+if(NOT ANDROID AND NOT IOS)
+    list(APPEND LIBS Qt6::HttpServer)
+endif()
+
 if(WIN32 OR (APPLE AND NOT IOS) OR (LINUX AND NOT ANDROID))
     set(LIBS ${LIBS} Qt6::Widgets)
 endif()

client/cmake/sources.cmake

@@ -201,6 +201,11 @@ file(GLOB CONFIGURATORS_CPP CONFIGURE_DEPENDS ${CLIENT_ROOT_DIR}/core/configurat
 file(GLOB_RECURSE CORE_MODELS_H CONFIGURE_DEPENDS ${CLIENT_ROOT_DIR}/core/models/*.h)
 file(GLOB_RECURSE CORE_MODELS_CPP CONFIGURE_DEPENDS ${CLIENT_ROOT_DIR}/core/models/*.cpp)
 
+if(NOT ANDROID AND NOT IOS)
+    file(GLOB LOCAL_PROXY_H CONFIGURE_DEPENDS ${CLIENT_ROOT_DIR}/core/local-proxy/*.h)
+    file(GLOB LOCAL_PROXY_CPP CONFIGURE_DEPENDS ${CLIENT_ROOT_DIR}/core/local-proxy/*.cpp)
+endif()
+
 file(GLOB UI_MODELS_H CONFIGURE_DEPENDS
     ${CLIENT_ROOT_DIR}/ui/models/*.h
     ${CLIENT_ROOT_DIR}/ui/models/protocols/*.h
@@ -246,6 +251,11 @@ set(SOURCES ${SOURCES}
     ${UI_CONTROLLERS_CPP}
 )
 
+if(NOT ANDROID AND NOT IOS)
+    list(APPEND HEADERS ${LOCAL_PROXY_H})
+    list(APPEND SOURCES ${LOCAL_PROXY_CPP})
+endif()
+
 if(WIN32)
     set(HEADERS ${HEADERS}
         ${CLIENT_ROOT_DIR}/core/protocols/ikev2VpnProtocolWindows.h

client/core/controllers/connectionController.cpp

@@ -218,6 +218,13 @@ ErrorCode ConnectionController::openConnection(const QString &serverId)
         return errorCode;
     }
 
+#if !defined(Q_OS_ANDROID) && !defined(Q_OS_IOS)
+    if (m_appSettingsRepository && m_appSettingsRepository->isLocalProxyHttpEnabled()) {
+        m_appSettingsRepository->setLocalProxyHttpEnabled(false);
+        emit localProxyStoppedBecauseVpnTurnedOn(tr("Local proxy stopped because VPN was turned on"));
+    }
+#endif
+
     emit openConnectionRequested(serverId, container, vpnConfiguration);
     return ErrorCode::NoError;
 }

client/core/controllers/connectionController.h

@@ -69,6 +69,7 @@ signals:
     void closeConnectionRequested();
     void setConnectionStateRequested(Vpn::ConnectionState state);
     void killSwitchModeChangedRequested(bool enabled);
+    void localProxyStoppedBecauseVpnTurnedOn(const QString &message);
 
 #ifdef Q_OS_ANDROID
     void restoreConnectionRequested();

client/core/controllers/coreController.cpp

@@ -1,7 +1,10 @@
 #include "coreController.h"
 
+#include <QCoreApplication>
 #include <QDirIterator>
+#include <QDebug>
 #include <QTranslator>
+#include <QStandardPaths>
 #include <QTimer>
 
 #include "core/utils/selfhosted/sshSession.h"
@@ -35,6 +38,10 @@ CoreController::CoreController(const QSharedPointer<VpnConnection> &vpnConnectio
     initAppleController();
     initLogging();
 
+#if !defined(Q_OS_ANDROID) && !defined(Q_OS_IOS)
+    initLocalProxy();
+#endif
+
     m_translator = new QTranslator(this);
     if (m_appSettingsRepository) {
         updateTranslator(m_appSettingsRepository->getAppLanguage());
@@ -48,6 +55,69 @@ void CoreController::setQmlContextProperty(const QString &name, QObject *value)
     }
 }
 
+#if !defined(Q_OS_ANDROID) && !defined(Q_OS_IOS)
+void CoreController::initLocalProxy()
+{
+    constexpr quint16 kLocalProxyApiPort = 49490;
+
+    m_proxyServer.reset(new ProxyServer(m_serversRepository, m_appSettingsRepository, this));
+
+    QObject::connect(QCoreApplication::instance(), &QCoreApplication::aboutToQuit, this, [this]() {
+        if (m_appSettingsRepository && m_appSettingsRepository->isLocalProxyHttpEnabled()) {
+            m_appSettingsRepository->setLocalProxyHttpEnabled(false);
+        }
+    });
+
+    auto syncLocalProxy = [this]() {
+        if (!m_proxyServer) {
+            return;
+        }
+
+        const bool httpEnabled = m_appSettingsRepository->isLocalProxyHttpEnabled();
+
+        if (!httpEnabled) {
+            qInfo() << "Local proxy: HTTP API disabled";
+            m_proxyServer->stop();
+            return;
+        }
+
+        if (!m_proxyServer->start(kLocalProxyApiPort)) {
+            qWarning() << "Local proxy: failed to start on port" << kLocalProxyApiPort;
+            m_appSettingsRepository->setLocalProxyHttpEnabled(false);
+            emit m_appSettingsRepository->localProxyStartFailed(tr("Local proxy failed to start. Check if the port is available."));
+            return;
+        }
+
+        if (!m_proxyServer->syncSettings()) {
+            qWarning() << "Local proxy: failed to start proxy core (Xray)";
+            m_appSettingsRepository->setLocalProxyHttpEnabled(false);
+            emit m_appSettingsRepository->localProxyStartFailed(tr("Couldn’t start the proxy due to an internal error. Try restarting the app."));
+            return;
+        }
+
+        qInfo() << "Local proxy: running on 127.0.0.1:" << kLocalProxyApiPort;
+    };
+
+    syncLocalProxy();
+
+    connect(m_appSettingsRepository, &SecureAppSettingsRepository::localProxySettingsChanged, this, syncLocalProxy);
+
+    connect(m_serversRepository, &SecureServersRepository::serverEdited, this, [this](const QString &serverId) {
+        if (m_appSettingsRepository && m_appSettingsRepository->isLocalProxyHttpEnabled()
+            && m_appSettingsRepository->localProxyOwnerId() == serverId) {
+            m_appSettingsRepository->bumpLocalProxyRestartToken();
+        }
+    });
+
+    connect(m_serversRepository, &SecureServersRepository::serverRemoved, this, [this](const QString &serverId, int) {
+        if (m_appSettingsRepository && m_appSettingsRepository->localProxyOwnerId() == serverId) {
+            m_appSettingsRepository->setLocalProxyOwnerId(QString());
+            m_appSettingsRepository->setLocalProxyHttpEnabled(false);
+        }
+    });
+}
+#endif
+
 void CoreController::initModels()
 {
     m_containersModel = new ContainersModel(this);
@@ -197,6 +267,11 @@ void CoreController::initControllers()
     m_pageController = new PageController(m_serversController, m_settingsController, this);
     setQmlContextProperty("PageController", m_pageController);
 
+#if !defined(Q_OS_ANDROID) && !defined(Q_OS_IOS)
+    connect(m_connectionController, &ConnectionController::localProxyStoppedBecauseVpnTurnedOn, m_pageController,
+            &PageController::showNotificationMessage);
+#endif
+
     m_serversUiController = new ServersUiController(m_serversController, m_settingsController, m_serversModel, m_containersModel, m_defaultServerContainersModel, this);
     setQmlContextProperty("ServersUiController", m_serversUiController);
 

client/core/controllers/coreController.h

@@ -78,6 +78,7 @@
 #include "ui/models/newsModel.h"
 
 #if !defined(Q_OS_ANDROID) && !defined(Q_OS_IOS)
+    #include "core/local-proxy/proxyserver.h"
     #include "ui/utils/notificationHandler.h"
 #endif
 
@@ -142,6 +143,9 @@ private:
     void initAppleController();
     void initLogging();
     void initSignalHandlers();
+#if !defined(Q_OS_ANDROID) && !defined(Q_OS_IOS)
+    void initLocalProxy();
+#endif
     void setQmlContextProperty(const QString &name, QObject *value);
 
     QQmlApplicationEngine *m_engine {}; // TODO use parent child system here?
@@ -227,6 +231,10 @@ private:
     TelemtConfigModel* m_telemtConfigModel;
 
     CoreSignalHandlers* m_signalHandlers;
+
+#if !defined(Q_OS_ANDROID) && !defined(Q_OS_IOS)
+    QScopedPointer<ProxyServer> m_proxyServer;
+#endif
 };
 
 #endif // CORECONTROLLER_H

client/core/controllers/settingsController.cpp

@@ -8,10 +8,19 @@
 #include "version.h"
 #include "ui/utils/qAutoStart.h"
 #include "logger.h"
+#if !defined(Q_OS_ANDROID) && !defined(Q_OS_IOS)
+    #include "core/local-proxy/portavailabilityhelper.h"
+#endif
 #ifdef Q_OS_ANDROID
     #include "platforms/android/android_controller.h"
 #endif
 
+namespace {
+constexpr int kDefaultProxyPort = 10808;
+constexpr int kLocalProxyPortMin = 1024;
+constexpr int kLocalProxyPortMax = 65535;
+}
+
 QString getPlatformName()
 {
 #if defined(Q_OS_WINDOWS)
@@ -38,6 +47,11 @@ SettingsController::SettingsController(SecureServersRepository* serversRepositor
 {
     m_appVersion = QString("%1 (%2, %3)").arg(QString(APP_VERSION), __DATE__, GIT_COMMIT_HASH);
     m_isDevModeEnabled = m_appSettingsRepository->isDevGatewayEnv();
+
+    connect(m_appSettingsRepository, &SecureAppSettingsRepository::localProxySettingsChanged, this,
+            &SettingsController::localProxySettingsUpdated);
+    connect(m_appSettingsRepository, &SecureAppSettingsRepository::localProxyStartFailed, this,
+            &SettingsController::localProxyStartFailed);
 }
 
 void SettingsController::toggleAmneziaDns(bool enable)
@@ -366,3 +380,114 @@ QString SettingsController::nextAvailableServerName() const
     return m_serversRepository->nextAvailableServerName();
 }
 
+bool SettingsController::isLocalProxySupported() const
+{
+#ifdef AMNEZIA_DESKTOP
+    return true;
+#else
+    return false;
+#endif
+}
+
+bool SettingsController::isLocalProxyHttpEnabled() const
+{
+    return m_appSettingsRepository->isLocalProxyHttpEnabled();
+}
+
+int SettingsController::localProxyPort() const
+{
+    return static_cast<int>(m_appSettingsRepository->localProxyPort());
+}
+
+QString SettingsController::localProxyOwnerId() const
+{
+    return m_appSettingsRepository->localProxyOwnerId();
+}
+
+bool SettingsController::isLocalProxyPortUserDefined() const
+{
+    return m_appSettingsRepository->isLocalProxyPortUserDefined();
+}
+
+bool SettingsController::setLocalProxyPort(int port)
+{
+    if (port < kLocalProxyPortMin || port > kLocalProxyPortMax) {
+        return false;
+    }
+
+    if (m_appSettingsRepository->localProxyPort() == static_cast<quint16>(port)) {
+        m_appSettingsRepository->setLocalProxyPortUserDefined(true);
+        return true;
+    }
+
+    m_appSettingsRepository->setLocalProxyPort(static_cast<quint16>(port));
+    m_appSettingsRepository->setLocalProxyPortUserDefined(true);
+    return true;
+}
+
+bool SettingsController::isLocalProxyPortBusy(int port) const
+{
+#if !defined(Q_OS_ANDROID) && !defined(Q_OS_IOS)
+    return !PortAvailabilityHelper::isPortAvailable(port);
+#else
+    Q_UNUSED(port);
+    return false;
+#endif
+}
+
+int SettingsController::findFirstAvailableLocalProxyPort(int startPort) const
+{
+#if !defined(Q_OS_ANDROID) && !defined(Q_OS_IOS)
+    const auto port = PortAvailabilityHelper::findFirstAvailablePort(startPort, kLocalProxyPortMax);
+    return port ? *port : -1;
+#else
+    Q_UNUSED(startPort);
+    return -1;
+#endif
+}
+
+bool SettingsController::enableLocalProxy(const QString &ownerId, int port)
+{
+#if defined(Q_OS_ANDROID) || defined(Q_OS_IOS)
+    Q_UNUSED(ownerId);
+    Q_UNUSED(port);
+    return false;
+#else
+    if (port < kLocalProxyPortMin || port > kLocalProxyPortMax || ownerId.isEmpty()) {
+        return false;
+    }
+
+    if (m_appSettingsRepository->isLocalProxyHttpEnabled() && m_appSettingsRepository->localProxyOwnerId() != ownerId) {
+        return false;
+    }
+
+    int selectedPort = port;
+
+    const bool isUserDefinedPort = m_appSettingsRepository->isLocalProxyPortUserDefined();
+    if (isUserDefinedPort) {
+        if (!PortAvailabilityHelper::isPortAvailable(selectedPort)) {
+            return false;
+        }
+    } else if (selectedPort != kDefaultProxyPort && !PortAvailabilityHelper::isPortAvailable(selectedPort)) {
+        return false;
+    }
+
+    if (m_appSettingsRepository->localProxyPort() != static_cast<quint16>(selectedPort)) {
+        m_appSettingsRepository->setLocalProxyPort(static_cast<quint16>(selectedPort));
+    }
+    m_appSettingsRepository->setLocalProxyPortUserDefined(isUserDefinedPort);
+
+    m_appSettingsRepository->setLocalProxyOwnerId(ownerId);
+    m_appSettingsRepository->setLocalProxyHttpEnabled(true);
+
+    return true;
+#endif
+}
+
+void SettingsController::disableLocalProxy()
+{
+    if (m_appSettingsRepository->isLocalProxyHttpEnabled()) {
+        m_appSettingsRepository->setLocalProxyHttpEnabled(false);
+    }
+}
+

client/core/controllers/settingsController.h

@@ -89,6 +89,18 @@ public:
     QLocale getAppLanguage() const;
     void setAppLanguage(const QLocale &locale);
 
+    // Local proxy
+    bool isLocalProxySupported() const;
+    bool isLocalProxyHttpEnabled() const;
+    int localProxyPort() const;
+    QString localProxyOwnerId() const;
+    bool isLocalProxyPortUserDefined() const;
+    bool setLocalProxyPort(int port);
+    bool isLocalProxyPortBusy(int port) const;
+    int findFirstAvailableLocalProxyPort(int startPort) const;
+    bool enableLocalProxy(const QString &ownerId, int port);
+    void disableLocalProxy();
+
 signals:
     void siteSplitTunnelingRouteModeChanged(RouteMode mode);
     void siteSplitTunnelingToggled(bool enabled);
@@ -96,6 +108,9 @@ signals:
     void appSplitTunnelingToggled(bool enabled);
     void appSplitTunnelingClearAppsList();
 
+    void localProxySettingsUpdated();
+    void localProxyStartFailed(const QString &message);
+
 private:
     QString getPlatform() const;
 

client/core/local-proxy/configmanager.cpp

@@ -0,0 +1,444 @@
+#include "configmanager.h"
+
+#include "core/controllers/gatewayController.h"
+#include "core/repositories/secureAppSettingsRepository.h"
+#include "core/repositories/secureServersRepository.h"
+#include "core/utils/api/apiUtils.h"
+#include "core/utils/constants/apiConstants.h"
+#include "core/utils/constants/apiKeys.h"
+#include "core/utils/constants/configKeys.h"
+#include "core/utils/containers/containerUtils.h"
+#include "portavailabilityhelper.h"
+#include "proxylogger.h"
+#include "version.h"
+
+#include <QDir>
+#include <QFile>
+#include <QJsonArray>
+#include <QJsonDocument>
+#include <QJsonParseError>
+#include <QSaveFile>
+#include <QSysInfo>
+#include <QStandardPaths>
+#include <QUuid>
+
+using namespace amnezia;
+
+ConfigManager::ConfigManager(SecureServersRepository *serversRepository, SecureAppSettingsRepository *appSettingsRepository)
+    : m_serversRepository(serversRepository), m_appSettingsRepository(appSettingsRepository)
+{
+    ProxyLogger::getInstance().debug("ConfigManager initialized (repository-backed)");
+}
+
+namespace {
+namespace gateway_key {
+constexpr char vless[] = "vless";
+} // namespace gateway_key
+
+constexpr quint16 kDefaultProxyPort = 10808;
+constexpr int kProxyPortMin = 1024;
+constexpr int kProxyPortMax = 65535;
+
+int resolveProxyPort(SecureAppSettingsRepository *appSettings)
+{
+    if (!appSettings) {
+        return kDefaultProxyPort;
+    }
+
+    const quint16 port = appSettings->localProxyPort();
+    if (port < kProxyPortMin || port > kProxyPortMax) {
+        return kDefaultProxyPort;
+    }
+
+    return static_cast<int>(port);
+}
+
+} // namespace
+
+bool ConfigManager::applyProxyPortToConfig(QJsonObject &config, int port) const
+{
+    if (!config.contains("inbounds") || !config.value("inbounds").isArray()) {
+        return false;
+    }
+
+    QJsonArray inbounds = config.value("inbounds").toArray();
+    if (inbounds.isEmpty() || !inbounds.at(0).isObject()) {
+        return false;
+    }
+
+    QJsonObject firstInbound = inbounds.at(0).toObject();
+    firstInbound.insert("port", port);
+    inbounds[0] = firstInbound;
+    config.insert("inbounds", inbounds);
+    return true;
+}
+
+QString ConfigManager::serializeConfig(const QJsonObject &config) const
+{
+    return QString::fromUtf8(QJsonDocument(config).toJson(QJsonDocument::Compact));
+}
+
+std::optional<ConfigManager::ConfigData> ConfigManager::buildConfig(QString &errorDescription) const
+{
+    errorDescription.clear();
+
+    if (!m_serversRepository || !m_appSettingsRepository) {
+        const QString message = QStringLiteral("Local proxy repositories are not available");
+        ProxyLogger::getInstance().error(message);
+        errorDescription = message;
+        return std::nullopt;
+    }
+
+    const QString ownerId = m_appSettingsRepository->localProxyOwnerId();
+    if (ownerId.isEmpty()) {
+        const QString message = QStringLiteral("Local proxy owner server id is not configured");
+        ProxyLogger::getInstance().warning(message);
+        errorDescription = message;
+        return std::nullopt;
+    }
+
+    const auto ownerServer = m_serversRepository->serverJsonById(ownerId);
+    if (!ownerServer) {
+        const QString message = QStringLiteral("Owner server with id %1 not found").arg(ownerId);
+        ProxyLogger::getInstance().error(message);
+        errorDescription = message;
+        return std::nullopt;
+    }
+
+    if (!apiUtils::isPremiumServer(*ownerServer)) {
+        const QString message = QStringLiteral("Server %1 is not premium, local proxy is unavailable")
+                                        .arg(ownerServer->value(configKey::name).toString());
+        ProxyLogger::getInstance().warning(message);
+        errorDescription = message;
+        return std::nullopt;
+    }
+
+    const auto serializedConfig = extractSerializedXrayConfig(*ownerServer);
+    if (!serializedConfig || serializedConfig->isEmpty()) {
+        const QString message = QStringLiteral("Server %1 lacks Xray last_config payload")
+                                        .arg(ownerServer->value(configKey::name).toString());
+        ProxyLogger::getInstance().error(message);
+        errorDescription = message;
+        return std::nullopt;
+    }
+
+    QJsonParseError parseError;
+    const QJsonDocument doc = QJsonDocument::fromJson(serializedConfig->toUtf8(), &parseError);
+    if (parseError.error != QJsonParseError::NoError || !doc.isObject()) {
+        const QString message = QStringLiteral("Failed to parse Xray config JSON: %1").arg(parseError.errorString());
+        ProxyLogger::getInstance().error(message);
+        errorDescription = message;
+        return std::nullopt;
+    }
+
+    ConfigData data;
+    data.ownerId = ownerId;
+    data.serverName = ownerServer->value(configKey::name).toString();
+    data.parsedConfig = doc.object();
+    const int proxyPort = resolveProxyPort(m_appSettingsRepository);
+    if (applyProxyPortToConfig(data.parsedConfig, proxyPort)) {
+        data.serializedConfig = serializeConfig(data.parsedConfig);
+    } else {
+        ProxyLogger::getInstance().warning(QStringLiteral("Failed to override local proxy inbound port; using original config"));
+        data.serializedConfig = *serializedConfig;
+    }
+
+    return data;
+}
+
+std::optional<ConfigManager::ConfigData> ConfigManager::buildConfigWithFetch(QString &errorDescription) const
+{
+    errorDescription.clear();
+
+    if (!m_serversRepository || !m_appSettingsRepository) {
+        const QString message = QStringLiteral("Local proxy repositories are not available");
+        ProxyLogger::getInstance().error(message);
+        errorDescription = message;
+        return std::nullopt;
+    }
+
+    const QString ownerId = m_appSettingsRepository->localProxyOwnerId();
+    if (ownerId.isEmpty()) {
+        const QString message = QStringLiteral("Local proxy owner server id is not configured");
+        ProxyLogger::getInstance().warning(message);
+        errorDescription = message;
+        return std::nullopt;
+    }
+
+    const auto ownerServer = m_serversRepository->serverJsonById(ownerId);
+    if (!ownerServer) {
+        const QString message = QStringLiteral("Owner server with id %1 not found").arg(ownerId);
+        ProxyLogger::getInstance().error(message);
+        errorDescription = message;
+        return std::nullopt;
+    }
+
+    if (!apiUtils::isPremiumServer(*ownerServer)) {
+        const QString message = QStringLiteral("Server %1 is not premium, local proxy is unavailable")
+                                        .arg(ownerServer->value(configKey::name).toString());
+        ProxyLogger::getInstance().warning(message);
+        errorDescription = message;
+        return std::nullopt;
+    }
+
+    auto serializedConfig = extractSerializedXrayConfig(*ownerServer);
+    if (!serializedConfig || serializedConfig->isEmpty()) {
+        auto fetchedConfig = fetchSerializedXrayConfigFromGateway(*ownerServer, errorDescription);
+        if (!fetchedConfig || fetchedConfig->isEmpty()) {
+            return std::nullopt;
+        }
+        serializedConfig = fetchedConfig;
+    }
+
+    QJsonParseError parseError;
+    const QJsonDocument doc = QJsonDocument::fromJson(serializedConfig->toUtf8(), &parseError);
+    if (parseError.error != QJsonParseError::NoError || !doc.isObject()) {
+        const QString message = QStringLiteral("Failed to parse Xray config JSON: %1").arg(parseError.errorString());
+        ProxyLogger::getInstance().error(message);
+        errorDescription = message;
+        return std::nullopt;
+    }
+
+    ConfigData data;
+    data.ownerId = ownerId;
+    data.serverName = ownerServer->value(configKey::name).toString();
+    data.parsedConfig = doc.object();
+
+    int selectedPort = resolveProxyPort(m_appSettingsRepository);
+    const bool isUserDefinedPort = m_appSettingsRepository->isLocalProxyPortUserDefined();
+
+    if (!PortAvailabilityHelper::isPortAvailable(selectedPort)) {
+        const bool canAutoSelect = !isUserDefinedPort && selectedPort == kDefaultProxyPort;
+        if (canAutoSelect) {
+            const auto freePort = PortAvailabilityHelper::findFirstAvailablePort(kDefaultProxyPort + 1, kProxyPortMax);
+            if (!freePort) {
+                errorDescription = QStringLiteral("No available local proxy port in range %1-%2")
+                                       .arg(kDefaultProxyPort + 1)
+                                       .arg(kProxyPortMax);
+                ProxyLogger::getInstance().error(errorDescription);
+                return std::nullopt;
+            }
+            selectedPort = *freePort;
+        } else {
+            errorDescription = QStringLiteral("Local proxy port %1 is already in use")
+                                   .arg(selectedPort);
+            ProxyLogger::getInstance().error(errorDescription);
+            return std::nullopt;
+        }
+    }
+
+    if (applyProxyPortToConfig(data.parsedConfig, selectedPort)) {
+        data.serializedConfig = serializeConfig(data.parsedConfig);
+    } else {
+        ProxyLogger::getInstance().warning(QStringLiteral("Failed to override local proxy inbound port; using original config"));
+        data.serializedConfig = *serializedConfig;
+    }
+
+    return data;
+}
+
+bool ConfigManager::writeTempConfig(const QString &serializedConfig, QString &configPath, QString &errorDescription) const
+{
+    errorDescription.clear();
+    configPath.clear();
+
+    const QString directory = tempDirectory();
+    if (!QDir().mkpath(directory)) {
+        const QString message = QStringLiteral("Failed to create temp config directory: %1").arg(directory);
+        ProxyLogger::getInstance().error(message);
+        errorDescription = message;
+        return false;
+    }
+
+    const QString path = tempConfigPath();
+    QSaveFile file(path);
+    if (!file.open(QIODevice::WriteOnly | QIODevice::Text)) {
+        const QString message = QStringLiteral("Failed to open temp config file %1: %2").arg(path, file.errorString());
+        ProxyLogger::getInstance().error(message);
+        errorDescription = message;
+        return false;
+    }
+
+    if (file.write(serializedConfig.toUtf8()) == -1) {
+        const QString message = QStringLiteral("Failed to write temp config file %1: %2").arg(path, file.errorString());
+        ProxyLogger::getInstance().error(message);
+        errorDescription = message;
+        return false;
+    }
+
+    if (!file.commit()) {
+        const QString message = QStringLiteral("Failed to commit temp config file %1").arg(path);
+        ProxyLogger::getInstance().error(message);
+        errorDescription = message;
+        return false;
+    }
+
+    ProxyLogger::getInstance().info(QStringLiteral("Xray config saved to %1").arg(path));
+    configPath = path;
+    return true;
+}
+
+bool ConfigManager::removeTempConfig() const
+{
+    const QString path = tempConfigPath();
+    QFile file(path);
+    if (!file.exists()) {
+        return true;
+    }
+
+    if (!file.remove()) {
+        ProxyLogger::getInstance().warning(QStringLiteral("Failed to remove temp config file %1: %2").arg(path, file.errorString()));
+        return false;
+    }
+
+    ProxyLogger::getInstance().debug(QStringLiteral("Removed temp config file %1").arg(path));
+    return true;
+}
+
+QString ConfigManager::tempConfigPath() const
+{
+    return QDir(tempDirectory()).filePath(QStringLiteral("xray_active.json"));
+}
+
+std::optional<QString> ConfigManager::extractSerializedXrayConfig(const QJsonObject &server) const
+{
+    const QJsonArray containers = server.value(configKey::containers).toArray();
+    const QString targetContainer = ContainerUtils::containerToString(DockerContainer::Xray);
+    const QString protoKey = QString(configKey::xray);
+
+    for (const QJsonValue &value : containers) {
+        const QJsonObject container = value.toObject();
+        if (container.value(configKey::container).toString() != targetContainer) {
+            continue;
+        }
+
+        const QJsonObject proto = container.value(protoKey).toObject();
+        const QString serialized = proto.value(configKey::lastConfig).toString();
+        if (!serialized.isEmpty()) {
+            return serialized;
+        }
+    }
+
+    return std::nullopt;
+}
+
+std::optional<QString> ConfigManager::fetchSerializedXrayConfigFromGateway(const QJsonObject &server, QString &errorDescription) const
+{
+    errorDescription.clear();
+
+    if (!m_appSettingsRepository) {
+        const QString message = QStringLiteral("App settings repository is not available");
+        ProxyLogger::getInstance().error(message);
+        errorDescription = message;
+        return std::nullopt;
+    }
+
+    const QJsonObject apiConfig = server.value(apiDefs::key::apiConfig).toObject();
+    if (apiConfig.isEmpty()) {
+        const QString message = QStringLiteral("Server API config is missing");
+        ProxyLogger::getInstance().warning(message);
+        errorDescription = message;
+        return std::nullopt;
+    }
+
+    const QString userCountryCode = apiConfig.value(apiDefs::key::userCountryCode).toString();
+    const QString serviceType = apiConfig.value(apiDefs::key::serviceType).toString();
+    if (userCountryCode.isEmpty() || serviceType.isEmpty()) {
+        const QString message = QStringLiteral("Server API config lacks service identifiers");
+        ProxyLogger::getInstance().warning(message);
+        errorDescription = message;
+        return std::nullopt;
+    }
+
+    QJsonObject apiPayload;
+    apiPayload[apiDefs::key::osVersion] = QSysInfo::productType();
+    apiPayload[apiDefs::key::appVersion] = QString(APP_VERSION);
+
+    const QString appLanguage = m_appSettingsRepository->getAppLanguage().name().split("_").first();
+    if (!appLanguage.isEmpty()) {
+        apiPayload[apiDefs::key::appLanguage] = appLanguage;
+    }
+
+    apiPayload[apiDefs::key::uuid] = m_appSettingsRepository->getInstallationUuid(true);
+    apiPayload[apiDefs::key::userCountryCode] = userCountryCode;
+    apiPayload[apiDefs::key::serviceType] = serviceType;
+    apiPayload[apiDefs::key::serviceProtocol] = QString(gateway_key::vless);
+    apiPayload[apiDefs::key::publicKey] = QUuid::createUuid().toString(QUuid::WithoutBraces);
+
+    const QJsonObject authData = server.value(apiDefs::key::authData).toObject();
+    if (!authData.isEmpty()) {
+        apiPayload[apiDefs::key::authData] = authData;
+    }
+
+    GatewayController gatewayController(m_appSettingsRepository->getGatewayEndpoint(), m_appSettingsRepository->isDevGatewayEnv(),
+                                        apiDefs::requestTimeoutMsecs, m_appSettingsRepository->isStrictKillSwitchEnabled());
+
+    QByteArray responseBody;
+    const amnezia::ErrorCode errorCode = gatewayController.post(QString("%1v1/config"), apiPayload, responseBody);
+    if (errorCode != amnezia::ErrorCode::NoError) {
+        const QString message = QStringLiteral("Gateway request failed with error code %1").arg(static_cast<int>(errorCode));
+        ProxyLogger::getInstance().error(message);
+        errorDescription = message;
+        return std::nullopt;
+    }
+
+    QJsonParseError responseError;
+    const QJsonDocument responseDoc = QJsonDocument::fromJson(responseBody, &responseError);
+    if (responseError.error != QJsonParseError::NoError || !responseDoc.isObject()) {
+        const QString message = QStringLiteral("Failed to parse gateway response: %1").arg(responseError.errorString());
+        ProxyLogger::getInstance().error(message);
+        errorDescription = message;
+        return std::nullopt;
+    }
+
+    QString data = responseDoc.object().value(configKey::config).toString();
+    if (data.isEmpty()) {
+        const QString message = QStringLiteral("Gateway response lacks config payload");
+        ProxyLogger::getInstance().error(message);
+        errorDescription = message;
+        return std::nullopt;
+    }
+
+    data.replace("vpn://", "");
+    QByteArray decoded = QByteArray::fromBase64(data.toUtf8(), QByteArray::Base64UrlEncoding | QByteArray::OmitTrailingEquals);
+    if (decoded.isEmpty()) {
+        const QString message = QStringLiteral("Gateway config payload is empty");
+        ProxyLogger::getInstance().error(message);
+        errorDescription = message;
+        return std::nullopt;
+    }
+
+    const QByteArray uncompressed = qUncompress(decoded);
+    if (!uncompressed.isEmpty()) {
+        decoded = uncompressed;
+    }
+
+    QJsonParseError configError;
+    const QJsonDocument configDoc = QJsonDocument::fromJson(decoded, &configError);
+    if (configError.error != QJsonParseError::NoError || !configDoc.isObject()) {
+        const QString message = QStringLiteral("Failed to parse gateway config JSON: %1").arg(configError.errorString());
+        ProxyLogger::getInstance().error(message);
+        errorDescription = message;
+        return std::nullopt;
+    }
+
+    const auto serializedConfig = extractSerializedXrayConfig(configDoc.object());
+    if (!serializedConfig || serializedConfig->isEmpty()) {
+        const QString message = QStringLiteral("Gateway response lacks Xray last_config payload");
+        ProxyLogger::getInstance().error(message);
+        errorDescription = message;
+        return std::nullopt;
+    }
+
+    ProxyLogger::getInstance().info("Fetched Xray config from gateway");
+    return serializedConfig;
+}
+
+QString ConfigManager::tempDirectory() const
+{
+    const QString baseDir = QStandardPaths::writableLocation(QStandardPaths::AppConfigLocation);
+    if (baseDir.isEmpty()) {
+        return QDir::temp().filePath(QStringLiteral("amnezia_local_proxy"));
+    }
+    return QDir(baseDir).filePath(QStringLiteral("local_proxy"));
+}

client/core/local-proxy/configmanager.h

@@ -0,0 +1,37 @@
+#pragma once
+
+#include <optional>
+
+#include <QJsonObject>
+#include <QString>
+
+class SecureServersRepository;
+class SecureAppSettingsRepository;
+
+class ConfigManager {
+public:
+    struct ConfigData {
+        QString ownerId;
+        QString serverName;
+        QString serializedConfig;
+        QJsonObject parsedConfig;
+    };
+
+    ConfigManager(SecureServersRepository *serversRepository, SecureAppSettingsRepository *appSettingsRepository);
+
+    std::optional<ConfigData> buildConfig(QString &errorDescription) const;
+    std::optional<ConfigData> buildConfigWithFetch(QString &errorDescription) const;
+    bool writeTempConfig(const QString &serializedConfig, QString &configPath, QString &errorDescription) const;
+    bool removeTempConfig() const;
+    QString tempConfigPath() const;
+
+private:
+    std::optional<QString> extractSerializedXrayConfig(const QJsonObject &server) const;
+    std::optional<QString> fetchSerializedXrayConfigFromGateway(const QJsonObject &server, QString &errorDescription) const;
+    QString tempDirectory() const;
+    bool applyProxyPortToConfig(QJsonObject &config, int port) const;
+    QString serializeConfig(const QJsonObject &config) const;
+
+    SecureServersRepository *m_serversRepository;
+    SecureAppSettingsRepository *m_appSettingsRepository;
+};

client/core/local-proxy/httpapi.cpp

@@ -0,0 +1,190 @@
+#include "httpapi.h"
+#include "proxylogger.h"
+#include <QJsonObject>
+#include <QJsonArray>
+#include <QHostAddress>
+#include <optional>
+
+namespace {
+
+std::optional<int> extractInboundPort(const QJsonObject &config)
+{
+    if (!config.contains("inbounds") || !config["inbounds"].isArray()) {
+        return std::nullopt;
+    }
+
+    const QJsonArray inbounds = config["inbounds"].toArray();
+    if (inbounds.isEmpty() || !inbounds.at(0).isObject()) {
+        return std::nullopt;
+    }
+
+    const QJsonObject firstInbound = inbounds.at(0).toObject();
+    if (!firstInbound.contains("port")) {
+        return std::nullopt;
+    }
+
+    return firstInbound.value("port").toInt();
+}
+
+QJsonValue proxyPortValue(const std::optional<int> &port)
+{
+    if (port.has_value()) {
+        return QJsonValue(*port);
+    }
+    return QJsonValue::Null;
+}
+
+QHttpServerResponse makeServiceUnavailablePingResponse()
+{
+    QJsonObject payload{
+        {"status", "error"},
+        {"proxyPort", QJsonValue::Null}
+    };
+    return QHttpServerResponse(payload, QHttpServerResponse::StatusCode::ServiceUnavailable);
+}
+
+QHttpServerResponse makeServiceUnavailableStatusResponse()
+{
+    QJsonObject payload{
+        {"status", "error"}
+    };
+    return QHttpServerResponse(payload, QHttpServerResponse::StatusCode::ServiceUnavailable);
+}
+
+} // namespace
+
+HttpApi::HttpApi(QWeakPointer<IProxyService> service, QObject* parent)
+    : QObject(parent)
+    , m_tcpServer(new QTcpServer(this))
+    , m_service(service)
+{
+    ProxyLogger::getInstance().debug("HttpApi initialized");
+}
+
+HttpApi::~HttpApi()
+{
+    stop();
+}
+
+bool HttpApi::start(quint16 port)
+{
+    ProxyLogger::getInstance().info(QString("Starting HTTP API server on port %1").arg(port));
+    
+    if (!m_tcpServer->listen(QHostAddress::LocalHost, port)) {
+        ProxyLogger::getInstance().error(QString("Failed to start HTTP API server on port %1").arg(port));
+        return false;
+    }
+
+    setupRoutes();
+    m_server.bind(m_tcpServer.data());
+    
+    ProxyLogger::getInstance().info(QString("HTTP API server is running on localhost:%1").arg(m_tcpServer->serverPort()));
+    ProxyLogger::getInstance().debug("Available endpoints:\n"
+                              "  POST   /api/v1/up\n"
+                              "  POST   /api/v1/down\n"
+                              "  GET    /api/v1/ping");
+    return true;
+}
+
+void HttpApi::stop()
+{
+    ProxyLogger::getInstance().info("Stopping HTTP API server");
+    if (m_tcpServer) {
+        m_tcpServer->close();
+    }
+}
+
+void HttpApi::setupRoutes()
+{
+    ProxyLogger::getInstance().debug("Setting up HTTP API routes");
+
+    m_server.route("/api/v1/up", QHttpServerRequest::Method::Post,
+        [this] {
+            ProxyLogger::getInstance().debug("Handling POST /api/v1/up request");
+            return handlePostUp();
+        });
+
+    m_server.route("/api/v1/down", QHttpServerRequest::Method::Post,
+        [this] {
+            ProxyLogger::getInstance().debug("Handling POST /api/v1/down request");
+            return handlePostDown();
+        });
+
+    m_server.route("/api/v1/ping", QHttpServerRequest::Method::Get,
+        [this] {
+            ProxyLogger::getInstance().debug("Handling GET /api/v1/ping request");
+            return handleGetPing();
+        });
+}
+
+QHttpServerResponse HttpApi::handlePostUp()
+{
+    if (auto service = m_service.lock()) {
+        const bool started = service->startXray();
+        QJsonObject response;
+        response["status"] = started ? "ok" : "error";
+
+        const auto port = started ? extractInboundPort(service->getConfig()) : std::optional<int>{};
+        response["proxyPort"] = proxyPortValue(port);
+
+        if (started) {
+            if (port.has_value()) {
+                ProxyLogger::getInstance().info(QString("Xray process started on port %1").arg(*port));
+            } else {
+                ProxyLogger::getInstance().warning("Xray started but inbound port is unknown (local proxy owner may be missing)");
+            }
+        } else {
+            ProxyLogger::getInstance().warning("Failed to start Xray process via HTTP API");
+        }
+
+        return QHttpServerResponse(response);
+    }
+
+    ProxyLogger::getInstance().error("Service unavailable: proxy backend is not initialized");
+    return makeServiceUnavailablePingResponse();
+}
+
+QHttpServerResponse HttpApi::handlePostDown()
+{
+    if (auto service = m_service.lock()) {
+        const bool stopped = service->stopXray();
+        QJsonObject response;
+        response["status"] = stopped ? "ok" : "error";
+        if (!stopped) {
+            ProxyLogger::getInstance().warning("Failed to stop Xray process via HTTP API");
+        } else {
+            ProxyLogger::getInstance().info("Xray process stopped via HTTP API");
+        }
+
+        return QHttpServerResponse(response);
+    }
+
+    ProxyLogger::getInstance().error("Service unavailable: proxy backend is not initialized");
+    return makeServiceUnavailableStatusResponse();
+}
+
+QHttpServerResponse HttpApi::handleGetPing() const
+{
+    if (auto service = m_service.lock()) {
+        QJsonObject response;
+        response["status"] = "ok";
+        const bool isRunning = service->isXrayRunning();
+        if (isRunning) {
+            const auto port = extractInboundPort(service->getConfig());
+            response["proxyPort"] = proxyPortValue(port);
+            if (port.has_value()) {
+                ProxyLogger::getInstance().debug(QString("Xray port: %1").arg(*port));
+            } else {
+                ProxyLogger::getInstance().warning("Unable to detect inbound port while Xray is running");
+            }
+        } else {
+            response["proxyPort"] = QJsonValue::Null;
+            ProxyLogger::getInstance().debug("Xray is not running");
+        }
+
+        return QHttpServerResponse(response);
+    }
+
+    ProxyLogger::getInstance().error("Service unavailable: proxy backend is not initialized");
+    return makeServiceUnavailablePingResponse();
+}

client/core/local-proxy/httpapi.h

@@ -0,0 +1,32 @@
+#pragma once
+
+#include <QObject>
+#include <QScopedPointer>
+#include <QHttpServer>
+#include <QHttpServerRequest>
+#include <QHttpServerResponse>
+#include <QTcpServer>
+#include <QWeakPointer>
+#include "iproxyservice.h"
+
+class HttpApi : public QObject {
+    Q_OBJECT
+
+public:
+    explicit HttpApi(QWeakPointer<IProxyService> service, QObject* parent = nullptr);
+    ~HttpApi();
+
+    bool start(quint16 port);
+    void stop();
+
+private:
+    void setupRoutes();
+
+    QHttpServerResponse handlePostUp();
+    QHttpServerResponse handlePostDown();
+    QHttpServerResponse handleGetPing() const;
+
+    QHttpServer m_server;
+    QScopedPointer<QTcpServer> m_tcpServer;
+    QWeakPointer<IProxyService> m_service;
+}; 

client/core/local-proxy/iproxyservice.h

@@ -0,0 +1,17 @@
+#pragma once
+
+#include <QJsonObject>
+#include <QString>
+
+class IProxyService {
+public:
+    virtual ~IProxyService() = default;
+
+    virtual QJsonObject getConfig() = 0;
+
+    virtual bool startXray() = 0;
+    virtual bool stopXray() = 0;
+    virtual bool isXrayRunning() const = 0;
+    virtual qint64 getXrayProcessId() const = 0;
+    virtual QString getXrayError() const = 0;
+}; 

client/core/local-proxy/portavailabilityhelper.cpp

@@ -0,0 +1,43 @@
+#include "portavailabilityhelper.h"
+
+#include <QHostAddress>
+#include <QTcpServer>
+
+namespace {
+constexpr int kProxyPortMin = 1024;
+constexpr int kProxyPortMax = 65535;
+}
+
+bool PortAvailabilityHelper::isPortAvailable(int port)
+{
+    if (port < kProxyPortMin || port > kProxyPortMax) {
+        return false;
+    }
+
+    QTcpServer server;
+    const bool success = server.listen(QHostAddress::LocalHost, static_cast<quint16>(port));
+    server.close();
+    return success;
+}
+
+std::optional<int> PortAvailabilityHelper::findFirstAvailablePort(int startPort, int endPort)
+{
+    if (startPort < kProxyPortMin) {
+        startPort = kProxyPortMin;
+    }
+    if (endPort > kProxyPortMax) {
+        endPort = kProxyPortMax;
+    }
+    if (startPort > endPort) {
+        return std::nullopt;
+    }
+
+    for (int port = startPort; port <= endPort; ++port) {
+        if (isPortAvailable(port)) {
+            return port;
+        }
+    }
+
+    return std::nullopt;
+}
+

client/core/local-proxy/portavailabilityhelper.h

@@ -0,0 +1,11 @@
+#pragma once
+
+#include <optional>
+
+class PortAvailabilityHelper
+{
+public:
+    static bool isPortAvailable(int port);
+    static std::optional<int> findFirstAvailablePort(int startPort, int endPort);
+};
+

client/core/local-proxy/proxylogger.cpp

@@ -0,0 +1,133 @@
+#include "proxylogger.h"
+#include <QDir>
+#include <QTextStream>
+
+ProxyLogger::ProxyLogger() : m_maxFileSize(0), m_currentLevel(LogLevel::Info)
+{
+}
+
+ProxyLogger::~ProxyLogger()
+{
+}
+
+ProxyLogger& ProxyLogger::getInstance()
+{
+    static ProxyLogger instance;
+    return instance;
+}
+
+void ProxyLogger::init(const QString& logPath, qint64 maxFileSize)
+{
+    QMutexLocker locker(&m_mutex);
+    m_logPath = logPath;
+    m_maxFileSize = maxFileSize;
+    
+    // Create logs directory if it doesn't exist
+    QDir dir = QFileInfo(m_logPath).dir();
+    if (!dir.exists()) {
+        dir.mkpath(".");
+    }
+}
+
+void ProxyLogger::setLogLevel(LogLevel level)
+{
+    m_currentLevel = level;
+}
+
+void ProxyLogger::log(LogLevel level, const QString& message)
+{
+    logInternal(level, message);
+}
+
+void ProxyLogger::debug(const QString& message)
+{
+    logInternal(LogLevel::Debug, message);
+}
+
+void ProxyLogger::info(const QString& message)
+{
+    logInternal(LogLevel::Info, message);
+}
+
+void ProxyLogger::warning(const QString& message)
+{
+    logInternal(LogLevel::Warning, message);
+}
+
+void ProxyLogger::error(const QString& message)
+{
+    logInternal(LogLevel::Error, message);
+}
+
+void ProxyLogger::logInternal(LogLevel level, const QString& message)
+{
+    if (m_logPath.isEmpty()) {
+        return;
+    }
+    
+    if (level < m_currentLevel) {
+        return;
+    }
+
+    QMutexLocker locker(&m_mutex);
+    
+    checkRotation();
+
+    QFile file(m_logPath);
+    if (!openLogFile(file)) {
+        return;
+    }
+
+    QTextStream stream(&file);
+    QString timestamp = QDateTime::currentDateTime().toString("yyyy-MM-dd hh:mm:ss.zzz");
+    stream << QString("[%1] [%2] %3\n").arg(timestamp, levelToString(level), message);
+    stream.flush();
+    file.close();
+}
+
+QString ProxyLogger::levelToString(LogLevel level)
+{
+    switch (level) {
+        case LogLevel::Debug:   return "DEBUG";
+        case LogLevel::Info:    return "INFO";
+        case LogLevel::Warning: return "WARNING";
+        case LogLevel::Error:   return "ERROR";
+        default:               return "UNKNOWN";
+    }
+}
+
+qint64 ProxyLogger::getCurrentFileSize() const
+{
+    QFile file(m_logPath);
+    if (file.exists()) {
+        return file.size();
+    }
+    return -1;
+}
+
+void ProxyLogger::checkRotation()
+{
+    if (m_maxFileSize > 0 && getCurrentFileSize() >= m_maxFileSize) {
+        // Delete the oldest file
+        QFile::remove(QString("%1.%2").arg(m_logPath).arg(MAX_BACKUP_FILES));
+
+        // Shift existing files
+        for (int i = MAX_BACKUP_FILES - 1; i >= 1; --i) {
+            QString oldName = QString("%1.%2").arg(m_logPath).arg(i);
+            QString newName = QString("%1.%2").arg(m_logPath).arg(i + 1);
+            QFile::rename(oldName, newName);
+        }
+
+        // Rename current file
+        QFile::rename(m_logPath, m_logPath + ".1");
+    }
+}
+
+bool ProxyLogger::openLogFile(QFile& file)
+{
+    if (!file.open(QIODevice::WriteOnly | QIODevice::Append | QIODevice::Text)) {
+        qDebug() << "Failed to open log file:" << m_logPath;
+        return false;
+    }
+    return true;
+} 

client/core/local-proxy/proxylogger.h

@@ -0,0 +1,54 @@
+#ifndef LOCAL_PROXY_LOGGER_H
+#define LOCAL_PROXY_LOGGER_H
+
+#include <QObject>
+#include <QFile>
+#include <QDateTime>
+#include <QMutex>
+#include <QString>
+
+class ProxyLogger
+{
+
+public:
+    enum class LogLevel {
+        Debug,
+        Info,
+        Warning,
+        Error
+    };
+
+    static ProxyLogger& getInstance();
+
+    void init(const QString& logPath, qint64 maxFileSize = 1024 * 1024 * 10); // 10MB by default
+    void setLogLevel(LogLevel level);
+
+    // Main logging method
+    void log(LogLevel level, const QString& message);
+
+    // Helper methods for convenience
+    void debug(const QString& message);
+    void info(const QString& message);
+    void warning(const QString& message);
+    void error(const QString& message);
+
+private:
+    ProxyLogger();
+    ~ProxyLogger();
+    ProxyLogger(const ProxyLogger&) = delete;
+    ProxyLogger& operator=(const ProxyLogger&) = delete;
+
+    void logInternal(LogLevel level, const QString& message);
+    void checkRotation();
+    QString levelToString(LogLevel level);
+    bool openLogFile(QFile& file);
+    qint64 getCurrentFileSize() const;
+
+    QString m_logPath;
+    qint64 m_maxFileSize;
+    LogLevel m_currentLevel;
+    QMutex m_mutex;
+    static const int MAX_BACKUP_FILES = 3;
+};
+
+#endif // LOCAL_PROXY_LOGGER_H 

client/core/local-proxy/proxyserver.cpp

@@ -0,0 +1,114 @@
+#include "proxyserver.h"
+
+#include "core/repositories/secureAppSettingsRepository.h"
+#include "core/repositories/secureServersRepository.h"
+
+#include <QDebug>
+
+ProxyServer::ProxyServer(SecureServersRepository *serversRepository, SecureAppSettingsRepository *appSettingsRepository,
+                         QObject *parent)
+    : QObject(parent)
+    , m_appSettingsRepository(appSettingsRepository)
+    , m_service(new ProxyService(serversRepository, appSettingsRepository, this))
+{
+    m_lastRestartToken = m_appSettingsRepository ? m_appSettingsRepository->localProxyRestartToken() : 0;
+}
+
+ProxyServer::~ProxyServer()
+{
+    stop();
+}
+
+bool ProxyServer::start(quint16 port)
+{
+    if (m_isRunning) {
+        if (m_currentApiPort == port) {
+            qInfo() << "Local proxy: already running on port" << port;
+            return true;
+        }
+
+        qInfo() << "Local proxy: restarting on new port" << port;
+        stop();
+    }
+
+    m_api.reset(new HttpApi(m_service.toWeakRef()));
+    const bool apiStarted = m_api->start(port);
+    if (!apiStarted) {
+        qWarning() << "Local proxy: port is busy:" << port;
+        m_api.reset();
+        m_isRunning = false;
+        m_currentApiPort = 0;
+        return false;
+    }
+
+    m_isRunning = true;
+    m_currentApiPort = port;
+
+    return true;
+}
+
+void ProxyServer::stop()
+{
+    stopXrayProcess();
+    if (m_api) {
+        m_api->stop();
+        m_api.reset();
+    }
+    m_isRunning = false;
+    m_currentApiPort = 0;
+    m_currentProxyPort = 0;
+}
+
+bool ProxyServer::startXrayProcess()
+{
+    return m_service->startXray();
+}
+
+void ProxyServer::stopXrayProcess()
+{
+    m_service->stopXray();
+}
+
+bool ProxyServer::syncSettings()
+{
+    if (!m_isRunning) {
+        qDebug() << "Local proxy: syncSettings called but server is not running";
+        return false;
+    }
+
+    const quint16 newProxyPort = m_appSettingsRepository ? m_appSettingsRepository->localProxyPort() : 0;
+    const int restartToken = m_appSettingsRepository ? m_appSettingsRepository->localProxyRestartToken() : 0;
+    const bool xrayRunning = m_service->isXrayRunning();
+
+    if (!xrayRunning) {
+        qInfo() << "Local proxy: starting Xray on port" << newProxyPort;
+        const bool started = startXrayProcess();
+        if (started) {
+            m_currentProxyPort = newProxyPort;
+            m_lastRestartToken = restartToken;
+        }
+        return started;
+    }
+
+    if (m_lastRestartToken != restartToken) {
+        qInfo() << "Local proxy: restarting Xray due to config change token";
+        const bool restarted = m_service->restartXray();
+        if (restarted) {
+            m_currentProxyPort = newProxyPort;
+            m_lastRestartToken = restartToken;
+        }
+        return restarted;
+    }
+
+    if (m_currentProxyPort != newProxyPort) {
+        qInfo() << "Local proxy: proxy port changed from" << m_currentProxyPort << "to" << newProxyPort;
+        const bool restarted = m_service->restartXray();
+        if (restarted) {
+            m_currentProxyPort = newProxyPort;
+            m_lastRestartToken = restartToken;
+        }
+        return restarted;
+    }
+
+    return true;
+}

client/core/local-proxy/proxyserver.h

@@ -0,0 +1,37 @@
+#pragma once
+
+#include <QObject>
+#include <QScopedPointer>
+#include <QSharedPointer>
+
+#include "httpapi.h"
+#include "proxyservice.h"
+
+class SecureServersRepository;
+class SecureAppSettingsRepository;
+
+class ProxyServer : public QObject
+{
+    Q_OBJECT
+
+public:
+    ProxyServer(SecureServersRepository *serversRepository, SecureAppSettingsRepository *appSettingsRepository,
+                QObject *parent = nullptr);
+    ~ProxyServer();
+
+    bool start(quint16 port = 49490);
+    void stop();
+    bool syncSettings();
+
+private:
+    bool startXrayProcess();
+    void stopXrayProcess();
+
+    SecureAppSettingsRepository *m_appSettingsRepository;
+    QScopedPointer<HttpApi> m_api;
+    QSharedPointer<ProxyService> m_service;
+    bool m_isRunning {false};
+    quint16 m_currentApiPort {0};
+    quint16 m_currentProxyPort {0};
+    int m_lastRestartToken {0};
+};

client/core/local-proxy/proxyservice.cpp

@@ -0,0 +1,118 @@
+#include "proxyservice.h"
+
+#include "proxylogger.h"
+
+namespace {
+
+void logConfigError(const QString &errorMessage)
+{
+    if (!errorMessage.isEmpty()) {
+        ProxyLogger::getInstance().error(errorMessage);
+    }
+}
+
+} // namespace
+
+ProxyService::ProxyService(SecureServersRepository *serversRepository, SecureAppSettingsRepository *appSettingsRepository,
+                           QObject *parent)
+    : QObject(parent)
+    , m_configManager(new ConfigManager(serversRepository, appSettingsRepository))
+    , m_xrayController(new XrayController())
+{
+    ProxyLogger::getInstance().debug("ProxyService initialized");
+}
+
+QJsonObject ProxyService::getConfig()
+{
+    if (!m_cachedConfig.isEmpty()) {
+        return m_cachedConfig;
+    }
+
+    QString error;
+    const auto configData = m_configManager->buildConfigWithFetch(error);
+    if (!configData) {
+        logConfigError(error);
+        return {};
+    }
+
+    m_cachedConfig = configData->parsedConfig;
+    return m_cachedConfig;
+}
+
+bool ProxyService::startXray()
+{
+    ProxyLogger::getInstance().info("Starting Xray");
+
+    if (m_xrayController->isXrayRunning()) {
+        ProxyLogger::getInstance().info("Xray is already running");
+        return true;
+    }
+
+    QString error;
+    const auto configData = m_configManager->buildConfigWithFetch(error);
+    if (!configData) {
+        logConfigError(error);
+        return false;
+    }
+
+    const bool success = m_xrayController->start(configData->serializedConfig);
+    if (success) {
+        m_cachedConfig = configData->parsedConfig;
+        ProxyLogger::getInstance().info("Xray started successfully");
+        emit xrayStatusChanged(true);
+        return true;
+    }
+
+    ProxyLogger::getInstance().error(QStringLiteral("Failed to start Xray: %1").arg(m_xrayController->getError()));
+    return false;
+}
+
+bool ProxyService::stopXray()
+{
+    ProxyLogger::getInstance().info("Stopping Xray");
+    const bool stopped = m_xrayController->stop();
+    if (stopped) {
+        ProxyLogger::getInstance().info("Xray stopped");
+        emit xrayStatusChanged(false);
+        return true;
+    }
+
+    ProxyLogger::getInstance().warning(QStringLiteral("Failed to stop Xray: %1").arg(m_xrayController->getError()));
+    return false;
+}
+
+bool ProxyService::isXrayRunning() const
+{
+    return m_xrayController->isXrayRunning();
+}
+
+qint64 ProxyService::getXrayProcessId() const
+{
+    return m_xrayController->getProcessId();
+}
+
+QString ProxyService::getXrayError() const
+{
+    return m_xrayController->getError();
+}
+
+void ProxyService::clearCache()
+{
+    m_cachedConfig = QJsonObject();
+    ProxyLogger::getInstance().debug("ProxyService cache cleared");
+}
+
+bool ProxyService::restartXray()
+{
+    ProxyLogger::getInstance().info("Restarting Xray with updated config");
+    clearCache();
+
+    if (m_xrayController->isXrayRunning()) {
+        if (!stopXray()) {
+            ProxyLogger::getInstance().error("Failed to stop Xray during restart, aborting");
+            return false;
+        }
+    }
+
+    return startXray();
+}

client/core/local-proxy/proxyservice.h

@@ -0,0 +1,39 @@
+#pragma once
+
+#include "configmanager.h"
+#include "iproxyservice.h"
+#include "xraycontroller.h"
+
+#include <QObject>
+#include <QScopedPointer>
+#include <QJsonObject>
+
+class SecureServersRepository;
+class SecureAppSettingsRepository;
+
+class ProxyService : public QObject, public IProxyService {
+    Q_OBJECT
+
+public:
+    ProxyService(SecureServersRepository *serversRepository, SecureAppSettingsRepository *appSettingsRepository,
+                 QObject *parent = nullptr);
+    ~ProxyService() = default;
+
+    QJsonObject getConfig() override;
+    bool startXray() override;
+    bool stopXray() override;
+    bool isXrayRunning() const override;
+    qint64 getXrayProcessId() const override;
+    QString getXrayError() const override;
+
+    void clearCache();
+    bool restartXray();
+
+signals:
+    void xrayStatusChanged(bool running);
+
+private:
+    QScopedPointer<ConfigManager> m_configManager;
+    QScopedPointer<XrayController> m_xrayController;
+    QJsonObject m_cachedConfig;
+}; 

client/core/local-proxy/xraycontroller.cpp

@@ -0,0 +1,105 @@
+#include "xraycontroller.h"
+
+#include "proxylogger.h"
+#include "core/utils/ipcClient.h"
+
+namespace {
+const QString kIpcUnavailableError = QStringLiteral("Failed to communicate with IPC service");
+}
+
+XrayController::XrayController(QObject *parent)
+    : QObject(parent)
+{
+    ProxyLogger::getInstance().debug("XrayController initialized");
+}
+
+XrayController::~XrayController()
+{
+    stop();
+}
+
+bool XrayController::start(const QString &configJson)
+{
+    if (m_isRunning) {
+        ProxyLogger::getInstance().info("Xray is already running");
+        return true;
+    }
+
+    ProxyLogger::getInstance().info("Request to start Xray via IPC");
+
+    m_lastError.clear();
+
+    if (configJson.trimmed().isEmpty()) {
+        m_lastError = QStringLiteral("Config content is empty");
+        ProxyLogger::getInstance().error(m_lastError);
+        return false;
+    }
+
+    const bool ipcResult = IpcClient::withInterface([&](QSharedPointer<IpcInterfaceReplica> iface) {
+        auto xrayStart = iface->xrayStart(configJson);
+        if (!xrayStart.waitForFinished() || !xrayStart.returnValue()) {
+            ProxyLogger::getInstance().warning("Failed to start Xray via IPC");
+            return false;
+        }
+
+        return true;
+    }, []() {
+        return false;
+    });
+
+    if (!ipcResult) {
+        m_lastError = kIpcUnavailableError;
+        ProxyLogger::getInstance().error(m_lastError);
+        return false;
+    }
+
+    ProxyLogger::getInstance().info("Xray start command sent to IPC service");
+    m_isRunning = true;
+    return true;
+}
+
+bool XrayController::stop()
+{
+    if (!m_isRunning) {
+        ProxyLogger::getInstance().debug("Skipping Xray stop via IPC: local proxy Xray is not running");
+        return true;
+    }
+
+    ProxyLogger::getInstance().info("Stopping Xray via IPC");
+
+    const bool ipcResult = IpcClient::withInterface([](QSharedPointer<IpcInterfaceReplica> iface) {
+        auto xrayStop = iface->xrayStop();
+        if (!xrayStop.waitForFinished() || !xrayStop.returnValue()) {
+            ProxyLogger::getInstance().warning("Failed to stop Xray via IPC");
+            return false;
+        }
+
+        return true;
+    }, []() {
+        return false;
+    });
+
+    if (!ipcResult) {
+        m_lastError = kIpcUnavailableError;
+        ProxyLogger::getInstance().warning(m_lastError);
+        return false;
+    }
+
+    m_isRunning = false;
+    return true;
+}
+
+bool XrayController::isXrayRunning() const
+{
+    return m_isRunning;
+}
+
+qint64 XrayController::getProcessId() const
+{
+    return -1;
+}
+
+QString XrayController::getError() const
+{
+    return m_lastError;
+}

client/core/local-proxy/xraycontroller.h

@@ -0,0 +1,22 @@
+#pragma once
+
+#include <QObject>
+#include <QString>
+
+class XrayController : public QObject {
+    Q_OBJECT
+
+public:
+    explicit XrayController(QObject* parent = nullptr);
+    ~XrayController();
+
+    bool start(const QString& configJson);
+    bool stop();
+    bool isXrayRunning() const;
+    qint64 getProcessId() const;
+    QString getError() const;
+
+private:
+    bool m_isRunning {false};
+    QString m_lastError;
+}; 

client/core/protocols/xrayProtocol.cpp

@@ -68,6 +68,8 @@ ErrorCode XrayProtocol::start()
 {
     qDebug() << "XrayProtocol::start()";
 
+    m_teardownDone = false;
+
     // Inject SOCKS5 auth into the inbound before starting xray.
     // Re-uses existing credentials if the config already has them (e.g. imported config).
     amnezia::serialization::inbounds::InboundCredentials creds;
@@ -120,6 +122,17 @@ void XrayProtocol::stop()
 {
     qDebug() << "XrayProtocol::stop()";
 
+    // The destructor calls stop() as a safety net, but stop() is also called
+    // explicitly on disconnect. Because stop() spins the event loop via
+    // waitForFinished(), the local proxy may start its own xray on the shared
+    // global engine in between. Running the teardown (xrayStop) twice would then
+    // kill the proxy's just-started xray. Run the engine teardown only once.
+    if (m_teardownDone) {
+        qDebug() << "XrayProtocol::stop() teardown already done, skipping";
+        return;
+    }
+    m_teardownDone = true;
+
     IpcClient::withInterface([](QSharedPointer<IpcInterfaceReplica> iface) {
         auto disableKillSwitch = iface->disableKillSwitch();
         if (!disableKillSwitch.waitForFinished() || !disableKillSwitch.returnValue())

client/core/protocols/xrayProtocol.h

@@ -38,6 +38,11 @@ private:
     int m_tun2socksRetryCount = 0;
     static constexpr int maxTun2SocksRetries = 5;
     static constexpr int tun2socksRetryDelayMs = 400;
+
+    // Guards against tearing down the shared xray engine more than once.
+    // The destructor also calls stop(); without this the second stop() would
+    // call xrayStop() on the global engine that the local proxy may already own.
+    bool m_teardownDone = false;
 };
 
 #endif // XRAYPROTOCOL_H

client/core/repositories/secureAppSettingsRepository.cpp

@@ -5,6 +5,8 @@
 #include <QJsonObject>
 #include <QUuid>
 
+#include <limits>
+
 #include "core/utils/errorCodes.h"
 #include "core/utils/routeModes.h"
 #include "core/utils/commonStructs.h"
@@ -440,3 +442,59 @@ void SecureAppSettingsRepository::setXraySavedConfigs(const QByteArray &data)
 {
     setValue("Xray/savedConfigs", data);
 }
+
+QString SecureAppSettingsRepository::localProxyOwnerId() const
+{
+    return value("Conf/localProxyOwnerId", "").toString();
+}
+
+void SecureAppSettingsRepository::setLocalProxyOwnerId(const QString &serverId)
+{
+    setValue("Conf/localProxyOwnerId", serverId);
+    emit localProxySettingsChanged();
+}
+
+quint16 SecureAppSettingsRepository::localProxyPort() const
+{
+    return static_cast<quint16>(value("Conf/localProxyPort", 10808).toUInt());
+}
+
+void SecureAppSettingsRepository::setLocalProxyPort(quint16 port)
+{
+    setValue("Conf/localProxyPort", port);
+    emit localProxySettingsChanged();
+}
+
+bool SecureAppSettingsRepository::isLocalProxyPortUserDefined() const
+{
+    return value("Conf/localProxyPortUserDefined", false).toBool();
+}
+
+void SecureAppSettingsRepository::setLocalProxyPortUserDefined(bool userDefined)
+{
+    setValue("Conf/localProxyPortUserDefined", userDefined);
+}
+
+bool SecureAppSettingsRepository::isLocalProxyHttpEnabled() const
+{
+    return value("Conf/localProxyHttpEnabled", false).toBool();
+}
+
+void SecureAppSettingsRepository::setLocalProxyHttpEnabled(bool enabled)
+{
+    setValue("Conf/localProxyHttpEnabled", enabled);
+    emit localProxySettingsChanged();
+}
+
+int SecureAppSettingsRepository::localProxyRestartToken() const
+{
+    return value("Conf/localProxyRestartToken", 0).toInt();
+}
+
+void SecureAppSettingsRepository::bumpLocalProxyRestartToken()
+{
+    const int current = localProxyRestartToken();
+    const int next = (current == std::numeric_limits<int>::max()) ? 0 : (current + 1);
+    setValue("Conf/localProxyRestartToken", next);
+    emit localProxySettingsChanged();
+}

client/core/repositories/secureAppSettingsRepository.h

@@ -93,6 +93,18 @@ public:
     QByteArray xraySavedConfigs() const;
     void setXraySavedConfigs(const QByteArray &data);
 
+    // Local proxy
+    QString localProxyOwnerId() const;
+    void setLocalProxyOwnerId(const QString &serverId);
+    quint16 localProxyPort() const;
+    void setLocalProxyPort(quint16 port);
+    bool isLocalProxyPortUserDefined() const;
+    void setLocalProxyPortUserDefined(bool userDefined);
+    bool isLocalProxyHttpEnabled() const;
+    void setLocalProxyHttpEnabled(bool enabled);
+    int localProxyRestartToken() const;
+    void bumpLocalProxyRestartToken();
+
 signals:
     void appLanguageChanged(QLocale locale);
     void allowedDnsServersChanged(const QStringList &servers);
@@ -106,6 +118,8 @@ signals:
     void saveLogsChanged(bool enabled);
     void screenshotsEnabledChanged(bool enabled);
     void settingsCleared();
+    void localProxySettingsChanged();
+    void localProxyStartFailed(const QString &message);
 
 private:
     void setVpnSites(RouteMode mode, const QVariantMap &sites);

client/core/repositories/secureServersRepository.cpp

@@ -309,6 +309,15 @@ serverConfigUtils::ConfigType SecureServersRepository::serverKind(const QString
     return serverConfigUtils::configTypeFromJson(withoutStorageServerId(it.value()));
 }
 
+std::optional<QJsonObject> SecureServersRepository::serverJsonById(const QString &serverId) const
+{
+    const auto it = m_serverJsonById.constFind(serverId);
+    if (it == m_serverJsonById.constEnd()) {
+        return std::nullopt;
+    }
+    return it.value();
+}
+
 std::optional<SelfHostedAdminServerConfig> SecureServersRepository::selfHostedAdminConfig(const QString &serverId) const
 {
     const auto it = m_serverJsonById.constFind(serverId);

client/core/repositories/secureServersRepository.h

@@ -31,6 +31,8 @@ public:
     void removeServer(const QString &serverId);
     serverConfigUtils::ConfigType serverKind(const QString &serverId) const;
 
+    std::optional<QJsonObject> serverJsonById(const QString &serverId) const;
+
     std::optional<SelfHostedAdminServerConfig> selfHostedAdminConfig(const QString &serverId) const;
     std::optional<SelfHostedUserServerConfig> selfHostedUserConfig(const QString &serverId) const;
     std::optional<NativeServerConfig> nativeConfig(const QString &serverId) const;

client/core/utils/networkUtilities.cpp

@@ -286,7 +286,7 @@ QPair<QString, QNetworkInterface> NetworkUtilities::getGatewayAndIface()
     return { resGateway, QNetworkInterface::interfaceFromIndex(resIndex) };
 #endif
 #ifdef Q_OS_LINUX
-    constexpr int BUFFER_SIZE = 8192;
+    constexpr int BUFFER_SIZE = 100;
     int     received_bytes = 0, msg_len = 0, route_attribute_len = 0;
     int     sock = -1, msgseq = 0;
     struct  nlmsghdr *nlh, *nlmsg;
@@ -294,7 +294,7 @@ QPair<QString, QNetworkInterface> NetworkUtilities::getGatewayAndIface()
     // This struct contain route attributes (route type)
     struct  rtattr *route_attribute;
     char    gateway_address[INET_ADDRSTRLEN], interface[IF_NAMESIZE];
-    char    msgbuf[100], buffer[BUFFER_SIZE];
+    char    msgbuf[BUFFER_SIZE], buffer[BUFFER_SIZE];
     char    *ptr = buffer;
     struct timeval tv;
 
@@ -339,8 +339,8 @@ QPair<QString, QNetworkInterface> NetworkUtilities::getGatewayAndIface()
         nlh = (struct nlmsghdr *) ptr;
 
         /* Check if the header is valid */
-        if((NLMSG_OK(nlh, received_bytes) == 0) ||
-            (nlh->nlmsg_type == NLMSG_ERROR))
+        if((NLMSG_OK(nlmsg, received_bytes) == 0) ||
+            (nlmsg->nlmsg_type == NLMSG_ERROR))
         {
             perror("Error in received packet");
             return {};
@@ -355,15 +355,13 @@ QPair<QString, QNetworkInterface> NetworkUtilities::getGatewayAndIface()
         }
 
         /* Break if its not a multi part message */
-        if ((nlh->nlmsg_flags & NLM_F_MULTI) == 0)
+        if ((nlmsg->nlmsg_flags & NLM_F_MULTI) == 0)
             break;
     }
-    while ((nlh->nlmsg_seq != msgseq) || (nlh->nlmsg_pid != getpid()));
+    while ((nlmsg->nlmsg_seq != msgseq) || (nlmsg->nlmsg_pid != getpid()));
 
     /* parse response */
-    int remaining = msg_len + received_bytes;
-    nlh = (struct nlmsghdr *) buffer;
-    for ( ; NLMSG_OK(nlh, remaining); nlh = NLMSG_NEXT(nlh, remaining))
+    for ( ; NLMSG_OK(nlh, received_bytes); nlh = NLMSG_NEXT(nlh, received_bytes))
     {
         /* Get the route data */
         route_entry = (struct rtmsg *) NLMSG_DATA(nlh);
@@ -372,10 +370,6 @@ QPair<QString, QNetworkInterface> NetworkUtilities::getGatewayAndIface()
         if (route_entry->rtm_table != RT_TABLE_MAIN)
             continue;
 
-        /* Reset per-route to avoid cross-route state pollution */
-        memset(gateway_address, 0, sizeof(gateway_address));
-        memset(interface, 0, sizeof(interface));
-
         route_attribute = (struct rtattr *) RTM_RTA(route_entry);
         route_attribute_len = RTM_PAYLOAD(nlh);
 
@@ -401,8 +395,6 @@ QPair<QString, QNetworkInterface> NetworkUtilities::getGatewayAndIface()
             break;
         }
     }
-    if (!(*gateway_address) || !(*interface))
-        qDebug() << "getGatewayAndIface: no gateway found";
     close(sock);
     return { gateway_address, QNetworkInterface::interfaceFromName(interface) };
 #endif

client/daemon/daemon.cpp

@@ -78,6 +78,14 @@ bool Daemon::activate(const InterfaceConfig& config) {
         return false;
       }
 
+      if (!dnsutils()->restoreResolvers()) {
+        return false;
+      }
+
+      if (!maybeUpdateResolvers(config)) {
+        return false;
+      }
+
       bool status = run(Switch, config);
       logger.debug() << "Connection status:" << status;
       if (status) {
@@ -134,6 +142,10 @@ bool Daemon::activate(const InterfaceConfig& config) {
     return false;
   }
 
+  if (!maybeUpdateResolvers(config)) {
+    return false;
+  }
+
   // set routing
   for (const IPAddress& ip : config.m_allowedIPAddressRanges) {
     if (!wgutils()->updateRoutePrefix(ip)) {
@@ -142,12 +154,6 @@ bool Daemon::activate(const InterfaceConfig& config) {
     }
   }
 
-#ifndef Q_OS_LINUX
-  if (!maybeUpdateResolvers(config)) {
-    return false;
-  }
-#endif
-
   bool status = run(Up, config);
   logger.debug() << "Connection status:" << status;
   if (status) {
@@ -162,20 +168,15 @@ bool Daemon::activate(const InterfaceConfig& config) {
 bool Daemon::maybeUpdateResolvers(const InterfaceConfig& config) {
   if ((config.m_hopType == InterfaceConfig::MultiHopExit) ||
       (config.m_hopType == InterfaceConfig::SingleHop)) {
-    if (!dnsutils()) {
-      logger.error() << "dnsutils is null, cannot update resolvers";
-      return false;
-    }
-
     QList<QHostAddress> resolvers;
     resolvers.append(QHostAddress(config.m_primaryDnsServer));
     if (!config.m_secondaryDnsServer.isEmpty()) {
         resolvers.append(QHostAddress(config.m_secondaryDnsServer));
     }
 
-    // If the DNS is the Gateway, also add IPv6 gateway (only if non-empty)
-    if (config.m_primaryDnsServer == config.m_serverIpv4Gateway &&
-        !config.m_serverIpv6Gateway.isEmpty()) {
+    // If the DNS is not the Gateway, it's a user defined DNS
+    // thus, not add any other :)
+    if (config.m_primaryDnsServer == config.m_serverIpv4Gateway) {
       resolvers.append(QHostAddress(config.m_serverIpv6Gateway));
     }
 
@@ -612,7 +613,7 @@ void Daemon::checkHandshake() {
       pendingHandshakes++;
     }
   }
-  
+
   // Check again if there were connections that haven't completed a handshake.
   if (pendingHandshakes > 0) {
     m_handshakeTimer.start(HANDSHAKE_POLL_MSEC);

client/platforms/linux/daemon/dnsutilslinux.cpp

@@ -7,11 +7,8 @@
 #include <net/if.h>
 
 #include <QDBusVariant>
-#include <QNetworkInterface>
-#include <QTimer>
 #include <QtDBus/QtDBus>
 
-#include "core/utils/networkUtilities.h"
 #include "leakdetector.h"
 #include "logger.h"
 
@@ -30,78 +27,24 @@ DnsUtilsLinux::DnsUtilsLinux(QObject* parent) : DnsUtils(parent) {
   logger.debug() << "DnsUtilsLinux created.";
 
   QDBusConnection conn = QDBusConnection::systemBus();
-  auto* watcher = new QDBusServiceWatcher(
-      DBUS_RESOLVE_SERVICE, conn,
-      QDBusServiceWatcher::WatchForRegistration |
-      QDBusServiceWatcher::WatchForUnregistration, this);
-
-  connect(watcher, &QDBusServiceWatcher::serviceRegistered,
-          this, &DnsUtilsLinux::onResolverRegistered);
-  connect(watcher, &QDBusServiceWatcher::serviceUnregistered,
-          this, &DnsUtilsLinux::onResolverUnregistered);
-
-  if (conn.interface()->isServiceRegistered(DBUS_RESOLVE_SERVICE)) {
-    onResolverRegistered();
-  }
-}
-
-void DnsUtilsLinux::onResolverRegistered() {
-  m_resolver.reset(new QDBusInterface(DBUS_RESOLVE_SERVICE, DBUS_RESOLVE_PATH,
-                                      DBUS_RESOLVE_MANAGER,
-                                      QDBusConnection::systemBus()));
-  logger.debug() << "systemd-resolved available, DNS resolver initialized";
-
-  if (m_revertAfterRegister > 0) {
-    logger.debug() << "Calling RevertLink after restart for ifindex" << m_revertAfterRegister;
-    QDBusMessage msg = QDBusMessage::createMethodCall(
-        DBUS_RESOLVE_SERVICE, DBUS_RESOLVE_PATH, DBUS_RESOLVE_MANAGER, "RevertLink");
-    msg.setArguments({QVariant::fromValue(m_revertAfterRegister)});
-    QDBusPendingReply<> reply = QDBusConnection::systemBus().asyncCall(msg, 5000);
-    int savedIdx = m_revertAfterRegister;
-    m_revertAfterRegister = 0;
-    QDBusPendingCallWatcher* watcher = new QDBusPendingCallWatcher(reply, this);
-    QObject::connect(watcher, &QDBusPendingCallWatcher::finished, this,
-                     [this, savedIdx](QDBusPendingCallWatcher* w) {
-                       QDBusPendingReply<> r = *w;
-                       if (r.isError()) {
-                         logger.debug() << "RevertLink after restart failed for ifindex" << savedIdx
-                                        << ":" << r.error().message();
-                       } else {
-                         logger.debug() << "RevertLink after restart succeeded for ifindex" << savedIdx;
-                       }
-                       w->deleteLater();
-                     });
-  }
-
-  if (!m_pendingIfname.isEmpty()) {
-    logger.debug() << "Re-applying DNS configuration for" << m_pendingIfname;
-    updateResolvers(m_pendingIfname, m_pendingResolvers);
-  }
-}
-
-void DnsUtilsLinux::onResolverUnregistered() {
-  logger.debug() << "systemd-resolved disappeared, dropping DNS resolver";
-  m_resolver.reset();
+  m_resolver = new QDBusInterface(DBUS_RESOLVE_SERVICE, DBUS_RESOLVE_PATH,
+                                  DBUS_RESOLVE_MANAGER, conn, this);
 }
 
 DnsUtilsLinux::~DnsUtilsLinux() {
   MZ_COUNT_DTOR(DnsUtilsLinux);
 
-  if (m_revertOnDestroy && m_resolver) {
-    if (m_gatewayIfindex > 0)
-      setLinkDefaultRoute(m_gatewayIfindex, true);
+  for (auto iterator = m_linkDomains.constBegin();
+       iterator != m_linkDomains.constEnd(); ++iterator) {
+    QList<QVariant> argumentList;
+    argumentList << QVariant::fromValue(iterator.key());
+    argumentList << QVariant::fromValue(iterator.value());
+    m_resolver->asyncCallWithArgumentList(QStringLiteral("SetLinkDomains"),
+                                          argumentList);
+  }
 
-    for (auto iterator = m_linkDomains.constBegin();
-         iterator != m_linkDomains.constEnd(); ++iterator) {
-      QList<QVariant> argumentList;
-      argumentList << QVariant::fromValue(iterator.key());
-      argumentList << QVariant::fromValue(iterator.value());
-      m_resolver->asyncCallWithArgumentList(QStringLiteral("SetLinkDomains"),
-                                            argumentList);
-    }
-    if (m_ifindex > 0) {
-      m_resolver->asyncCall(QStringLiteral("RevertLink"), m_ifindex);
-    }
+  if (m_ifindex > 0) {
+    m_resolver->asyncCall(QStringLiteral("RevertLink"), m_ifindex);
   }
 
   logger.debug() << "DnsUtilsLinux destroyed.";
@@ -109,37 +52,12 @@ DnsUtilsLinux::~DnsUtilsLinux() {
 
 bool DnsUtilsLinux::updateResolvers(const QString& ifname,
                                     const QList<QHostAddress>& resolvers) {
-  m_revertAfterRegister = 0;
-
-  if (m_gatewayIfindex > 0) {
-    setLinkDefaultRoute(m_gatewayIfindex, true);
-    m_gatewayIfindex = 0;
-  }
-
   m_ifindex = if_nametoindex(qPrintable(ifname));
   if (m_ifindex <= 0) {
     logger.error() << "Unable to resolve ifindex for" << ifname;
     return false;
   }
 
-  // Reset retry counter only when called externally (not from scheduleRetry)
-  if (ifname != m_pendingIfname || resolvers != m_pendingResolvers)
-    m_domainRetries = 0;
-
-  m_pendingIfname = ifname;
-  m_pendingResolvers = resolvers;
-
-  if (!m_resolver) {
-    logger.debug() << "systemd-resolved not ready, queuing DNS configuration";
-    return true;
-  }
-
-  const int gwIdx = NetworkUtilities::getGatewayAndIface().second.index();
-  if (gwIdx > 0 && gwIdx != m_ifindex && gwIdx != m_gatewayIfindex) {
-    m_gatewayIfindex = gwIdx;
-    setLinkDefaultRoute(gwIdx, false);
-  }
-
   setLinkDNS(m_ifindex, resolvers);
   setLinkDefaultRoute(m_ifindex, true);
   updateLinkDomains();
@@ -147,54 +65,38 @@ bool DnsUtilsLinux::updateResolvers(const QString& ifname,
 }
 
 bool DnsUtilsLinux::restoreResolvers() {
-  m_revertOnDestroy = true;
-  m_pendingIfname.clear();
-  m_pendingResolvers.clear();
-
-  if (m_gatewayIfindex > 0) {
-    setLinkDefaultRoute(m_gatewayIfindex, true);
-    m_gatewayIfindex = 0;
-  }
-
   for (auto iterator = m_linkDomains.constBegin();
        iterator != m_linkDomains.constEnd(); ++iterator) {
     setLinkDomains(iterator.key(), iterator.value());
   }
   m_linkDomains.clear();
 
+  /* Revert the VPN interface's DNS configuration */
   if (m_ifindex > 0) {
-    m_revertAfterRegister = m_ifindex;
+    QList<QVariant> argumentList = {QVariant::fromValue(m_ifindex)};
+    QDBusPendingReply<> reply = m_resolver->asyncCallWithArgumentList(
+        QStringLiteral("RevertLink"), argumentList);
+
+    QDBusPendingCallWatcher* watcher = new QDBusPendingCallWatcher(reply, this);
+    QObject::connect(watcher, SIGNAL(finished(QDBusPendingCallWatcher*)), this,
+                     SLOT(dnsCallCompleted(QDBusPendingCallWatcher*)));
+
     m_ifindex = 0;
   }
 
   return true;
 }
 
-void DnsUtilsLinux::scheduleRetry() {
-  if (m_pendingIfname.isEmpty() || m_retryPending || m_domainRetries >= 5)
-    return;
-  m_retryPending = true;
-  ++m_domainRetries;
-  logger.debug() << "Retrying full DNS setup (" << m_domainRetries << "/5)";
-  QTimer::singleShot(1000, this, [this]() {
-    m_retryPending = false;
-    if (!m_pendingIfname.isEmpty())
-      updateResolvers(m_pendingIfname, m_pendingResolvers);
-  });
-}
-
 void DnsUtilsLinux::dnsCallCompleted(QDBusPendingCallWatcher* call) {
   QDBusPendingReply<> reply = *call;
   if (reply.isError()) {
-    logger.debug() << "DBus call failed (may be transient after systemd-resolved restart)";
-    scheduleRetry();
+    logger.error() << "Error received from the DBus service";
   }
   delete call;
 }
 
 void DnsUtilsLinux::setLinkDNS(int ifindex,
                                const QList<QHostAddress>& resolvers) {
-  if (!m_resolver) return;
   QList<DnsResolver> resolverList;
   char ifnamebuf[IF_NAMESIZE];
   const char* ifname = if_indextoname(ifindex, ifnamebuf);
@@ -209,10 +111,8 @@ void DnsUtilsLinux::setLinkDNS(int ifindex,
   QList<QVariant> argumentList;
   argumentList << QVariant::fromValue(ifindex);
   argumentList << QVariant::fromValue(resolverList);
-  QDBusMessage msg = QDBusMessage::createMethodCall(
-      DBUS_RESOLVE_SERVICE, DBUS_RESOLVE_PATH, DBUS_RESOLVE_MANAGER, "SetLinkDNS");
-  msg.setArguments(argumentList);
-  QDBusPendingReply<> reply = QDBusConnection::systemBus().asyncCall(msg, 5000);
+  QDBusPendingReply<> reply = m_resolver->asyncCallWithArgumentList(
+      QStringLiteral("SetLinkDNS"), argumentList);
 
   QDBusPendingCallWatcher* watcher = new QDBusPendingCallWatcher(reply, this);
   QObject::connect(watcher, SIGNAL(finished(QDBusPendingCallWatcher*)), this,
@@ -221,7 +121,6 @@ void DnsUtilsLinux::setLinkDNS(int ifindex,
 
 void DnsUtilsLinux::setLinkDomains(int ifindex,
                                    const QList<DnsLinkDomain>& domains) {
-  if (!m_resolver) return;
   char ifnamebuf[IF_NAMESIZE];
   const char* ifname = if_indextoname(ifindex, ifnamebuf);
   if (ifname) {
@@ -236,10 +135,8 @@ void DnsUtilsLinux::setLinkDomains(int ifindex,
   QList<QVariant> argumentList;
   argumentList << QVariant::fromValue(ifindex);
   argumentList << QVariant::fromValue(domains);
-  QDBusMessage msg = QDBusMessage::createMethodCall(
-      DBUS_RESOLVE_SERVICE, DBUS_RESOLVE_PATH, DBUS_RESOLVE_MANAGER, "SetLinkDomains");
-  msg.setArguments(argumentList);
-  QDBusPendingReply<> reply = QDBusConnection::systemBus().asyncCall(msg, 5000);
+  QDBusPendingReply<> reply = m_resolver->asyncCallWithArgumentList(
+      QStringLiteral("SetLinkDomains"), argumentList);
 
   QDBusPendingCallWatcher* watcher = new QDBusPendingCallWatcher(reply, this);
   QObject::connect(watcher, SIGNAL(finished(QDBusPendingCallWatcher*)), this,
@@ -247,14 +144,11 @@ void DnsUtilsLinux::setLinkDomains(int ifindex,
 }
 
 void DnsUtilsLinux::setLinkDefaultRoute(int ifindex, bool enable) {
-  if (!m_resolver) return;
   QList<QVariant> argumentList;
   argumentList << QVariant::fromValue(ifindex);
   argumentList << QVariant::fromValue(enable);
-  QDBusMessage msg = QDBusMessage::createMethodCall(
-      DBUS_RESOLVE_SERVICE, DBUS_RESOLVE_PATH, DBUS_RESOLVE_MANAGER, "SetLinkDefaultRoute");
-  msg.setArguments(argumentList);
-  QDBusPendingReply<> reply = QDBusConnection::systemBus().asyncCall(msg, 5000);
+  QDBusPendingReply<> reply = m_resolver->asyncCallWithArgumentList(
+      QStringLiteral("SetLinkDefaultRoute"), argumentList);
 
   QDBusPendingCallWatcher* watcher = new QDBusPendingCallWatcher(reply, this);
   QObject::connect(watcher, SIGNAL(finished(QDBusPendingCallWatcher*)), this,
@@ -262,7 +156,6 @@ void DnsUtilsLinux::setLinkDefaultRoute(int ifindex, bool enable) {
 }
 
 void DnsUtilsLinux::updateLinkDomains() {
-  if (!m_resolver) return;
   /* Get the list of search domains, and remove any others that might conspire
    * to satisfy DNS resolution. Unfortunately, this is a pain because Qt doesn't
    * seem to be able to demarshall complex property types.
@@ -272,7 +165,7 @@ void DnsUtilsLinux::updateLinkDomains() {
   message << QString(DBUS_RESOLVE_MANAGER);
   message << QString("Domains");
   QDBusPendingReply<QVariant> reply =
-      m_resolver->connection().asyncCall(message, 5000);
+      m_resolver->connection().asyncCall(message);
 
   QDBusPendingCallWatcher* watcher = new QDBusPendingCallWatcher(reply, this);
   QObject::connect(watcher, SIGNAL(finished(QDBusPendingCallWatcher*)), this,
@@ -281,13 +174,11 @@ void DnsUtilsLinux::updateLinkDomains() {
 
 void DnsUtilsLinux::dnsDomainsReceived(QDBusPendingCallWatcher* call) {
   QDBusPendingReply<QVariant> reply = *call;
-  call->deleteLater();
   if (reply.isError()) {
-    logger.debug() << "DBus Domains call failed (may be transient after systemd-resolved restart)";
-    scheduleRetry();
+    logger.error() << "Error retrieving the DNS  domains from the DBus service";
+    delete call;
     return;
   }
-  m_domainRetries = 0;
 
   /* Update the state of the DNS domains */
   m_linkDomains.clear();
@@ -313,17 +204,9 @@ void DnsUtilsLinux::dnsDomainsReceived(QDBusPendingCallWatcher* call) {
   }
 
   /* Add a root search domain for the new interface. */
-  if (m_ifindex > 0) {
-    setLinkDomains(m_ifindex, {root});
-
-    /* Disable DefaultRoute on the physical gateway so systemd-resolved
-     * routes all DNS through the VPN interface. */
-    const int gwIdx = NetworkUtilities::getGatewayAndIface().second.index();
-    if (gwIdx > 0 && gwIdx != m_ifindex && gwIdx != m_gatewayIfindex) {
-      m_gatewayIfindex = gwIdx;
-      setLinkDefaultRoute(gwIdx, false);
-    }
-  }
+  QList<DnsLinkDomain> newlist = {root};
+  setLinkDomains(m_ifindex, newlist);
+  delete call;
 }
 
 static DnsMetatypeRegistrationProxy s_dnsMetatypeProxy;

client/platforms/linux/daemon/dnsutilslinux.h

@@ -6,12 +6,7 @@
 #define DNSUTILSLINUX_H
 
 #include <QDBusInterface>
-#include <QScopedPointer>
 #include <QDBusPendingCallWatcher>
-#include <QDBusServiceWatcher>
-#include <QHostAddress>
-#include <QList>
-#include <QString>
 
 #include "daemon/dnsutils.h"
 #include "dbustypeslinux.h"
@@ -34,25 +29,13 @@ class DnsUtilsLinux final : public DnsUtils {
   void updateLinkDomains();
 
  private slots:
-  void onResolverRegistered();
-  void onResolverUnregistered();
   void dnsCallCompleted(QDBusPendingCallWatcher*);
   void dnsDomainsReceived(QDBusPendingCallWatcher*);
 
- private:
-  void scheduleRetry();
-
  private:
   int m_ifindex = 0;
-  int m_gatewayIfindex = 0;
-  int m_domainRetries = 0;
-  bool m_revertOnDestroy = false;
-  bool m_retryPending = false;
-  int m_revertAfterRegister = 0;
   QMap<int, DnsLinkDomainList> m_linkDomains;
-  QScopedPointer<QDBusInterface> m_resolver;
-  QString m_pendingIfname;
-  QList<QHostAddress> m_pendingResolvers;
+  QDBusInterface* m_resolver = nullptr;
 };
 
 #endif  // DNSUTILSLINUX_H

client/platforms/linux/daemon/linuxfirewall.cpp

@@ -33,7 +33,6 @@
 #include "linuxfirewall.h"
 #include "logger.h"
 #include "xray_defs.h"
-#include <QFileInfo>
 #include <QProcess>
 
 #define BRAND_CODE "amn"
@@ -103,7 +102,14 @@ int LinuxFirewall::linkChain(LinuxFirewall::IPVersion ip, const QString& chain,
     const QString cmd = getCommand(ip);
     if (mustBeFirst)
     {
-        return execute(QStringLiteral("if ! %1 -L %2 -n --line-numbers -t %4 2> /dev/null | awk 'int($1) == 1 && $2 == \"%3\" { found=1 } END { if(found==1) { exit 0 } else { exit 1 } }' ; then %1 -I %2 -j %3 -t %4 && %1 -L %2 -n --line-numbers -t %4 2> /dev/null | awk 'int($1) > 1 && $2 == \"%3\" { print $1; exit }' | xargs -r %1 -t %4 -D %2 ; fi").arg(cmd, parent, chain, tableName));
+        // This monster shell script does the following:
+        // 1. Check if a rule with the appropriate target exists at the top of the parent chain
+        // 2. If not, insert a jump rule at the top of the parent chain
+        // 3. Look for and delete a single rule with the designated target at an index > 1
+        //    (we can't safely delete all rules at once since rule numbers change)
+        // TODO: occasionally this script results in warnings in logs "Bad rule (does a matching rule exist in the chain?)" - this happens when
+        // the e.g OUTPUT chain is empty but this script attempts to delete things from it anyway. It doesn't cause any problems, but we should still fix at some point..
+        return execute(QStringLiteral("if ! %1 -L %2 -n --line-numbers -t %4 2> /dev/null | awk 'int($1) == 1 && $2 == \"%3\" { found=1 } END { if(found==1) { exit 0 } else { exit 1 } }' ; then %1 -I %2 -j %3 -t %4 && %1 -L %2 -n --line-numbers -t %4 2> /dev/null | awk 'int($1) > 1 && $2 == \"%3\" { print $1; exit }' | xargs %1 -t %4 -D %2 ; fi").arg(cmd, parent, chain, tableName));
     }
     else
         return execute(QStringLiteral("if ! %1 -C %2 -j %3 -t %4 2> /dev/null ; then %1 -A %2 -j %3 -t %4; fi").arg(cmd, parent, chain, tableName));
@@ -285,8 +291,6 @@ void LinuxFirewall::install()
 
     installAnchor(IPv4, QStringLiteral("110.allowNets"), {});
 
-    installAnchor(Both, QStringLiteral("400.allowPIA"), {});
-
     installAnchor(Both, QStringLiteral("100.blockAll"), {
                                                             QStringLiteral("-j REJECT"),
                                                         });
@@ -450,33 +454,16 @@ void LinuxFirewall::updateDNSServers(const QStringList& servers)
     static QStringList existingServers {};
 
     existingServers = servers;
-    const QString chain = QStringLiteral("%1.320.allowDNS").arg(kAnchorName);
-    executeIptables(QStringLiteral("iptables"), {QStringLiteral("-F"), chain});
-    const QStringList ifaces = {
-        QStringLiteral("amn0+"), QStringLiteral("tun0+"), QStringLiteral("tun2+")
-    };
-    for (const QString& server : servers) {
-        for (const QString& iface : ifaces) {
-            executeIptables(QStringLiteral("iptables"),
-                {QStringLiteral("-A"), chain, QStringLiteral("-o"), iface,
-                 QStringLiteral("-d"), server, QStringLiteral("-p"), QStringLiteral("udp"),
-                 QStringLiteral("--dport"), QStringLiteral("53"), QStringLiteral("-j"), QStringLiteral("ACCEPT")});
-            executeIptables(QStringLiteral("iptables"),
-                {QStringLiteral("-A"), chain, QStringLiteral("-o"), iface,
-                 QStringLiteral("-d"), server, QStringLiteral("-p"), QStringLiteral("tcp"),
-                 QStringLiteral("--dport"), QStringLiteral("53"), QStringLiteral("-j"), QStringLiteral("ACCEPT")});
-        }
-    }
+    execute(QStringLiteral("iptables -F %1.320.allowDNS").arg(kAnchorName));
+    for (const QString& rule : getDNSRules(servers))
+        execute(QStringLiteral("iptables -A %1.320.allowDNS %2").arg(kAnchorName, rule));
 }
 
 void LinuxFirewall::updateAllowNets(const QStringList& servers)
 {
-    const QString chain = QStringLiteral("%1.110.allowNets").arg(kAnchorName);
-    executeIptables(QStringLiteral("iptables"), {QStringLiteral("-F"), chain});
-    for (const QString& server : servers)
-        executeIptables(QStringLiteral("iptables"),
-            {QStringLiteral("-A"), chain, QStringLiteral("-d"), server,
-             QStringLiteral("-j"), QStringLiteral("ACCEPT")});
+    execute(QStringLiteral("iptables -F %1.110.allowNets").arg(kAnchorName));
+    for (const QString& rule : getAllowRule(servers))
+        execute(QStringLiteral("iptables -A %1.110.allowNets %2").arg(kAnchorName, rule));
 }
 
 void LinuxFirewall::updateBlockNets(const QStringList& servers)
@@ -484,12 +471,9 @@ void LinuxFirewall::updateBlockNets(const QStringList& servers)
     static QStringList existingServers {};
 
     existingServers = servers;
-    const QString chain = QStringLiteral("%1.120.blockNets").arg(kAnchorName);
-    executeIptables(QStringLiteral("iptables"), {QStringLiteral("-F"), chain});
-    for (const QString& server : servers)
-        executeIptables(QStringLiteral("iptables"),
-            {QStringLiteral("-A"), chain, QStringLiteral("-d"), server,
-             QStringLiteral("-j"), QStringLiteral("REJECT")});
+    execute(QStringLiteral("iptables -F %1.120.blockNets").arg(kAnchorName));
+    for (const QString& rule : getBlockRule(servers))
+        execute(QStringLiteral("iptables -A %1.120.blockNets %2").arg(kAnchorName, rule));
 }
 
 int waitForExitCode(QProcess& process)
@@ -522,39 +506,10 @@ int LinuxFirewall::execute(const QString &command, bool ignoreErrors)
     return exitCode;
 }
 
-int LinuxFirewall::executeIptables(const QString &program, const QStringList &args, bool ignoreErrors)
-{
-    QProcess p;
-    p.start(program, args, QProcess::ReadOnly);
-    p.closeWriteChannel();
-
-    int exitCode = waitForExitCode(p);
-    auto out = p.readAllStandardOutput().trimmed();
-    auto err = p.readAllStandardError().trimmed();
-    if ((exitCode != 0 || !err.isEmpty()) && !ignoreErrors)
-        logger.warning() << "(" << exitCode << ") $ " << program << args.join(QLatin1Char(' '));
-    if (!out.isEmpty())
-        logger.info() << out;
-    if (!err.isEmpty())
-        logger.warning() << err;
-    return exitCode;
-}
-
 void LinuxFirewall::setupTrafficSplitting()
 {
-    const QString cgroupBase = QStringLiteral("/sys/fs/cgroup/net_cls");
-    if (!QFileInfo::exists(cgroupBase)) {
-        logger.warning() << "net_cls cgroup v1 not available, traffic splitting disabled";
-        return;
-    }
-
-    execute(QStringLiteral(
-        "if ! grep -qE '^[0-9]+[[:space:]]+%1$' /etc/iproute2/rt_tables 2>/dev/null ; then "
-        "echo '200 %1' >> /etc/iproute2/rt_tables ; fi"
-    ).arg(kRtableName));
-
     auto cGroupDir = "/sys/fs/cgroup/net_cls/" BRAND_CODE "vpnexclusions/";
-    logger.info() << "Setting up cgroup in" << cGroupDir << "for traffic splitting";
+    logger.info() << "Should be setting up cgroup in" << cGroupDir << "for traffic splitting";
     execute(QStringLiteral("if [ ! -d %1 ] ; then mkdir %1 ; sleep 0.1 ; echo %2 > %1/net_cls.classid ; fi").arg(cGroupDir).arg(kCGroupId));
     // Set a rule with priority 100 (lower priority than local but higher than main/default, 0 is highest priority)
     execute(QStringLiteral("if ! ip rule list | grep -q %1 ; then ip rule add from all fwmark %1 lookup %2 pri 100 ; fi").arg(kPacketTag, kRtableName));
@@ -563,7 +518,7 @@ void LinuxFirewall::setupTrafficSplitting()
 void LinuxFirewall::teardownTrafficSplitting()
 {
     logger.info() << "Tearing down cgroup and routing rules";
-    execute(QStringLiteral("if ip rule list | grep -q %1; then ip rule del from all fwmark %1 lookup %2 2>/dev/null ; fi").arg(kPacketTag, kRtableName));
-    execute(QStringLiteral("ip route flush table %1 2>/dev/null || true").arg(kRtableName));
+    execute(QStringLiteral("if ip rule list | grep -q %1; then ip rule del from all fwmark %1 lookup %2 2> /dev/null ; fi").arg(kPacketTag, kRtableName));
+    execute(QStringLiteral("ip route flush table %1").arg(kRtableName));
     execute(QStringLiteral("ip route flush cache"));
 }

client/platforms/linux/daemon/linuxfirewall.h

@@ -85,7 +85,6 @@ private:
     static void setupTrafficSplitting();
     static void teardownTrafficSplitting();
     static int execute(const QString& command, bool ignoreErrors = false);
-    static int executeIptables(const QString& program, const QStringList& args, bool ignoreErrors = false);
 private:
     // Chain names
     static QString kOutputChain, kRootChain, kPostRoutingChain, kPreRoutingChain;

client/platforms/linux/daemon/wireguardutilslinux.cpp

@@ -237,11 +237,7 @@ bool WireguardUtilsLinux::updatePeer(const InterfaceConfig& config) {
     // Exclude the server address, except for multihop exit servers.
     if ((config.m_hopType != InterfaceConfig::MultiHopExit) &&
         (m_rtmonitor != nullptr)) {
-        if (!config.m_serverIpv4AddrIn.isEmpty() &&
-            !m_rtmonitor->addExclusionRoute(IPAddress(config.m_serverIpv4AddrIn))) {
-            logger.error() << "No gateway — cannot add server exclusion route";
-            return false;
-        }
+        m_rtmonitor->addExclusionRoute(IPAddress(config.m_serverIpv4AddrIn));
         m_rtmonitor->addExclusionRoute(IPAddress(config.m_serverIpv6AddrIn));
     }
 

client/ui/controllers/qml/pageController.h

@@ -45,6 +45,8 @@ namespace PageLoader
         PageSettingsApiDevices,
         PageSettingsApiSubscriptionKey,
         PageSettingsKillSwitchExceptions,
+        PageSettingsConnectionType,
+        PageSettingsLocalProxy,
 
         PageServiceSftpSettings,
         PageServiceTorWebsiteSettings,

client/ui/controllers/settingsUiController.cpp

@@ -37,6 +37,11 @@ SettingsUiController::SettingsUiController(SettingsController* settingsControlle
     if (m_settingsController->isDevGatewayEnv()) {
         m_settingsController->enableDevMode();
     }
+
+    connect(m_settingsController, &SettingsController::localProxySettingsUpdated, this,
+            &SettingsUiController::localProxySettingsUpdated);
+    connect(m_settingsController, &SettingsController::localProxyStartFailed, this,
+            &SettingsUiController::localProxyStartFailed);
 }
 
 void SettingsUiController::toggleAmneziaDns(bool enable)
@@ -358,3 +363,53 @@ void SettingsUiController::disableHomeAdLabel()
     m_settingsController->disableHomeAdLabel();
     emit isHomeAdLabelVisibleChanged(false);
 }
+
+bool SettingsUiController::isLocalProxySupported() const
+{
+    return m_settingsController->isLocalProxySupported();
+}
+
+bool SettingsUiController::isLocalProxyHttpEnabled() const
+{
+    return m_settingsController->isLocalProxyHttpEnabled();
+}
+
+int SettingsUiController::localProxyPort() const
+{
+    return m_settingsController->localProxyPort();
+}
+
+QString SettingsUiController::localProxyOwnerId() const
+{
+    return m_settingsController->localProxyOwnerId();
+}
+
+bool SettingsUiController::setLocalProxyPort(int port)
+{
+    return m_settingsController->setLocalProxyPort(port);
+}
+
+bool SettingsUiController::isLocalProxyPortBusy(int port) const
+{
+    return m_settingsController->isLocalProxyPortBusy(port);
+}
+
+bool SettingsUiController::isLocalProxyPortUserDefined() const
+{
+    return m_settingsController->isLocalProxyPortUserDefined();
+}
+
+int SettingsUiController::findFirstAvailableLocalProxyPort(int startPort) const
+{
+    return m_settingsController->findFirstAvailableLocalProxyPort(startPort);
+}
+
+bool SettingsUiController::enableLocalProxy(const QString &ownerId, int port)
+{
+    return m_settingsController->enableLocalProxy(ownerId, port);
+}
+
+void SettingsUiController::disableLocalProxy()
+{
+    m_settingsController->disableLocalProxy();
+}

client/ui/controllers/settingsUiController.h

@@ -31,6 +31,10 @@ public:
     Q_PROPERTY(bool isHomeAdLabelVisible READ isHomeAdLabelVisible NOTIFY isHomeAdLabelVisibleChanged)
     Q_PROPERTY(bool autoStartEnabled READ isAutoStartEnabled NOTIFY autoStartChanged)
     Q_PROPERTY(bool startMinimized READ isStartMinimizedEnabled NOTIFY startMinimizedChanged)
+    Q_PROPERTY(bool isLocalProxySupported READ isLocalProxySupported CONSTANT)
+    Q_PROPERTY(bool isLocalProxyHttpEnabled READ isLocalProxyHttpEnabled NOTIFY localProxySettingsUpdated)
+    Q_PROPERTY(int localProxyPort READ localProxyPort WRITE setLocalProxyPort NOTIFY localProxySettingsUpdated)
+    Q_PROPERTY(QString localProxyOwnerId READ localProxyOwnerId NOTIFY localProxySettingsUpdated)
 
 public slots:
     void toggleAmneziaDns(bool enable);
@@ -101,6 +105,17 @@ public slots:
     bool isHomeAdLabelVisible();
     void disableHomeAdLabel();
 
+    bool isLocalProxySupported() const;
+    bool isLocalProxyHttpEnabled() const;
+    int localProxyPort() const;
+    QString localProxyOwnerId() const;
+    bool setLocalProxyPort(int port);
+    bool isLocalProxyPortBusy(int port) const;
+    bool isLocalProxyPortUserDefined() const;
+    int findFirstAvailableLocalProxyPort(int startPort) const;
+    bool enableLocalProxy(const QString &ownerId, int port);
+    void disableLocalProxy();
+
 signals:
     void primaryDnsChanged();
     void secondaryDnsChanged();
@@ -135,6 +150,8 @@ signals:
     void isHomeAdLabelVisibleChanged(bool visible);
     void autoStartChanged();
     void startMinimizedChanged();
+    void localProxySettingsUpdated();
+    void localProxyStartFailed(const QString &message);
 
 private:
     SettingsController* m_settingsController;

client/ui/models/serversModel.cpp

@@ -152,4 +152,3 @@ ServerCredentials ServersModel::serverCredentials(int index) const
     }
     return m_descriptions.at(index).selfHostedSshCredentials;
 }
-

client/ui/models/serversModel.h

@@ -10,6 +10,7 @@
 class ServersModel : public QAbstractListModel
 {
     Q_OBJECT
+
 public:
     enum Roles {
         NameRole = Qt::UserRole + 1,

client/ui/qml/Controls2/BaseHeaderType.qml

@@ -12,6 +12,7 @@ Item {
     property int headerTextMaximumLineCount: 2
     property int headerTextElide: Qt.ElideRight
     property string descriptionText
+    property string descriptionColor: AmneziaStyle.color.mutedGray
     property string descriptionLinkText
     property string descriptionLinkUrl
     property alias headerRow: headerRow
@@ -42,7 +43,7 @@ Item {
             Layout.topMargin: 16
             Layout.fillWidth: true
             text: root.descriptionText
-            color: AmneziaStyle.color.mutedGray
+            color: root.descriptionColor
             visible: root.descriptionText !== ""
         }
 

client/ui/qml/Controls2/TextFieldWithHeaderType.qml

@@ -15,6 +15,7 @@ Item {
     property string headerTextColor: AmneziaStyle.color.mutedGray
 
     property alias errorText: errorField.text
+    property bool clearErrorOnTextChanged: true
     property bool checkEmptyText: false
     property bool rightButtonClickedOnEnter: false
 
@@ -135,7 +136,9 @@ Item {
                         }
 
                         onTextChanged: {
-                            root.errorText = ""
+                            if (root.clearErrorOnTextChanged) {
+                                root.errorText = ""
+                            }
                         }
 
                         onActiveFocusChanged: {

client/ui/qml/Pages2/PageSettingsApiServerInfo.qml

@@ -320,11 +320,27 @@ PageType {
             }
 
             LabelWithButtonType {
-                id: vpnKey
+                id: connectionSwitcher
 
                 Layout.fillWidth: true
                 Layout.topMargin: warning.visible ? 16 : 0
+                text: qsTr("Connection")
+                descriptionText: SettingsController.isLocalProxySupported
+                                  ? qsTr("Protocol selection and local proxy setup")
+                                  : qsTr("Protocol selection")
+                rightImageSource: "qrc:/images/controls/chevron-right.svg"
 
+                clickedFunction: function() {
+                    PageController.goToPage(PageEnum.PageSettingsConnectionType)
+                }
+            }
+
+            DividerType {}
+
+            LabelWithButtonType {
+                id: vpnKey
+
+                Layout.fillWidth: true
                 visible: footer.isVisibleForAmneziaFree
 
                 text: qsTr("Subscription Key")

client/ui/qml/Pages2/PageSettingsConnectionType.qml

@@ -0,0 +1,98 @@
+import QtQuick
+import QtQuick.Controls
+import QtQuick.Layouts
+
+import PageEnum 1.0
+import Style 1.0
+
+import "./"
+import "../Controls2"
+import "../Config"
+
+PageType {
+    id: root
+
+    BackButtonType {
+        id: backButton
+
+        anchors.top: parent.top
+        anchors.left: parent.left
+        anchors.right: parent.right
+        anchors.topMargin: 20 + PageController.safeAreaTopMargin
+
+        onActiveFocusChanged: {
+            if(backButton.enabled && backButton.activeFocus) {
+                listView.positionViewAtBeginning()
+            }
+        }
+    }
+
+    ListViewType {
+        id: listView
+
+        anchors.top: backButton.bottom
+        anchors.bottom: parent.bottom
+        anchors.left: parent.left
+        anchors.right: parent.right
+
+        header: ColumnLayout {
+            width: listView.width
+
+            BaseHeaderType {
+                Layout.fillWidth: true
+                Layout.leftMargin: 16
+                Layout.rightMargin: 16
+
+                headerText: qsTr("Connection")
+            }
+        }
+
+        model: 1
+
+        delegate: ColumnLayout {
+            width: listView.width
+
+            LabelWithButtonType {
+                id: vpnProtocolButton
+
+                Layout.fillWidth: true
+                Layout.topMargin: 16
+                Layout.leftMargin: 16
+                Layout.rightMargin: 16
+
+                text: qsTr("VPN protocol")
+                rightImageSource: "qrc:/images/controls/chevron-right.svg"
+
+                clickedFunction: function() {
+                    PageController.goToPage(PageEnum.PageSettingsServerProtocols)
+                }
+            }
+
+            DividerType {}
+
+            LabelWithButtonType {
+                id: localProxyButton
+
+                Layout.fillWidth: true
+                Layout.leftMargin: 16
+                Layout.rightMargin: 16
+                visible: SettingsController.isLocalProxySupported && ServersUiController.processedServerIsPremium
+                Layout.preferredHeight: visible ? implicitHeight : 0
+
+                text: qsTr("Local proxy")
+                descriptionText: SettingsController.isLocalProxyHttpEnabled ? qsTr("Running: 127.0.0.1:%1").arg(SettingsController.localProxyPort || 0)
+                                                                            : qsTr("Off")
+                rightImageSource: "qrc:/images/controls/chevron-right.svg"
+
+                clickedFunction: function() {
+                    PageController.goToPage(PageEnum.PageSettingsLocalProxy)
+                }
+            }
+
+            DividerType {
+                visible: SettingsController.isLocalProxySupported
+                Layout.preferredHeight: visible ? implicitHeight : 0
+            }
+        }
+    }
+}

client/ui/qml/Pages2/PageSettingsLocalProxy.qml

@@ -0,0 +1,426 @@
+import QtQuick
+import QtQuick.Controls
+import QtQuick.Layouts
+
+import PageEnum 1.0
+import Style 1.0
+
+import "./"
+import "../Controls2"
+import "../Controls2/TextTypes"
+import "../Config"
+
+PageType {
+    id: root
+
+    readonly property int localProxyPortMin: 1024
+    readonly property int localProxyPortMax: 65535
+    readonly property int defaultLocalProxyPort: 10808
+
+    property string portValidationError: ""
+    property int pendingStartRequestedPort: -1
+    property int pendingStartAutoSelectedPort: -1
+    property bool pendingStartVpnWasActive: false
+    property bool pendingEnableAfterVpnDisconnect: false
+    property string pendingEnableServerId: ""
+    property int pendingEnableRequestedPort: -1
+    property int pendingEnableAutoSelectedPort: -1
+    property int pendingEnablePortToUse: -1
+
+    function clearPendingEnableAfterVpnDisconnect() {
+        root.pendingEnableAfterVpnDisconnect = false
+        root.pendingEnableServerId = ""
+        root.pendingEnableRequestedPort = -1
+        root.pendingEnableAutoSelectedPort = -1
+        root.pendingEnablePortToUse = -1
+    }
+
+    function enableLocalProxyNow(serverId, requestedPort, autoSelectedPort, portToEnable, vpnWasActive) {
+        if (!SettingsController.enableLocalProxy(serverId, portToEnable)) {
+            PageController.showNotificationMessage(qsTr("Failed to enable local proxy. Check the port (%1-%2).")
+                .arg(root.localProxyPortMin)
+                .arg(root.localProxyPortMax))
+            return false
+        }
+
+        root.pendingStartRequestedPort = requestedPort
+        root.pendingStartAutoSelectedPort = autoSelectedPort
+        root.pendingStartVpnWasActive = vpnWasActive
+        startSuccessToastTimer.restart()
+        return true
+    }
+
+    function getPortField() {
+        var item = listView.itemAtIndex(0)
+        return item !== null ? item.children[0] : null
+    }
+
+    function computePortErrorText() {
+        var portField = getPortField()
+        if (portField === null) return ""
+        const text = portField.textField.text.trim()
+        if (text === "") {
+            return qsTr("Enter a port")
+        }
+        const value = parseInt(text)
+        if (isNaN(value) || value < root.localProxyPortMin || value > root.localProxyPortMax) {
+            return qsTr("Port must be between %1 and %2")
+                .arg(root.localProxyPortMin)
+                .arg(root.localProxyPortMax)
+        }
+        if (SettingsController.isLocalProxyPortBusy(value)) {
+            return qsTr("Port %1 is already in use on this device. Choose another one")
+                .arg(value)
+        }
+        return ""
+    }
+
+    function handleLocalProxyToggle(checked) {
+        if (checked) {
+            if (!ServersUiController.processedServerIsPremium) {
+                PageController.showNotificationMessage(qsTr("Local proxy is available only for Amnezia Premium"))
+                return
+            }
+            const wasVpnActive = ConnectionController.isConnected || ConnectionController.isConnectionInProgress
+
+            let serverId = ServersUiController.processedServerId
+            if (!serverId) {
+                serverId = ServersUiController.defaultServerId
+            }
+            if (!serverId) {
+                PageController.showNotificationMessage(qsTr("Unable to determine the current server"))
+                return
+            }
+
+            if (SettingsController.isLocalProxyHttpEnabled
+                    && SettingsController.localProxyOwnerId
+                    && SettingsController.localProxyOwnerId !== serverId) {
+                PageController.showNotificationMessage(qsTr("Local proxy is already enabled for another server"))
+                return
+            }
+
+            const requestedPort = SettingsController.localProxyPort
+            if (requestedPort < root.localProxyPortMin || requestedPort > root.localProxyPortMax) {
+                PageController.showNotificationMessage(qsTr("Port must be between %1 and %2")
+                    .arg(root.localProxyPortMin)
+                    .arg(root.localProxyPortMax))
+                return
+            }
+
+            let autoSelectedPort = -1
+            if (SettingsController.isLocalProxyPortBusy(requestedPort)) {
+                if (SettingsController.isLocalProxyPortUserDefined()
+                        || requestedPort !== root.defaultLocalProxyPort) {
+                    PageController.showNotificationMessage(qsTr("Port %1 is already in use on this device. Choose another one")
+                        .arg(requestedPort))
+                    return
+                }
+
+                autoSelectedPort = SettingsController.findFirstAvailableLocalProxyPort(root.defaultLocalProxyPort + 1)
+                if (autoSelectedPort <= 0) {
+                    PageController.showNotificationMessage(qsTr("Port %1 is already in use on this device. Choose another one")
+                        .arg(requestedPort))
+                    return
+                }
+            }
+
+            const portToEnable = autoSelectedPort > 0 ? autoSelectedPort : requestedPort
+            if (wasVpnActive) {
+                root.pendingEnableAfterVpnDisconnect = true
+                root.pendingEnableServerId = serverId
+                root.pendingEnableRequestedPort = requestedPort
+                root.pendingEnableAutoSelectedPort = autoSelectedPort
+                root.pendingEnablePortToUse = portToEnable
+                ConnectionController.closeConnection()
+                return
+            }
+
+            root.enableLocalProxyNow(serverId, requestedPort, autoSelectedPort, portToEnable, false)
+        } else {
+            startSuccessToastTimer.stop()
+            root.clearPendingEnableAfterVpnDisconnect()
+            root.pendingStartRequestedPort = -1
+            root.pendingStartAutoSelectedPort = -1
+            root.pendingStartVpnWasActive = false
+            SettingsController.disableLocalProxy()
+            PageController.showNotificationMessage(qsTr("Local proxy stopped"))
+        }
+    }
+
+    BackButtonType {
+        id: backButton
+
+        anchors.top: parent.top
+        anchors.left: parent.left
+        anchors.right: parent.right
+        anchors.topMargin: 20 + PageController.safeAreaTopMargin
+
+        onActiveFocusChanged: {
+            if (activeFocus) {
+                listView.positionViewAtBeginning()
+            }
+        }
+    }
+
+    ListViewType {
+        id: listView
+
+        anchors.top: backButton.bottom
+        anchors.bottom: parent.bottom
+        anchors.left: parent.left
+        anchors.right: parent.right
+
+        header: ColumnLayout {
+            width: listView.width
+
+            HeaderTypeWithSwitcher {
+                id: localProxyHeader
+
+                Layout.fillWidth: true
+                Layout.leftMargin: 16
+                Layout.rightMargin: 16
+                headerText: qsTr("Local Proxy")
+                descriptionText: qsTr("Use a proxy to route selected apps (for example, the CensorTracker extension) through Amnezia Premium.")
+                showSwitcher: ServersUiController.processedServerIsPremium
+                switcher {
+                    checked: SettingsController.isLocalProxyHttpEnabled
+                }
+                switcherFunction: function(checked) {
+                    // Ignore UI sync toggles; react only to real state change intent.
+                    if (checked === SettingsController.isLocalProxyHttpEnabled) {
+                        return
+                    }
+                    root.handleLocalProxyToggle(checked)
+                    // Keep checked declaratively linked after any user interaction path.
+                    localProxyHeader.switcher.checked = Qt.binding(function() {
+                        return SettingsController.isLocalProxyHttpEnabled
+                    })
+                }
+            }
+
+            ParagraphTextType {
+                Layout.fillWidth: true
+                Layout.topMargin: 12
+                Layout.leftMargin: 16
+                Layout.rightMargin: 16
+
+                color: localProxyHeader.descriptionColor
+                text: qsTr("Only one can be on at a time: VPN or local proxy.")
+            }
+
+            BasicButtonType {
+                Layout.topMargin: 8
+                Layout.leftMargin: 8
+                Layout.bottomMargin: 28
+                implicitHeight: 32
+
+                defaultColor: AmneziaStyle.color.transparent
+                hoveredColor: AmneziaStyle.color.translucentWhite
+                pressedColor: AmneziaStyle.color.sheerWhite
+                disabledColor: AmneziaStyle.color.mutedGray
+                textColor: AmneziaStyle.color.goldenApricot
+
+                text: qsTr("Learn more")
+                clickedFunc: function() {
+                    const path = LanguageModel.currentLanguageName === "Русский"
+                        ? "ru/documentation/instructions/local-proxy"
+                        : "documentation/instructions/local-proxy"
+                    Qt.openUrlExternally(LanguageModel.getCurrentDocsUrl(path))
+                }
+            }
+        }
+
+        model: 1 // fake model to force the ListView to be created without a model
+
+        delegate: ColumnLayout {
+            width: listView.width
+            spacing: 16
+
+            TextFieldWithHeaderType {
+                id: portField
+
+                Layout.fillWidth: true
+                Layout.leftMargin: 16
+                Layout.rightMargin: 16
+
+                headerText: qsTr("Address and port")
+                buttonText: qsTr("Copy")
+                errorText: root.portValidationError
+                clearErrorOnTextChanged: false
+
+                enabled: true
+                rightButtonClickedOnEnter: false
+
+                clickedFunc: function() {
+                    const portText = portField.effectivePortText()
+                    GC.copyToClipBoard("127.0.0.1:" + portText)
+                    PageController.showNotificationMessage(qsTr("Copied: 127.0.0.1:%1").arg(portText))
+                }
+
+                textField.validator: RegularExpressionValidator {
+                    regularExpression: /^[0-9]{0,5}$/
+                }
+                textField.leftPadding: portPrefix.implicitWidth
+                textField.placeholderText: root.defaultLocalProxyPort.toString()
+                textField.inputMethodHints: Qt.ImhDigitsOnly | Qt.ImhNoPredictiveText
+
+                function syncPortValue() {
+                    const port = SettingsController.localProxyPort
+                    const isValidPort = port >= root.localProxyPortMin && port <= root.localProxyPortMax
+                    textField.text = isValidPort ? port.toString() : ""
+                }
+
+                function portValue() {
+                    const value = parseInt(textField.text)
+                    return isNaN(value) ? -1 : value
+                }
+
+                function effectivePortText() {
+                    const value = portValue()
+                    if (value >= root.localProxyPortMin && value <= root.localProxyPortMax) {
+                        return value.toString()
+                    }
+                    const fallback = SettingsController.localProxyPort
+                    if (fallback >= root.localProxyPortMin && fallback <= root.localProxyPortMax) {
+                        return fallback.toString()
+                    }
+                    return root.defaultLocalProxyPort.toString()
+                }
+
+                Component.onCompleted: syncPortValue()
+
+                textField.onTextChanged: {
+                    if (textField.activeFocus) {
+                        root.portValidationError = ""
+                    }
+                }
+            }
+
+            Text {
+                id: portPrefix
+
+                parent: portField.textField
+                text: "127.0.0.1:"
+                color: AmneziaStyle.color.paleGray
+                font.pixelSize: portField.textField.font.pixelSize
+                font.weight: portField.textField.font.weight
+                font.family: portField.textField.font.family
+                z: 1
+
+                anchors.left: parent.left
+                anchors.verticalCenter: parent.verticalCenter
+            }
+
+            BasicButtonType {
+                Layout.fillWidth: true
+                Layout.leftMargin: 16
+                Layout.rightMargin: 16
+
+                text: qsTr("Save")
+                enabled: true
+
+                clickedFunc: function() {
+                    if (SettingsController.isLocalProxyHttpEnabled) {
+                        PageController.showNotificationMessage(qsTr("Disable Local Proxy to change the port"))
+                        return
+                    }
+                    const validationError = root.computePortErrorText()
+                    root.portValidationError = validationError
+                    if (validationError !== "") {
+                        return
+                    }
+
+                    const value = portField.portValue()
+                    if (!SettingsController.setLocalProxyPort(value)) {
+                        PageController.showNotificationMessage(qsTr("Failed to save port. Valid range: %1-%2")
+                            .arg(root.localProxyPortMin)
+                            .arg(root.localProxyPortMax))
+                    } else {
+                        PageController.showNotificationMessage(qsTr("Port saved: %1").arg(value))
+                    }
+                    portField.syncPortValue()
+                }
+            }
+        }
+    }
+
+    Timer {
+        id: startSuccessToastTimer
+        interval: 250
+        repeat: false
+        running: false
+        onTriggered: {
+            if (!SettingsController.isLocalProxyHttpEnabled) {
+                return
+            }
+
+            if (root.pendingStartAutoSelectedPort > 0) {
+                PageController.showNotificationMessage(qsTr("Port %1 is in use — selected free port %2.")
+                    .arg(root.defaultLocalProxyPort)
+                    .arg(root.pendingStartAutoSelectedPort))
+            } else if (root.pendingStartVpnWasActive && root.pendingStartRequestedPort > 0) {
+                PageController.showNotificationMessage(qsTr("VPN turned off. Local proxy is running: 127.0.0.1:%1")
+                    .arg(root.pendingStartRequestedPort))
+            } else if (root.pendingStartRequestedPort > 0) {
+                PageController.showNotificationMessage(qsTr("Local proxy is running: 127.0.0.1:%1")
+                    .arg(root.pendingStartRequestedPort))
+            }
+
+            root.pendingStartRequestedPort = -1
+            root.pendingStartAutoSelectedPort = -1
+            root.pendingStartVpnWasActive = false
+        }
+    }
+
+    Connections {
+        target: ConnectionController
+
+        function onConnectionStateChanged() {
+            if (!root.pendingEnableAfterVpnDisconnect) {
+                return
+            }
+
+            if (ConnectionController.isConnected || ConnectionController.isConnectionInProgress) {
+                return
+            }
+
+            const serverId = root.pendingEnableServerId
+            const requestedPort = root.pendingEnableRequestedPort
+            const autoSelectedPort = root.pendingEnableAutoSelectedPort
+            const portToEnable = root.pendingEnablePortToUse
+            root.clearPendingEnableAfterVpnDisconnect()
+
+            root.enableLocalProxyNow(serverId, requestedPort, autoSelectedPort, portToEnable, true)
+        }
+    }
+
+    Connections {
+        target: SettingsController
+
+        function onLocalProxySettingsUpdated() {
+            var portField = root.getPortField()
+            if (portField !== null && !portField.textField.activeFocus) {
+                portField.syncPortValue()
+            }
+        }
+
+        function onLocalProxyStartFailed(message) {
+            startSuccessToastTimer.stop()
+            root.pendingStartRequestedPort = -1
+            root.pendingStartAutoSelectedPort = -1
+            root.pendingStartVpnWasActive = false
+            PageController.showNotificationMessage(message)
+        }
+    }
+
+    Connections {
+        target: ServersUiController
+
+        function onProcessedServerIdChanged() {
+            var portField = root.getPortField()
+            if (portField !== null && !portField.textField.activeFocus) {
+                portField.syncPortValue()
+            }
+        }
+    }
+}

client/ui/qml/qml.qrc

@@ -105,6 +105,8 @@
         <file>Pages2/PageSettingsDns.qml</file>
         <file>Pages2/PageSettingsKillSwitch.qml</file>
         <file>Pages2/PageSettingsKillSwitchExceptions.qml</file>
+        <file>Pages2/PageSettingsConnectionType.qml</file>
+        <file>Pages2/PageSettingsLocalProxy.qml</file>
         <file>Pages2/PageSettingsLogging.qml</file>
         <file>Pages2/PageSettingsServerData.qml</file>
         <file>Pages2/PageSettingsServerInfo.qml</file>

client/vpnConnection.cpp

@@ -17,7 +17,6 @@
 #ifdef AMNEZIA_DESKTOP
     #include "core/utils/ipcClient.h"
     #include <core/protocols/wireGuardProtocol.h>
-    #include "daemon/wireguardutils.h"
 #endif
 
 #ifdef Q_OS_ANDROID
@@ -128,23 +127,6 @@ void VpnConnection::onConnectionStateChanged(Vpn::ConnectionState state)
                 else
                     qWarning() << "VpnConnection::onConnectionStateChanged: Failed to flush DNS";
 
-#ifdef Q_OS_LINUX
-                if (ContainerUtils::isAwgContainer(container) || container == DockerContainer::WireGuard) {
-                    QString dns1 = m_vpnConfiguration.value(configKey::dns1).toString();
-                    QString dns2 = m_vpnConfiguration.value(configKey::dns2).toString();
-                    QList<QHostAddress> resolvers;
-                    if (!dns1.isEmpty()) resolvers << QHostAddress(dns1);
-                    if (!dns2.isEmpty()) resolvers << QHostAddress(dns2);
-                    if (!resolvers.isEmpty()) {
-                        auto r = iface->updateResolvers(WG_INTERFACE, resolvers);
-                        if (r.waitForFinished() && r.returnValue())
-                            qDebug() << "VpnConnection: DNS resolvers set via systemd-resolved";
-                        else
-                            qWarning() << "VpnConnection: Failed to set DNS resolvers";
-                    }
-                }
-#endif
-
                 if (!ContainerUtils::isAwgContainer(container) && container != DockerContainer::WireGuard) {
                     QString dns1 = m_vpnConfiguration.value(configKey::dns1).toString();
                     QString dns2 = m_vpnConfiguration.value(configKey::dns2).toString();
@@ -178,11 +160,6 @@ void VpnConnection::onConnectionStateChanged(Vpn::ConnectionState state)
             } break;
             case Vpn::ConnectionState::Disconnected:
             case Vpn::ConnectionState::Error: {
-#ifdef Q_OS_LINUX
-                if (ContainerUtils::isAwgContainer(container) || container == DockerContainer::WireGuard) {
-                    iface->restoreResolvers();
-                }
-#endif
                 auto flushDns = iface->flushDns();
                 if (flushDns.waitForFinished() && flushDns.returnValue())
                     qDebug() << "VpnConnection::onConnectionStateChanged: Successfully flushed DNS";

ipc/ipc.h

@@ -3,8 +3,6 @@
 
 #include <QObject>
 #include <QString>
-#include <QRegularExpression>
-#include <QSet>
 
 #include "../client/core/utils/utilities.h"
 
@@ -17,8 +15,7 @@ enum PermittedProcess {
     OpenVPN,
     Wireguard,
     Tun2Socks,
-    CertUtil,
-    _Count
+    CertUtil
 };
 
 inline QString permittedProcessPath(PermittedProcess pid)
@@ -60,56 +57,16 @@ inline QStringList sanitizeArguments(PermittedProcess proc, const QStringList &a
     QList<Validator> positionalArgs;
 
     switch (proc) {
-    case OpenVPN: {
-        static const QSet<QString> blocked = {
-            QStringLiteral("--script-security"),
-            QStringLiteral("--up"),
-            QStringLiteral("--down"),
-            QStringLiteral("--route-up"),
-            QStringLiteral("--ipchange"),
-            QStringLiteral("--tls-verify"),
-            QStringLiteral("--plugin"),
-            QStringLiteral("--auth-user-pass-verify"),
-            QStringLiteral("--learn-address"),
-            QStringLiteral("--client-connect"),
-            QStringLiteral("--client-disconnect"),
-            QStringLiteral("--management"),
-            QStringLiteral("--management-external-key")
-        };
-        QStringList out;
-        for (int i = 0; i < args.size(); ++i) {
-            if (blocked.contains(args[i])) {
-                qWarning() << "IPC: blocked OpenVPN argument:" << args[i];
-                ++i; // skip following value
-                continue;
-            }
-            out << args[i];
-        }
-        return out;
-    }
-    case Wireguard: {
-        static const QRegularExpression hookRe(
-            QStringLiteral(R"((?i)(PostUp|PreUp|PostDown|PreDown)\s*=)"));
-        QStringList out;
-        for (const QString& a : args) {
-            if (hookRe.match(a).hasMatch()) {
-                qWarning() << "IPC: blocked WireGuard hook argument:" << a;
-                continue;
-            }
-            out << a;
-        }
-        return out;
-    }
     case Tun2Socks:
         namedArgs["-device"] = [](const QString& v) { return v.startsWith("tun://"); };
         namedArgs["-proxy"] = [](const QString& v) { return v.startsWith("socks5://"); };
         break;
-    case CertUtil:
-        return args;
     default:
-        return {};
+        //FIXME
+        return args;
     }
 
+
     QStringList sanitized;
 
     for (int i = 0, pos = 0; i < args.size(); i++) {

ipc/ipcserver.cpp

@@ -22,27 +22,6 @@
     #include "tapcontroller_win.h"
 #endif
 
-#ifdef Q_OS_LINUX
-#include <sys/socket.h>
-#include <sys/types.h>
-
-extern uid_t g_allowedUid;
-extern bool g_allowedUidSet;
-
-static bool checkPrivPeerCredentials(QLocalSocket *socket) {
-    struct ucred cred{};
-    socklen_t len = sizeof(cred);
-    if (getsockopt(socket->socketDescriptor(), SOL_SOCKET, SO_PEERCRED, &cred, &len) != 0) {
-        qWarning() << "IpcServer: SO_PEERCRED failed, rejecting privileged process connection";
-        return false;
-    }
-    if (cred.uid == 0) return true;
-    if (g_allowedUidSet && cred.uid == g_allowedUid) return true;
-    qWarning() << "IpcServer: rejected privileged process connection from unauthorized UID" << cred.uid;
-    return false;
-}
-#endif
-
 
 IpcServer::IpcServer(QObject *parent) : IpcInterfaceSource(parent)
 {
@@ -69,16 +48,8 @@ int IpcServer::createPrivilegedProcess()
     // Make sure any connections are handed to QtRO
     QObject::connect(pd.localServer.data(), &QLocalServer::newConnection, this, [pd]() {
         qDebug() << "IpcServer new connection";
-        QLocalSocket *conn = pd.localServer->nextPendingConnection();
-#ifdef Q_OS_LINUX
-        if (!checkPrivPeerCredentials(conn)) {
-            conn->close();
-            conn->deleteLater();
-            return;
-        }
-#endif
         if (pd.serverNode) {
-            pd.serverNode->addHostSideConnection(conn);
+            pd.serverNode->addHostSideConnection(pd.localServer->nextPendingConnection());
             pd.serverNode->enableRemoting(pd.ipcProcess.data());
         }
     });

ipc/ipcserverprocess.cpp

@@ -77,11 +77,6 @@ void IpcServerProcess::setProcessChannelMode(QProcess::ProcessChannelMode mode)
 
 void IpcServerProcess::setProgram(int programId)
 {
-    if (programId <= static_cast<int>(amnezia::PermittedProcess::Invalid) ||
-        programId >= static_cast<int>(amnezia::PermittedProcess::_Count)) {
-        qWarning() << "IPC: invalid programId" << programId << ", ignoring";
-        return;
-    }
     m_program = static_cast<amnezia::PermittedProcess>(programId);
     m_process->setProgram(amnezia::permittedProcessPath(m_program));
     m_process->setArguments({});

service/server/killswitch.cpp

@@ -3,7 +3,6 @@
 
 #include <QApplication>
 #include <QHostAddress>
-#include <QRegularExpression>
 
 #include "../client/core/utils/protocolEnum.h"
 #include "../client/core/protocols/protocolUtils.h"
@@ -12,37 +11,6 @@
 #include "qjsonarray.h"
 #include "version.h"
 
-#if defined(Q_OS_LINUX) || defined(Q_OS_MACOS)
-static bool isValidIpOrCidr(const QString &value) {
-    static const QRegularExpression re(
-        QStringLiteral(R"(^(\d{1,3}\.){3}\d{1,3}(/\d{1,2})?$)"));
-    if (!re.match(value).hasMatch()) return false;
-    const QStringList ipParts = value.split(QLatin1Char('/'))[0].split(QLatin1Char('.'));
-    for (const QString &part : ipParts) {
-        bool ok;
-        int octet = part.toInt(&ok);
-        if (!ok || octet < 0 || octet > 255) return false;
-    }
-    if (value.contains(QLatin1Char('/'))) {
-        bool ok;
-        int prefix = value.split(QLatin1Char('/'))[1].toInt(&ok);
-        if (!ok || prefix < 0 || prefix > 32) return false;
-    }
-    return true;
-}
-
-static QStringList filterIpList(const QStringList &values) {
-    QStringList safe;
-    for (const QString &v : values) {
-        if (isValidIpOrCidr(v))
-            safe << v;
-        else
-            qWarning() << "IPC: rejected invalid IP/CIDR value:" << v;
-    }
-    return safe;
-}
-#endif
-
 #ifdef Q_OS_WIN
     #include "../client/platforms/windows/daemon/windowsfirewall.h"
     #include "../client/platforms/windows/daemon/windowsdaemon.h"
@@ -198,11 +166,7 @@ bool KillSwitch::disableAllTraffic() {
 
 bool KillSwitch::resetAllowedRange(const QStringList &ranges) {
 
-#ifdef Q_OS_LINUX
-    m_allowedRanges = filterIpList(ranges);
-#else
     m_allowedRanges = ranges;
-#endif
 
 #ifdef Q_OS_LINUX
     LinuxFirewall::setAnchorEnabled(LinuxFirewall::IPv4, QStringLiteral("110.allowNets"), true);
@@ -225,12 +189,7 @@ bool KillSwitch::resetAllowedRange(const QStringList &ranges) {
 }
 
 bool KillSwitch::addAllowedRange(const QStringList &ranges) {
-#ifdef Q_OS_LINUX
-    const QStringList safeRanges = filterIpList(ranges);
-#else
-    const QStringList &safeRanges = ranges;
-#endif
-    for (const QString &range : safeRanges) {
+    for (const QString &range : ranges) {
         if (!range.isEmpty() && !m_allowedRanges.contains(range)) {
             m_allowedRanges.append(range);
         }
@@ -358,9 +317,9 @@ bool KillSwitch::enableKillSwitch(const QJsonObject &configStr, int vpnAdapterIn
     LinuxFirewall::setAnchorEnabled(LinuxFirewall::Both, QStringLiteral("000.allowLoopback"), true);
     LinuxFirewall::setAnchorEnabled(LinuxFirewall::Both, QStringLiteral("100.blockAll"), blockAll);
     LinuxFirewall::setAnchorEnabled(LinuxFirewall::IPv4, QStringLiteral("110.allowNets"), allowNets);
-    LinuxFirewall::updateAllowNets(filterIpList(allownets));
+    LinuxFirewall::updateAllowNets(allownets);
     LinuxFirewall::setAnchorEnabled(LinuxFirewall::IPv4, QStringLiteral("120.blockNets"), blockAll);
-    LinuxFirewall::updateBlockNets(filterIpList(blocknets));
+    LinuxFirewall::updateBlockNets(blocknets);
     LinuxFirewall::setAnchorEnabled(LinuxFirewall::Both, QStringLiteral("130.allowMarkedXray"), true);
     LinuxFirewall::setAnchorEnabled(LinuxFirewall::IPv4, QStringLiteral("200.allowVPN"), true);
     LinuxFirewall::setAnchorEnabled(LinuxFirewall::IPv6, QStringLiteral("250.blockIPv6"), true);
@@ -369,36 +328,23 @@ bool KillSwitch::enableKillSwitch(const QJsonObject &configStr, int vpnAdapterIn
     LinuxFirewall::setAnchorEnabled(LinuxFirewall::IPv4, QStringLiteral("310.blockDNS"), true);
     QStringList dnsServers;
 
-    const QString dns1 = configStr.value(amnezia::configKey::dns1).toString();
-    if (isValidIpOrCidr(dns1))
-        dnsServers.append(dns1);
-    else if (!dns1.isEmpty())
-        qWarning() << "IPC: rejected invalid dns1:" << dns1;
+    dnsServers.append(configStr.value(amnezia::configKey::dns1).toString());
 
     // We don't use secondary DNS if primary DNS is AmneziaDNS
-    if (!dns1.contains(amnezia::protocols::dns::amneziaDnsIp)) {
-        const QString dns2 = configStr.value(amnezia::configKey::dns2).toString();
-        if (isValidIpOrCidr(dns2))
-            dnsServers.append(dns2);
-        else if (!dns2.isEmpty())
-            qWarning() << "IPC: rejected invalid dns2:" << dns2;
+    if (!configStr.value(amnezia::configKey::dns1).toString().contains(amnezia::protocols::dns::amneziaDnsIp)) {
+        dnsServers.append(configStr.value(amnezia::configKey::dns2).toString());
     }
 
     dnsServers.append("127.0.0.1");
     dnsServers.append("127.0.0.53");
-
-
+    
     for (auto dns : configStr.value(amnezia::configKey::allowedDnsServers).toArray()) {
         if (!dns.isString()) {
             break;
         }
-        const QString dnsStr = dns.toString();
-        if (isValidIpOrCidr(dnsStr))
-            dnsServers.append(dnsStr);
-        else if (!dnsStr.isEmpty())
-            qWarning() << "IPC: rejected invalid allowedDnsServer:" << dnsStr;
+        dnsServers.append(dns.toString());
     }
-
+    
     LinuxFirewall::updateDNSServers(dnsServers);
     LinuxFirewall::setAnchorEnabled(LinuxFirewall::IPv4, QStringLiteral("320.allowDNS"), true);
     LinuxFirewall::setAnchorEnabled(LinuxFirewall::Both, QStringLiteral("400.allowPIA"), true);
@@ -414,40 +360,28 @@ bool KillSwitch::enableKillSwitch(const QJsonObject &configStr, int vpnAdapterIn
     MacOSFirewall::setAnchorEnabled(QStringLiteral("000.allowLoopback"), true);
     MacOSFirewall::setAnchorEnabled(QStringLiteral("100.blockAll"), blockAll);
     MacOSFirewall::setAnchorEnabled(QStringLiteral("110.allowNets"), allowNets);
-    MacOSFirewall::setAnchorTable(QStringLiteral("110.allowNets"), allowNets, QStringLiteral("allownets"), filterIpList(allownets));
+    MacOSFirewall::setAnchorTable(QStringLiteral("110.allowNets"), allowNets, QStringLiteral("allownets"), allownets);
 
     MacOSFirewall::setAnchorEnabled(QStringLiteral("120.blockNets"), blockNets);
-    MacOSFirewall::setAnchorTable(QStringLiteral("120.blockNets"), blockNets, QStringLiteral("blocknets"), filterIpList(blocknets));
+    MacOSFirewall::setAnchorTable(QStringLiteral("120.blockNets"), blockNets, QStringLiteral("blocknets"), blocknets);
     MacOSFirewall::setAnchorEnabled(QStringLiteral("200.allowVPN"), true);
     MacOSFirewall::setAnchorEnabled(QStringLiteral("250.blockIPv6"), true);
     MacOSFirewall::setAnchorEnabled(QStringLiteral("290.allowDHCP"), true);
     MacOSFirewall::setAnchorEnabled(QStringLiteral("300.allowLAN"), true);
 
     QStringList dnsServers;
-    const QString dns1 = configStr.value(amnezia::configKey::dns1).toString();
-    if (isValidIpOrCidr(dns1))
-        dnsServers.append(dns1);
-    else if (!dns1.isEmpty())
-        qWarning() << "IPC: rejected invalid dns1:" << dns1;
+    dnsServers.append(configStr.value(amnezia::configKey::dns1).toString());
 
     // We don't use secondary DNS if primary DNS is AmneziaDNS
-    if (!dns1.contains(amnezia::protocols::dns::amneziaDnsIp)) {
-        const QString dns2 = configStr.value(amnezia::configKey::dns2).toString();
-        if (isValidIpOrCidr(dns2))
-            dnsServers.append(dns2);
-        else if (!dns2.isEmpty())
-            qWarning() << "IPC: rejected invalid dns2:" << dns2;
+    if (!configStr.value(amnezia::configKey::dns1).toString().contains(amnezia::protocols::dns::amneziaDnsIp)) {
+        dnsServers.append(configStr.value(amnezia::configKey::dns2).toString());
     }
-
+    
     for (auto dns : configStr.value(amnezia::configKey::allowedDnsServers).toArray()) {
         if (!dns.isString()) {
             break;
         }
-        const QString dnsStr = dns.toString();
-        if (isValidIpOrCidr(dnsStr))
-            dnsServers.append(dnsStr);
-        else if (!dnsStr.isEmpty())
-            qWarning() << "IPC: rejected invalid allowedDnsServer:" << dnsStr;
+        dnsServers.append(dns.toString());
     }
     
     MacOSFirewall::setAnchorEnabled(QStringLiteral("310.blockDNS"), true);

service/server/localserver.cpp

@@ -17,35 +17,6 @@
     #include "tapcontroller_win.h"
 #endif
 
-#ifdef Q_OS_LINUX
-#include <sys/socket.h>
-#include <sys/types.h>
-#include <unistd.h>
-
-uid_t g_allowedUid = static_cast<uid_t>(-1);
-bool g_allowedUidSet = false;
-
-static bool checkPeerCredentials(QLocalSocket *socket) {
-    struct ucred cred{};
-    socklen_t len = sizeof(cred);
-    if (getsockopt(socket->socketDescriptor(), SOL_SOCKET, SO_PEERCRED, &cred, &len) != 0) {
-        qWarning() << "LocalServer: SO_PEERCRED failed, rejecting connection";
-        return false;
-    }
-    if (cred.uid == 0) return true;
-    if (!g_allowedUidSet) {
-        g_allowedUid = cred.uid;
-        g_allowedUidSet = true;
-        qDebug() << "LocalServer: registered session UID" << g_allowedUid;
-    }
-    if (cred.uid != g_allowedUid) {
-        qWarning() << "LocalServer: rejected connection from unauthorized UID" << cred.uid;
-        return false;
-    }
-    return true;
-}
-#endif
-
 namespace {
 Logger logger("WgDaemonServer");
 }
@@ -64,15 +35,7 @@ LocalServer::LocalServer(QObject *parent) : QObject(parent),
 
     QObject::connect(m_server.data(), &QLocalServer::newConnection, this, [this]() {
         qDebug() << "LocalServer new connection";
-        QLocalSocket *conn = m_server->nextPendingConnection();
-#ifdef Q_OS_LINUX
-        if (!checkPeerCredentials(conn)) {
-            conn->close();
-            conn->deleteLater();
-            return;
-        }
-#endif
-        m_serverNode.addHostSideConnection(conn);
+        m_serverNode.addHostSideConnection(m_server->nextPendingConnection());
 
         if (!m_isRemotingEnabled) {
             m_isRemotingEnabled = true;

service/server/router_linux.cpp

@@ -182,7 +182,7 @@ bool RouterLinux::flushDns()
     if (output.isEmpty())
         qDebug().noquote() << "Flush dns completed";
     else
-        qDebug().noquote() << "OUTPUT systemctl restart: " + output;
+        qDebug().noquote() << "OUTPUT systemctl restart nscd/systemd-resolved: " + output;
 
     return true;
 }