cleanup

.github/workflows/deploy.yml

@@ -10,10 +10,10 @@ env:
 
 jobs:
   Build-Linux-Ubuntu:
-    runs-on: android-runner
+    runs-on: 4-core
 
     env:
-      QT_VERSION: 6.10.1
+      QT_VERSION: 6.8.3
       QIF_VERSION: 4.7
       PROD_AGW_PUBLIC_KEY: ${{ secrets.PROD_AGW_PUBLIC_KEY }}
       PROD_S3_ENDPOINT: ${{ secrets.PROD_S3_ENDPOINT }}
@@ -58,7 +58,7 @@ jobs:
 
     - name: 'Build project'
       run: |
-        sudo apt-get install libxkbcommon-x11-0 libsecret-1-dev
+        sudo apt-get install libxkbcommon-x11-0
         export QT_BIN_DIR=${{ runner.temp }}/Qt/${{ env.QT_VERSION }}/gcc_64/bin
         export QIF_BIN_DIR=${{ runner.temp }}/Qt/Tools/QtInstallerFramework/${{ env.QIF_VERSION }}/bin
         bash deploy/build_linux.sh
@@ -537,7 +537,7 @@ jobs:
 # ------------------------------------------------------
 
   Build-Android:
-    runs-on: android-runner
+    runs-on: 4-core
 
     env:
       ANDROID_BUILD_PLATFORM: android-36

.github/workflows/tag-upload.yml

@@ -24,7 +24,7 @@ jobs:
       - name: Verify git tag
         run: |
           TAG_NAME=${{ inputs.RELEASE_VERSION }}
-          CMAKE_TAG=$(grep 'set(AMNEZIAVPN_VERSION' CMakeLists.txt | sed -E 's/.*AMNEZIAVPN_VERSION ([0-9]+\.[0-9]+\.[0-9]+\.[0-9]+).*/\1/')
+          CMAKE_TAG=$(grep 'project.*VERSION' CMakeLists.txt | sed -E 's/.* ([0-9]+.[0-9]+.[0-9]+.[0-9]+)$/\1/')
           if [[ "$TAG_NAME" == "$CMAKE_TAG" ]]; then
             echo "Git tag ($TAG_NAME) matches CMakeLists.txt version ($CMAKE_TAG)."
           else

.gitignore

@@ -1,5 +1,9 @@
 # User settings
 *.user
+
+# Gateway configs (contains sensitive endpoints)
+gateway.json
+client/gateway.json
 macOSPackage/
 AmneziaVPN.dmg
 AmneziaVPN.exe
@@ -140,6 +144,3 @@ ios-ne-build.sh
 macos-ne-build.sh
 macos-signed-build.sh
 macos-with-sign-build.sh
-DeveloperIdApplicationCertificate.p12
-DeveloperIdInstallerCertificate.p12
-

.gitmodules

@@ -14,7 +14,3 @@
 [submodule "client/3rd/QSimpleCrypto"]
 	path = client/3rd/QSimpleCrypto
 	url = https://github.com/amnezia-vpn/QSimpleCrypto.git
-[submodule "client/3rd/qtgamepad"]
-	path = client/3rd/qtgamepad
-	url = https://github.com/amnezia-vpn/qtgamepad.git
-	branch = 6.6

CMakeLists.txt

@@ -1,7 +1,7 @@
 cmake_minimum_required(VERSION 3.25.0 FATAL_ERROR)
 
 set(PROJECT AmneziaVPN)
-set(AMNEZIAVPN_VERSION 4.8.14.5)
+set(AMNEZIAVPN_VERSION 4.8.12.8)
 
 project(${PROJECT} VERSION ${AMNEZIAVPN_VERSION}
         DESCRIPTION "AmneziaVPN"
@@ -12,7 +12,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 2118)
+set(APP_ANDROID_VERSION_CODE 2104)
 
 if(${CMAKE_SYSTEM_NAME} STREQUAL "Linux")
     set(MZ_PLATFORM_NAME "linux")
@@ -61,9 +61,6 @@ if(WIN32 AND NOT IOS AND NOT ANDROID AND NOT MACOS_NE)
     set(CPACK_PACKAGE_VENDOR "AmneziaVPN")
     set(CPACK_PACKAGE_VERSION ${AMNEZIAVPN_VERSION})
     set(CPACK_PACKAGE_DESCRIPTION_SUMMARY "AmneziaVPN client")
-    set(AMNEZIA_LICENSE_TXT "${CMAKE_BINARY_DIR}/LICENSE.txt")
-    configure_file("${CMAKE_SOURCE_DIR}/LICENSE" "${AMNEZIA_LICENSE_TXT}" COPYONLY)
-    set(CPACK_RESOURCE_FILE_LICENSE "${AMNEZIA_LICENSE_TXT}")
     set(CPACK_PACKAGE_INSTALL_DIRECTORY "AmneziaVPN")
     set(CPACK_PACKAGE_DIRECTORY "${CMAKE_BINARY_DIR}")
     set(CPACK_PACKAGE_EXECUTABLES "AmneziaVPN" "AmneziaVPN")

README.md

@@ -179,7 +179,7 @@ You may face compiling issues in QT Creator after you've worked in Android Studi
 
 ## License
 
-This project is licensed under the GNU General Public License v3.0 (see LICENSE) and also includes third-party components distributed under their own terms (see THIRD_PARTY_LICENSES.md).
+GPL v3.0
 
 ## Donate
 

THIRD_PARTY_LICENSES.md

@@ -1,149 +0,0 @@
-# Third-Party Licenses
-
-This project is licensed under the GNU General Public License v3.0.
-This file lists third-party software components used by this repository.
-Each component is distributed under its own license as linked below.
-
----
-
-## QtKeychain
-
-- Source: https://github.com/frankosterfeld/qtkeychain
-- License: BSD License
-- License Text: https://www.gnu.org/licenses/license-list.html#ModifiedBSD
-
----
-
-## QSimpleCrypto
-
-- Source: https://github.com/n1flh31mur/QSimpleCrypto
-- License: Apache License 2.0
-- License Text: https://github.com/n1flh31mur/QSimpleCrypto/blob/master/LICENSE
-
----
-
-## SortFilterProxyModel
-
-- Source: https://github.com/oKcerG/SortFilterProxyModel
-- License: MIT License
-- License Text: https://github.com/oKcerG/SortFilterProxyModel/blob/master/LICENSE
-
----
-
-## QJsonStruct
-
-- Source: https://github.com/Qv2ray/QJsonStruct
-- License: MIT License
-- License Text: https://github.com/Qv2ray/QJsonStruct/blob/master/LICENSE
-
----
-
-## QR Code Generator (qrcodegen)
-
-- Source: https://github.com/nayuki/QR-Code-generator
-- License: MIT License
-- License Text: https://www.nayuki.io/page/qr-code-generator-library
-
----
-
-## Qt Gamepad
-
-- Source: https://github.com/qt/qtgamepad
-- License: GNU General Public License v3.0 (GPL-3.0)
-- License Text: https://www.gnu.org/licenses/gpl-3.0.en.html
-
----
-
-## AmneziaWG Apple (WireGuard)
-
-- Source: https://github.com/amnezia-vpn/amneziawg-apple
-- License: MIT License
-- License Text: https://github.com/amnezia-vpn/amneziawg-apple/blob/master/COPYING
-
----
-
-## AmneziaWG Android
-
-- Source: https://github.com/amnezia-vpn/amneziawg-go
-- License: MIT License
-- License Text: https://github.com/amnezia-vpn/amneziawg-go/blob/master/LICENSE
-
----
-
-## Xray Core
-
-- Source: https://github.com/XTLS/Xray-core
-- License: Mozilla Public License 2.0 (MPL-2.0)
-- License Text: https://github.com/XTLS/Xray-core/blob/main/LICENSE
-
----
-
-## Cloak
-
-- Source: https://github.com/cbeuw/Cloak
-- License: GNU General Public License v3.0 (GPL-3.0)
-- License Text: https://github.com/cbeuw/Cloak/blob/master/LICENSE
-
----
-
-## Shadowsocks
-
-- Source: https://github.com/shadowsocks/shadowsocks-libev
-- License: GPL-3.0-or-later
-- License Text: http://www.gnu.org/licenses/
-
----
-
-## OpenSSL
-
-- Source: https://github.com/openssl/openssl
-- License: Apache License 2.0
-- License Text: https://www.openssl.org/source/license.html
-
----
-
-## libssh
-
-- Source: https://www.libssh.org/
-- License: GNU Lesser General Public License (LGPL)
-- License Text: https://www.gnu.org/licenses/old-licenses/lgpl-2.1.html
-
----
-
-## OpenVPNAdapter
-
-- Source: https://github.com/ss-abramchuk/OpenVPNAdapter
-- License: GNU Affero General Public License v3.0 (AGPL-3.0)
-- License Text: https://github.com/ss-abramchuk/OpenVPNAdapter/blob/master/LICENSE
-
----
-
-## Wintun
-
-- Source: https://www.wintun.net/
-- License: Prebuilt Binaries License
-- License Text: https://github.com/WireGuard/wintun/blob/master/prebuilt-binaries-license.txt
-
----
-
-## Mullvad Split Tunnel Driver
-
-- Source: https://github.com/mullvad/win-split-tunnel
-- License: GNU General Public License v3.0 (GPL-3.0) and Mozilla Public License Version 2.0
-- License Text: https://github.com/mullvad/win-split-tunnel/blob/master/LICENSE-GPL.md https://github.com/mullvad/win-split-tunnel/blob/master/LICENSE-MPL.txt
-
----
-
-## tun2socks
-
-- Source: https://github.com/eycorsican/go-tun2socks
-- License: MIT License
-- License Text: https://github.com/eycorsican/go-tun2socks/blob/master/LICENSE
-
----
-
-## TAP-Windows Driver
-
-- Source: https://github.com/OpenVPN/tap-windows6
-- License: tap-windows6 license
-- License Text: https://github.com/OpenVPN/tap-windows6/blob/master/COPYING

client/CMakeLists.txt

@@ -33,6 +33,21 @@ add_definitions(-DDEV_S3_ENDPOINT="$ENV{DEV_S3_ENDPOINT}")
 add_definitions(-DFREE_V2_ENDPOINT="$ENV{FREE_V2_ENDPOINT}")
 add_definitions(-DPREM_V1_ENDPOINT="$ENV{PREM_V1_ENDPOINT}")
 
+add_definitions(-DAGW_DNS_SERVER="$ENV{AGW_DNS_SERVER}")
+add_definitions(-DAGW_DNS_DOMAIN="$ENV{AGW_DNS_DOMAIN}")
+add_definitions(-DAGW_DNS_PRIMARY="$ENV{AGW_DNS_PRIMARY}")
+add_definitions(-DAGW_DNS_PORT_UDP="$ENV{AGW_DNS_PORT_UDP}")
+add_definitions(-DAGW_DNS_PORT_DOT="$ENV{AGW_DNS_PORT_DOT}")
+add_definitions(-DAGW_DNS_PORT_DOH="$ENV{AGW_DNS_PORT_DOH}")
+add_definitions(-DAGW_DNS_PORT_DOQ="$ENV{AGW_DNS_PORT_DOQ}")
+add_definitions(-DAGW_DNS_DOH_PATH="$ENV{AGW_DNS_DOH_PATH}")
+add_definitions(-DAGW_DNS_RETRY_COUNT="$ENV{AGW_DNS_RETRY_COUNT}")
+add_definitions(-DAGW_DNS_TIMEOUT_MS="$ENV{AGW_DNS_TIMEOUT_MS}")
+
+if(DEFINED ENV{AGW_INSECURE_SSL} AND NOT "$ENV{AGW_INSECURE_SSL}" STREQUAL "" AND NOT "$ENV{AGW_INSECURE_SSL}" STREQUAL "0")
+    add_definitions(-DAGW_INSECURE_SSL=1)
+endif()
+
 if(WIN32 OR (APPLE AND NOT IOS) OR (LINUX AND NOT ANDROID))
     set(PACKAGES ${PACKAGES} Widgets)
 endif()
@@ -59,6 +74,7 @@ target_include_directories(${PROJECT} PUBLIC
 if(WIN32 OR (APPLE AND NOT IOS AND NOT MACOS_NE) OR (LINUX AND NOT ANDROID))
     qt_add_repc_replicas(${PROJECT} ${CMAKE_CURRENT_LIST_DIR}/../ipc/ipc_interface.rep)
     qt_add_repc_replicas(${PROJECT} ${CMAKE_CURRENT_LIST_DIR}/../ipc/ipc_process_interface.rep)
+    qt_add_repc_replicas(${PROJECT} ${CMAKE_CURRENT_LIST_DIR}/../ipc/ipc_process_tun2socks.rep)
 endif()
 
 qt6_add_resources(QRC ${QRC} ${CMAKE_CURRENT_LIST_DIR}/resources.qrc)
@@ -78,7 +94,6 @@ set(AMNEZIAVPN_TS_FILES
 )
 
 file(GLOB_RECURSE AMNEZIAVPN_TS_SOURCES *.qrc *.cpp *.h *.ui)
-list(FILTER AMNEZIAVPN_TS_SOURCES EXCLUDE REGEX "qtgamepad/examples")
 
 qt_create_translation(AMNEZIAVPN_QM_FILES ${AMNEZIAVPN_TS_SOURCES} ${AMNEZIAVPN_TS_FILES})
 
@@ -228,13 +243,10 @@ if(NOT IOS AND NOT ANDROID AND NOT MACOS_NE)
 endif()
 
 target_sources(${PROJECT} PRIVATE ${SOURCES} ${HEADERS} ${RESOURCES} ${QRC} ${I18NQRC})
+qt_finalize_target(${PROJECT})
 
-# Finalize the executable so Qt can gather/deploy QML modules and plugins correctly (Android needs this).
-if(COMMAND qt_import_qml_plugins)
-    qt_import_qml_plugins(${PROJECT})
-endif()
-if(COMMAND qt_finalize_executable)
-    qt_finalize_executable(${PROJECT})
-else()
-    qt_finalize_target(${PROJECT})
+option(BUILD_TESTS "Build transport integration tests" OFF)
+if(BUILD_TESTS)
+    enable_testing()
+    add_subdirectory(tests)
 endif()

client/amnezia_application.cpp

@@ -109,16 +109,6 @@ void AmneziaApplication::init()
             // install filter on main window
             if (auto win = qobject_cast<QQuickWindow*>(obj)) {
                 win->installEventFilter(this);
-#ifdef Q_OS_ANDROID
-                QObject::connect(win, &QQuickWindow::sceneGraphError,
-                    [](QQuickWindow::SceneGraphError, const QString &msg) {
-                        qWarning() << "Scene graph error (suppressed):" << msg;
-                    });
-                // Keep graphics context alive across hide/show cycles to avoid
-                // eglSwapBuffers/makeCurrent being called on a context Android has reclaimed.
-                win->setPersistentSceneGraph(true);
-                win->setPersistentGraphics(true);
-#endif
                 win->show();
             }
         },

client/android/src/org/amnezia/vpn/AmneziaActivity.kt

@@ -26,8 +26,6 @@ import android.os.ParcelFileDescriptor
 import android.os.SystemClock
 import android.provider.OpenableColumns
 import android.provider.Settings
-import android.view.InputDevice
-import android.view.KeyEvent
 import android.view.MotionEvent
 import android.view.View
 import android.view.ViewGroup
@@ -75,8 +73,6 @@ private const val OPEN_FILE_ACTION_CODE = 3
 private const val CHECK_NOTIFICATION_PERMISSION_ACTION_CODE = 4
 
 private const val PREFS_NOTIFICATION_PERMISSION_ASKED = "NOTIFICATION_PERMISSION_ASKED"
-private const val OPEN_FILE_AFTER_RESUME_DELAY_MS = 400L
-private const val KEY_PENDING_OPEN_FILE_URI = "pending_open_file_uri"
 
 class AmneziaActivity : QtActivity() {
 
@@ -93,12 +89,6 @@ class AmneziaActivity : QtActivity() {
     private val actionResultHandlers = mutableMapOf<Int, ActivityResultHandler>()
     private val permissionRequestHandlers = mutableMapOf<Int, PermissionRequestHandler>()
 
-    private var isActivityResumed = false
-    private var hasWindowFocus = false
-    private val resumeHandler = Handler(Looper.getMainLooper())
-    private var pendingOpenFileUri: String? = null
-    private var openFileDeliveryScheduled = false
-
     private val vpnServiceEventHandler: Handler by lazy(NONE) {
         object : Handler(Looper.getMainLooper()) {
             override fun handleMessage(msg: Message) {
@@ -200,18 +190,11 @@ class AmneziaActivity : QtActivity() {
                 doBindService()
             }
         )
-        pendingOpenFileUri = savedInstanceState?.getString(KEY_PENDING_OPEN_FILE_URI)
-        openFileDeliveryScheduled = false
         registerBroadcastReceivers()
         intent?.let(::processIntent)
         runBlocking { vpnProto = proto.await() }
     }
 
-    override fun onSaveInstanceState(outState: Bundle) {
-        super.onSaveInstanceState(outState)
-        pendingOpenFileUri?.let { outState.putString(KEY_PENDING_OPEN_FILE_URI, it) }
-    }
-
     private fun loadLibs() {
         listOf(
             "rsapss",
@@ -277,11 +260,6 @@ class AmneziaActivity : QtActivity() {
     }
 
     override fun onStop() {
-        isActivityResumed = false
-        hasWindowFocus = false
-        // Cancel all pending operations when activity stops
-        resumeHandler.removeCallbacksAndMessages(null)
-        openFileDeliveryScheduled = false
         Log.d(TAG, "Stop Amnezia activity")
         doUnbindService()
         mainScope.launch {
@@ -293,129 +271,35 @@ class AmneziaActivity : QtActivity() {
 
     override fun onWindowFocusChanged(hasFocus: Boolean) {
         super.onWindowFocusChanged(hasFocus)
-        hasWindowFocus = hasFocus
         Log.d(TAG, "Window focus changed: hasFocus=$hasFocus")
-
-        if (!hasFocus) {
-            // Cancel pending operations if window loses focus
-            resumeHandler.removeCallbacksAndMessages(null)
-        } else if (isActivityResumed && Build.VERSION.SDK_INT >= Build.VERSION_CODES.UPSIDE_DOWN_CAKE) {
-            window.decorView.apply {
-                invalidate()
-                resumeHandler.postDelayed({
-                    if (isActivityResumed && hasWindowFocus && !isFinishing && !isDestroyed) {
-                        sendTouch(1f, 1f)
-                    }
-                }, 50)
-                resumeHandler.postDelayed({
-                    if (isActivityResumed && hasWindowFocus && !isFinishing && !isDestroyed) {
-                        sendTouch(2f, 2f)
-                        requestLayout()
-                        invalidate()
-                    }
-                }, 150)
-            }
-        }
     }
 
-    override fun dispatchKeyEvent(event: KeyEvent): Boolean {
-        val keyCode = event.keyCode
-        val pressed = event.action == KeyEvent.ACTION_DOWN
-
-        when (keyCode) {
-            KeyEvent.KEYCODE_BUTTON_A,
-            KeyEvent.KEYCODE_BUTTON_B,
-            KeyEvent.KEYCODE_BUTTON_X,
-            KeyEvent.KEYCODE_BUTTON_Y,
-            KeyEvent.KEYCODE_BUTTON_START,
-            KeyEvent.KEYCODE_BUTTON_SELECT -> {
-                    nativeGamepadKeyEvent(0, keyCode, pressed)
-                    return true
-            }
-            KeyEvent.KEYCODE_DPAD_CENTER,
-            KeyEvent.KEYCODE_DPAD_UP,
-            KeyEvent.KEYCODE_DPAD_DOWN,
-            KeyEvent.KEYCODE_DPAD_LEFT,
-            KeyEvent.KEYCODE_DPAD_RIGHT -> {
-                    val syntheticKeyCode = if (keyCode == KeyEvent.KEYCODE_DPAD_CENTER) KeyEvent.KEYCODE_ENTER else keyCode
-                    val synthetic = KeyEvent(
-                        event.downTime, event.eventTime, event.action, syntheticKeyCode,
-                        event.repeatCount, event.metaState, -1, event.scanCode,
-                        event.flags, InputDevice.SOURCE_KEYBOARD
-                    )
-                    return super.dispatchKeyEvent(synthetic)
-            }
-        }
-
-        return super.dispatchKeyEvent(event)
-    }
-
-    private external fun nativeGamepadKeyEvent(deviceId: Int, keyCode: Int, pressed: Boolean)
-
     override fun onPause() {
-        // Notify Qt to stop rendering BEFORE super.onPause() destroys the EGL surface.
-        // Using a coroutine here would be too late — the surface is gone by the time
-        // the coroutine runs. A direct synchronous call gives Qt's render thread the
-        // best chance to process visible=false before surface destruction.
-        if (qtInitialized.isCompleted) {
-            QtAndroidController.onActivityPaused()
-        }
         super.onPause()
-        isActivityResumed = false
-        // Cancel all pending operations when activity pauses
-        resumeHandler.removeCallbacksAndMessages(null)
-        openFileDeliveryScheduled = false
         Log.d(TAG, "Pause Amnezia activity")
     }
 
     override fun onResume() {
         super.onResume()
-        isActivityResumed = true
-        Log.d(TAG, "Resume Amnezia activity")
-        if (qtInitialized.isCompleted) {
-            QtAndroidController.onActivityResumed()
-        }
-
-        if (pendingOpenFileUri != null && !openFileDeliveryScheduled) {
-            val uri = pendingOpenFileUri!!
-            openFileDeliveryScheduled = true
-            resumeHandler.postDelayed({
-                if (!isFinishing && !isDestroyed) {
-                    pendingOpenFileUri = null
-                    openFileDeliveryScheduled = false
-                    mainScope.launch {
-                        qtInitialized.await()
-                        QtAndroidController.onFileOpened(uri)
-                    }
-                }
-            }, OPEN_FILE_AFTER_RESUME_DELAY_MS)
-        }
-
-        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.UPSIDE_DOWN_CAKE) {
+       /* if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.UPSIDE_DOWN_CAKE) {
             window.decorView.apply {
                 invalidate()
 
-                resumeHandler.postDelayed({
-                    // Check if activity is still resumed and has focus before executing
-                    if (isActivityResumed && hasWindowFocus && !isFinishing && !isDestroyed) {
-                        sendTouch(1f, 1f)
-                    }
+                postDelayed({
+                    sendTouch(1f, 1f)
                 }, 100)
-
-                resumeHandler.postDelayed({
-                    if (isActivityResumed && hasWindowFocus && !isFinishing && !isDestroyed) {
-                        sendTouch(2f, 2f)
-                    }
+                
+                postDelayed({
+                    sendTouch(2f, 2f)
                 }, 200)
-
-                resumeHandler.postDelayed({
-                    if (isActivityResumed && hasWindowFocus && !isFinishing && !isDestroyed) {
-                        requestLayout()
-                        invalidate()
-                    }
+                
+                postDelayed({
+                    requestLayout()
+                    invalidate()
                 }, 250)
             }
-        }
+        }  */      
+        Log.d(TAG, "Resume Amnezia activity")
     }
 
     private fun configureWindowForEdgeToEdge() {
@@ -453,35 +337,31 @@ class AmneziaActivity : QtActivity() {
         ViewCompat.setOnApplyWindowInsetsListener(window.decorView) { view, windowInsets ->
             val imeInsets = windowInsets.getInsets(WindowInsetsCompat.Type.ime())
             val imeVisible = windowInsets.isVisible(WindowInsetsCompat.Type.ime())
-
+            
             val imeHeight = if (imeVisible) imeInsets.bottom else 0
 
             val density = resources.displayMetrics.density
             val imeHeightDp = (imeHeight / density).toInt()
-
+            
             // Also track system bars (navigation bar, status bar) changes
             val systemBarsInsets = windowInsets.getInsets(WindowInsetsCompat.Type.systemBars())
             val navBarHeight = systemBarsInsets.bottom
             val navBarHeightDp = (navBarHeight / density).toInt()
             val statusBarHeight = systemBarsInsets.top
             val statusBarHeightDp = (statusBarHeight / density).toInt()
-
+            
             mainScope.launch {
                 qtInitialized.await()
                 QtAndroidController.onImeInsetsChanged(imeHeightDp)
                 QtAndroidController.onSystemBarsInsetsChanged(navBarHeightDp, statusBarHeightDp)
             }
-
+            
             // Return windowInsets instead of CONSUMED to allow proper handling
             windowInsets
         }
     }
 
     override fun onDestroy() {
-        isActivityResumed = false
-        hasWindowFocus = false
-        // Cancel all pending operations when activity is destroyed
-        resumeHandler.removeCallbacksAndMessages(null)
         Log.d(TAG, "Destroy Amnezia activity")
         unregisterBroadcastReceiver(notificationStateReceiver)
         notificationStateReceiver = null
@@ -807,13 +687,9 @@ class AmneziaActivity : QtActivity() {
                             grantUriPermission(packageName, this, Intent.FLAG_GRANT_READ_URI_PERMISSION)
                         }?.toString() ?: ""
                         Log.v(TAG, "Open file: $uri")
-                        if (uri.isNotEmpty()) {
-                            pendingOpenFileUri = uri
-                        } else {
-                            mainScope.launch {
-                                qtInitialized.await()
-                                QtAndroidController.onFileOpened(uri)
-                            }
+                        mainScope.launch {
+                            qtInitialized.await()
+                            QtAndroidController.onFileOpened(uri)
                         }
                     }
                 ))
@@ -842,7 +718,7 @@ class AmneziaActivity : QtActivity() {
     @Suppress("unused")
     fun getFd(fileName: String): Int {
         Log.v(TAG, "Get fd for $fileName")
-        return blockingCall(Dispatchers.IO) {
+        return blockingCall {
             try {
                 pfd = contentResolver.openFileDescriptor(Uri.parse(fileName), "r")
                 pfd?.fd ?: -1

client/android/src/org/amnezia/vpn/TvFilePicker.kt

@@ -1,10 +1,7 @@
 package org.amnezia.vpn
 
 import android.content.ActivityNotFoundException
-import android.content.Context
 import android.content.Intent
-import android.content.pm.PackageManager
-import android.os.Build
 import android.os.Bundle
 import androidx.activity.ComponentActivity
 import androidx.activity.result.contract.ActivityResultContracts
@@ -14,29 +11,8 @@ private const val TAG = "TvFilePicker"
 
 class TvFilePicker : ComponentActivity() {
 
-    private val fileChooseResultLauncher = registerForActivityResult(object : ActivityResultContracts.OpenDocument() {
-        override fun createIntent(context: Context, input: Array<String>): Intent {
-            val intent = super.createIntent(context, input)
-
-            val activitiesToResolveIntent = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
-                context.packageManager.queryIntentActivities(intent, PackageManager.ResolveInfoFlags.of(PackageManager.MATCH_DEFAULT_ONLY.toLong()))
-            } else {
-                @Suppress("DEPRECATION")
-                context.packageManager.queryIntentActivities(intent, PackageManager.MATCH_DEFAULT_ONLY)
-            }
-            if (activitiesToResolveIntent.all {
-                    val name = it.activityInfo.packageName
-                    name.startsWith("com.google.android.tv.frameworkpackagestubs") || name.startsWith("com.android.tv.frameworkpackagestubs")
-                }) {
-                throw ActivityNotFoundException()
-            }
-            return intent
-        }
-    }) {
-        setResult(RESULT_OK, Intent().apply {
-            data = it
-            addFlags(Intent.FLAG_GRANT_READ_URI_PERMISSION)
-        })
+    private val fileChooseResultLauncher = registerForActivityResult(ActivityResultContracts.GetContent()) {
+        setResult(RESULT_OK, Intent().apply { data = it })
         finish()
     }
 
@@ -55,7 +31,7 @@ class TvFilePicker : ComponentActivity() {
     private fun getFile() {
         try {
             Log.v(TAG, "getFile")
-            fileChooseResultLauncher.launch(arrayOf("*/*"))
+            fileChooseResultLauncher.launch("*/*")
         } catch (_: ActivityNotFoundException) {
             Log.w(TAG, "Activity not found")
             setResult(RESULT_CANCELED, Intent().apply { putExtra("activityNotFound", true) })

client/android/src/org/amnezia/vpn/qt/QtAndroidController.kt

@@ -31,7 +31,4 @@ object QtAndroidController {
 
     external fun onImeInsetsChanged(heightDp: Int)
     external fun onSystemBarsInsetsChanged(navBarHeightDp: Int, statusBarHeightDp: Int)
-
-    external fun onActivityPaused()
-    external fun onActivityResumed()
 }

client/cmake/3rdparty.cmake

@@ -83,26 +83,6 @@ add_compile_definitions(_WINSOCKAPI_)
 set(BUILD_SHARED_LIBS OFF CACHE BOOL "" FORCE)
 set(BUILD_WITH_QT6 ON)
 add_subdirectory(${CLIENT_ROOT_DIR}/3rd/qtkeychain)
-
-if(ANDROID)
-    # Use qtgamepad from amnezia-vpn/qtgamepad repository
-    # Only if Qt6CorePrivate is available (required by qtgamepad)
-    find_package(Qt6CorePrivate CONFIG QUIET)
-    if(Qt6CorePrivate_FOUND)
-        add_subdirectory(${CLIENT_ROOT_DIR}/3rd/qtgamepad)
-        # Link both the C++ module and QML plugin
-        if(TARGET GamepadLegacy)
-            target_link_libraries(${PROJECT} PRIVATE GamepadLegacy)
-        endif()
-        if(TARGET GamepadLegacyQuickPrivate)
-            target_link_libraries(${PROJECT} PRIVATE GamepadLegacyQuickPrivate)
-        endif()
-        message(STATUS "Gamepad support enabled for Android")
-    else()
-        message(STATUS "Qt6CorePrivate not found. Gamepad support disabled for Android.")
-    endif()
-endif()
-
 set(LIBS ${LIBS} qt6keychain)
 
 include_directories(

client/cmake/macos_ne.cmake

@@ -163,7 +163,7 @@ add_custom_command(TARGET ${PROJECT} POST_BUILD
     COMMAND ${CMAKE_COMMAND} -E make_directory
             $<TARGET_BUNDLE_DIR:AmneziaVPN>/Contents/Frameworks
     COMMAND /usr/bin/find "$<TARGET_BUNDLE_DIR:AmneziaVPN>/Contents/Frameworks/OpenVPNAdapter.framework" -name "*.sha256" -delete
-    COMMAND /usr/bin/codesign --force --sign "Apple Distribution: Privacy Technologies OU"
+    COMMAND /usr/bin/codesign --force --sign "Apple Distribution"
             "$<TARGET_BUNDLE_DIR:AmneziaVPN>/Contents/Frameworks/OpenVPNAdapter.framework/Versions/Current/OpenVPNAdapter"
     COMMAND ${QT_BIN_DIR_DETECTED}/macdeployqt $<TARGET_BUNDLE_DIR:AmneziaVPN> -appstore-compliant -qmldir=${CMAKE_CURRENT_SOURCE_DIR}
     COMMENT "Signing OpenVPNAdapter framework"

client/cmake/sources.cmake

@@ -23,6 +23,12 @@ set(HEADERS ${HEADERS}
     ${CMAKE_CURRENT_BINARY_DIR}/version.h
     ${CLIENT_ROOT_DIR}/core/sshclient.h
     ${CLIENT_ROOT_DIR}/core/networkUtilities.h
+    ${CLIENT_ROOT_DIR}/core/transport/igatewaytransport.h
+    ${CLIENT_ROOT_DIR}/core/transport/httpGatewayTransport.h
+    ${CLIENT_ROOT_DIR}/core/transport/dnsGatewayTransport.h
+    ${CLIENT_ROOT_DIR}/core/transport/dns/dnsResolver.h
+    ${CLIENT_ROOT_DIR}/core/transport/dns/dnsTunnel.h
+    ${CLIENT_ROOT_DIR}/core/transport/dns/dnsPacket_p.h
     ${CLIENT_ROOT_DIR}/core/serialization/serialization.h
     ${CLIENT_ROOT_DIR}/core/serialization/transfer.h
     ${CLIENT_ROOT_DIR}/../common/logger/logger.h
@@ -68,6 +74,11 @@ set(SOURCES ${SOURCES}
     ${CLIENT_ROOT_DIR}/protocols/vpnprotocol.cpp
     ${CLIENT_ROOT_DIR}/core/sshclient.cpp
     ${CLIENT_ROOT_DIR}/core/networkUtilities.cpp
+    ${CLIENT_ROOT_DIR}/core/transport/httpGatewayTransport.cpp
+    ${CLIENT_ROOT_DIR}/core/transport/dnsGatewayTransport.cpp
+    ${CLIENT_ROOT_DIR}/core/transport/dns/dnsResolver.cpp
+    ${CLIENT_ROOT_DIR}/core/transport/dns/dnsTunnel.cpp
+    ${CLIENT_ROOT_DIR}/core/transport/dns/dnsPacket.cpp
     ${CLIENT_ROOT_DIR}/core/serialization/outbound.cpp
     ${CLIENT_ROOT_DIR}/core/serialization/inbound.cpp
     ${CLIENT_ROOT_DIR}/core/serialization/ss.cpp
@@ -181,6 +192,7 @@ if(WIN32 OR (APPLE AND NOT IOS AND NOT MACOS_NE) OR (LINUX AND NOT ANDROID))
 
     set(HEADERS ${HEADERS}
         ${CLIENT_ROOT_DIR}/core/ipcclient.h
+        ${CLIENT_ROOT_DIR}/core/privileged_process.h
         ${CLIENT_ROOT_DIR}/ui/systemtray_notificationhandler.h
         ${CLIENT_ROOT_DIR}/protocols/openvpnprotocol.h
         ${CLIENT_ROOT_DIR}/protocols/openvpnovercloakprotocol.h
@@ -193,6 +205,7 @@ if(WIN32 OR (APPLE AND NOT IOS AND NOT MACOS_NE) OR (LINUX AND NOT ANDROID))
 
     set(SOURCES ${SOURCES}
         ${CLIENT_ROOT_DIR}/core/ipcclient.cpp
+        ${CLIENT_ROOT_DIR}/core/privileged_process.cpp
         ${CLIENT_ROOT_DIR}/mozilla/localsocketcontroller.cpp
         ${CLIENT_ROOT_DIR}/ui/systemtray_notificationhandler.cpp
         ${CLIENT_ROOT_DIR}/protocols/openvpnprotocol.cpp

client/core/api/apiDefs.h

@@ -10,10 +10,8 @@ namespace apiDefs
         AmneziaFreeV3,
         AmneziaPremiumV1,
         AmneziaPremiumV2,
-        AmneziaTrialV2,
         SelfHosted,
-        ExternalPremium,
-        ExternalTrial
+        ExternalPremium
     };
 
     enum ConfigSource {
@@ -34,7 +32,6 @@ namespace apiDefs
         constexpr QLatin1String stackType("stack_type");
         constexpr QLatin1String serviceType("service_type");
         constexpr QLatin1String cliVersion("cli_version");
-        constexpr QLatin1String cliName("cli_name");
         constexpr QLatin1String supportedProtocols("supported_protocols");
 
         constexpr QLatin1String vpnKey("vpn_key");
@@ -82,7 +79,7 @@ namespace apiDefs
         constexpr QLatin1String adEndpoint("ad_endpoint");
     }
 
-    const int requestTimeoutMsecs = 12 * 1000; // 12 secs
+    const int requestTimeoutMsecs = 30 * 1000; // 30 secs (increased for DNS transport testing)
 }
 
 #endif // APIDEFS_H

client/core/api/apiUtils.cpp

@@ -58,24 +58,18 @@ apiDefs::ConfigType apiUtils::getConfigType(const QJsonObject &serverConfigObjec
     };
     case apiDefs::ConfigSource::AmneziaGateway: {
         constexpr QLatin1String servicePremium("amnezia-premium");
-        constexpr QLatin1String serviceTrial("amnezia-trial");
         constexpr QLatin1String serviceFree("amnezia-free");
         constexpr QLatin1String serviceExternalPremium("external-premium");
-        constexpr QLatin1String serviceExternalTrial("external-trial");
 
         auto apiConfigObject = serverConfigObject.value(apiDefs::key::apiConfig).toObject();
         auto serviceType = apiConfigObject.value(apiDefs::key::serviceType).toString();
 
         if (serviceType == servicePremium) {
             return apiDefs::ConfigType::AmneziaPremiumV2;
-        } else if (serviceType == serviceTrial) {
-            return apiDefs::ConfigType::AmneziaTrialV2;
         } else if (serviceType == serviceFree) {
             return apiDefs::ConfigType::AmneziaFreeV3;
         } else if (serviceType == serviceExternalPremium) {
             return apiDefs::ConfigType::ExternalPremium;
-        } else if (serviceType == serviceExternalTrial) {
-            return apiDefs::ConfigType::ExternalTrial;
         }
     }
     default: {
@@ -96,7 +90,6 @@ amnezia::ErrorCode apiUtils::checkNetworkReplyErrors(const QList<QSslError> &ssl
     const int httpStatusCodeConflict = 409;
     const int httpStatusCodeNotFound = 404;
     const int httpStatusCodeNotImplemented = 501;
-    const int httpStatusCodeUnprocessableEntity = 422;
 
     if (!sslErrors.empty()) {
         qDebug().noquote() << sslErrors;
@@ -129,8 +122,6 @@ amnezia::ErrorCode apiUtils::checkNetworkReplyErrors(const QList<QSslError> &ssl
             return amnezia::ErrorCode::ApiNotFoundError;
         } else if (httpStatusFromBody == httpStatusCodeNotImplemented) {
             return amnezia::ErrorCode::ApiUpdateRequestError;
-        } else if (httpStatusFromBody == httpStatusCodeUnprocessableEntity) {
-            return amnezia::ErrorCode::ApiSubscriptionExpiredError;
         }
         return amnezia::ErrorCode::ApiConfigDownloadError;
     }
@@ -142,8 +133,7 @@ amnezia::ErrorCode apiUtils::checkNetworkReplyErrors(const QList<QSslError> &ssl
 bool apiUtils::isPremiumServer(const QJsonObject &serverConfigObject)
 {
     static const QSet<apiDefs::ConfigType> premiumTypes = { apiDefs::ConfigType::AmneziaPremiumV1, apiDefs::ConfigType::AmneziaPremiumV2,
-                                                            apiDefs::ConfigType::AmneziaTrialV2, apiDefs::ConfigType::ExternalPremium,
-                                                            apiDefs::ConfigType::ExternalTrial };
+                                                            apiDefs::ConfigType::ExternalPremium };
     return premiumTypes.contains(getConfigType(serverConfigObject));
 }
 
@@ -187,9 +177,7 @@ QString apiUtils::getPremiumV1VpnKey(const QJsonObject &serverConfigObject)
 
 QString apiUtils::getPremiumV2VpnKey(const QJsonObject &serverConfigObject)
 {
-    auto configType = apiUtils::getConfigType(serverConfigObject);
-    if (configType != apiDefs::ConfigType::AmneziaPremiumV2 && configType != apiDefs::ConfigType::AmneziaTrialV2
-        && configType != apiDefs::ConfigType::ExternalPremium && configType != apiDefs::ConfigType::ExternalTrial) {
+    if (apiUtils::getConfigType(serverConfigObject) != apiDefs::ConfigType::AmneziaPremiumV2) {
         return {};
     }
 

client/core/controllers/coreController.cpp

@@ -135,7 +135,7 @@ void CoreController::initControllers()
             new SettingsController(m_serversModel, m_containersModel, m_languageModel, m_sitesModel, m_appSplitTunnelingModel, m_settings));
     m_engine->rootContext()->setContextProperty("SettingsController", m_settingsController.get());
 
-    m_sitesController.reset(new SitesController(m_settings, m_sitesModel));
+    m_sitesController.reset(new SitesController(m_settings, m_vpnConnection, m_sitesModel));
     m_engine->rootContext()->setContextProperty("SitesController", m_sitesController.get());
 
     m_allowedDnsController.reset(new AllowedDnsController(m_settings, m_allowedDnsModel));
@@ -153,8 +153,6 @@ void CoreController::initControllers()
 
     m_apiConfigsController.reset(new ApiConfigsController(m_serversModel, m_apiServicesModel, m_settings));
     m_engine->rootContext()->setContextProperty("ApiConfigsController", m_apiConfigsController.get());
-    connect(m_apiConfigsController.get(), &ApiConfigsController::subscriptionRefreshNeeded,
-            this, [this]() { m_apiSettingsController->getAccountInfo(false); });
 
     m_apiNewsController.reset(new ApiNewsController(m_newsModel, m_settings, m_serversModel, this));
     m_engine->rootContext()->setContextProperty("ApiNewsController", m_apiNewsController.get());
@@ -370,11 +368,7 @@ void CoreController::initPrepareConfigHandler()
             return;
         }
 
-        m_installController->validateConfig();
-    });
-
-    connect(m_installController.get(), &InstallController::configValidated, this, [this](bool isValid) {
-        if (!isValid) {
+        if (!m_installController->isConfigValid()) {
             emit m_vpnConnection->connectionStateChanged(Vpn::ConnectionState::Disconnected);
             return;
         }

client/core/controllers/gatewayController.cpp

@@ -1,29 +1,22 @@
 #include "gatewayController.h"
 
-#include <algorithm>
-#include <functional>
-#include <random>
-
-#include <QCryptographicHash>
+#include <QDebug>
 #include <QJsonArray>
 #include <QJsonDocument>
 #include <QJsonObject>
-#include <QNetworkReply>
-#include <QPromise>
-#include <QUrl>
+#include <QMutexLocker>
+#include <QSharedPointer>
+#include <QThread>
+#include <QtConcurrent>
 
 #include "QBlockCipher.h"
 #include "QRsa.h"
 
 #include "amnezia_application.h"
-#include "core/api/apiUtils.h"
-#include "core/networkUtilities.h"
+#include "core/transport/dnsGatewayTransport.h"
+#include "core/transport/httpGatewayTransport.h"
 #include "utilities.h"
 
-#ifdef AMNEZIA_DESKTOP
-    #include "core/ipcclient.h"
-#endif
-
 namespace
 {
     namespace configKey
@@ -36,636 +29,330 @@ namespace
         constexpr char keyPayload[] = "key_payload";
     }
 
-    constexpr QLatin1String errorResponsePattern1("No active configuration found for");
-    constexpr QLatin1String errorResponsePattern2("No non-revoked public key found for");
-    constexpr QLatin1String errorResponsePattern3("Account not found.");
-
-    constexpr QLatin1String updateRequestResponsePattern("client version update is required");
-
-    constexpr int httpStatusCodeNotFound = 404;
-    constexpr int httpStatusCodeConflict = 409;
-
-    constexpr int httpStatusCodeNotImplemented = 501;
-    constexpr int httpStatusCodeUnprocessableEntity = 422;
-}
-
-GatewayController::GatewayController(const QString &gatewayEndpoint, const bool isDevEnvironment, const int requestTimeoutMsecs,
-                                     const bool isStrictKillSwitchEnabled, QObject *parent)
-    : QObject(parent),
-      m_gatewayEndpoint(gatewayEndpoint),
-      m_isDevEnvironment(isDevEnvironment),
-      m_requestTimeoutMsecs(requestTimeoutMsecs),
-      m_isStrictKillSwitchEnabled(isStrictKillSwitchEnabled)
-{
-}
-
-GatewayController::EncryptedRequestData GatewayController::prepareRequest(const QString &endpoint, const QJsonObject &apiPayload)
-{
-    EncryptedRequestData encRequestData;
-    encRequestData.errorCode = ErrorCode::NoError;
-
-#ifdef Q_OS_IOS
-    IosController::Instance()->requestInetAccess();
-    QThread::msleep(10);
-#endif
-
-    encRequestData.request.setTransferTimeout(m_requestTimeoutMsecs);
-    encRequestData.request.setHeader(QNetworkRequest::ContentTypeHeader, "application/json");
-    encRequestData.request.setRawHeader(QString("X-Client-Request-ID").toUtf8(), QUuid::createUuid().toString(QUuid::WithoutBraces).toUtf8());
-    encRequestData.request.setUrl(endpoint.arg(m_proxyUrl.isEmpty() ? m_gatewayEndpoint : m_proxyUrl));
-
-    // bypass killSwitch exceptions for API-gateway
-#ifdef AMNEZIA_DESKTOP
-    if (m_isStrictKillSwitchEnabled) {
-        QString host = QUrl(encRequestData.request.url()).host();
-        QString ip = NetworkUtilities::getIPAddress(host);
-        if (!ip.isEmpty()) {
-            IpcClient::withInterface([&](QSharedPointer<IpcInterfaceReplica> iface) {
-                QRemoteObjectPendingReply<bool> reply = iface->addKillSwitchAllowedRange(QStringList { ip });
-                if (!reply.waitForFinished(1000) || !reply.returnValue())
-                    qWarning() << "GatewayController::prepareRequest(): Failed to execute remote addKillSwitchAllowedRange call";
-            });
+    amnezia::transport::dns::DnsProtocol dnsProtocolFromPrimary(PrimaryTransport p)
+    {
+        switch (p) {
+        case PrimaryTransport::DnsUdp: return amnezia::transport::dns::DnsProtocol::Udp;
+        case PrimaryTransport::DnsTcp: return amnezia::transport::dns::DnsProtocol::Tcp;
+        case PrimaryTransport::DnsDot: return amnezia::transport::dns::DnsProtocol::Tls;
+        case PrimaryTransport::DnsDoh: return amnezia::transport::dns::DnsProtocol::Https;
+        case PrimaryTransport::DnsDoq: return amnezia::transport::dns::DnsProtocol::Quic;
+        default: return amnezia::transport::dns::DnsProtocol::Udp;
         }
     }
-#endif
+} // namespace
+
+TransportsConfig TransportsConfig::fromJson(const QJsonObject &json)
+{
+    using amnezia::transport::dns::DnsProtocol;
+
+    TransportsConfig config;
+
+    QString primaryStr = json.value("primary").toString("http").toLower();
+    if (primaryStr == "http") {
+        config.primary = PrimaryTransport::Http;
+    } else if (primaryStr == "dns_udp" || primaryStr == "udp") {
+        config.primary = PrimaryTransport::DnsUdp;
+    } else if (primaryStr == "dns_tcp" || primaryStr == "tcp") {
+        config.primary = PrimaryTransport::DnsTcp;
+    } else if (primaryStr == "dns_dot" || primaryStr == "dot") {
+        config.primary = PrimaryTransport::DnsDot;
+    } else if (primaryStr == "dns_doh" || primaryStr == "doh") {
+        config.primary = PrimaryTransport::DnsDoh;
+    } else if (primaryStr == "dns_doq" || primaryStr == "doq") {
+        config.primary = PrimaryTransport::DnsDoq;
+    }
+
+    config.retryCount = json.value("retry_count").toInt(3);
+    config.timeoutMs = json.value("timeout_ms").toInt(10000);
+
+    if (json.contains("http")) {
+        QJsonObject httpObj = json["http"].toObject();
+        config.httpEnabled = httpObj.value("enabled").toBool(true);
+        config.httpEndpoint = httpObj.value("endpoint").toString();
+    }
+
+    if (json.contains("dns_transports")) {
+        QJsonArray transportsArray = json["dns_transports"].toArray();
+        for (const auto &transportVal : transportsArray) {
+            QJsonObject transportObj = transportVal.toObject();
+            DnsTransportEntry entry;
+
+            entry.server = transportObj.value("server").toString();
+            entry.domain = transportObj.value("domain").toString();
+            entry.port = static_cast<quint16>(transportObj.value("port").toInt(15353));
+            entry.dohPath = transportObj.value("path").toString("/dns-query");
+
+            QString typeStr = transportObj.value("type").toString().toLower();
+            if (typeStr == "udp") {
+                entry.type = DnsProtocol::Udp;
+            } else if (typeStr == "tcp") {
+                entry.type = DnsProtocol::Tcp;
+            } else if (typeStr == "dot" || typeStr == "tls") {
+                entry.type = DnsProtocol::Tls;
+                if (!transportObj.contains("port")) entry.port = 8853;
+            } else if (typeStr == "doh" || typeStr == "https") {
+                entry.type = DnsProtocol::Https;
+                if (!transportObj.contains("port")) entry.port = 443;
+            } else if (typeStr == "doq" || typeStr == "quic") {
+                entry.type = DnsProtocol::Quic;
+                if (!transportObj.contains("port")) entry.port = 8853;
+            } else {
+                continue;
+            }
+
+            if (entry.isValid()) {
+                config.dnsTransports.append(entry);
+            }
+        }
+    }
+
+    return config;
+}
+
+GatewayController::GatewayController(const QString &gatewayEndpoint,
+                                     const bool isDevEnvironment,
+                                     const int requestTimeoutMsecs,
+                                     const bool isStrictKillSwitchEnabled,
+                                     QObject *parent)
+    : QObject(parent),
+      m_requestTimeoutMsecs(requestTimeoutMsecs),
+      m_gatewayEndpoint(gatewayEndpoint),
+      m_isDevEnvironment(isDevEnvironment),
+      m_isStrictKillSwitchEnabled(isStrictKillSwitchEnabled)
+{
+    auto httpTransport = std::make_shared<amnezia::transport::HttpGatewayTransport>(
+            m_gatewayEndpoint, m_isDevEnvironment, m_requestTimeoutMsecs, m_isStrictKillSwitchEnabled);
+    {
+        QMutexLocker lock(&m_transportMutex);
+        m_transport = std::move(httpTransport);
+    }
+}
+
+std::shared_ptr<amnezia::transport::IGatewayTransport> GatewayController::buildTransport(
+        const TransportsConfig &config, int requestTimeoutMsecs, bool isDevEnvironment, bool isStrictKillSwitchEnabled)
+{
+    using namespace amnezia::transport;
+
+    auto makeHttp = [&](const QString &httpEndpoint) {
+        return std::make_shared<HttpGatewayTransport>(
+                httpEndpoint, isDevEnvironment, requestTimeoutMsecs, isStrictKillSwitchEnabled);
+    };
+
+    if (config.primary == PrimaryTransport::Http) {
+        return makeHttp(config.httpEndpoint);
+    }
+
+    const auto wantedProtocol = dnsProtocolFromPrimary(config.primary);
+    for (const auto &entry : config.dnsTransports) {
+        if (entry.type == wantedProtocol && entry.isValid()) {
+            return std::make_shared<DnsGatewayTransport>(
+                    entry.type, entry.server, entry.domain, entry.port,
+                    requestTimeoutMsecs, isStrictKillSwitchEnabled, entry.dohPath);
+        }
+    }
+
+    return makeHttp(config.httpEndpoint);
+}
+
+void GatewayController::setTransportsConfig(const TransportsConfig &config)
+{
+    if (config.timeoutMs > 0) {
+        m_requestTimeoutMsecs = config.timeoutMs;
+    }
+    if (!config.httpEndpoint.isEmpty()) {
+        m_gatewayEndpoint = config.httpEndpoint;
+    }
+
+    TransportsConfig effective = config;
+    if (effective.httpEndpoint.isEmpty()) {
+        effective.httpEndpoint = m_gatewayEndpoint;
+    }
+
+    auto newTransport = buildTransport(effective, m_requestTimeoutMsecs, m_isDevEnvironment, m_isStrictKillSwitchEnabled);
+    QString activeName;
+    {
+        QMutexLocker lock(&m_transportMutex);
+        m_transport = std::move(newTransport);
+        activeName = m_transport ? m_transport->name() : QStringLiteral("none");
+    }
+
+    qDebug() << "[Transport] Active transport set to" << activeName;
+}
+
+TransportsConfig GatewayController::buildTransportsConfig()
+{
+    using amnezia::transport::dns::DnsProtocol;
+
+    TransportsConfig config;
+
+    QString server = QString(AGW_DNS_SERVER).trimmed();
+    QString domain = QString(AGW_DNS_DOMAIN).trimmed();
+
+    if (server.isEmpty() || domain.isEmpty()) {
+        qDebug() << "[Transport] DNS server/domain not configured, HTTP only";
+        return config;
+    }
+
+    QString primaryStr = QString(AGW_DNS_PRIMARY).trimmed().toLower();
+    if (primaryStr == "udp" || primaryStr == "dns_udp") {
+        config.primary = PrimaryTransport::DnsUdp;
+    } else if (primaryStr == "tcp" || primaryStr == "dns_tcp") {
+        config.primary = PrimaryTransport::DnsTcp;
+    } else if (primaryStr == "dot" || primaryStr == "dns_dot") {
+        config.primary = PrimaryTransport::DnsDot;
+    } else if (primaryStr == "doh" || primaryStr == "dns_doh") {
+        config.primary = PrimaryTransport::DnsDoh;
+    } else if (primaryStr == "doq" || primaryStr == "dns_doq") {
+        config.primary = PrimaryTransport::DnsDoq;
+    } else {
+        config.primary = PrimaryTransport::Http;
+    }
+
+    int retryCount = QString(AGW_DNS_RETRY_COUNT).trimmed().toInt();
+    config.retryCount = (retryCount > 0) ? retryCount : 3;
+
+    int timeoutMs = QString(AGW_DNS_TIMEOUT_MS).trimmed().toInt();
+    config.timeoutMs = (timeoutMs > 0) ? timeoutMs : 10000;
+
+    config.httpEnabled = true;
+
+    auto addTransport = [&](DnsProtocol type, const char *portDefine, quint16 defaultPort,
+                            const QString &dohPath = QString()) {
+        DnsTransportEntry entry;
+        entry.type = type;
+        entry.server = server;
+        entry.domain = domain;
+        quint16 port = QString(portDefine).trimmed().toUShort();
+        entry.port = (port > 0) ? port : defaultPort;
+        if (!dohPath.isEmpty()) entry.dohPath = dohPath;
+        config.dnsTransports.append(entry);
+    };
+
+    addTransport(DnsProtocol::Udp, AGW_DNS_PORT_UDP, 5353);
+    addTransport(DnsProtocol::Tcp, AGW_DNS_PORT_UDP, 5353);
+    addTransport(DnsProtocol::Tls, AGW_DNS_PORT_DOT, 853);
+
+    QString dohPath = QString(AGW_DNS_DOH_PATH).trimmed();
+    if (dohPath.isEmpty()) dohPath = "/dns-query";
+    addTransport(DnsProtocol::Https, AGW_DNS_PORT_DOH, 443, dohPath);
+
+    addTransport(DnsProtocol::Quic, AGW_DNS_PORT_DOQ, 8853);
+
+    qDebug() << "[Transport] Built config from env: server=" << server << "domain=" << domain
+             << "transports=" << config.dnsTransports.size() << "primary=" << static_cast<int>(config.primary);
+
+    return config;
+}
+
+GatewayController::EncryptedRequest GatewayController::encryptRequest(const QJsonObject &apiPayload)
+{
+    EncryptedRequest result;
+    result.errorCode = amnezia::ErrorCode::NoError;
 
     QSimpleCrypto::QBlockCipher blockCipher;
-    encRequestData.key = blockCipher.generatePrivateSalt(32);
-    encRequestData.iv = blockCipher.generatePrivateSalt(32);
-    encRequestData.salt = blockCipher.generatePrivateSalt(8);
+    result.key = blockCipher.generatePrivateSalt(32);
+    result.iv = blockCipher.generatePrivateSalt(16);
+    result.salt = blockCipher.generatePrivateSalt(8);
 
     QJsonObject keyPayload;
-    keyPayload[configKey::aesKey] = QString(encRequestData.key.toBase64());
-    keyPayload[configKey::aesIv] = QString(encRequestData.iv.toBase64());
-    keyPayload[configKey::aesSalt] = QString(encRequestData.salt.toBase64());
+    keyPayload[configKey::aesKey] = QString(result.key.toBase64());
+    keyPayload[configKey::aesIv] = QString(result.iv.toBase64());
+    keyPayload[configKey::aesSalt] = QString(result.salt.toBase64());
 
     QByteArray encryptedKeyPayload;
     QByteArray encryptedApiPayload;
     try {
         QSimpleCrypto::QRsa rsa;
-
         EVP_PKEY *publicKey = nullptr;
         try {
             QByteArray rsaKey = m_isDevEnvironment ? DEV_AGW_PUBLIC_KEY : PROD_AGW_PUBLIC_KEY;
-            QSimpleCrypto::QRsa rsa;
+            rsaKey = rsaKey.trimmed();
+            rsaKey.replace("\\n", "\n");
             publicKey = rsa.getPublicKeyFromByteArray(rsaKey);
         } catch (...) {
             Utils::logException();
             qCritical() << "error loading public key from environment variables";
-            encRequestData.errorCode = ErrorCode::ApiMissingAgwPublicKey;
-            return encRequestData;
+            result.errorCode = amnezia::ErrorCode::ApiMissingAgwPublicKey;
+            return result;
         }
 
-        encryptedKeyPayload = rsa.encrypt(QJsonDocument(keyPayload).toJson(), publicKey, RSA_PKCS1_PADDING);
+        encryptedKeyPayload = rsa.encrypt(QJsonDocument(keyPayload).toJson(QJsonDocument::Compact),
+                                          publicKey, RSA_PKCS1_PADDING);
         EVP_PKEY_free(publicKey);
 
-        encryptedApiPayload = blockCipher.encryptAesBlockCipher(QJsonDocument(apiPayload).toJson(), encRequestData.key, encRequestData.iv,
-                                                                "", encRequestData.salt);
+        encryptedApiPayload = blockCipher.encryptAesBlockCipher(QJsonDocument(apiPayload).toJson(QJsonDocument::Compact),
+                                                                result.key, result.iv, "", result.salt);
     } catch (...) {
         Utils::logException();
         qCritical() << "error when encrypting the request body";
-        encRequestData.errorCode = ErrorCode::ApiConfigDecryptionError;
-        return encRequestData;
+        result.errorCode = amnezia::ErrorCode::ApiConfigDecryptionError;
+        return result;
     }
 
     QJsonObject requestBody;
     requestBody[configKey::keyPayload] = QString(encryptedKeyPayload.toBase64());
     requestBody[configKey::apiPayload] = QString(encryptedApiPayload.toBase64());
 
-    encRequestData.requestBody = QJsonDocument(requestBody).toJson();
-    return encRequestData;
+    result.body = QJsonDocument(requestBody).toJson(QJsonDocument::Compact);
+    return result;
 }
 
-GatewayController::DecryptionResult GatewayController::tryDecryptResponseBody(const QByteArray &encryptedResponseBody,
-                                                                              QNetworkReply::NetworkError replyError, const QByteArray &key,
-                                                                              const QByteArray &iv, const QByteArray &salt)
+amnezia::transport::DecryptionResult GatewayController::decryptResponse(const QByteArray &encryptedResponseBody,
+                                                                         const QByteArray &key,
+                                                                         const QByteArray &iv,
+                                                                         const QByteArray &salt) const
 {
-    DecryptionResult result;
-    result.decryptedBody = encryptedResponseBody;
-    result.isDecryptionSuccessful = false;
+    amnezia::transport::DecryptionResult result;
+    result.decrypted = encryptedResponseBody;
+    result.isOk = false;
+
+    if (encryptedResponseBody.isEmpty()) {
+        return result;
+    }
 
     try {
         QSimpleCrypto::QBlockCipher blockCipher;
-        result.decryptedBody = blockCipher.decryptAesBlockCipher(encryptedResponseBody, key, iv, "", salt);
-        result.isDecryptionSuccessful = true;
+        result.decrypted = blockCipher.decryptAesBlockCipher(encryptedResponseBody, key, iv, "", salt);
+        result.isOk = true;
     } catch (...) {
-        result.decryptedBody = encryptedResponseBody;
-        result.isDecryptionSuccessful = false;
+        result.decrypted = encryptedResponseBody;
+        result.isOk = false;
     }
 
     return result;
 }
 
-ErrorCode GatewayController::post(const QString &endpoint, const QJsonObject apiPayload, QByteArray &responseBody)
+std::shared_ptr<amnezia::transport::IGatewayTransport> GatewayController::currentTransport() const
 {
-    EncryptedRequestData encRequestData = prepareRequest(endpoint, apiPayload);
-    if (encRequestData.errorCode != ErrorCode::NoError) {
-        return encRequestData.errorCode;
-    }
-
-    QNetworkReply *reply = amnApp->networkManager()->post(encRequestData.request, encRequestData.requestBody);
-
-    QEventLoop wait;
-    connect(reply, &QNetworkReply::finished, &wait, &QEventLoop::quit);
-
-    QList<QSslError> sslErrors;
-    connect(reply, &QNetworkReply::sslErrors, [this, &sslErrors](const QList<QSslError> &errors) { sslErrors = errors; });
-    wait.exec(QEventLoop::ExcludeUserInputEvents);
-
-    QByteArray encryptedResponseBody = reply->readAll();
-    QString replyErrorString = reply->errorString();
-    auto replyError = reply->error();
-    int httpStatusCode = reply->attribute(QNetworkRequest::HttpStatusCodeAttribute).toInt();
-
-    reply->deleteLater();
-
-    auto decryptionResult =
-            tryDecryptResponseBody(encryptedResponseBody, replyError, encRequestData.key, encRequestData.iv, encRequestData.salt);
-
-    if (sslErrors.isEmpty() && shouldBypassProxy(replyError, decryptionResult.decryptedBody, decryptionResult.isDecryptionSuccessful)) {
-        auto requestFunction = [&encRequestData, &encryptedResponseBody](const QString &url) {
-            encRequestData.request.setUrl(url);
-            return amnApp->networkManager()->post(encRequestData.request, encRequestData.requestBody);
-        };
-
-        auto replyProcessingFunction = [&encryptedResponseBody, &replyErrorString, &replyError, &httpStatusCode, &sslErrors, &encRequestData,
-                                        &decryptionResult, this](QNetworkReply *reply, const QList<QSslError> &nestedSslErrors) {
-            encryptedResponseBody = reply->readAll();
-            replyErrorString = reply->errorString();
-            replyError = reply->error();
-            httpStatusCode = reply->attribute(QNetworkRequest::HttpStatusCodeAttribute).toInt();
-
-            decryptionResult =
-                    tryDecryptResponseBody(encryptedResponseBody, replyError, encRequestData.key, encRequestData.iv, encRequestData.salt);
-
-            if (!sslErrors.isEmpty()
-                || shouldBypassProxy(replyError, decryptionResult.decryptedBody, decryptionResult.isDecryptionSuccessful)) {
-                sslErrors = nestedSslErrors;
-                return false;
-            }
-            return true;
-        };
-
-        auto serviceType = apiPayload.value(apiDefs::key::serviceType).toString("");
-        auto userCountryCode = apiPayload.value(apiDefs::key::userCountryCode).toString("");
-        bypassProxy(endpoint, serviceType, userCountryCode, requestFunction, replyProcessingFunction);
-    }
-
-    auto errorCode =
-            apiUtils::checkNetworkReplyErrors(sslErrors, replyErrorString, replyError, httpStatusCode, decryptionResult.decryptedBody);
-    if (errorCode) {
-        return errorCode;
-    }
-
-    if (!decryptionResult.isDecryptionSuccessful) {
-        qCritical() << "error when decrypting the request body";
-        return ErrorCode::ApiConfigDecryptionError;
-    }
-
-    responseBody = decryptionResult.decryptedBody;
-    return ErrorCode::NoError;
+    QMutexLocker lock(&m_transportMutex);
+    return m_transport;
 }
 
-QFuture<QPair<ErrorCode, QByteArray>> GatewayController::postAsync(const QString &endpoint, const QJsonObject apiPayload)
+amnezia::ErrorCode GatewayController::post(const QString &endpoint, const QJsonObject apiPayload, QByteArray &responseBody)
 {
-    auto promise = QSharedPointer<QPromise<QPair<ErrorCode, QByteArray>>>::create();
-    promise->start();
-
-    EncryptedRequestData encRequestData = prepareRequest(endpoint, apiPayload);
-    if (encRequestData.errorCode != ErrorCode::NoError) {
-        promise->addResult(qMakePair(encRequestData.errorCode, QByteArray()));
-        promise->finish();
-        return promise->future();
+    EncryptedRequest enc = encryptRequest(apiPayload);
+    if (enc.errorCode != amnezia::ErrorCode::NoError) {
+        return enc.errorCode;
     }
 
-    QNetworkReply *reply = amnApp->networkManager()->post(encRequestData.request, encRequestData.requestBody);
-
-    auto sslErrors = QSharedPointer<QList<QSslError>>::create();
-
-    connect(reply, &QNetworkReply::sslErrors, [sslErrors](const QList<QSslError> &errors) { *sslErrors = errors; });
-
-    connect(reply, &QNetworkReply::finished, reply, [promise, sslErrors, encRequestData, endpoint, apiPayload, reply, this]() mutable {
-        QByteArray encryptedResponseBody = reply->readAll();
-        QString replyErrorString = reply->errorString();
-        auto replyError = reply->error();
-        int httpStatusCode = reply->attribute(QNetworkRequest::HttpStatusCodeAttribute).toInt();
-
-        reply->deleteLater();
-
-        auto decryptionResult =
-                tryDecryptResponseBody(encryptedResponseBody, replyError, encRequestData.key, encRequestData.iv, encRequestData.salt);
-
-        auto processResponse = [promise, encRequestData](const GatewayController::DecryptionResult &decryptionResult,
-                                                         const QList<QSslError> &sslErrors, QNetworkReply::NetworkError replyError,
-                                                         const QString &replyErrorString, int httpStatusCode) {
-            auto errorCode = apiUtils::checkNetworkReplyErrors(sslErrors, replyErrorString, replyError, httpStatusCode,
-                                                               decryptionResult.decryptedBody);
-            if (errorCode) {
-                promise->addResult(qMakePair(errorCode, QByteArray()));
-                promise->finish();
-                return;
-            }
-
-            if (!decryptionResult.isDecryptionSuccessful) {
-                Utils::logException();
-                qCritical() << "error when decrypting the request body";
-                promise->addResult(qMakePair(ErrorCode::ApiConfigDecryptionError, QByteArray()));
-                promise->finish();
-                return;
-            }
-
-            promise->addResult(qMakePair(ErrorCode::NoError, decryptionResult.decryptedBody));
-            promise->finish();
-        };
-
-        if (sslErrors->isEmpty() && shouldBypassProxy(replyError, decryptionResult.decryptedBody, decryptionResult.isDecryptionSuccessful)) {
-            auto serviceType = apiPayload.value(apiDefs::key::serviceType).toString("");
-            auto userCountryCode = apiPayload.value(apiDefs::key::userCountryCode).toString("");
-
-            QStringList baseUrls;
-            if (m_isDevEnvironment) {
-                baseUrls = QString(DEV_S3_ENDPOINT).split(", ");
-            } else {
-                baseUrls = QString(PROD_S3_ENDPOINT).split(", ");
-            }
-
-            QStringList proxyStorageUrls;
-            if (!serviceType.isEmpty()) {
-                for (const auto &baseUrl : baseUrls) {
-                    QByteArray path = ("endpoints-" + serviceType + "-" + userCountryCode).toUtf8();
-                    proxyStorageUrls.push_back(baseUrl + path.toBase64(QByteArray::Base64UrlEncoding | QByteArray::OmitTrailingEquals)
-                                               + ".json");
-                }
-            }
-            for (const auto &baseUrl : baseUrls)
-                proxyStorageUrls.push_back(baseUrl + "endpoints.json");
-
-            getProxyUrlsAsync(proxyStorageUrls, 0, [this, encRequestData, endpoint, processResponse](const QStringList &proxyUrls) {
-                getProxyUrlAsync(proxyUrls, 0, [this, encRequestData, endpoint, processResponse](const QString &proxyUrl) {
-                    bypassProxyAsync(endpoint, proxyUrl, encRequestData,
-                                     [processResponse, this](const QByteArray &decryptedBody, bool isDecryptionSuccessful,
-                                                             const QList<QSslError> &sslErrors, QNetworkReply::NetworkError replyError,
-                                                             const QString &replyErrorString, int httpStatusCode) {
-                                         GatewayController::DecryptionResult result;
-                                         result.decryptedBody = decryptedBody;
-                                         result.isDecryptionSuccessful = isDecryptionSuccessful;
-                                         processResponse(result, sslErrors, replyError, replyErrorString, httpStatusCode);
-                                     });
-                });
-            });
-
-        } else {
-            processResponse(decryptionResult, *sslErrors, replyError, replyErrorString, httpStatusCode);
-        }
-    });
-
-    return promise->future();
-}
-
-QStringList GatewayController::getProxyUrls(const QString &serviceType, const QString &userCountryCode)
-{
-    QNetworkRequest request;
-    request.setTransferTimeout(m_requestTimeoutMsecs);
-    request.setHeader(QNetworkRequest::ContentTypeHeader, "application/json");
-
-    QEventLoop wait;
-    QList<QSslError> sslErrors;
-    QNetworkReply *reply;
-
-    QStringList baseUrls;
-    if (m_isDevEnvironment) {
-        baseUrls = QString(DEV_S3_ENDPOINT).split(", ");
-    } else {
-        baseUrls = QString(PROD_S3_ENDPOINT).split(", ");
-    }
-    std::random_device randomDevice;
-    std::mt19937 generator(randomDevice());
-    std::shuffle(baseUrls.begin(), baseUrls.end(), generator);
-
-    QByteArray key = m_isDevEnvironment ? DEV_AGW_PUBLIC_KEY : PROD_AGW_PUBLIC_KEY;
-
-    QStringList proxyStorageUrls;
-    if (!serviceType.isEmpty()) {
-        for (const auto &baseUrl : baseUrls) {
-            QByteArray path = ("endpoints-" + serviceType + "-" + userCountryCode).toUtf8();
-            proxyStorageUrls.push_back(baseUrl + path.toBase64(QByteArray::Base64UrlEncoding | QByteArray::OmitTrailingEquals) + ".json");
-        }
-    }
-    for (const auto &baseUrl : baseUrls) {
-        proxyStorageUrls.push_back(baseUrl + "endpoints.json");
+    auto transport = currentTransport();
+    if (!transport) {
+        return amnezia::ErrorCode::AmneziaServiceConnectionFailed;
     }
 
-    for (const auto &proxyStorageUrl : proxyStorageUrls) {
-        request.setUrl(proxyStorageUrl);
-        reply = amnApp->networkManager()->get(request);
-
-        connect(reply, &QNetworkReply::finished, &wait, &QEventLoop::quit);
-        connect(reply, &QNetworkReply::sslErrors, [this, &sslErrors](const QList<QSslError> &errors) { sslErrors = errors; });
-        wait.exec(QEventLoop::ExcludeUserInputEvents);
-
-        if (reply->error() == QNetworkReply::NetworkError::NoError) {
-            auto encryptedResponseBody = reply->readAll();
-            reply->deleteLater();
-
-            EVP_PKEY *privateKey = nullptr;
-            QByteArray responseBody;
-            try {
-                if (!m_isDevEnvironment) {
-                    QCryptographicHash hash(QCryptographicHash::Sha512);
-                    hash.addData(key);
-                    QByteArray hashResult = hash.result().toHex();
-
-                    QByteArray key = QByteArray::fromHex(hashResult.left(64));
-                    QByteArray iv = QByteArray::fromHex(hashResult.mid(64, 32));
-
-                    QByteArray ba = QByteArray::fromBase64(encryptedResponseBody);
-
-                    QSimpleCrypto::QBlockCipher blockCipher;
-                    responseBody = blockCipher.decryptAesBlockCipher(ba, key, iv);
-                } else {
-                    responseBody = encryptedResponseBody;
-                }
-            } catch (...) {
-                Utils::logException();
-                qCritical() << "error loading private key from environment variables or decrypting payload" << encryptedResponseBody;
-                continue;
-            }
-
-            auto endpointsArray = QJsonDocument::fromJson(responseBody).array();
-
-            QStringList endpoints;
-            for (const auto &endpoint : endpointsArray) {
-                endpoints.push_back(endpoint.toString());
-            }
-            return endpoints;
-        } else {
-            auto replyError = reply->error();
-            int httpStatusCode = reply->attribute(QNetworkRequest::HttpStatusCodeAttribute).toInt();
-            qDebug() << replyError;
-            qDebug() << httpStatusCode;
-            qDebug() << "go to the next storage endpoint";
-
-            reply->deleteLater();
-        }
-    }
-    return {};
-}
-
-bool GatewayController::shouldBypassProxy(const QNetworkReply::NetworkError &replyError, const QByteArray &decryptedResponseBody,
-                                          bool isDecryptionSuccessful)
-{
-    const QByteArray &responseBody = decryptedResponseBody;
-
-    int httpStatus = -1;
-    if (isDecryptionSuccessful) {
-        QJsonDocument jsonDoc = QJsonDocument::fromJson(responseBody);
-        if (jsonDoc.isObject()) {
-            QJsonObject jsonObj = jsonDoc.object();
-            httpStatus = jsonObj.value("http_status").toInt(-1);
-        }
-    } else {
-        qDebug() << "failed to decrypt the data";
-        return true;
-    }
-
-    if (replyError == QNetworkReply::NetworkError::OperationCanceledError || replyError == QNetworkReply::NetworkError::TimeoutError) {
-        qDebug() << "timeout occurred";
-        qDebug() << replyError;
-        return true;
-    } else if (responseBody.contains("html")) {
-        qDebug() << "the response contains an html tag";
-        return true;
-    } else if (httpStatus == httpStatusCodeNotFound) {
-        if (responseBody.contains(errorResponsePattern1) || responseBody.contains(errorResponsePattern2)
-            || responseBody.contains(errorResponsePattern3)) {
-            return false;
-        } else {
-            qDebug() << replyError;
-            return true;
-        }
-    } else if (httpStatus == httpStatusCodeNotImplemented) {
-        if (responseBody.contains(updateRequestResponsePattern)) {
-            return false;
-        } else {
-            qDebug() << replyError;
-            return true;
-        }
-    } else if (httpStatus == httpStatusCodeConflict) {
-        return false;
-    } else if (httpStatus == httpStatusCodeUnprocessableEntity) {
-        return false;
-    } else if (replyError != QNetworkReply::NetworkError::NoError) {
-        qDebug() << replyError;
-        return true;
-    }
-    return false;
-}
-
-void GatewayController::bypassProxy(const QString &endpoint, const QString &serviceType, const QString &userCountryCode,
-                                    std::function<QNetworkReply *(const QString &url)> requestFunction,
-                                    std::function<bool(QNetworkReply *reply, const QList<QSslError> &sslErrors)> replyProcessingFunction)
-{
-    QStringList proxyUrls = getProxyUrls(serviceType, userCountryCode);
-    std::random_device randomDevice;
-    std::mt19937 generator(randomDevice());
-    std::shuffle(proxyUrls.begin(), proxyUrls.end(), generator);
-
-    QByteArray responseBody;
-
-    auto bypassFunction = [this](const QString &endpoint, const QString &proxyUrl,
-                                 std::function<QNetworkReply *(const QString &url)> requestFunction,
-                                 std::function<bool(QNetworkReply * reply, const QList<QSslError> &sslErrors)> replyProcessingFunction) {
-        QEventLoop wait;
-        QList<QSslError> sslErrors;
-
-        qDebug() << "go to the next proxy endpoint";
-        QNetworkReply *reply = requestFunction(endpoint.arg(proxyUrl));
-
-        QObject::connect(reply, &QNetworkReply::finished, &wait, &QEventLoop::quit);
-        connect(reply, &QNetworkReply::sslErrors, [this, &sslErrors](const QList<QSslError> &errors) { sslErrors = errors; });
-        wait.exec(QEventLoop::ExcludeUserInputEvents);
-
-        auto result = replyProcessingFunction(reply, sslErrors);
-        reply->deleteLater();
-        return result;
+    auto decryptionHook = [this, key = enc.key, iv = enc.iv, salt = enc.salt](const QByteArray &encrypted) {
+        return decryptResponse(encrypted, key, iv, salt);
     };
 
-    if (m_proxyUrl.isEmpty()) {
-        QNetworkRequest request;
-        request.setTransferTimeout(1000);
-        request.setHeader(QNetworkRequest::ContentTypeHeader, "application/json");
-
-        QEventLoop wait;
-        QList<QSslError> sslErrors;
-        QNetworkReply *reply;
-
-        for (const QString &proxyUrl : proxyUrls) {
-            request.setUrl(proxyUrl + "lmbd-health");
-            reply = amnApp->networkManager()->get(request);
-
-            connect(reply, &QNetworkReply::finished, &wait, &QEventLoop::quit);
-            connect(reply, &QNetworkReply::sslErrors, [this, &sslErrors](const QList<QSslError> &errors) { sslErrors = errors; });
-            wait.exec(QEventLoop::ExcludeUserInputEvents);
-
-            if (reply->error() == QNetworkReply::NetworkError::NoError) {
-                reply->deleteLater();
-
-                m_proxyUrl = proxyUrl;
-                if (!m_proxyUrl.isEmpty()) {
-                    break;
-                }
-            } else {
-                reply->deleteLater();
-            }
-        }
-    }
-
-    if (!m_proxyUrl.isEmpty()) {
-        if (bypassFunction(endpoint, m_proxyUrl, requestFunction, replyProcessingFunction)) {
-            return;
-        }
-    }
-
-    for (const QString &proxyUrl : proxyUrls) {
-        if (bypassFunction(endpoint, proxyUrl, requestFunction, replyProcessingFunction)) {
-            m_proxyUrl = proxyUrl;
-            break;
-        }
-    }
+    return transport->send(endpoint, enc.body, responseBody, decryptionHook);
 }
 
-void GatewayController::getProxyUrlsAsync(const QStringList proxyStorageUrls, const int currentProxyStorageIndex,
-                                          std::function<void(const QStringList &)> onComplete)
+QFuture<QPair<amnezia::ErrorCode, QByteArray>> GatewayController::postAsync(const QString &endpoint, const QJsonObject apiPayload)
 {
-    if (currentProxyStorageIndex >= proxyStorageUrls.size()) {
-        onComplete({});
-        return;
-    }
-
-    QNetworkRequest request;
-    request.setTransferTimeout(m_requestTimeoutMsecs);
-    request.setHeader(QNetworkRequest::ContentTypeHeader, "application/json");
-    request.setUrl(proxyStorageUrls[currentProxyStorageIndex]);
-
-    QNetworkReply *reply = amnApp->networkManager()->get(request);
-
-    // connect(reply, &QNetworkReply::sslErrors, this, [state](const QList<QSslError> &e) { *(state->sslErrors) = e; });
-
-    connect(reply, &QNetworkReply::finished, this, [this, proxyStorageUrls, currentProxyStorageIndex, onComplete, reply]() {
-        if (reply->error() == QNetworkReply::NoError) {
-            QByteArray encrypted = reply->readAll();
-            reply->deleteLater();
-
-            QByteArray responseBody;
-            try {
-                QByteArray key = m_isDevEnvironment ? DEV_AGW_PUBLIC_KEY : PROD_AGW_PUBLIC_KEY;
-                if (!m_isDevEnvironment) {
-                    QCryptographicHash hash(QCryptographicHash::Sha512);
-                    hash.addData(key);
-                    QByteArray h = hash.result().toHex();
-
-                    QByteArray decKey = QByteArray::fromHex(h.left(64));
-                    QByteArray iv = QByteArray::fromHex(h.mid(64, 32));
-                    QByteArray ba = QByteArray::fromBase64(encrypted);
-
-                    QSimpleCrypto::QBlockCipher cipher;
-                    responseBody = cipher.decryptAesBlockCipher(ba, decKey, iv);
-                } else {
-                    responseBody = encrypted;
-                }
-            } catch (...) {
-                Utils::logException();
-                qCritical() << "error decrypting payload";
-                QMetaObject::invokeMethod(
-                        this, [=]() { getProxyUrlsAsync(proxyStorageUrls, currentProxyStorageIndex + 1, onComplete); }, Qt::QueuedConnection);
-                return;
-            }
-
-            QJsonArray endpointsArray = QJsonDocument::fromJson(responseBody).array();
-            QStringList endpoints;
-            for (const QJsonValue &endpoint : endpointsArray)
-                endpoints.push_back(endpoint.toString());
-
-            QStringList shuffled = endpoints;
-            std::random_device randomDevice;
-            std::mt19937 generator(randomDevice());
-            std::shuffle(shuffled.begin(), shuffled.end(), generator);
-
-            onComplete(shuffled);
-            return;
-        }
-
-        int httpStatusCode = reply->attribute(QNetworkRequest::HttpStatusCodeAttribute).toInt();
-        qDebug() << httpStatusCode;
-        qDebug() << "go to the next storage endpoint";
-        reply->deleteLater();
-        QMetaObject::invokeMethod(
-                this, [=]() { getProxyUrlsAsync(proxyStorageUrls, currentProxyStorageIndex + 1, onComplete); }, Qt::QueuedConnection);
-    });
-}
-
-void GatewayController::getProxyUrlAsync(const QStringList proxyUrls, const int currentProxyIndex,
-                                         std::function<void(const QString &)> onComplete)
-{
-    if (currentProxyIndex >= proxyUrls.size()) {
-        onComplete("");
-        return;
-    }
-
-    QNetworkRequest request;
-    request.setTransferTimeout(1000);
-    request.setHeader(QNetworkRequest::ContentTypeHeader, "application/json");
-    request.setUrl(proxyUrls[currentProxyIndex] + "lmbd-health");
-
-    QNetworkReply *reply = amnApp->networkManager()->get(request);
-
-    // connect(reply, &QNetworkReply::sslErrors, this, [state](const QList<QSslError> &e) {
-    //     *(state->sslErrors) = e;
-    // });
-
-    connect(reply, &QNetworkReply::finished, this, [this, proxyUrls, currentProxyIndex, onComplete, reply]() {
-        reply->deleteLater();
-
-        if (reply->error() == QNetworkReply::NoError) {
-            m_proxyUrl = proxyUrls[currentProxyIndex];
-            onComplete(m_proxyUrl);
-            return;
-        }
-
-        qDebug() << "go to the next proxy endpoint";
-        QMetaObject::invokeMethod(this, [=]() { getProxyUrlAsync(proxyUrls, currentProxyIndex + 1, onComplete); }, Qt::QueuedConnection);
-    });
-}
-
-void GatewayController::bypassProxyAsync(
-        const QString &endpoint, const QString &proxyUrl, EncryptedRequestData encRequestData,
-        std::function<void(const QByteArray &, bool, const QList<QSslError> &, QNetworkReply::NetworkError, const QString &, int)> onComplete)
-{
-    auto sslErrors = QSharedPointer<QList<QSslError>>::create();
-    if (proxyUrl.isEmpty()) {
-        onComplete(QByteArray(), false, *sslErrors, QNetworkReply::InternalServerError, "empty proxy url", 0);
-        return;
-    }
-
-    QNetworkRequest request = encRequestData.request;
-    request.setUrl(endpoint.arg(proxyUrl));
-
-    QNetworkReply *reply = amnApp->networkManager()->post(request, encRequestData.requestBody);
-
-    connect(reply, &QNetworkReply::sslErrors, this, [sslErrors](const QList<QSslError> &errors) { *sslErrors = errors; });
-
-    connect(reply, &QNetworkReply::finished, this, [sslErrors, onComplete, encRequestData, reply, this]() {
-        QByteArray encryptedResponseBody = reply->readAll();
-        QString replyErrorString = reply->errorString();
-        auto replyError = reply->error();
-        int httpStatusCode = reply->attribute(QNetworkRequest::HttpStatusCodeAttribute).toInt();
-
-        reply->deleteLater();
-
-        auto decryptionResult =
-                tryDecryptResponseBody(encryptedResponseBody, replyError, encRequestData.key, encRequestData.iv, encRequestData.salt);
-
-        onComplete(decryptionResult.decryptedBody, decryptionResult.isDecryptionSuccessful, *sslErrors, replyError, replyErrorString,
-                   httpStatusCode);
+    return QtConcurrent::run([this, endpoint, apiPayload]() {
+        QByteArray responseBody;
+        amnezia::ErrorCode errorCode = post(endpoint, apiPayload, responseBody);
+        return qMakePair(errorCode, responseBody);
     });
 }

client/core/controllers/gatewayController.h

@@ -2,69 +2,87 @@
 #define GATEWAYCONTROLLER_H
 
 #include <QFuture>
-#include <QNetworkReply>
+#include <QJsonArray>
+#include <QJsonObject>
+#include <QMutex>
 #include <QObject>
 #include <QPair>
-#include <QPromise>
-#include <QSharedPointer>
+#include <memory>
 
 #include "core/defs.h"
+#include "core/transport/dns/dnsResolver.h"
+#include "core/transport/igatewaytransport.h"
 
-#ifdef Q_OS_IOS
-    #include "platforms/ios/ios_controller.h"
-#endif
+struct DnsTransportEntry
+{
+    amnezia::transport::dns::DnsProtocol type = amnezia::transport::dns::DnsProtocol::Udp;
+    QString server;
+    QString domain;
+    quint16 port = 15353;
+    QString dohPath = "/dns-query";
+
+    bool isValid() const { return !server.isEmpty() && !domain.isEmpty(); }
+};
+
+enum class PrimaryTransport { Http, DnsUdp, DnsTcp, DnsDot, DnsDoh, DnsDoq };
+
+struct TransportsConfig
+{
+    PrimaryTransport primary = PrimaryTransport::Http;
+    bool httpEnabled = true;
+    QString httpEndpoint;
+    QList<DnsTransportEntry> dnsTransports;
+    int retryCount = 3;
+    int timeoutMs = 10000;
+
+    bool isValid() const { return httpEnabled || !dnsTransports.isEmpty(); }
+    static TransportsConfig fromJson(const QJsonObject &json);
+};
 
 class GatewayController : public QObject
 {
     Q_OBJECT
 
 public:
-    explicit GatewayController(const QString &gatewayEndpoint, const bool isDevEnvironment, const int requestTimeoutMsecs,
-                               const bool isStrictKillSwitchEnabled, QObject *parent = nullptr);
+    explicit GatewayController(const QString &gatewayEndpoint,
+                               const bool isDevEnvironment,
+                               const int requestTimeoutMsecs,
+                               const bool isStrictKillSwitchEnabled,
+                               QObject *parent = nullptr);
 
     amnezia::ErrorCode post(const QString &endpoint, const QJsonObject apiPayload, QByteArray &responseBody);
     QFuture<QPair<amnezia::ErrorCode, QByteArray>> postAsync(const QString &endpoint, const QJsonObject apiPayload);
 
+    static TransportsConfig buildTransportsConfig();
+    void setTransportsConfig(const TransportsConfig &config);
+
 private:
-    struct EncryptedRequestData
+    struct EncryptedRequest
     {
-        QNetworkRequest request;
-        QByteArray requestBody;
+        QByteArray body;
         QByteArray key;
         QByteArray iv;
         QByteArray salt;
-        amnezia::ErrorCode errorCode;
+        amnezia::ErrorCode errorCode = amnezia::ErrorCode::NoError;
     };
 
-    struct DecryptionResult
-    {
-        QByteArray decryptedBody;
-        bool isDecryptionSuccessful;
-    };
+    EncryptedRequest encryptRequest(const QJsonObject &apiPayload);
+    amnezia::transport::DecryptionResult decryptResponse(const QByteArray &encryptedResponseBody,
+                                                         const QByteArray &key,
+                                                         const QByteArray &iv,
+                                                         const QByteArray &salt) const;
 
-    EncryptedRequestData prepareRequest(const QString &endpoint, const QJsonObject &apiPayload);
-    DecryptionResult tryDecryptResponseBody(const QByteArray &encryptedResponseBody, QNetworkReply::NetworkError replyError,
-                                            const QByteArray &key, const QByteArray &iv, const QByteArray &salt);
-
-    QStringList getProxyUrls(const QString &serviceType, const QString &userCountryCode);
-    bool shouldBypassProxy(const QNetworkReply::NetworkError &replyError, const QByteArray &decryptedResponseBody, bool isDecryptionSuccessful);
-    void bypassProxy(const QString &endpoint, const QString &serviceType, const QString &userCountryCode,
-                     std::function<QNetworkReply *(const QString &url)> requestFunction,
-                     std::function<bool(QNetworkReply *reply, const QList<QSslError> &sslErrors)> replyProcessingFunction);
-
-    void getProxyUrlsAsync(const QStringList proxyStorageUrls, const int currentProxyStorageIndex,
-                           std::function<void(const QStringList &)> onComplete);
-    void getProxyUrlAsync(const QStringList proxyUrls, const int currentProxyIndex, std::function<void(const QString &)> onComplete);
-    void bypassProxyAsync(
-            const QString &endpoint, const QString &proxyUrl, EncryptedRequestData encRequestData,
-            std::function<void(const QByteArray &, bool, const QList<QSslError> &, QNetworkReply::NetworkError, const QString &, int)> onComplete);
+    std::shared_ptr<amnezia::transport::IGatewayTransport> currentTransport() const;
+    static std::shared_ptr<amnezia::transport::IGatewayTransport> buildTransport(
+            const TransportsConfig &config, int requestTimeoutMsecs, bool isDevEnvironment, bool isStrictKillSwitchEnabled);
 
     int m_requestTimeoutMsecs;
     QString m_gatewayEndpoint;
     bool m_isDevEnvironment = false;
     bool m_isStrictKillSwitchEnabled = false;
 
-    inline static QString m_proxyUrl;
+    mutable QMutex m_transportMutex;
+    std::shared_ptr<amnezia::transport::IGatewayTransport> m_transport;
 };
 
 #endif // GATEWAYCONTROLLER_H

client/core/controllers/serverController.cpp

@@ -419,18 +419,6 @@ ErrorCode ServerController::installDockerWorker(const ServerCredentials &credent
                       cbReadStdOut, cbReadStdErr);
 
     qDebug().noquote() << "ServerController::installDockerWorker" << stdOut;
-    if (container == DockerContainer::Awg2) {
-        QRegularExpression regex(R"(Linux\s+(\d+)\.(\d+)[^\d]*)");
-        QRegularExpressionMatch match = regex.match(stdOut);
-        if (match.hasMatch()) {
-            int majorVersion = match.captured(1).toInt();
-            int minorVersion = match.captured(2).toInt();
-
-            if (majorVersion < 4 || (majorVersion == 4 && minorVersion < 14)) {
-                return ErrorCode::ServerLinuxKernelTooOld;
-            }
-        }
-    }
     if (stdOut.contains("lock"))
         return ErrorCode::ServerPacketManagerError;
     if (stdOut.contains("command not found"))

client/core/defs.h

@@ -61,7 +61,6 @@ namespace amnezia
         ServerDockerOnCgroupsV2 = 211,
         ServerCgroupMountpoint = 212,
         DockerPullRateLimit = 213,
-        ServerLinuxKernelTooOld = 214,
 
         // Ssh connection errors
         SshRequestDeniedError = 300,

client/core/errorstrings.cpp

@@ -29,7 +29,6 @@ QString errorString(ErrorCode code) {
     case(ErrorCode::ServerDockerOnCgroupsV2): errorMessage = QObject::tr("Docker error: runc doesn't work on cgroups v2"); break;
     case(ErrorCode::ServerCgroupMountpoint): errorMessage = QObject::tr("Server error: cgroup mountpoint does not exist"); break;
     case(ErrorCode::DockerPullRateLimit): errorMessage = QObject::tr("Docker error: The pull rate limit has been reached"); break;
-    case(ErrorCode::ServerLinuxKernelTooOld): errorMessage = QObject::tr("Server error: Linux kernel is too old"); break;
 
     // Libssh errors
     case(ErrorCode::SshRequestDeniedError): errorMessage = QObject::tr("SSH request was denied"); break;

client/core/ipcclient.cpp

@@ -7,6 +7,7 @@ IpcClient::IpcClient(QObject *parent) : QObject(parent)
 {
     m_node.connectToNode(QUrl("local:" + amnezia::getIpcServiceUrl()));
     m_interface.reset(m_node.acquire<IpcInterfaceReplica>());
+    m_tun2socks.reset(m_node.acquire<IpcProcessTun2SocksReplica>());
 }
 
 IpcClient& IpcClient::Instance()
@@ -32,43 +33,68 @@ QSharedPointer<IpcInterfaceReplica> IpcClient::Interface()
     return rep;
 }
 
-QSharedPointer<IpcProcessInterfaceReplica> IpcClient::CreatePrivilegedProcess()
+QSharedPointer<IpcProcessTun2SocksReplica> IpcClient::InterfaceTun2Socks()
 {
-    return withInterface([](QSharedPointer<IpcInterfaceReplica> &iface) -> QSharedPointer<IpcProcessInterfaceReplica> {
-        auto createPrivilegedProcess = iface->createPrivilegedProcess();
-        if (!createPrivilegedProcess.waitForFinished()) {
-            qCritical() << "Failed to create privileged process";
-            return nullptr;
-        }
-
-        const int pid = createPrivilegedProcess.returnValue();
-
-        auto* node = new QRemoteObjectNode();
-        node->connectToNode(QUrl(QString("local:%1").arg(amnezia::getIpcProcessUrl(pid))));
-
-        QSharedPointer<IpcProcessInterfaceReplica> rep(
-            node->acquire<IpcProcessInterfaceReplica>(),
-            [node] (IpcProcessInterfaceReplica *ptr) {
-                delete ptr;
-                node->deleteLater();
-            }
-        );
-        if (rep.isNull()) {
-            qCritical() << "IpcClient::CreatePrivilegedProcess(): Failed to acquire replica";
-            return nullptr;
-        }
-        if (!rep->waitForSource()) {
-            qCritical() << "IpcClient::CreatePrivilegedProcess(): Failed to initialize replica";
-            return nullptr;
-        }
-        if (!rep->isReplicaValid()) {
-            qCritical() << "IpcClient::CreatePrivilegedProcess(): Replica is invalid";
-            return nullptr;
-        }
-
-        return rep;
-    },
-    []() -> QSharedPointer<IpcProcessInterfaceReplica> {
+    QSharedPointer<IpcProcessTun2SocksReplica> rep = Instance().m_tun2socks;
+    if (rep.isNull()) {
+        qCritical() << "IpcClient::InterfaceTun2Socks: Replica is undefined";
         return nullptr;
-    });
+    }
+    if (!rep->waitForSource(1000)) {
+        qCritical() << "IpcClient::InterfaceTun2Socks: Failed to initialize replica";
+        return nullptr;
+    }
+    if (!rep->isReplicaValid()) {
+        qWarning() << "IpcClient::InterfaceTun2Socks(): Replica is invalid";
+    }
+    return rep;
+}
+
+QSharedPointer<PrivilegedProcess> IpcClient::CreatePrivilegedProcess()
+{
+    QSharedPointer<IpcInterfaceReplica> rep = Interface();
+    if (!rep) {
+        qCritical() << "IpcClient::createPrivilegedProcess: Replica is invalid";
+        return nullptr;
+    }
+
+    QRemoteObjectPendingReply<int> pidReply = rep->createPrivilegedProcess();
+    if (!pidReply.waitForFinished(5000)){
+        qCritical() << "IpcClient::createPrivilegedProcess: Failed to execute RO createPrivilegedProcess call";
+        return nullptr;
+    }
+
+    int pid = pidReply.returnValue();
+    QSharedPointer<ProcessDescriptor> pd(new ProcessDescriptor());
+
+    pd->localSocket.reset(new QLocalSocket(pd->replicaNode.data()));
+
+    connect(pd->localSocket.data(), &QLocalSocket::connected, pd->replicaNode.data(), [pd]() {
+        pd->replicaNode->addClientSideConnection(pd->localSocket.data());
+
+        IpcProcessInterfaceReplica *repl = pd->replicaNode->acquire<IpcProcessInterfaceReplica>();
+        // TODO: rework the unsafe cast below
+        PrivilegedProcess *priv = static_cast<PrivilegedProcess *>(repl);
+        pd->ipcProcess.reset(priv);
+        if (!pd->ipcProcess) {
+            qWarning() << "Acquire PrivilegedProcess failed";
+        } else {
+            pd->ipcProcess->waitForSource(1000);
+            if (!pd->ipcProcess->isReplicaValid()) {
+                qWarning() << "PrivilegedProcess replica is not connected!";
+            }
+
+            QObject::connect(pd->ipcProcess.data(), &PrivilegedProcess::destroyed, pd->ipcProcess.data(),
+                             [pd]() { pd->replicaNode->deleteLater(); });
+        }
+    });
+
+    pd->localSocket->connectToServer(amnezia::getIpcProcessUrl(pid));
+    if (!pd->localSocket->waitForConnected()) {
+        qCritical() << "IpcClient::createPrivilegedProcess: Failed to connect to process' socket";
+        return nullptr;
+    }
+
+    auto processReplica = QSharedPointer<PrivilegedProcess>(pd->ipcProcess);
+    return processReplica;
 }

client/core/ipcclient.h

@@ -5,7 +5,9 @@
 #include <QObject>
 
 #include "rep_ipc_interface_replica.h"
-#include "rep_ipc_process_interface_replica.h"
+#include "rep_ipc_process_tun2socks_replica.h"
+
+#include "privileged_process.h"
 
 class IpcClient : public QObject
 {
@@ -16,7 +18,8 @@ public:
     static IpcClient& Instance();
 
     static QSharedPointer<IpcInterfaceReplica> Interface();
-    static QSharedPointer<IpcProcessInterfaceReplica> CreatePrivilegedProcess();
+    static QSharedPointer<IpcProcessTun2SocksReplica> InterfaceTun2Socks();
+    static QSharedPointer<PrivilegedProcess> CreatePrivilegedProcess();
 
     template <typename Func>
     static auto withInterface(Func func)
@@ -51,6 +54,18 @@ signals:
 private:
     QRemoteObjectNode m_node;
     QSharedPointer<IpcInterfaceReplica> m_interface;
+    QSharedPointer<IpcProcessTun2SocksReplica> m_tun2socks;
+
+    struct ProcessDescriptor {
+        ProcessDescriptor () {
+            replicaNode = QSharedPointer<QRemoteObjectNode>(new QRemoteObjectNode());
+            ipcProcess = QSharedPointer<PrivilegedProcess>();
+            localSocket = QSharedPointer<QLocalSocket>();
+        }
+        QSharedPointer<PrivilegedProcess> ipcProcess;
+        QSharedPointer<QRemoteObjectNode> replicaNode;
+        QSharedPointer<QLocalSocket> localSocket;
+    };
 };
 
 #endif // IPCCLIENT_H

client/core/networkUtilities.cpp

@@ -44,6 +44,7 @@
 
 #include <QHostAddress>
 #include <QHostInfo>
+#include <QDebug>
 
 QRegularExpression NetworkUtilities::ipAddressRegExp()
 {

client/core/privileged_process.cpp

@@ -0,0 +1,27 @@
+#include "privileged_process.h"
+
+PrivilegedProcess::PrivilegedProcess() :
+    IpcProcessInterfaceReplica()
+{
+}
+
+PrivilegedProcess::~PrivilegedProcess()
+{
+    qDebug() << "PrivilegedProcess::~PrivilegedProcess()";
+}
+
+void PrivilegedProcess::waitForFinished(int msecs)
+{
+    QSharedPointer<QEventLoop> loop(new QEventLoop);
+    connect(this, &PrivilegedProcess::finished, this, [this, loop](int exitCode, QProcess::ExitStatus exitStatus) mutable{
+        loop->quit();
+        loop.clear();
+    });
+
+    QTimer::singleShot(msecs, this, [this, loop]() mutable {
+        loop->quit();
+        loop.clear();
+    });
+
+    loop->exec();
+}

client/core/privileged_process.h

@@ -0,0 +1,24 @@
+#ifndef PRIVILEGED_PROCESS_H
+#define PRIVILEGED_PROCESS_H
+
+#include <QObject>
+
+#include "rep_ipc_process_interface_replica.h"
+// This class is dangerous - instance of this class casted from base class,
+// so it support only functions
+// Do not add any members into it
+//
+class PrivilegedProcess : public IpcProcessInterfaceReplica
+{
+    Q_OBJECT
+public:
+    PrivilegedProcess();
+    ~PrivilegedProcess() override;
+
+    void waitForFinished(int msecs);
+
+};
+
+#endif // PRIVILEGED_PROCESS_H
+
+

client/core/transport/dns/dnsPacket.cpp

@@ -0,0 +1,153 @@
+#include "dnsPacket_p.h"
+
+#include <QHostInfo>
+#include <cstring>
+
+namespace amnezia::transport::dns::detail
+{
+
+QHostAddress resolveHostAddress(const QString &host)
+{
+    QHostAddress addr(host);
+    if (!addr.isNull()) return addr;
+    QHostInfo info = QHostInfo::fromName(host);
+    if (!info.addresses().isEmpty()) return info.addresses().first();
+    return QHostAddress();
+}
+
+QByteArray encodeDnsName(const QString &hostname)
+{
+    QByteArray result;
+    const QStringList parts = hostname.split('.');
+
+    for (const QString &part : parts) {
+        if (part.length() > 63) {
+            return QByteArray();
+        }
+        result.append(static_cast<char>(part.length()));
+        result.append(part.toUtf8());
+    }
+    result.append(static_cast<char>(0));
+    return result;
+}
+
+QByteArray buildDnsQuery(const QString &hostname, quint16 transactionId)
+{
+    QByteArray packet;
+
+    DnsHeader header;
+    header.id = qToBigEndian(transactionId);
+    header.flags = qToBigEndian<quint16>(0x0100);
+    header.qdcount = qToBigEndian<quint16>(1);
+    header.ancount = 0;
+    header.nscount = 0;
+    header.arcount = 0;
+
+    packet.append(reinterpret_cast<const char *>(&header), sizeof(DnsHeader));
+
+    const QByteArray qname = encodeDnsName(hostname);
+    if (qname.isEmpty()) {
+        return QByteArray();
+    }
+    packet.append(qname);
+
+    quint16 qtype = qToBigEndian<quint16>(DNS_TYPE_A);
+    packet.append(reinterpret_cast<const char *>(&qtype), sizeof(quint16));
+
+    quint16 qclass = qToBigEndian<quint16>(DNS_CLASS_IN);
+    packet.append(reinterpret_cast<const char *>(&qclass), sizeof(quint16));
+
+    return packet;
+}
+
+QString parseDnsResponse(const QByteArray &response, bool isTcp)
+{
+    if (response.size() < static_cast<int>(sizeof(DnsHeader))) {
+        return QString();
+    }
+
+    int offset = isTcp ? 2 : 0;
+    if (response.size() < offset + static_cast<int>(sizeof(DnsHeader))) {
+        return QString();
+    }
+
+    DnsHeader header;
+    std::memcpy(&header, response.constData() + offset, sizeof(DnsHeader));
+    offset += sizeof(DnsHeader);
+
+    const quint16 flags = qFromBigEndian(header.flags);
+    const quint16 ancount = qFromBigEndian(header.ancount);
+
+    if ((flags & 0x8000) == 0 || (flags & 0x000F) != 0) {
+        return QString();
+    }
+
+    if (ancount == 0) {
+        return QString();
+    }
+
+    while (offset < response.size() && response.at(offset) != 0) {
+        const quint8 length = static_cast<quint8>(response.at(offset));
+        if (length > 63) {
+            return QString();
+        }
+        offset += length + 1;
+    }
+    if (offset >= response.size()) {
+        return QString();
+    }
+    offset++;
+
+    offset += 4;
+
+    for (int i = 0; i < ancount && offset < response.size(); ++i) {
+        if (offset >= response.size()) {
+            break;
+        }
+
+        const quint8 nameByte = static_cast<quint8>(response.at(offset));
+        if ((nameByte & 0xC0) == 0xC0) {
+            offset += 2;
+        } else {
+            while (offset < response.size() && response.at(offset) != 0) {
+                const quint8 length = static_cast<quint8>(response.at(offset));
+                if (length > 63) {
+                    return QString();
+                }
+                offset += length + 1;
+            }
+            offset++;
+        }
+
+        if (offset + 10 > response.size()) {
+            break;
+        }
+
+        const quint16 type =
+                qFromBigEndian<quint16>(*reinterpret_cast<const quint16 *>(response.constData() + offset));
+        offset += 2;
+        offset += 2;
+        offset += 4;
+
+        const quint16 rdlength =
+                qFromBigEndian<quint16>(*reinterpret_cast<const quint16 *>(response.constData() + offset));
+        offset += 2;
+
+        if (type == DNS_TYPE_A && rdlength == 4) {
+            if (offset + 4 > response.size()) {
+                break;
+            }
+
+            QHostAddress ip;
+            ip.setAddress(
+                    qFromBigEndian<quint32>(*reinterpret_cast<const quint32 *>(response.constData() + offset)));
+            return ip.toString();
+        }
+
+        offset += rdlength;
+    }
+
+    return QString();
+}
+
+} // namespace amnezia::transport::dns::detail

client/core/transport/dns/dnsPacket_p.h

@@ -0,0 +1,38 @@
+#ifndef DNSPACKET_P_H
+#define DNSPACKET_P_H
+
+#include <QByteArray>
+#include <QHostAddress>
+#include <QString>
+#include <QtEndian>
+
+namespace amnezia::transport::dns::detail
+{
+
+constexpr quint16 DNS_PORT = 53;
+constexpr quint16 DNS_TYPE_A = 1;
+constexpr quint16 DNS_CLASS_IN = 1;
+
+#pragma pack(push, 1)
+struct DnsHeader
+{
+    quint16 id;
+    quint16 flags;
+    quint16 qdcount;
+    quint16 ancount;
+    quint16 nscount;
+    quint16 arcount;
+};
+#pragma pack(pop)
+
+QHostAddress resolveHostAddress(const QString &host);
+
+QByteArray encodeDnsName(const QString &hostname);
+
+QByteArray buildDnsQuery(const QString &hostname, quint16 transactionId);
+
+QString parseDnsResponse(const QByteArray &response, bool isTcp);
+
+} // namespace amnezia::transport::dns::detail
+
+#endif // DNSPACKET_P_H

client/core/transport/dns/dnsResolver.cpp

@@ -0,0 +1,354 @@
+#include "dnsResolver.h"
+
+#include "dnsPacket_p.h"
+
+#include <QDateTime>
+#include <QEventLoop>
+#include <QHostAddress>
+#include <QNetworkAccessManager>
+#include <QNetworkDatagram>
+#include <QNetworkReply>
+#include <QNetworkRequest>
+#include <QSslSocket>
+#include <QTcpSocket>
+#include <QTimer>
+#include <QUdpSocket>
+#include <QUrl>
+
+namespace amnezia::transport::dns::DnsResolver
+{
+
+using detail::buildDnsQuery;
+using detail::parseDnsResponse;
+using detail::resolveHostAddress;
+
+QString resolve(const QString &hostname,
+                const QString &dnsServer,
+                DnsProtocol protocol,
+                quint16 port,
+                int timeoutMsecs,
+                const QString &dohEndpoint)
+{
+    switch (protocol) {
+    case DnsProtocol::Udp:
+        return resolveOverUdp(hostname, dnsServer, port, timeoutMsecs);
+    case DnsProtocol::Tcp:
+        return resolveOverTcp(hostname, dnsServer, port, timeoutMsecs);
+    case DnsProtocol::Tls:
+        return resolveOverTls(hostname, dnsServer, port, timeoutMsecs);
+    case DnsProtocol::Https:
+        return resolveOverHttps(hostname, dnsServer, dohEndpoint, timeoutMsecs);
+    case DnsProtocol::Quic:
+        return resolveOverQuic(hostname, dnsServer, port, timeoutMsecs);
+    }
+    return QString();
+}
+
+QString resolveOverUdp(const QString &hostname, const QString &dnsServer, quint16 port, int timeoutMsecs)
+{
+    QUdpSocket socket;
+
+    const quint16 transactionId = static_cast<quint16>(QDateTime::currentMSecsSinceEpoch() & 0xFFFF);
+    const QByteArray query = buildDnsQuery(hostname, transactionId);
+    if (query.isEmpty()) {
+        return QString();
+    }
+
+    const QHostAddress dnsAddress = resolveHostAddress(dnsServer);
+    if (dnsAddress.isNull()) {
+        return QString();
+    }
+
+    const qint64 bytesWritten = socket.writeDatagram(query, dnsAddress, port);
+    if (bytesWritten != query.size()) {
+        return QString();
+    }
+
+    QEventLoop loop;
+    QTimer timer;
+    timer.setSingleShot(true);
+    timer.setInterval(timeoutMsecs);
+
+    QByteArray response;
+    bool responseReceived = false;
+
+    QObject::connect(&timer, &QTimer::timeout, &loop, &QEventLoop::quit);
+    QObject::connect(&socket, &QUdpSocket::readyRead, [&]() {
+        while (socket.hasPendingDatagrams()) {
+            QNetworkDatagram datagram = socket.receiveDatagram();
+            if (datagram.isValid()) {
+                response = datagram.data();
+                responseReceived = true;
+                loop.quit();
+            }
+        }
+    });
+
+    timer.start();
+    loop.exec();
+    timer.stop();
+
+    if (!responseReceived || response.isEmpty()) {
+        return QString();
+    }
+
+    return parseDnsResponse(response, false);
+}
+
+QString resolveOverTcp(const QString &hostname, const QString &dnsServer, quint16 port, int timeoutMsecs)
+{
+    QTcpSocket socket;
+
+    const QHostAddress dnsAddress = resolveHostAddress(dnsServer);
+    if (dnsAddress.isNull()) {
+        return QString();
+    }
+
+    socket.connectToHost(dnsAddress, port);
+    if (!socket.waitForConnected(timeoutMsecs)) {
+        return QString();
+    }
+
+    const quint16 transactionId = static_cast<quint16>(QDateTime::currentMSecsSinceEpoch() & 0xFFFF);
+    const QByteArray query = buildDnsQuery(hostname, transactionId);
+    if (query.isEmpty()) {
+        socket.close();
+        return QString();
+    }
+
+    quint16 length = qToBigEndian<quint16>(static_cast<quint16>(query.size()));
+    QByteArray tcpQuery;
+    tcpQuery.append(reinterpret_cast<const char *>(&length), sizeof(quint16));
+    tcpQuery.append(query);
+
+    const qint64 bytesWritten = socket.write(tcpQuery);
+    if (bytesWritten != tcpQuery.size() || !socket.waitForBytesWritten(timeoutMsecs)) {
+        socket.close();
+        return QString();
+    }
+
+    QEventLoop loop;
+    QTimer timer;
+    timer.setSingleShot(true);
+    timer.setInterval(timeoutMsecs);
+
+    QByteArray response;
+    bool responseReceived = false;
+
+    QObject::connect(&timer, &QTimer::timeout, &loop, &QEventLoop::quit);
+    QObject::connect(&socket, &QTcpSocket::readyRead, [&]() {
+        if (socket.bytesAvailable() >= 2 && response.isEmpty()) {
+            QByteArray lengthBytes = socket.read(2);
+            if (lengthBytes.size() == 2) {
+                const quint16 responseLength =
+                        qFromBigEndian<quint16>(*reinterpret_cast<const quint16 *>(lengthBytes.constData()));
+                while (socket.bytesAvailable() < responseLength) {
+                    if (!socket.waitForReadyRead(timeoutMsecs / 2)) {
+                        break;
+                    }
+                }
+                if (socket.bytesAvailable() >= responseLength) {
+                    response = socket.read(responseLength);
+                    responseReceived = true;
+                    loop.quit();
+                }
+            }
+        }
+    });
+
+    timer.start();
+    loop.exec();
+    timer.stop();
+
+    socket.close();
+
+    if (!responseReceived || response.isEmpty()) {
+        return QString();
+    }
+
+    return parseDnsResponse(response, true);
+}
+
+QString resolveOverTls(const QString &hostname, const QString &dnsServer, quint16 port, int timeoutMsecs)
+{
+    QSslSocket socket;
+
+    const QHostAddress dnsAddress = resolveHostAddress(dnsServer);
+    if (dnsAddress.isNull()) {
+        return QString();
+    }
+
+    socket.setPeerVerifyMode(QSslSocket::QueryPeer);
+    socket.connectToHostEncrypted(dnsAddress.toString(), port);
+
+    if (!socket.waitForConnected(timeoutMsecs)) {
+        return QString();
+    }
+
+    if (!socket.waitForEncrypted(timeoutMsecs)) {
+        socket.close();
+        return QString();
+    }
+
+    const quint16 transactionId = static_cast<quint16>(QDateTime::currentMSecsSinceEpoch() & 0xFFFF);
+    const QByteArray query = buildDnsQuery(hostname, transactionId);
+    if (query.isEmpty()) {
+        socket.close();
+        return QString();
+    }
+
+    quint16 length = qToBigEndian<quint16>(static_cast<quint16>(query.size()));
+    QByteArray tlsQuery;
+    tlsQuery.append(reinterpret_cast<const char *>(&length), sizeof(quint16));
+    tlsQuery.append(query);
+
+    const qint64 bytesWritten = socket.write(tlsQuery);
+    if (bytesWritten != tlsQuery.size() || !socket.waitForBytesWritten(timeoutMsecs)) {
+        socket.close();
+        return QString();
+    }
+
+    QEventLoop loop;
+    QTimer timer;
+    timer.setSingleShot(true);
+    timer.setInterval(timeoutMsecs);
+
+    QByteArray response;
+    bool responseReceived = false;
+
+    QObject::connect(&timer, &QTimer::timeout, &loop, &QEventLoop::quit);
+    QObject::connect(&socket, &QSslSocket::readyRead, [&]() {
+        if (socket.bytesAvailable() >= 2 && response.isEmpty()) {
+            QByteArray lengthBytes = socket.read(2);
+            if (lengthBytes.size() == 2) {
+                const quint16 responseLength =
+                        qFromBigEndian<quint16>(*reinterpret_cast<const quint16 *>(lengthBytes.constData()));
+                while (socket.bytesAvailable() < responseLength) {
+                    if (!socket.waitForReadyRead(timeoutMsecs / 2)) {
+                        break;
+                    }
+                }
+                if (socket.bytesAvailable() >= responseLength) {
+                    response = socket.read(responseLength);
+                    responseReceived = true;
+                    loop.quit();
+                }
+            }
+        }
+    });
+
+    timer.start();
+    loop.exec();
+    timer.stop();
+
+    socket.close();
+
+    if (!responseReceived || response.isEmpty()) {
+        return QString();
+    }
+
+    return parseDnsResponse(response, true);
+}
+
+QString resolveOverHttps(const QString &hostname, const QString &dnsServer, const QString &endpoint, int timeoutMsecs)
+{
+    const QString dohUrl = QStringLiteral("https://%1%2").arg(dnsServer, endpoint);
+
+    const quint16 transactionId = static_cast<quint16>(QDateTime::currentMSecsSinceEpoch() & 0xFFFF);
+    const QByteArray query = buildDnsQuery(hostname, transactionId);
+    if (query.isEmpty()) {
+        return QString();
+    }
+
+    QNetworkRequest request;
+    request.setUrl(QUrl(dohUrl));
+    request.setHeader(QNetworkRequest::ContentTypeHeader, "application/dns-message");
+    request.setRawHeader("Accept", "application/dns-message");
+    request.setTransferTimeout(timeoutMsecs);
+
+    QNetworkAccessManager nam;
+    QNetworkReply *reply = nam.post(request, query);
+
+    QEventLoop loop;
+    QTimer timer;
+    timer.setSingleShot(true);
+    timer.setInterval(timeoutMsecs);
+
+    QByteArray response;
+    bool responseReceived = false;
+
+    QObject::connect(&timer, &QTimer::timeout, &loop, &QEventLoop::quit);
+    QObject::connect(reply, &QNetworkReply::finished, [&]() {
+        if (reply->error() == QNetworkReply::NoError) {
+            response = reply->readAll();
+            responseReceived = true;
+        }
+        loop.quit();
+    });
+
+    timer.start();
+    loop.exec();
+    timer.stop();
+
+    reply->deleteLater();
+
+    if (!responseReceived || response.isEmpty()) {
+        return QString();
+    }
+
+    return parseDnsResponse(response, false);
+}
+
+QString resolveOverQuic(const QString &hostname, const QString &dnsServer, quint16 port, int timeoutMsecs)
+{
+    // QUIC требует специальной библиотеки — пока используем UDP fallback
+    QUdpSocket socket;
+
+    const QHostAddress dnsAddress = resolveHostAddress(dnsServer);
+    if (dnsAddress.isNull()) {
+        return QString();
+    }
+
+    const quint16 transactionId = static_cast<quint16>(QDateTime::currentMSecsSinceEpoch() & 0xFFFF);
+    const QByteArray query = buildDnsQuery(hostname, transactionId);
+    if (query.isEmpty()) {
+        return QString();
+    }
+
+    const qint64 bytesWritten = socket.writeDatagram(query, dnsAddress, port);
+    if (bytesWritten != query.size()) {
+        return QString();
+    }
+
+    QEventLoop loop;
+    QTimer timer;
+    timer.setSingleShot(true);
+    timer.setInterval(timeoutMsecs);
+
+    QByteArray response;
+    bool responseReceived = false;
+
+    QObject::connect(&timer, &QTimer::timeout, &loop, &QEventLoop::quit);
+    QObject::connect(&socket, &QUdpSocket::readyRead, [&]() {
+        while (socket.hasPendingDatagrams()) {
+            QNetworkDatagram datagram = socket.receiveDatagram();
+            if (datagram.isValid()) {
+                response = datagram.data();
+                responseReceived = true;
+                loop.quit();
+            }
+        }
+    });
+
+    timer.start();
+    loop.exec();
+    timer.stop();
+
+    if (!responseReceived || response.isEmpty()) {
+        return QString();
+    }
+
+    return parseDnsResponse(response, false);
+}
+
+} // namespace amnezia::transport::dns::DnsResolver

client/core/transport/dns/dnsResolver.h

@@ -0,0 +1,29 @@
+#ifndef DNSRESOLVER_H
+#define DNSRESOLVER_H
+
+#include <QString>
+
+namespace amnezia::transport::dns
+{
+
+enum class DnsProtocol { Udp, Tcp, Tls, Https, Quic };
+
+namespace DnsResolver
+{
+    QString resolve(const QString &hostname,
+                    const QString &dnsServer,
+                    DnsProtocol protocol,
+                    quint16 port,
+                    int timeoutMsecs = 3000,
+                    const QString &dohEndpoint = QStringLiteral("/dns-query"));
+
+    QString resolveOverUdp(const QString &hostname, const QString &dnsServer, quint16 port, int timeoutMsecs = 3000);
+    QString resolveOverTcp(const QString &hostname, const QString &dnsServer, quint16 port, int timeoutMsecs = 3000);
+    QString resolveOverTls(const QString &hostname, const QString &dnsServer, quint16 port, int timeoutMsecs = 3000);
+    QString resolveOverHttps(const QString &hostname, const QString &dnsServer, const QString &endpoint, int timeoutMsecs = 3000);
+    QString resolveOverQuic(const QString &hostname, const QString &dnsServer, quint16 port, int timeoutMsecs = 3000);
+} // namespace DnsResolver
+
+} // namespace amnezia::transport::dns
+
+#endif // DNSRESOLVER_H

client/core/transport/dns/dnsTunnel.cpp

@@ -0,0 +1,817 @@
+#include "dnsTunnel.h"
+
+#include "dnsPacket_p.h"
+
+#include <QDateTime>
+#include <QDebug>
+#include <QElapsedTimer>
+#include <QEventLoop>
+#include <QHostAddress>
+#include <QList>
+#include <QMap>
+#include <QNetworkAccessManager>
+#include <QNetworkDatagram>
+#include <QNetworkReply>
+#include <QNetworkRequest>
+#include <QSharedPointer>
+#include <QSslError>
+#include <QSslSocket>
+#include <QStringList>
+#include <QTcpSocket>
+#include <QThread>
+#include <QTimer>
+#include <QUdpSocket>
+#include <QUrl>
+
+namespace amnezia::transport::dns::DnsTunnel
+{
+
+using detail::resolveHostAddress;
+
+namespace
+{
+    constexpr quint16 EDNS0_PAYLOAD_OPTION_CODE = 65001;
+    constexpr quint16 EDNS0_CHUNK_REQUEST_CODE = 65002;
+    constexpr quint16 EDNS0_CHUNK_RESPONSE_CODE = 65003;
+
+    struct ChunkMeta
+    {
+        QByteArray chunkId;
+        quint16 totalChunks = 0;
+        quint16 chunkIndex = 0;
+        quint32 totalSize = 0;
+    };
+
+    void appendUint16BE(QByteArray &data, quint16 value)
+    {
+        data.append(static_cast<char>((value >> 8) & 0xFF));
+        data.append(static_cast<char>(value & 0xFF));
+    }
+
+    QByteArray buildDnsChunkRequest(const QString &queryName, quint16 transactionId,
+                                    const QByteArray &chunkId, quint16 chunkIndex)
+    {
+        QByteArray query;
+
+        appendUint16BE(query, transactionId);
+        appendUint16BE(query, 0x0100);
+        appendUint16BE(query, 1);
+        appendUint16BE(query, 0);
+        appendUint16BE(query, 0);
+        appendUint16BE(query, 1);
+
+        const QStringList labels = queryName.split('.');
+        for (const QString &label : labels) {
+            QByteArray labelBytes = label.toUtf8();
+            query.append(static_cast<char>(labelBytes.size()));
+            query.append(labelBytes);
+        }
+        query.append(static_cast<char>(0));
+        appendUint16BE(query, 16);
+        appendUint16BE(query, 1);
+
+        const quint16 optionDataLen = 4 + 18;
+
+        query.append(static_cast<char>(0));
+        appendUint16BE(query, 41);
+        appendUint16BE(query, 4096);
+        query.append(static_cast<char>(0));
+        query.append(static_cast<char>(0));
+        appendUint16BE(query, 0);
+        appendUint16BE(query, optionDataLen);
+
+        appendUint16BE(query, EDNS0_CHUNK_REQUEST_CODE);
+        appendUint16BE(query, 18);
+        query.append(chunkId.left(16).leftJustified(16, '\0'));
+        appendUint16BE(query, chunkIndex);
+
+        return query;
+    }
+
+    ChunkMeta parseChunkMeta(const QByteArray &response)
+    {
+        ChunkMeta meta;
+
+        if (response.size() < 12) return meta;
+
+        const quint8 *data = reinterpret_cast<const quint8 *>(response.constData());
+
+        const quint16 qdCount = (data[4] << 8) | data[5];
+        const quint16 anCount = (data[6] << 8) | data[7];
+        const quint16 nsCount = (data[8] << 8) | data[9];
+        const quint16 arCount = (data[10] << 8) | data[11];
+
+        int pos = 12;
+
+        auto skipDnsName = [&]() -> bool {
+            int maxLabels = 128;
+            while (pos < response.size() && data[pos] != 0 && maxLabels-- > 0) {
+                if ((data[pos] & 0xC0) == 0xC0) {
+                    pos += 2;
+                    return pos <= response.size();
+                }
+                const int labelLen = data[pos];
+                if (pos + 1 + labelLen > response.size()) return false;
+                pos += labelLen + 1;
+            }
+            if (pos < response.size() && data[pos] == 0) pos++;
+            return pos <= response.size();
+        };
+
+        for (int i = 0; i < qdCount && pos < response.size(); ++i) {
+            if (!skipDnsName()) return meta;
+            if (pos + 4 > response.size()) return meta;
+            pos += 4;
+        }
+
+        for (int i = 0; i < anCount && pos < response.size(); ++i) {
+            if (!skipDnsName()) return meta;
+            if (pos + 10 > response.size()) return meta;
+            const quint16 rdlen = (data[pos + 8] << 8) | data[pos + 9];
+            if (pos + 10 + rdlen > response.size()) return meta;
+            pos += 10 + rdlen;
+        }
+
+        for (int i = 0; i < nsCount && pos < response.size(); ++i) {
+            if (!skipDnsName()) return meta;
+            if (pos + 10 > response.size()) return meta;
+            const quint16 rdlen = (data[pos + 8] << 8) | data[pos + 9];
+            if (pos + 10 + rdlen > response.size()) return meta;
+            pos += 10 + rdlen;
+        }
+
+        for (int i = 0; i < arCount && pos < response.size(); ++i) {
+            if (pos < response.size() && data[pos] == 0) {
+                pos++;
+            } else {
+                if (!skipDnsName()) return meta;
+            }
+
+            if (pos + 10 > response.size()) return meta;
+
+            const quint16 rtype = (data[pos] << 8) | data[pos + 1];
+            const quint16 rdlen = (data[pos + 8] << 8) | data[pos + 9];
+            if (pos + 10 + rdlen > response.size()) return meta;
+            pos += 10;
+
+            if (rtype == 41 && rdlen > 0) {
+                const int optEnd = pos + rdlen;
+                while (pos + 4 <= optEnd) {
+                    const quint16 optCode = (data[pos] << 8) | data[pos + 1];
+                    const quint16 optLen = (data[pos + 2] << 8) | data[pos + 3];
+                    pos += 4;
+
+                    if (optCode == EDNS0_CHUNK_RESPONSE_CODE && optLen >= 24) {
+                        meta.chunkId = QByteArray(reinterpret_cast<const char *>(data + pos), 16);
+                        meta.totalChunks = (data[pos + 16] << 8) | data[pos + 17];
+                        meta.chunkIndex = (data[pos + 18] << 8) | data[pos + 19];
+                        meta.totalSize = (static_cast<quint32>(data[pos + 20]) << 24)
+                                | (static_cast<quint32>(data[pos + 21]) << 16)
+                                | (static_cast<quint32>(data[pos + 22]) << 8) | data[pos + 23];
+                        return meta;
+                    }
+                    pos += optLen;
+                }
+            } else {
+                pos += rdlen;
+            }
+        }
+
+        return meta;
+    }
+
+    QByteArray buildDnsTxtQueryWithPayload(const QString &queryName, quint16 transactionId, const QByteArray &payload)
+    {
+        QByteArray query;
+
+        appendUint16BE(query, transactionId);
+        appendUint16BE(query, 0x0100);
+        appendUint16BE(query, 1);
+        appendUint16BE(query, 0);
+        appendUint16BE(query, 0);
+        appendUint16BE(query, 1);
+
+        const QStringList labels = queryName.split('.');
+        for (const QString &label : labels) {
+            QByteArray labelBytes = label.toUtf8();
+            query.append(static_cast<char>(labelBytes.size()));
+            query.append(labelBytes);
+        }
+        query.append(static_cast<char>(0));
+        appendUint16BE(query, 16);
+        appendUint16BE(query, 1);
+
+        const QByteArray payloadBase64 = payload.toBase64();
+        const quint16 optionDataLen = 4 + payloadBase64.size();
+
+        query.append(static_cast<char>(0));
+        appendUint16BE(query, 41);
+        appendUint16BE(query, 4096);
+        query.append(static_cast<char>(0));
+        query.append(static_cast<char>(0));
+        appendUint16BE(query, 0);
+        appendUint16BE(query, optionDataLen);
+
+        appendUint16BE(query, EDNS0_PAYLOAD_OPTION_CODE);
+        appendUint16BE(query, payloadBase64.size());
+        query.append(payloadBase64);
+
+        return query;
+    }
+
+    QByteArray parseDnsTxtResponse(const QByteArray &response)
+    {
+        if (response.size() < 12) {
+            return QByteArray();
+        }
+
+        const uchar *data = reinterpret_cast<const uchar *>(response.constData());
+        int pos = 0;
+
+        pos += 2;
+        const quint16 flags = (data[pos] << 8) | data[pos + 1]; pos += 2;
+        const quint16 qdCount = (data[pos] << 8) | data[pos + 1]; pos += 2;
+        const quint16 anCount = (data[pos] << 8) | data[pos + 1]; pos += 2;
+        pos += 2;
+        pos += 2;
+
+        if ((flags & 0x8000) == 0) {
+            return QByteArray();
+        }
+
+        if (anCount > 100 || qdCount > 10) {
+            return QByteArray();
+        }
+
+        auto skipDnsName = [&]() -> bool {
+            int maxLabels = 128;
+            while (pos < response.size() && data[pos] != 0 && maxLabels-- > 0) {
+                if ((data[pos] & 0xC0) == 0xC0) {
+                    pos += 2;
+                    return pos <= response.size();
+                }
+                const int labelLen = data[pos];
+                if (pos + 1 + labelLen > response.size()) return false;
+                pos += labelLen + 1;
+            }
+            if (pos < response.size() && data[pos] == 0) pos++;
+            return pos <= response.size();
+        };
+
+        for (int i = 0; i < qdCount && pos < response.size(); ++i) {
+            if (!skipDnsName()) {
+                return QByteArray();
+            }
+            if (pos + 4 > response.size()) return QByteArray();
+            pos += 4;
+        }
+
+        QByteArray combinedTxt;
+        for (int i = 0; i < anCount && pos < response.size(); ++i) {
+            if (!skipDnsName()) {
+                break;
+            }
+
+            if (pos + 10 > response.size()) {
+                break;
+            }
+
+            const quint16 rtype = (data[pos] << 8) | data[pos + 1]; pos += 2;
+            pos += 2; // class
+            pos += 4; // ttl
+            const quint16 rdlength = (data[pos] << 8) | data[pos + 1]; pos += 2;
+
+            if (pos + rdlength > response.size()) {
+                break;
+            }
+
+            if (rtype == 16) {
+                const int rdEnd = pos + rdlength;
+                while (pos < rdEnd && pos < response.size()) {
+                    const quint8 txtLen = data[pos++];
+                    if (txtLen > 0 && pos + txtLen <= rdEnd && pos + txtLen <= response.size()) {
+                        combinedTxt.append(reinterpret_cast<const char *>(data + pos), txtLen);
+                        pos += txtLen;
+                    } else {
+                        break;
+                    }
+                }
+            } else {
+                pos += rdlength;
+            }
+        }
+
+        if (combinedTxt.isEmpty()) {
+            return QByteArray();
+        }
+
+        return QByteArray::fromBase64(combinedTxt);
+    }
+} // namespace
+
+QByteArray send(const QByteArray &payload,
+                const QString &endpointName,
+                const QString &baseDomain,
+                const QString &dnsServer,
+                DnsProtocol protocol,
+                quint16 port,
+                int timeoutMsecs,
+                const QString &dohEndpoint)
+{
+    const QString queryName = QStringLiteral("%1.%2").arg(endpointName, baseDomain);
+
+    switch (protocol) {
+    case DnsProtocol::Udp:
+        return sendOverUdpChunked(payload, queryName, dnsServer, port, timeoutMsecs);
+    case DnsProtocol::Tcp:
+        return sendOverTcp(payload, queryName, dnsServer, port, timeoutMsecs);
+    case DnsProtocol::Tls:
+        return sendOverTls(payload, queryName, dnsServer, port, timeoutMsecs);
+    case DnsProtocol::Https:
+        return sendOverHttps(payload, queryName, dnsServer, port, dohEndpoint, timeoutMsecs);
+    case DnsProtocol::Quic:
+        return QByteArray();
+    }
+    return QByteArray();
+}
+
+QByteArray sendOverUdp(const QByteArray &payload, const QString &queryName,
+                       const QString &dnsServer, quint16 port, int timeoutMsecs)
+{
+    QUdpSocket socket;
+
+    const quint16 transactionId = static_cast<quint16>(QDateTime::currentMSecsSinceEpoch() & 0xFFFF);
+    const QByteArray query = buildDnsTxtQueryWithPayload(queryName, transactionId, payload);
+
+    if (query.isEmpty()) {
+        return QByteArray();
+    }
+
+    const QHostAddress dnsAddress = resolveHostAddress(dnsServer);
+    if (dnsAddress.isNull()) {
+        return QByteArray();
+    }
+
+    const qint64 bytesWritten = socket.writeDatagram(query, dnsAddress, port);
+    if (bytesWritten != query.size()) {
+        return QByteArray();
+    }
+
+    QElapsedTimer timer;
+    timer.start();
+
+    while (timer.elapsed() < timeoutMsecs) {
+        if (socket.waitForReadyRead(qMax(1, timeoutMsecs - static_cast<int>(timer.elapsed())))) {
+            while (socket.hasPendingDatagrams()) {
+                QNetworkDatagram datagram = socket.receiveDatagram();
+                if (datagram.isValid()) {
+                    return parseDnsTxtResponse(datagram.data());
+                }
+            }
+        }
+    }
+
+    return QByteArray();
+}
+
+QByteArray sendOverTcp(const QByteArray &payload, const QString &queryName,
+                       const QString &dnsServer, quint16 port, int timeoutMsecs)
+{
+    qDebug() << "[DNS-TCP] start: queryName=" << queryName << "server=" << dnsServer
+             << "port=" << port << "payloadBytes=" << payload.size();
+    QTcpSocket socket;
+
+    const QHostAddress dnsAddress = resolveHostAddress(dnsServer);
+    if (dnsAddress.isNull()) {
+        qWarning() << "[DNS-TCP] failed to resolve" << dnsServer;
+        return QByteArray();
+    }
+
+    socket.connectToHost(dnsAddress, port);
+    if (!socket.waitForConnected(timeoutMsecs)) {
+        qWarning() << "[DNS-TCP] connect failed:" << socket.errorString();
+        return QByteArray();
+    }
+    qDebug() << "[DNS-TCP] connected";
+
+    const quint16 transactionId = static_cast<quint16>(QDateTime::currentMSecsSinceEpoch() & 0xFFFF);
+    const QByteArray query = buildDnsTxtQueryWithPayload(queryName, transactionId, payload);
+
+    if (query.isEmpty()) {
+        qWarning() << "[DNS-TCP] failed to build DNS query";
+        socket.close();
+        return QByteArray();
+    }
+    qDebug() << "[DNS-TCP] built DNS query bytes=" << query.size() << "txid=" << transactionId;
+    quint16 length = qToBigEndian<quint16>(static_cast<quint16>(query.size()));
+    QByteArray tcpQuery;
+    tcpQuery.append(reinterpret_cast<const char *>(&length), sizeof(quint16));
+    tcpQuery.append(query);
+
+    const qint64 bytesWritten = socket.write(tcpQuery);
+    qDebug() << "[DNS-TCP] wrote bytes=" << bytesWritten << "/ expected=" << tcpQuery.size();
+    if (bytesWritten != tcpQuery.size() || !socket.waitForBytesWritten(timeoutMsecs)) {
+        qWarning() << "[DNS-TCP] write failed:" << socket.errorString();
+        socket.close();
+        return QByteArray();
+    }
+
+    QElapsedTimer timer;
+    timer.start();
+
+    while (socket.bytesAvailable() < 2) {
+        const int remaining = timeoutMsecs - timer.elapsed();
+        if (remaining <= 0 || !socket.waitForReadyRead(remaining)) {
+            qWarning() << "[DNS-TCP] timeout waiting for response length, socketState="
+                       << socket.state() << "err=" << socket.errorString()
+                       << "bytesAvailable=" << socket.bytesAvailable();
+            socket.close();
+            return QByteArray();
+        }
+    }
+
+    QByteArray lengthBytes = socket.read(2);
+    if (lengthBytes.size() != 2) {
+        qWarning() << "[DNS-TCP] could not read length prefix";
+        socket.close();
+        return QByteArray();
+    }
+
+    const quint16 responseLength =
+            qFromBigEndian<quint16>(*reinterpret_cast<const quint16 *>(lengthBytes.constData()));
+    qDebug() << "[DNS-TCP] response length prefix=" << responseLength;
+
+    QByteArray response;
+    while (response.size() < responseLength) {
+        const int remaining = timeoutMsecs - timer.elapsed();
+        if (remaining <= 0) {
+            qWarning() << "[DNS-TCP] timeout reading body, got" << response.size() << "/" << responseLength;
+            socket.close();
+            return QByteArray();
+        }
+
+        if (socket.bytesAvailable() > 0) {
+            response.append(socket.read(responseLength - response.size()));
+        } else if (!socket.waitForReadyRead(remaining)) {
+            qWarning() << "[DNS-TCP] timeout in waitForReadyRead, got" << response.size() << "/" << responseLength;
+            socket.close();
+            return QByteArray();
+        }
+    }
+
+    qDebug() << "[DNS-TCP] full response read, bytes=" << response.size();
+    socket.close();
+    QByteArray parsed = parseDnsTxtResponse(response);
+    qDebug() << "[DNS-TCP] parsed TXT payload bytes=" << parsed.size();
+    return parsed;
+}
+
+QByteArray sendOverTls(const QByteArray &payload, const QString &queryName,
+                       const QString &dnsServer, quint16 port, int timeoutMsecs)
+{
+    QSslSocket socket;
+#ifdef AGW_INSECURE_SSL
+    socket.setPeerVerifyMode(QSslSocket::VerifyNone);
+    QObject::connect(&socket, QOverload<const QList<QSslError> &>::of(&QSslSocket::sslErrors),
+                     &socket, [&socket](const QList<QSslError> &errs) {
+                         qWarning() << "[DoT] sslErrors (ignored, AGW_INSECURE_SSL=1):" << errs;
+                         socket.ignoreSslErrors();
+                     });
+#else
+    socket.setPeerVerifyMode(QSslSocket::VerifyPeer);
+#endif
+
+    const QHostAddress dnsAddress = resolveHostAddress(dnsServer);
+    if (dnsAddress.isNull()) {
+        qWarning() << "[DoT] failed to resolve" << dnsServer;
+        return QByteArray();
+    }
+
+    socket.connectToHostEncrypted(dnsServer, port);
+    if (!socket.waitForEncrypted(timeoutMsecs)) {
+        qWarning() << "[DoT] handshake failed:" << socket.errorString();
+        return QByteArray();
+    }
+
+    const quint16 transactionId = static_cast<quint16>(QDateTime::currentMSecsSinceEpoch() & 0xFFFF);
+    const QByteArray query = buildDnsTxtQueryWithPayload(queryName, transactionId, payload);
+
+    if (query.isEmpty()) {
+        socket.close();
+        return QByteArray();
+    }
+
+    quint16 length = qToBigEndian<quint16>(static_cast<quint16>(query.size()));
+    QByteArray tcpQuery;
+    tcpQuery.append(reinterpret_cast<const char *>(&length), sizeof(quint16));
+    tcpQuery.append(query);
+
+    const qint64 bytesWritten = socket.write(tcpQuery);
+    if (bytesWritten != tcpQuery.size() || !socket.waitForBytesWritten(timeoutMsecs)) {
+        socket.close();
+        return QByteArray();
+    }
+
+    QElapsedTimer timer;
+    timer.start();
+
+    while (socket.bytesAvailable() < 2) {
+        const int remaining = timeoutMsecs - timer.elapsed();
+        if (remaining <= 0 || !socket.waitForReadyRead(remaining)) {
+            socket.close();
+            return QByteArray();
+        }
+    }
+
+    QByteArray lengthBytes = socket.read(2);
+    if (lengthBytes.size() != 2) {
+        socket.close();
+        return QByteArray();
+    }
+
+    const quint16 responseLength =
+            qFromBigEndian<quint16>(*reinterpret_cast<const quint16 *>(lengthBytes.constData()));
+
+    QByteArray response;
+    while (response.size() < responseLength) {
+        const int remaining = timeoutMsecs - timer.elapsed();
+        if (remaining <= 0) {
+            socket.close();
+            return QByteArray();
+        }
+
+        if (socket.bytesAvailable() > 0) {
+            response.append(socket.read(responseLength - response.size()));
+        } else if (!socket.waitForReadyRead(remaining)) {
+            socket.close();
+            return QByteArray();
+        }
+    }
+
+    socket.close();
+    return parseDnsTxtResponse(response);
+}
+
+QByteArray sendOverHttps(const QByteArray &payload, const QString &queryName,
+                         const QString &dnsServer, quint16 port, const QString &endpoint, int timeoutMsecs)
+{
+    const quint16 transactionId = static_cast<quint16>(QDateTime::currentMSecsSinceEpoch() & 0xFFFF);
+    const QByteArray dnsQuery = buildDnsTxtQueryWithPayload(queryName, transactionId, payload);
+
+    qDebug() << "[DoH] queryName=" << queryName << "payloadBytes=" << payload.size()
+             << "dnsQueryBytes=" << dnsQuery.size() << "txid=" << transactionId;
+
+    if (dnsQuery.isEmpty()) {
+        qWarning() << "[DoH] failed to build DNS query (payload too big or queryName invalid)";
+        return QByteArray();
+    }
+
+    const QString scheme = (port == 443) ? QStringLiteral("https") : QStringLiteral("http");
+    const QString url = QStringLiteral("%1://%2:%3%4").arg(scheme).arg(dnsServer).arg(port).arg(endpoint);
+
+    qDebug() << "[DoH] POST" << url << "timeoutMs=" << timeoutMsecs;
+
+    QNetworkRequest request((QUrl(url)));
+    request.setHeader(QNetworkRequest::ContentTypeHeader, "application/dns-message");
+    request.setRawHeader("Accept", "application/dns-message");
+    request.setTransferTimeout(timeoutMsecs);
+
+    QNetworkAccessManager manager;
+    QNetworkReply *reply = manager.post(request, dnsQuery);
+
+    QObject::connect(reply, &QNetworkReply::sslErrors, reply,
+                     [reply](const QList<QSslError> &errs) {
+                         qWarning() << "[DoH] sslErrors:" << errs;
+#ifdef AGW_INSECURE_SSL
+                         qWarning() << "[DoH] AGW_INSECURE_SSL=1, ignoring SSL errors";
+                         reply->ignoreSslErrors();
+#endif
+                     });
+
+    QEventLoop loop;
+    QObject::connect(reply, &QNetworkReply::finished, &loop, &QEventLoop::quit);
+
+    QTimer::singleShot(timeoutMsecs, &loop, &QEventLoop::quit);
+    loop.exec();
+
+    if (!reply->isFinished()) {
+        qWarning() << "[DoH] timeout after" << timeoutMsecs << "ms, aborting";
+        reply->abort();
+        reply->deleteLater();
+        return QByteArray();
+    }
+
+    if (reply->error() != QNetworkReply::NoError) {
+        qWarning() << "[DoH] reply error:" << reply->error() << reply->errorString()
+                   << "httpStatus=" << reply->attribute(QNetworkRequest::HttpStatusCodeAttribute);
+        reply->deleteLater();
+        return QByteArray();
+    }
+
+    QByteArray response = reply->readAll();
+    qDebug() << "[DoH] raw HTTP response bytes=" << response.size()
+             << "httpStatus=" << reply->attribute(QNetworkRequest::HttpStatusCodeAttribute);
+    reply->deleteLater();
+
+    if (response.isEmpty()) {
+        qWarning() << "[DoH] empty HTTP response body";
+        return QByteArray();
+    }
+
+    QByteArray parsed = parseDnsTxtResponse(response);
+    qDebug() << "[DoH] parsed TXT payload bytes=" << parsed.size();
+    return parsed;
+}
+
+QByteArray sendOverUdpChunked(const QByteArray &payload, const QString &queryName,
+                              const QString &dnsServer, quint16 port, int timeoutMsecs)
+{
+    qDebug() << "[DNS-UDP] start: queryName=" << queryName << "server=" << dnsServer
+             << "port=" << port << "payloadBytes=" << payload.size() << "timeoutMs=" << timeoutMsecs;
+    const QHostAddress dnsAddress = resolveHostAddress(dnsServer);
+    if (dnsAddress.isNull()) {
+        qWarning() << "[DNS-UDP] failed to resolve" << dnsServer;
+        return QByteArray();
+    }
+    qDebug() << "[DNS-UDP] resolved to" << dnsAddress.toString();
+
+    constexpr int MAX_INITIAL_RETRIES = 3;
+    constexpr int MAX_CHUNK_RETRIES = 2;
+    constexpr int MAX_CONCURRENT_REQUESTS = 5;
+    constexpr int BASE_TIMEOUT_MS = 2000;
+
+    auto sendUdpRequestWithTimeout = [&](const QByteArray &query, int requestTimeoutMs) -> QByteArray {
+        QUdpSocket socket;
+        const qint64 written = socket.writeDatagram(query, dnsAddress, port);
+        if (written != query.size()) {
+            return QByteArray();
+        }
+
+        QElapsedTimer timer;
+        timer.start();
+
+        while (timer.elapsed() < requestTimeoutMs) {
+            if (socket.waitForReadyRead(qMax(1, requestTimeoutMs - static_cast<int>(timer.elapsed())))) {
+                while (socket.hasPendingDatagrams()) {
+                    QNetworkDatagram datagram = socket.receiveDatagram();
+                    if (datagram.isValid()) {
+                        return datagram.data();
+                    }
+                }
+            }
+        }
+
+        return QByteArray();
+    };
+
+    auto sendWithRetry = [&](const QByteArray &query, int maxRetries) -> QByteArray {
+        for (int attempt = 0; attempt < maxRetries; ++attempt) {
+            const int timeout = BASE_TIMEOUT_MS * (attempt + 1);
+            QByteArray response = sendUdpRequestWithTimeout(query, timeout);
+            if (!response.isEmpty()) {
+                return response;
+            }
+
+            if (attempt < maxRetries - 1) {
+                QThread::msleep(timeout / 2);
+            }
+        }
+        return QByteArray();
+    };
+
+    const quint16 transactionId = static_cast<quint16>(QDateTime::currentMSecsSinceEpoch() & 0xFFFF);
+    const QByteArray initialQuery = buildDnsTxtQueryWithPayload(queryName, transactionId, payload);
+
+    qDebug() << "[DNS-UDP] initialQuery size=" << initialQuery.size() << "txid=" << transactionId;
+
+    if (initialQuery.isEmpty()) {
+        qWarning() << "[DNS-UDP] failed to build initial query (payload too big or queryName invalid)";
+        return QByteArray();
+    }
+
+    const QByteArray firstResponse = sendWithRetry(initialQuery, MAX_INITIAL_RETRIES);
+    qDebug() << "[DNS-UDP] first response size=" << firstResponse.size();
+
+    if (firstResponse.isEmpty()) {
+        qWarning() << "[DNS-UDP] no response from server after" << MAX_INITIAL_RETRIES << "retries";
+        return QByteArray();
+    }
+
+    const ChunkMeta meta = parseChunkMeta(firstResponse);
+    const QByteArray firstTxtData = parseDnsTxtResponse(firstResponse);
+
+    qDebug() << "[DNS-UDP] meta totalChunks=" << meta.totalChunks
+             << "chunkId=" << meta.chunkId << "firstTxtData size=" << firstTxtData.size();
+
+    if (firstTxtData.isEmpty()) {
+        qWarning() << "[DNS-UDP] failed to parse TXT data from first response";
+        return QByteArray();
+    }
+
+    if (meta.totalChunks <= 1) {
+        qDebug() << "[DNS-UDP] single chunk, returning" << firstTxtData.size() << "bytes";
+        return firstTxtData;
+    }
+
+    QMap<int, QByteArray> chunks;
+    chunks[0] = firstTxtData;
+
+    auto requestChunksBatch = [&](const QList<int> &chunkIndices, int batchTimeout) {
+        if (chunkIndices.isEmpty()) return;
+
+        QList<QSharedPointer<QUdpSocket>> sockets;
+        QMap<QUdpSocket *, int> socketToIndex;
+
+        for (int idx : chunkIndices) {
+            if (chunks.contains(idx)) continue;
+
+            const quint16 chunkTxId =
+                    static_cast<quint16>((QDateTime::currentMSecsSinceEpoch() + idx) & 0xFFFF);
+            const QByteArray chunkQuery =
+                    buildDnsChunkRequest(queryName, chunkTxId, meta.chunkId, idx);
+
+            if (chunkQuery.isEmpty()) {
+                continue;
+            }
+
+            auto socket = QSharedPointer<QUdpSocket>::create();
+            socket->writeDatagram(chunkQuery, dnsAddress, port);
+            socketToIndex[socket.data()] = idx;
+            sockets.append(socket);
+        }
+
+        if (sockets.isEmpty()) return;
+
+        QElapsedTimer deadline;
+        deadline.start();
+        int receivedCount = 0;
+        const int expectedCount = sockets.size();
+
+        while (deadline.elapsed() < batchTimeout && receivedCount < expectedCount
+               && chunks.size() < meta.totalChunks) {
+            for (auto &socket : sockets) {
+                if (socket->waitForReadyRead(50)) {
+                    while (socket->hasPendingDatagrams()) {
+                        QNetworkDatagram datagram = socket->receiveDatagram();
+                        if (datagram.isValid()) {
+                            const QByteArray chunkTxtData = parseDnsTxtResponse(datagram.data());
+                            if (!chunkTxtData.isEmpty()) {
+                                const ChunkMeta chunkMeta = parseChunkMeta(datagram.data());
+                                const int idx = (chunkMeta.totalChunks > 0)
+                                        ? chunkMeta.chunkIndex
+                                        : socketToIndex.value(socket.data(), -1);
+                                if (idx >= 0 && !chunks.contains(idx)) {
+                                    chunks[idx] = chunkTxtData;
+                                    receivedCount++;
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    };
+
+    const int totalTimeout = qMax(timeoutMsecs / 2, 5000);
+    const int batchTimeout = totalTimeout / (MAX_CHUNK_RETRIES + 1);
+
+    for (int retryRound = 0; retryRound <= MAX_CHUNK_RETRIES; ++retryRound) {
+        QList<int> missing;
+        for (int i = 1; i < meta.totalChunks; ++i) {
+            if (!chunks.contains(i)) {
+                missing.append(i);
+            }
+        }
+
+        if (missing.isEmpty()) {
+            break;
+        }
+
+        for (int batchStart = 0; batchStart < missing.size(); batchStart += MAX_CONCURRENT_REQUESTS) {
+            const QList<int> batch = missing.mid(batchStart, MAX_CONCURRENT_REQUESTS);
+            requestChunksBatch(batch, batchTimeout);
+        }
+    }
+
+    QList<int> finalMissing;
+    for (int i = 0; i < meta.totalChunks; ++i) {
+        if (!chunks.contains(i)) {
+            finalMissing.append(i);
+        }
+    }
+
+    if (!finalMissing.isEmpty()) {
+        return QByteArray();
+    }
+
+    QByteArray combined;
+    combined.reserve(meta.totalSize > 0 ? meta.totalSize : meta.totalChunks * 500);
+
+    for (int i = 0; i < meta.totalChunks; ++i) {
+        combined.append(chunks[i]);
+    }
+
+    return combined;
+}
+
+} // namespace amnezia::transport::dns::DnsTunnel

client/core/transport/dns/dnsTunnel.h

@@ -0,0 +1,35 @@
+#ifndef DNSTUNNEL_H
+#define DNSTUNNEL_H
+
+#include <QByteArray>
+#include <QString>
+
+#include "dnsResolver.h"
+
+namespace amnezia::transport::dns::DnsTunnel
+{
+
+QByteArray send(const QByteArray &payload,
+                const QString &endpointName,
+                const QString &baseDomain,
+                const QString &dnsServer,
+                DnsProtocol protocol,
+                quint16 port,
+                int timeoutMsecs = 30000,
+                const QString &dohEndpoint = QStringLiteral("/dns-query"));
+
+QByteArray sendOverUdp(const QByteArray &payload, const QString &queryName,
+                       const QString &dnsServer, quint16 port, int timeoutMsecs);
+QByteArray sendOverTcp(const QByteArray &payload, const QString &queryName,
+                       const QString &dnsServer, quint16 port, int timeoutMsecs);
+QByteArray sendOverTls(const QByteArray &payload, const QString &queryName,
+                       const QString &dnsServer, quint16 port, int timeoutMsecs);
+QByteArray sendOverHttps(const QByteArray &payload, const QString &queryName,
+                         const QString &dnsServer, quint16 port, const QString &endpoint, int timeoutMsecs);
+
+QByteArray sendOverUdpChunked(const QByteArray &payload, const QString &queryName,
+                              const QString &dnsServer, quint16 port, int timeoutMsecs);
+
+} // namespace amnezia::transport::dns::DnsTunnel
+
+#endif // DNSTUNNEL_H

client/core/transport/dnsGatewayTransport.cpp

@@ -0,0 +1,157 @@
+#include "dnsGatewayTransport.h"
+
+#include <QDebug>
+#include <QHostAddress>
+#include <QHostInfo>
+#include <QSharedPointer>
+#include <QStringList>
+
+#include "dns/dnsTunnel.h"
+#include "core/networkUtilities.h"
+
+#ifdef AMNEZIA_DESKTOP
+    #include "core/ipcclient.h"
+#endif
+
+namespace amnezia::transport
+{
+
+DnsGatewayTransport::DnsGatewayTransport(dns::DnsProtocol protocol,
+                                         const QString &dnsServer,
+                                         const QString &baseDomain,
+                                         quint16 port,
+                                         int timeoutMsecs,
+                                         bool isStrictKillSwitchEnabled,
+                                         const QString &dohEndpoint)
+    : m_protocol(protocol),
+      m_dnsServer(dnsServer),
+      m_baseDomain(baseDomain),
+      m_port(port),
+      m_timeoutMsecs(timeoutMsecs),
+      m_isStrictKillSwitchEnabled(isStrictKillSwitchEnabled),
+      m_dohEndpoint(dohEndpoint)
+{
+}
+
+QString DnsGatewayTransport::name() const
+{
+    switch (m_protocol) {
+    case dns::DnsProtocol::Udp:   return QStringLiteral("DNS-UDP");
+    case dns::DnsProtocol::Tcp:   return QStringLiteral("DNS-TCP");
+    case dns::DnsProtocol::Tls:   return QStringLiteral("DNS-DoT");
+    case dns::DnsProtocol::Https: return QStringLiteral("DNS-DoH");
+    case dns::DnsProtocol::Quic:  return QStringLiteral("DNS-DoQ");
+    }
+    return QStringLiteral("DNS");
+}
+
+QString DnsGatewayTransport::resolveServerOnce()
+{
+    if (m_resolved.load()) {
+        return m_resolvedServerIp;
+    }
+
+    QHostAddress addr(m_dnsServer);
+    if (!addr.isNull()) {
+        m_resolvedServerIp = m_dnsServer;
+    } else {
+        QHostInfo info = QHostInfo::fromName(m_dnsServer);
+        if (!info.addresses().isEmpty()) {
+            m_resolvedServerIp = info.addresses().first().toString();
+        } else {
+            m_resolvedServerIp = m_dnsServer;
+        }
+    }
+    m_resolved.store(true);
+    return m_resolvedServerIp;
+}
+
+void DnsGatewayTransport::applyKillSwitchAllowlist(const QString &ip)
+{
+#ifdef AMNEZIA_DESKTOP
+    if (!m_isStrictKillSwitchEnabled || ip.isEmpty()) {
+        return;
+    }
+    IpcClient::withInterface([&](QSharedPointer<IpcInterfaceReplica> iface) {
+        QRemoteObjectPendingReply<bool> reply = iface->addKillSwitchAllowedRange(QStringList { ip });
+        if (!reply.waitForFinished(1000) || !reply.returnValue()) {
+            qWarning() << "DnsGatewayTransport: addKillSwitchAllowedRange failed for" << ip;
+        }
+    });
+#else
+    Q_UNUSED(ip)
+#endif
+}
+
+amnezia::ErrorCode DnsGatewayTransport::send(const QString &endpointTemplate,
+                                             const QByteArray &requestBody,
+                                             QByteArray &decryptedResponse,
+                                             const DecryptionHook &decryptionHook)
+{
+    QString endpointName = endpointTemplate;
+    endpointName.remove("%1");
+    if (endpointName.startsWith(QLatin1String("v1/"))) {
+        endpointName = endpointName.mid(3);
+    }
+    while (endpointName.endsWith(QLatin1Char('/'))) {
+        endpointName.chop(1);
+    }
+    while (endpointName.startsWith(QLatin1Char('/'))) {
+        endpointName = endpointName.mid(1);
+    }
+
+    qDebug() << "[DNS-Transport]" << name() << "send() endpointTemplate=" << endpointTemplate
+             << "endpointName=" << endpointName << "baseDomain=" << m_baseDomain
+             << "server=" << m_dnsServer << "port=" << m_port
+             << "dohPath=" << m_dohEndpoint << "timeoutMs=" << m_timeoutMsecs
+             << "requestBodyBytes=" << requestBody.size();
+
+    if (endpointName.isEmpty() || m_baseDomain.isEmpty() || m_dnsServer.isEmpty()) {
+        qWarning() << "[DNS-Transport] ABORT: empty endpoint/baseDomain/server";
+        return amnezia::ErrorCode::AmneziaServiceConnectionFailed;
+    }
+
+    const bool needsHostname = (m_protocol == dns::DnsProtocol::Tls
+                                || m_protocol == dns::DnsProtocol::Https);
+
+    QString serverIp = resolveServerOnce();
+    QString serverForRequest = needsHostname ? m_dnsServer : serverIp;
+
+    qDebug() << "[DNS-Transport] resolved server IP=" << serverIp
+             << "serverForRequest=" << serverForRequest
+             << "needsHostname=" << needsHostname;
+
+    applyKillSwitchAllowlist(serverIp);
+
+    const QByteArray encrypted = dns::DnsTunnel::send(requestBody,
+                                                      endpointName,
+                                                      m_baseDomain,
+                                                      serverForRequest,
+                                                      m_protocol,
+                                                      m_port,
+                                                      m_timeoutMsecs,
+                                                      m_dohEndpoint);
+    qDebug() << "[DNS-Transport] DnsTunnel::send returned" << encrypted.size() << "bytes";
+    if (encrypted.isEmpty()) {
+        qWarning() << "[DNS-Transport] DnsTunnel returned empty payload, treat as connection failure";
+        return amnezia::ErrorCode::AmneziaServiceConnectionFailed;
+    }
+
+    if (!decryptionHook) {
+        qCritical() << "[DNS-Transport] decryption hook is null";
+        return amnezia::ErrorCode::ApiConfigDecryptionError;
+    }
+
+    DecryptionResult decrypted = decryptionHook(encrypted);
+    if (!decrypted.isOk) {
+        qCritical() << "[DNS-Transport] response decryption failed (encrypted bytes="
+                    << encrypted.size() << ")";
+        return amnezia::ErrorCode::ApiConfigDecryptionError;
+    }
+
+    qDebug() << "[DNS-Transport] success, decrypted response bytes=" << decrypted.decrypted.size();
+    decryptedResponse = decrypted.decrypted;
+    return amnezia::ErrorCode::NoError;
+}
+
+} // namespace amnezia::transport

client/core/transport/dnsGatewayTransport.h

@@ -0,0 +1,49 @@
+#ifndef DNSGATEWAYTRANSPORT_H
+#define DNSGATEWAYTRANSPORT_H
+
+#include <QString>
+#include <atomic>
+
+#include "dns/dnsResolver.h"
+#include "igatewaytransport.h"
+
+namespace amnezia::transport
+{
+
+class DnsGatewayTransport : public IGatewayTransport
+{
+public:
+    DnsGatewayTransport(dns::DnsProtocol protocol,
+                        const QString &dnsServer,
+                        const QString &baseDomain,
+                        quint16 port,
+                        int timeoutMsecs,
+                        bool isStrictKillSwitchEnabled,
+                        const QString &dohEndpoint = QStringLiteral("/dns-query"));
+
+    QString name() const override;
+
+    amnezia::ErrorCode send(const QString &endpointTemplate,
+                            const QByteArray &requestBody,
+                            QByteArray &decryptedResponse,
+                            const DecryptionHook &decryptionHook) override;
+
+private:
+    QString resolveServerOnce();
+    void applyKillSwitchAllowlist(const QString &ip);
+
+    dns::DnsProtocol m_protocol;
+    QString m_dnsServer;
+    QString m_baseDomain;
+    quint16 m_port;
+    int m_timeoutMsecs;
+    bool m_isStrictKillSwitchEnabled;
+    QString m_dohEndpoint;
+
+    std::atomic_bool m_resolved{ false };
+    QString m_resolvedServerIp;
+};
+
+} // namespace amnezia::transport
+
+#endif // DNSGATEWAYTRANSPORT_H

client/core/transport/httpGatewayTransport.cpp

@@ -0,0 +1,345 @@
+#include "httpGatewayTransport.h"
+
+#include <algorithm>
+#include <random>
+
+#include <QCryptographicHash>
+#include <QDebug>
+#include <QEventLoop>
+#include <QHostAddress>
+#include <QJsonArray>
+#include <QJsonDocument>
+#include <QMutexLocker>
+#include <QNetworkAccessManager>
+#include <QNetworkReply>
+#include <QNetworkRequest>
+#include <QSharedPointer>
+#include <QThread>
+#include <QUrl>
+#include <QUuid>
+
+#include "QBlockCipher.h"
+
+#include "amnezia_application.h"
+#include "core/api/apiUtils.h"
+#include "core/networkUtilities.h"
+#include "utilities.h"
+
+#ifdef AMNEZIA_DESKTOP
+    #include "core/ipcclient.h"
+#endif
+
+#ifdef Q_OS_IOS
+    #include "platforms/ios/ios_controller.h"
+#endif
+
+namespace amnezia::transport
+{
+
+QMutex HttpGatewayTransport::s_proxyMutex;
+QString HttpGatewayTransport::s_proxyUrl;
+
+namespace
+{
+    constexpr int kProxyHealthTimeoutMsecs = 1000;
+    constexpr int httpStatusCodeNotFound = 404;
+    constexpr int httpStatusCodeConflict = 409;
+    constexpr int httpStatusCodeNotImplemented = 501;
+
+    constexpr QLatin1String errorResponsePattern1("No active configuration found for");
+    constexpr QLatin1String errorResponsePattern2("No non-revoked public key found for");
+    constexpr QLatin1String errorResponsePattern3("Account not found.");
+    constexpr QLatin1String updateRequestResponsePattern("client version update is required");
+} // namespace
+
+HttpGatewayTransport::HttpGatewayTransport(const QString &endpoint,
+                                           bool isDevEnvironment,
+                                           int requestTimeoutMsecs,
+                                           bool isStrictKillSwitchEnabled)
+    : m_endpoint(endpoint),
+      m_isDevEnvironment(isDevEnvironment),
+      m_requestTimeoutMsecs(requestTimeoutMsecs),
+      m_isStrictKillSwitchEnabled(isStrictKillSwitchEnabled)
+{
+}
+
+void HttpGatewayTransport::applyKillSwitchAllowlist(const QString &host)
+{
+#ifdef AMNEZIA_DESKTOP
+    if (!m_isStrictKillSwitchEnabled || host.isEmpty()) {
+        return;
+    }
+    const QString ip = NetworkUtilities::getIPAddress(host);
+    if (ip.isEmpty()) {
+        return;
+    }
+    IpcClient::withInterface([&](QSharedPointer<IpcInterfaceReplica> iface) {
+        QRemoteObjectPendingReply<bool> reply = iface->addKillSwitchAllowedRange(QStringList { ip });
+        if (!reply.waitForFinished(1000) || !reply.returnValue()) {
+            qWarning() << "HttpGatewayTransport: addKillSwitchAllowedRange failed for" << ip;
+        }
+    });
+#else
+    Q_UNUSED(host)
+#endif
+}
+
+HttpGatewayTransport::ReplyOutcome HttpGatewayTransport::doPost(const QString &fullUrl, const QByteArray &requestBody)
+{
+    ReplyOutcome outcome;
+
+#ifdef Q_OS_IOS
+    IosController::Instance()->requestInetAccess();
+    QThread::msleep(10);
+#endif
+
+    QNetworkRequest request;
+    request.setTransferTimeout(m_requestTimeoutMsecs);
+    request.setHeader(QNetworkRequest::ContentTypeHeader, "application/json");
+    request.setRawHeader("X-Client-Request-ID",
+                         QUuid::createUuid().toString(QUuid::WithoutBraces).toUtf8());
+    request.setUrl(fullUrl);
+
+    applyKillSwitchAllowlist(QUrl(fullUrl).host());
+
+    QNetworkReply *reply = amnApp->networkManager()->post(request, requestBody);
+
+    QEventLoop wait;
+    QObject::connect(reply, &QNetworkReply::finished, &wait, &QEventLoop::quit);
+    QObject::connect(reply, &QNetworkReply::sslErrors, [&, reply](const QList<QSslError> &errors) {
+        outcome.sslErrors = errors;
+#ifdef AGW_INSECURE_SSL
+        qWarning() << "[HTTP] sslErrors (ignored, AGW_INSECURE_SSL=1):" << errors;
+        reply->ignoreSslErrors();
+        outcome.sslErrors.clear();
+#endif
+    });
+    wait.exec(QEventLoop::ExcludeUserInputEvents);
+
+    outcome.encryptedBody = reply->readAll();
+    outcome.errorString = reply->errorString();
+    outcome.networkError = reply->error();
+    outcome.httpStatusCode = reply->attribute(QNetworkRequest::HttpStatusCodeAttribute).toInt();
+
+    reply->deleteLater();
+    return outcome;
+}
+
+bool HttpGatewayTransport::shouldBypass(const ReplyOutcome &outcome, const DecryptionResult &decrypted) const
+{
+    if (!outcome.sslErrors.isEmpty()) {
+        return false;
+    }
+
+    if (!decrypted.isOk) {
+        return true;
+    }
+
+    int apiHttpStatus = -1;
+    QJsonDocument jsonDoc = QJsonDocument::fromJson(decrypted.decrypted);
+    if (jsonDoc.isObject()) {
+        apiHttpStatus = jsonDoc.object().value("http_status").toInt(-1);
+    }
+
+    if (outcome.networkError == QNetworkReply::NetworkError::OperationCanceledError
+        || outcome.networkError == QNetworkReply::NetworkError::TimeoutError) {
+        return true;
+    }
+    if (decrypted.decrypted.contains("html")) {
+        return true;
+    }
+    if (apiHttpStatus == httpStatusCodeNotFound) {
+        if (decrypted.decrypted.contains(errorResponsePattern1)
+            || decrypted.decrypted.contains(errorResponsePattern2)
+            || decrypted.decrypted.contains(errorResponsePattern3)) {
+            return false;
+        }
+        return true;
+    }
+    if (apiHttpStatus == httpStatusCodeNotImplemented) {
+        if (decrypted.decrypted.contains(updateRequestResponsePattern)) {
+            return false;
+        }
+        return true;
+    }
+    if (apiHttpStatus == httpStatusCodeConflict) {
+        return false;
+    }
+    if (outcome.networkError != QNetworkReply::NetworkError::NoError) {
+        return true;
+    }
+    return false;
+}
+
+QStringList HttpGatewayTransport::fetchProxyUrls(const QByteArray &/*serviceHint*/)
+{
+    QStringList baseUrls = m_isDevEnvironment
+            ? QString(DEV_S3_ENDPOINT).split(", ")
+            : QString(PROD_S3_ENDPOINT).split(", ");
+
+    QByteArray rsaKey = m_isDevEnvironment ? DEV_AGW_PUBLIC_KEY : PROD_AGW_PUBLIC_KEY;
+
+    QStringList proxyStorageUrls;
+    for (const auto &baseUrl : baseUrls) {
+        proxyStorageUrls.push_back(baseUrl + "endpoints.json");
+    }
+
+    QNetworkRequest request;
+    request.setTransferTimeout(m_requestTimeoutMsecs);
+    request.setHeader(QNetworkRequest::ContentTypeHeader, "application/json");
+
+    for (const auto &proxyStorageUrl : proxyStorageUrls) {
+        request.setUrl(proxyStorageUrl);
+        QNetworkReply *reply = amnApp->networkManager()->get(request);
+        QEventLoop wait;
+        QObject::connect(reply, &QNetworkReply::finished, &wait, &QEventLoop::quit);
+        wait.exec(QEventLoop::ExcludeUserInputEvents);
+
+        if (reply->error() != QNetworkReply::NoError) {
+            reply->deleteLater();
+            continue;
+        }
+
+        QByteArray encryptedResponseBody = reply->readAll();
+        reply->deleteLater();
+
+        QByteArray responseBody;
+        try {
+            if (!m_isDevEnvironment) {
+                QCryptographicHash hash(QCryptographicHash::Sha512);
+                hash.addData(rsaKey);
+                QByteArray hashResult = hash.result().toHex();
+
+                QByteArray key = QByteArray::fromHex(hashResult.left(64));
+                QByteArray iv = QByteArray::fromHex(hashResult.mid(64, 32));
+
+                QSimpleCrypto::QBlockCipher blockCipher;
+                responseBody = blockCipher.decryptAesBlockCipher(QByteArray::fromBase64(encryptedResponseBody), key, iv);
+            } else {
+                responseBody = encryptedResponseBody;
+            }
+        } catch (...) {
+            Utils::logException();
+            qCritical() << "HttpGatewayTransport: error decrypting proxy storage payload";
+            continue;
+        }
+
+        QJsonArray endpointsArray = QJsonDocument::fromJson(responseBody).array();
+        QStringList endpoints;
+        endpoints.reserve(endpointsArray.size());
+        for (const QJsonValue &endpoint : endpointsArray) {
+            endpoints.push_back(endpoint.toString());
+        }
+        return endpoints;
+    }
+
+    return {};
+}
+
+amnezia::ErrorCode HttpGatewayTransport::send(const QString &endpointTemplate,
+                                              const QByteArray &requestBody,
+                                              QByteArray &decryptedResponse,
+                                              const DecryptionHook &decryptionHook)
+{
+    auto buildOutcome = [&](const QString &gatewayBase) {
+        return doPost(endpointTemplate.arg(gatewayBase), requestBody);
+    };
+
+    auto tryDecrypt = [&](const QByteArray &encrypted) -> DecryptionResult {
+        if (!decryptionHook) {
+            DecryptionResult r;
+            r.decrypted = encrypted;
+            r.isOk = false;
+            return r;
+        }
+        return decryptionHook(encrypted);
+    };
+
+    QString cachedProxy;
+    {
+        QMutexLocker lock(&s_proxyMutex);
+        cachedProxy = s_proxyUrl;
+    }
+    const QString primaryBase = cachedProxy.isEmpty() ? m_endpoint : cachedProxy;
+
+    ReplyOutcome outcome = buildOutcome(primaryBase);
+    DecryptionResult decrypted = tryDecrypt(outcome.encryptedBody);
+
+    if (outcome.sslErrors.isEmpty() && shouldBypass(outcome, decrypted)) {
+        QStringList proxyUrls = fetchProxyUrls(QByteArray());
+        std::random_device randomDevice;
+        std::mt19937 generator(randomDevice());
+        std::shuffle(proxyUrls.begin(), proxyUrls.end(), generator);
+
+        bool bypassResolved = false;
+
+        if (cachedProxy.isEmpty()) {
+            QNetworkRequest healthRequest;
+            healthRequest.setTransferTimeout(kProxyHealthTimeoutMsecs);
+            healthRequest.setHeader(QNetworkRequest::ContentTypeHeader, "application/json");
+
+            for (const QString &proxyUrl : std::as_const(proxyUrls)) {
+                healthRequest.setUrl(proxyUrl + "lmbd-health");
+                QNetworkReply *reply = amnApp->networkManager()->get(healthRequest);
+                QEventLoop wait;
+                QObject::connect(reply, &QNetworkReply::finished, &wait, &QEventLoop::quit);
+                wait.exec(QEventLoop::ExcludeUserInputEvents);
+
+                const auto err = reply->error();
+                reply->deleteLater();
+                if (err == QNetworkReply::NoError) {
+                    QMutexLocker lock(&s_proxyMutex);
+                    s_proxyUrl = proxyUrl;
+                    cachedProxy = proxyUrl;
+                    break;
+                }
+            }
+        }
+
+        if (!cachedProxy.isEmpty()) {
+            ReplyOutcome retry = buildOutcome(cachedProxy);
+            DecryptionResult retryDecrypted = tryDecrypt(retry.encryptedBody);
+            if (retry.sslErrors.isEmpty() && !shouldBypass(retry, retryDecrypted)) {
+                outcome = retry;
+                decrypted = retryDecrypted;
+                bypassResolved = true;
+            }
+        }
+
+        if (!bypassResolved) {
+            for (const QString &proxyUrl : std::as_const(proxyUrls)) {
+                ReplyOutcome retry = buildOutcome(proxyUrl);
+                DecryptionResult retryDecrypted = tryDecrypt(retry.encryptedBody);
+                if (retry.sslErrors.isEmpty() && !shouldBypass(retry, retryDecrypted)) {
+                    {
+                        QMutexLocker lock(&s_proxyMutex);
+                        s_proxyUrl = proxyUrl;
+                    }
+                    outcome = retry;
+                    decrypted = retryDecrypted;
+                    bypassResolved = true;
+                    break;
+                }
+            }
+        }
+    }
+
+    auto errorCode = apiUtils::checkNetworkReplyErrors(outcome.sslErrors,
+                                                       outcome.errorString,
+                                                       outcome.networkError,
+                                                       outcome.httpStatusCode,
+                                                       decrypted.decrypted);
+    if (errorCode != amnezia::ErrorCode::NoError) {
+        return errorCode;
+    }
+
+    if (!decrypted.isOk) {
+        qCritical() << "HttpGatewayTransport: response decryption failed";
+        return amnezia::ErrorCode::ApiConfigDecryptionError;
+    }
+
+    decryptedResponse = decrypted.decrypted;
+    return amnezia::ErrorCode::NoError;
+}
+
+} // namespace amnezia::transport

client/core/transport/httpGatewayTransport.h

@@ -0,0 +1,58 @@
+#ifndef HTTPGATEWAYTRANSPORT_H
+#define HTTPGATEWAYTRANSPORT_H
+
+#include <QByteArray>
+#include <QList>
+#include <QMutex>
+#include <QNetworkReply>
+#include <QSslError>
+#include <QString>
+#include <QStringList>
+
+#include "igatewaytransport.h"
+
+namespace amnezia::transport
+{
+
+class HttpGatewayTransport : public IGatewayTransport
+{
+public:
+    HttpGatewayTransport(const QString &endpoint,
+                         bool isDevEnvironment,
+                         int requestTimeoutMsecs,
+                         bool isStrictKillSwitchEnabled);
+
+    QString name() const override { return QStringLiteral("HTTP"); }
+
+    amnezia::ErrorCode send(const QString &endpointTemplate,
+                            const QByteArray &requestBody,
+                            QByteArray &decryptedResponse,
+                            const DecryptionHook &decryptionHook) override;
+
+private:
+    struct ReplyOutcome
+    {
+        QByteArray encryptedBody;
+        QList<QSslError> sslErrors;
+        QNetworkReply::NetworkError networkError = QNetworkReply::NoError;
+        QString errorString;
+        int httpStatusCode = 0;
+    };
+
+    ReplyOutcome doPost(const QString &fullUrl, const QByteArray &requestBody);
+    void applyKillSwitchAllowlist(const QString &host);
+    QStringList fetchProxyUrls(const QByteArray &serviceHint);
+    bool shouldBypass(const ReplyOutcome &outcome, const DecryptionResult &decrypted) const;
+
+    QString m_endpoint;
+    bool m_isDevEnvironment;
+    int m_requestTimeoutMsecs;
+    bool m_isStrictKillSwitchEnabled;
+
+    static QMutex s_proxyMutex;
+    static QString s_proxyUrl;
+};
+
+} // namespace amnezia::transport
+
+#endif // HTTPGATEWAYTRANSPORT_H

client/core/transport/igatewaytransport.h

@@ -0,0 +1,36 @@
+#ifndef IGATEWAYTRANSPORT_H
+#define IGATEWAYTRANSPORT_H
+
+#include <QByteArray>
+#include <QString>
+#include <functional>
+
+#include "core/defs.h"
+
+namespace amnezia::transport
+{
+
+struct DecryptionResult
+{
+    QByteArray decrypted;
+    bool isOk = false;
+};
+
+using DecryptionHook = std::function<DecryptionResult(const QByteArray &encrypted)>;
+
+class IGatewayTransport
+{
+public:
+    virtual ~IGatewayTransport() = default;
+
+    virtual QString name() const = 0;
+
+    virtual amnezia::ErrorCode send(const QString &endpointTemplate,
+                                    const QByteArray &requestBody,
+                                    QByteArray &decryptedResponse,
+                                    const DecryptionHook &decryptionHook) = 0;
+};
+
+} // namespace amnezia::transport
+
+#endif // IGATEWAYTRANSPORT_H

client/gateway.example.json

@@ -0,0 +1,44 @@
+{
+  "primary": "http",
+  "retry_count": 3,
+  "timeout_ms": 10000,
+  
+  "http": {
+    "enabled": true,
+    "endpoint": "https://your-gateway.example.com/"
+  },
+  
+  "dns_transports": [
+    {
+      "type": "udp",
+      "server": "your-gateway.example.com",
+      "domain": "gateway.example.com",
+      "port": 5453
+    },
+    {
+      "type": "tcp",
+      "server": "your-gateway.example.com",
+      "domain": "gateway.example.com",
+      "port": 5453
+    },
+    {
+      "type": "dot",
+      "server": "your-gateway.example.com",
+      "domain": "gateway.example.com",
+      "port": 8853
+    },
+    {
+      "type": "doh",
+      "server": "your-gateway.example.com",
+      "domain": "gateway.example.com",
+      "port": 443,
+      "path": "/dns-query"
+    },
+    {
+      "type": "doq",
+      "server": "your-gateway.example.com",
+      "domain": "gateway.example.com",
+      "port": 8854
+    }
+  ]
+}

client/mozilla/localsocketcontroller.cpp

@@ -270,7 +270,12 @@ void LocalSocketController::activate(const QJsonObject &rawConfig) {
              && !wgConfig.value(amnezia::config_key::initPacketMagicHeader).isUndefined()
              && !wgConfig.value(amnezia::config_key::responsePacketMagicHeader).isUndefined()
              && !wgConfig.value(amnezia::config_key::underloadPacketMagicHeader).isUndefined()
-             && !wgConfig.value(amnezia::config_key::transportPacketMagicHeader).isUndefined()) {
+             && !wgConfig.value(amnezia::config_key::transportPacketMagicHeader).isUndefined()
+             && !wgConfig.value(amnezia::config_key::specialJunk1).isUndefined()
+             && !wgConfig.value(amnezia::config_key::specialJunk2).isUndefined()
+             && !wgConfig.value(amnezia::config_key::specialJunk3).isUndefined()
+             && !wgConfig.value(amnezia::config_key::specialJunk4).isUndefined()
+             && !wgConfig.value(amnezia::config_key::specialJunk5).isUndefined()) {
     json.insert(amnezia::config_key::junkPacketCount, wgConfig.value(amnezia::config_key::junkPacketCount));
     json.insert(amnezia::config_key::junkPacketMinSize, wgConfig.value(amnezia::config_key::junkPacketMinSize));
     json.insert(amnezia::config_key::junkPacketMaxSize, wgConfig.value(amnezia::config_key::junkPacketMaxSize));

client/mozilla/networkwatcher.cpp

@@ -72,9 +72,9 @@ void NetworkWatcher::initialize() {
   connect(m_impl, &NetworkWatcherImpl::unsecuredNetwork, this,
           &NetworkWatcher::unsecuredNetwork);
   connect(m_impl, &NetworkWatcherImpl::networkChanged, this,
-          &NetworkWatcher::networkChanged);
-  connect(m_impl, &NetworkWatcherImpl::wakeup, this,
-          &NetworkWatcher::wakeup);
+          &NetworkWatcher::networkChange);
+  connect(m_impl, &NetworkWatcherImpl::sleepMode, this,
+          &NetworkWatcher::onSleepMode);
   m_impl->initialize();
 
   // Enable sleep/wake monitoring for VPN auto-reconnection
@@ -97,6 +97,12 @@ void NetworkWatcher::settingsChanged() {
   logger.debug() << "NetworkWatcher settings changed - keeping sleep monitoring active";
 }
 
+void NetworkWatcher::onSleepMode()
+{
+  logger.debug() << "Resumed from sleep mode";
+  emit sleepMode();
+}
+
 void NetworkWatcher::unsecuredNetwork(const QString& networkName,
                                       const QString& networkId) {
   logger.debug() << "Unsecured network:" << logger.sensitive(networkName)

client/mozilla/networkwatcher.h

@@ -29,11 +29,13 @@ public:
     // false to restore.
     void simulateDisconnection(bool simulatedDisconnection);
 
+    void onSleepMode();
+
     QNetworkInformation::Reachability getReachability();
 
 signals:
-    void networkChanged();
-    void wakeup();
+    void networkChange();
+    void sleepMode();
 
 private:
     void settingsChanged();

client/mozilla/networkwatcherimpl.h

@@ -41,7 +41,7 @@ signals:
     // TODO: Only windows-networkwatcher has this, the other plattforms should
     // too.
     void networkChanged(QString newBSSID);
-    void wakeup();
+    void sleepMode();
 
 
 private:

client/platforms/android/android_controller.cpp

@@ -101,9 +101,7 @@ bool AndroidController::initialize()
         {"onAuthResult", "(Z)V", reinterpret_cast<void *>(onAuthResult)},
         {"decodeQrCode", "(Ljava/lang/String;)Z", reinterpret_cast<bool *>(decodeQrCode)},
         {"onImeInsetsChanged", "(I)V", reinterpret_cast<void *>(onImeInsetsChanged)},
-        {"onSystemBarsInsetsChanged", "(II)V", reinterpret_cast<void *>(onSystemBarsInsetsChanged)},
-        {"onActivityPaused", "()V", reinterpret_cast<void *>(onActivityPaused)},
-        {"onActivityResumed", "()V", reinterpret_cast<void *>(onActivityResumed)}
+        {"onSystemBarsInsetsChanged", "(II)V", reinterpret_cast<void *>(onSystemBarsInsetsChanged)}
     };
 
     QJniEnvironment env;
@@ -560,22 +558,3 @@ void AndroidController::onSystemBarsInsetsChanged(JNIEnv *env, jobject thiz, jin
     emit AndroidController::instance()->systemBarsInsetsChanged(navBarHeightDp, statusBarHeightDp);
 }
 
-// static
-void AndroidController::onActivityPaused(JNIEnv *env, jobject thiz)
-{
-    Q_UNUSED(env);
-    Q_UNUSED(thiz);
-
-    emit AndroidController::instance()->activityPaused();
-}
-
-// static
-void AndroidController::onActivityResumed(JNIEnv *env, jobject thiz)
-{
-    Q_UNUSED(env);
-    Q_UNUSED(thiz);
-
-    emit AndroidController::instance()->activityResumed();
-}
-
-

client/platforms/android/android_controller.h

@@ -75,8 +75,6 @@ signals:
     void authenticationResult(bool result);
     void imeInsetsChanged(int heightDp);
     void systemBarsInsetsChanged(int navBarHeightDp, int statusBarHeightDp);
-    void activityPaused();
-    void activityResumed();
 
 private:
     bool isWaitingStatus = true;
@@ -107,8 +105,6 @@ private:
     static bool decodeQrCode(JNIEnv *env, jobject thiz, jstring data);
     static void onImeInsetsChanged(JNIEnv *env, jobject thiz, jint heightDp);
     static void onSystemBarsInsetsChanged(JNIEnv *env, jobject thiz, jint navBarHeightDp, jint statusBarHeightDp);
-    static void onActivityPaused(JNIEnv *env, jobject thiz);
-    static void onActivityResumed(JNIEnv *env, jobject thiz);
 
     template <typename Ret, typename ...Args>
     static auto callActivityMethod(const char *methodName, const char *signature, Args &&...args);

client/platforms/ios/PacketTunnelProvider+OpenVPN.swift

@@ -126,7 +126,8 @@ extension PacketTunnelProvider {
         }
 
         vpnReachability.startTracking { [weak self] status in
-            self?.handleOpenVPNReachabilityChange(status)
+            guard status == .reachableViaWiFi else { return }
+            self?.ovpnAdapter?.reconnect(afterTimeInterval: 5)
         }
 
         startHandler = completionHandler

client/platforms/ios/PacketTunnelProvider+Xray.swift

@@ -21,44 +21,6 @@ extension Constants {
 }
 
 extension PacketTunnelProvider {
-    private func applyXraySplitTunnel(_ xrayConfig: XrayConfig,
-                                      settings: NEPacketTunnelNetworkSettings) {
-        guard let splitTunnelType = xrayConfig.splitTunnelType else {
-            return
-        }
-
-        guard let splitTunnelSites = xrayConfig.splitTunnelSites else {
-            xrayLog(.error, message: "Split tunnel sites are not set")
-            return
-        }
-
-        if splitTunnelType == 1 {
-            var ipv4IncludedRoutes = [NEIPv4Route]()
-
-            for allowedIPString in splitTunnelSites {
-                if let allowedIP = IPAddressRange(from: allowedIPString) {
-                    ipv4IncludedRoutes.append(NEIPv4Route(
-                        destinationAddress: "\(allowedIP.address)",
-                        subnetMask: "\(allowedIP.subnetMask())"))
-                }
-            }
-
-            settings.ipv4Settings?.includedRoutes = ipv4IncludedRoutes
-        } else if splitTunnelType == 2 {
-            var ipv4ExcludedRoutes = [NEIPv4Route]()
-
-            for excludedIPString in splitTunnelSites {
-                if let excludedIP = IPAddressRange(from: excludedIPString) {
-                    ipv4ExcludedRoutes.append(NEIPv4Route(
-                        destinationAddress: "\(excludedIP.address)",
-                        subnetMask: "\(excludedIP.subnetMask())"))
-                }
-            }
-
-            settings.ipv4Settings?.excludedRoutes = ipv4ExcludedRoutes
-        }
-    }
-
     func startXray(completionHandler: @escaping (Error?) -> Void) {
 
         // Xray configuration
@@ -110,7 +72,6 @@ extension PacketTunnelProvider {
             settings.dnsSettings = !dnsArray.isEmpty
             ? NEDNSSettings(servers: dnsArray)
             : NEDNSSettings(servers: ["1.1.1.1"])
-            applyXraySplitTunnel(xrayConfig, settings: settings)
 
             let xrayConfigData = xrayConfig.config.data(using: .utf8)
 

client/platforms/ios/PacketTunnelProvider.swift

@@ -41,15 +41,10 @@ class PacketTunnelProvider: NEPacketTunnelProvider {
     var ovpnAdapter: OpenVPNAdapter?
     private lazy var openVPNPacketFlowAdapter = PacketTunnelFlowAdapter(flow: packetFlow)
     private let pathMonitorQueue = DispatchQueue(label: Constants.processQueueName + ".path-monitor")
-    private let networkChangeQueue = DispatchQueue(label: Constants.processQueueName + ".network-change")
     private let pathMonitor = NWPathMonitor()
     private var didReceiveInitialPathUpdate = false
     private var currentPath: Network.NWPath?
     private var currentPathSignature: String?
-    private var pendingOpenVPNReconnectWorkItem: DispatchWorkItem?
-    private var pendingNetworkChangeWorkItem: DispatchWorkItem?
-    private var isApplyingNetworkChange = false
-    private var lastOpenVPNReachabilityStatus: OpenVPNReachabilityStatus?
 
     var splitTunnelType: Int?
     var splitTunnelSites: [String]?
@@ -83,22 +78,14 @@ class PacketTunnelProvider: NEPacketTunnelProvider {
 
             guard hasMeaningfulChange, let proto = self.protoType else { return }
 
-            // WireGuard/AWG manages network changes internally in its own adapter.
+            // WireGuard/AWG manages network changes internally; avoid restarting the tunnel here.
             if proto == .wireguard {
                 return
             }
 
-            if proto == .openvpn {
-                self.scheduleOpenVPNReconnect(reason: "NWPath changed")
-                return
+            DispatchQueue.main.async {
+                self.handle(networkChange: path) { _ in }
             }
-
-            if self.isApplyingNetworkChange || self.reasserting {
-                xrayLog(.debug, message: "Ignoring path change while xray restart is in progress")
-                return
-            }
-
-            self.scheduleNetworkChangeHandling(for: proto, path: path)
         }
         pathMonitor.start(queue: pathMonitorQueue)
 
@@ -210,8 +197,6 @@ class PacketTunnelProvider: NEPacketTunnelProvider {
             return
         }
 
-        cancelPendingOpenVPNReconnect()
-        cancelPendingNetworkChangeHandling()
         didReceiveInitialPathUpdate = false
         updateActiveInterfaceIndexForCurrentPath()
 
@@ -230,9 +215,6 @@ class PacketTunnelProvider: NEPacketTunnelProvider {
 
   
     override func stopTunnel(with reason: NEProviderStopReason, completionHandler: @escaping () -> Void) {
-        cancelPendingOpenVPNReconnect()
-        cancelPendingNetworkChangeHandling()
-
         guard let protoType else {
             completionHandler()
             return
@@ -277,111 +259,9 @@ class PacketTunnelProvider: NEPacketTunnelProvider {
     }
   
     private func handle(networkChange changePath: Network.NWPath, completion: @escaping (Error?) -> Void) {
-        guard protoType == .xray else {
-            updateActiveInterfaceIndex(for: changePath)
-            completion(nil)
-            return
-        }
-
         updateActiveInterfaceIndex(for: changePath)
-        reasserting = true
-        xrayLog(.info, message: "Applying network change to xray tunnel")
-        stopXray { }
-        startXray { [weak self] error in
-            self?.reasserting = false
-            completion(error)
-        }
-    }
-
-    private func scheduleNetworkChangeHandling(for proto: TunnelProtoType, path: Network.NWPath) {
-        guard proto == .xray else { return }
-
-        pendingNetworkChangeWorkItem?.cancel()
-
-        let workItem = DispatchWorkItem { [weak self] in
-            guard let self else { return }
-            self.pendingNetworkChangeWorkItem = nil
-
-            if self.isApplyingNetworkChange || self.reasserting {
-                xrayLog(.debug, message: "Skipping network change while restart is already in progress")
-                return
-            }
-
-            self.isApplyingNetworkChange = true
-            DispatchQueue.main.async {
-                self.handle(networkChange: path) { [weak self] _ in
-                    self?.networkChangeQueue.async {
-                        self?.isApplyingNetworkChange = false
-                    }
-                }
-            }
-        }
-
-        pendingNetworkChangeWorkItem = workItem
-        networkChangeQueue.asyncAfter(deadline: .now() + 1.0, execute: workItem)
-    }
-
-    private func scheduleOpenVPNReconnect(reason: String) {
-        guard protoType == .openvpn else { return }
-
-        pendingOpenVPNReconnectWorkItem?.cancel()
-
-        let workItem = DispatchWorkItem { [weak self] in
-            guard let self else { return }
-            self.pendingOpenVPNReconnectWorkItem = nil
-
-            guard self.protoType == .openvpn else { return }
-
-            if self.reasserting {
-                ovpnLog(.debug, message: "Skipping OpenVPN reconnect while session is already reasserting")
-                return
-            }
-
-            DispatchQueue.main.async { [weak self] in
-                guard let self else { return }
-                guard !self.reasserting else {
-                    ovpnLog(.debug, message: "Skipping OpenVPN reconnect while session is already reasserting")
-                    return
-                }
-
-                ovpnLog(.info, message: "\(reason), reconnecting OpenVPN session")
-                self.ovpnAdapter?.reconnect(afterTimeInterval: 1)
-            }
-        }
-
-        pendingOpenVPNReconnectWorkItem = workItem
-        networkChangeQueue.asyncAfter(deadline: .now() + 1.0, execute: workItem)
-    }
-
-    func handleOpenVPNReachabilityChange(_ status: OpenVPNReachabilityStatus) {
-        defer { lastOpenVPNReachabilityStatus = status }
-
-        guard let previousStatus = lastOpenVPNReachabilityStatus else {
-            return
-        }
-
-        guard previousStatus != status else {
-            return
-        }
-
-        switch status {
-        case .reachableViaWiFi, .reachableViaWWAN:
-            scheduleOpenVPNReconnect(reason: "Reachability changed")
-        default:
-            break
-        }
-    }
-
-    private func cancelPendingOpenVPNReconnect() {
-        pendingOpenVPNReconnectWorkItem?.cancel()
-        pendingOpenVPNReconnectWorkItem = nil
-        lastOpenVPNReachabilityStatus = nil
-    }
-
-    private func cancelPendingNetworkChangeHandling() {
-        pendingNetworkChangeWorkItem?.cancel()
-        pendingNetworkChangeWorkItem = nil
-        isApplyingNetworkChange = false
+        wg_log(.info, message: "Tunnel restarted.")
+        startTunnel(options: nil, completionHandler: completion)
     }
 }
 
@@ -391,14 +271,8 @@ private extension PacketTunnelProvider {
         signatureComponents.append(path.isExpensive ? "exp" : "noexp")
         signatureComponents.append(path.isConstrained ? "con" : "nocon")
 
-        // Ignore loopback and tunnel-style `.other` interfaces so Xray does not
-        // react to its own utun lifecycle as if the physical uplink changed.
-        let preferredTypes: [NWInterface.InterfaceType] = [.wiredEthernet, .wifi, .cellular]
-        let externalInterfaces = path.availableInterfaces.filter { interface in
-            interface.type == .wiredEthernet || interface.type == .wifi || interface.type == .cellular
-        }
-
-        let sortedInterfaces = externalInterfaces.sorted { lhs, rhs in
+        let preferredTypes: [NWInterface.InterfaceType] = [.wiredEthernet, .wifi, .cellular, .loopback, .other]
+        let sortedInterfaces = path.availableInterfaces.sorted { lhs, rhs in
             if lhs.type == rhs.type {
                 return lhs.index < rhs.index
             }
@@ -419,8 +293,8 @@ private extension PacketTunnelProvider {
             case .wiredEthernet: typeName = "ethernet"
             case .wifi: typeName = "wifi"
             case .cellular: typeName = "cellular"
-            case .loopback, .other:
-                continue
+            case .loopback: typeName = "loopback"
+            case .other: typeName = "other"
             @unknown default: typeName = "unknown"
             }
             signatureComponents.append("\(typeName):\(interface.index)")

client/platforms/ios/XrayConfig.swift

@@ -3,7 +3,5 @@ import Foundation
 struct XrayConfig: Decodable {
     let dns1: String?
     let dns2: String?
-    let splitTunnelType: Int?
-    let splitTunnelSites: [String]?
     let config: String
 }

client/platforms/ios/ios_controller.mm

@@ -684,15 +684,6 @@ bool IosController::setupXray()
     QJsonObject finalConfig;
     finalConfig.insert(config_key::dns1, m_rawConfig[config_key::dns1].toString());
     finalConfig.insert(config_key::dns2, m_rawConfig[config_key::dns2].toString());
-    finalConfig.insert(config_key::splitTunnelType, m_rawConfig[config_key::splitTunnelType]);
-
-    QJsonArray splitTunnelSites = m_rawConfig[config_key::splitTunnelSites].toArray();
-
-    for(int index = 0; index < splitTunnelSites.count(); index++) {
-        splitTunnelSites[index] = splitTunnelSites[index].toString().remove(" ");
-    }
-
-    finalConfig.insert(config_key::splitTunnelSites, splitTunnelSites);
     finalConfig.insert(config_key::config, xrayConfigStr);
 
     QJsonDocument finalConfigDoc(finalConfig);

client/platforms/linux/daemon/linuxfirewall.cpp

@@ -108,7 +108,7 @@ int LinuxFirewall::linkChain(LinuxFirewall::IPVersion ip, const QString& chain,
         //    (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 -r %1 -t %4 -D %2 ; fi").arg(cmd, parent, chain, tableName));
+        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));
@@ -289,7 +289,6 @@ void LinuxFirewall::install()
     installAnchor(Both, QStringLiteral("100.blockAll"), {
                                                             QStringLiteral("-j REJECT"),
                                                         });
-    installAnchor(Both, QStringLiteral("400.allowPIA"), {});
     // NAT rules
     installAnchor(Both, QStringLiteral("100.transIp"), {
 
@@ -496,23 +495,13 @@ int LinuxFirewall::execute(const QString &command, bool ignoreErrors)
         logger.debug() << "(" << exitCode << ") $ " << command;
     if (!out.isEmpty())
         logger.info() << out;
-    if (!err.isEmpty() && !ignoreErrors)
+    if (!err.isEmpty())
         logger.warning() << err;
     return exitCode;
 }
 
 void LinuxFirewall::setupTrafficSplitting()
 {
-    // Register the routing table name so the ip tool can resolve it by name
-    execute(QStringLiteral("grep -q '%1' /etc/iproute2/rt_tables || printf '200\\t%1\\n' >> /etc/iproute2/rt_tables").arg(kRtableName));
-
-    // On cgroup v2 (unified hierarchy) systems /sys/fs/cgroup/net_cls/ does not exist.
-    // Try to mount the legacy net_cls cgroup v1 controller so traffic splitting works.
-    execute(QStringLiteral(
-        "if [ ! -d /sys/fs/cgroup/net_cls ] ; then "
-        "mkdir -p /sys/fs/cgroup/net_cls && "
-        "mount -t cgroup -o net_cls cgroup /sys/fs/cgroup/net_cls ; fi"));
-
     auto cGroupDir = "/sys/fs/cgroup/net_cls/" BRAND_CODE "vpnexclusions/";
     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));
@@ -524,9 +513,6 @@ 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));
-    // Ignore errors here: on first teardown the table name may not be registered yet
-    execute(QStringLiteral("ip route flush table %1").arg(kRtableName), true);
+    execute(QStringLiteral("ip route flush table %1").arg(kRtableName));
     execute(QStringLiteral("ip route flush cache"));
-    // Remove the rt_tables entry we added
-    execute(QStringLiteral("sed -i '/%1/d' /etc/iproute2/rt_tables").arg(kRtableName));
 }

client/platforms/linux/linuxnetworkwatcher.cpp

@@ -41,8 +41,8 @@ void LinuxNetworkWatcher::initialize() {
   connect(m_worker, &LinuxNetworkWatcherWorker::unsecuredNetwork, this,
           &LinuxNetworkWatcher::unsecuredNetwork);
 
-  connect(m_worker, &LinuxNetworkWatcherWorker::wakeup, this,
-          &NetworkWatcherImpl::wakeup);
+  connect(m_worker, &LinuxNetworkWatcherWorker::sleepMode, this,
+          &NetworkWatcherImpl::sleepMode);
 
   // Let's wait a few seconds to allow the UI to be fully loaded and shown.
   // This is not strictly needed, but it's better for user experience because

client/platforms/linux/linuxnetworkwatcherworker.cpp

@@ -200,7 +200,7 @@ void LinuxNetworkWatcherWorker::checkDevices() {
 void LinuxNetworkWatcherWorker::NMStateChanged(quint32 state)
 {
   if (state == NM_STATE_ASLEEP) {
-    emit wakeup();
+    emit sleepMode();
   }
 
   logger.debug() << "NMStateChanged " << state;

client/platforms/linux/linuxnetworkwatcherworker.h

@@ -23,7 +23,7 @@ class LinuxNetworkWatcherWorker final : public QObject {
 
  signals:
   void unsecuredNetwork(const QString& networkName, const QString& networkId);
-  void wakeup();
+  void sleepMode();
 
  public slots:
   void initialize();

client/platforms/macos/macosnetworkwatcher.mm

@@ -173,10 +173,10 @@ void PowerNotificationsListener::sleepWakeupCallBack(void *refParam, io_service_
 
     case kIOMessageSystemHasPoweredOn:
         /* Announces that the system and its devices have woken up. */
-        logger.debug() << "System has powered on - emitting wakeup signal from dedicated CFRunLoop thread";
+        logger.debug() << "System has powered on - emitting sleepMode signal from dedicated CFRunLoop thread";
         if (listener->m_watcher) {
             // Use QMetaObject::invokeMethod for thread-safe signal emission
-            QMetaObject::invokeMethod(listener->m_watcher, "wakeup", Qt::QueuedConnection);
+            QMetaObject::invokeMethod(listener->m_watcher, "sleepMode", Qt::QueuedConnection);
         }
         break;
 

client/platforms/windows/daemon/windowsdaemon.cpp

@@ -62,9 +62,6 @@ void WindowsDaemon::prepareActivation(const InterfaceConfig& config, int inetAda
 }
 
 void WindowsDaemon::activateSplitTunnel(const InterfaceConfig& config, int vpnAdapterIndex) {
-    if (m_splitTunnelManager == nullptr)
-        return;
-
   if (config.m_vpnDisabledApps.length() > 0) {
       m_splitTunnelManager->start(m_inetAdapterIndex, vpnAdapterIndex);
       m_splitTunnelManager->excludeApps(config.m_vpnDisabledApps);

client/platforms/windows/windowsnetworkwatcher.cpp

@@ -41,7 +41,7 @@ LRESULT WindowsNetworkWatcher::PowerWndProcCallback(HWND hwnd, UINT uMsg, WPARAM
   switch (uMsg) {
   case WM_POWERBROADCAST:
     if (wParam == PBT_APMRESUMESUSPEND) {
-        emit obj->wakeup();
+        emit obj->sleepMode();
     }
     break;
   default:

client/protocols/openvpnprotocol.cpp

@@ -232,6 +232,12 @@ ErrorCode OpenVpnProtocol::start()
         return ErrorCode::AmneziaServiceConnectionFailed;
     }
 
+    m_openVpnProcess->waitForSource(5000);
+    if (!m_openVpnProcess->isInitialized()) {
+        qWarning() << "IpcProcess replica is not connected!";
+        setLastError(ErrorCode::AmneziaServiceConnectionFailed);
+        return ErrorCode::AmneziaServiceConnectionFailed;
+    }
     m_openVpnProcess->setProgram(PermittedProcess::OpenVPN);
     QStringList arguments({
             "--config", configPath(), "--management", m_managementHost, QString::number(mgmtPort),
@@ -240,13 +246,13 @@ ErrorCode OpenVpnProtocol::start()
     m_openVpnProcess->setArguments(arguments);
 
     qDebug() << arguments.join(" ");
-    connect(m_openVpnProcess.data(), &IpcProcessInterfaceReplica::errorOccurred,
+    connect(m_openVpnProcess.data(), &PrivilegedProcess::errorOccurred,
             [&](QProcess::ProcessError error) { qDebug() << "PrivilegedProcess errorOccurred" << error; });
 
-    connect(m_openVpnProcess.data(), &IpcProcessInterfaceReplica::stateChanged,
+    connect(m_openVpnProcess.data(), &PrivilegedProcess::stateChanged,
             [&](QProcess::ProcessState newState) { qDebug() << "PrivilegedProcess stateChanged" << newState; });
 
-    connect(m_openVpnProcess.data(), &IpcProcessInterfaceReplica::finished, this,
+    connect(m_openVpnProcess.data(), &PrivilegedProcess::finished, this,
             [&]() { setConnectionState(Vpn::ConnectionState::Disconnected); });
 
     m_openVpnProcess->start();

client/protocols/openvpnprotocol.h

@@ -53,7 +53,7 @@ private:
     void updateRouteGateway(QString line);
     void updateVpnGateway(const QString &line);
 
-    QSharedPointer<IpcProcessInterfaceReplica> m_openVpnProcess;
+    QSharedPointer<PrivilegedProcess> m_openVpnProcess;
 };
 
 #endif // OPENVPNPROTOCOL_H

client/protocols/protocols_defs.h

@@ -233,7 +233,7 @@ namespace amnezia
             constexpr char defaultResponsePacketMagicHeader[] = "3288052141";
             constexpr char defaultTransportPacketMagicHeader[] = "2528465083";
             constexpr char defaultUnderloadPacketMagicHeader[] = "1766607858";
-            constexpr char defaultSpecialJunk1[] = "<r 2><b 0x858000010001000000000669636c6f756403636f6d0000010001c00c000100010000105a00044d583737>";
+            constexpr char defaultSpecialJunk1[] = "<b 0x084481800001000300000000077469636b65747306776964676574096b696e6f706f69736b0272750000010001c00c0005000100000039001806776964676574077469636b6574730679616e646578c025c0390005000100000039002b1765787465726e616c2d7469636b6574732d776964676574066166697368610679616e646578036e657400c05d000100010000001c000457fafe25>";
             constexpr char defaultSpecialJunk2[] = "";
             constexpr char defaultSpecialJunk3[] = "";
             constexpr char defaultSpecialJunk4[] = "";

client/protocols/wireguardprotocol.cpp

@@ -15,7 +15,7 @@ WireguardProtocol::WireguardProtocol(const QJsonObject &configuration, QObject *
     m_impl.reset(new LocalSocketController());
     connect(m_impl.get(), &ControllerImpl::connected, this,
             [this](const QString &pubkey, const QDateTime &connectionTimestamp) {
-                setConnectionState(Vpn::ConnectionState::Connected);
+                emit connectionStateChanged(Vpn::ConnectionState::Connected);
             });
     connect(m_impl.get(), &ControllerImpl::statusUpdated, this,
             [this](const QString& serverIpv4Gateway,
@@ -38,7 +38,7 @@ WireguardProtocol::WireguardProtocol(const QJsonObject &configuration, QObject *
             });
 
     connect(m_impl.get(), &ControllerImpl::disconnected, this,
-            [this]() { setConnectionState(Vpn::ConnectionState::Disconnected); });
+            [this]() { emit connectionStateChanged(Vpn::ConnectionState::Disconnected); });
     m_impl->initialize(nullptr, nullptr);
 }
 

client/protocols/xrayprotocol.cpp

@@ -1,7 +1,6 @@
 #include "xrayprotocol.h"
 
 #include "core/ipcclient.h"
-#include "ipc.h"
 #include "utilities.h"
 #include "core/networkUtilities.h"
 
@@ -10,37 +9,14 @@
 #include <QJsonObject>
 #include <QNetworkInterface>
 #include <QJsonDocument>
-#include <QtCore/qlogging.h>
-#include <QtCore/qobjectdefs.h>
-#include <QtCore/qprocess.h>
-
-#ifdef Q_OS_MACOS
-static const QString tunName = "utun22";
-#else
-static const QString tunName = "tun2";
-#endif
 
 XrayProtocol::XrayProtocol(const QJsonObject &configuration, QObject *parent) : VpnProtocol(configuration, parent)
 {
+    readXrayConfiguration(configuration);
+    m_routeGateway = NetworkUtilities::getGatewayAndIface().first;
     m_vpnGateway = amnezia::protocols::xray::defaultLocalAddr;
     m_vpnLocalAddress = amnezia::protocols::xray::defaultLocalAddr;
-    m_routeGateway = NetworkUtilities::getGatewayAndIface().first;
-
-    m_routeMode = static_cast<Settings::RouteMode>(configuration.value(amnezia::config_key::splitTunnelType).toInt());
-    m_remoteAddress = NetworkUtilities::getIPAddress(m_rawConfig.value(amnezia::config_key::hostName).toString());
-
-    const QString primaryDns = configuration.value(amnezia::config_key::dns1).toString();
-    m_dnsServers.push_back(QHostAddress(primaryDns));
-    if (primaryDns != amnezia::protocols::dns::amneziaDnsIp) {
-        const QString secondaryDns = configuration.value(amnezia::config_key::dns2).toString();
-        m_dnsServers.push_back(QHostAddress(secondaryDns));
-    }
-
-    QJsonObject xrayConfiguration = configuration.value(ProtocolProps::key_proto_config_data(Proto::Xray)).toObject();
-    if (xrayConfiguration.isEmpty()) {
-        xrayConfiguration = configuration.value(ProtocolProps::key_proto_config_data(Proto::SSXray)).toObject();
-    }
-    m_xrayConfig = xrayConfiguration;
+    m_t2sProcess = IpcClient::InterfaceTun2Socks();
 }
 
 XrayProtocol::~XrayProtocol()
@@ -53,16 +29,72 @@ ErrorCode XrayProtocol::start()
 {
     qDebug() << "XrayProtocol::start()";
 
-    return IpcClient::withInterface([&](QSharedPointer<IpcInterfaceReplica> iface) {
-        auto xrayStart = iface->xrayStart(QJsonDocument(m_xrayConfig).toJson());
-        if (!xrayStart.waitForFinished() || !xrayStart.returnValue()) {
-            qCritical() << "Failed to start xray";
-            return ErrorCode::XrayExecutableCrashed;
-        }
-        return startTun2Socks();
+    const ErrorCode err = IpcClient::withInterface([&](QSharedPointer<IpcInterfaceReplica> iface) {
+        iface->xrayStart(QJsonDocument(m_xrayConfig).toJson());
+        return ErrorCode::NoError;
     }, [] () {
         return ErrorCode::AmneziaServiceConnectionFailed;
     });
+    if (err != ErrorCode::NoError)
+        return err;
+
+    setConnectionState(Vpn::ConnectionState::Connecting);
+    return startTun2Sock();
+}
+
+ErrorCode XrayProtocol::startTun2Sock()
+{
+    m_t2sProcess->start();
+
+    connect(m_t2sProcess.data(), &IpcProcessTun2SocksReplica::stateChanged, this,
+            [&](QProcess::ProcessState newState) { qDebug() << "PrivilegedProcess stateChanged" << newState; });
+
+    connect(m_t2sProcess.data(), &IpcProcessTun2SocksReplica::setConnectionState, this, [&](int vpnState) {
+        qDebug() << "PrivilegedProcess setConnectionState " << vpnState;
+        IpcClient::withInterface([&](QSharedPointer<IpcInterfaceReplica> iface) {
+            if (vpnState == Vpn::ConnectionState::Connected) {
+                setConnectionState(Vpn::ConnectionState::Connecting);
+                QList<QHostAddress> dnsAddr;
+
+                dnsAddr.push_back(QHostAddress(m_primaryDNS));
+                // We don't use secondary DNS if primary DNS is AmneziaDNS
+                if (!m_primaryDNS.contains(amnezia::protocols::dns::amneziaDnsIp)) {
+                    dnsAddr.push_back(QHostAddress(m_secondaryDNS));
+                }
+    #ifdef Q_OS_WIN
+                QThread::msleep(8000);
+    #endif
+    #ifdef Q_OS_MACOS
+                QThread::msleep(5000);
+                iface->createTun("utun22", amnezia::protocols::xray::defaultLocalAddr);
+                iface->updateResolvers("utun22", dnsAddr);
+    #endif
+    #ifdef Q_OS_LINUX
+                QThread::msleep(1000);
+                iface->createTun("tun2", amnezia::protocols::xray::defaultLocalAddr);
+                iface->updateResolvers("tun2", dnsAddr);
+    #endif
+                if (m_routeMode == Settings::RouteMode::VpnAllSites) {
+                    iface->routeAddList(m_vpnGateway, QStringList() << "1.0.0.0/8" << "2.0.0.0/7" << "4.0.0.0/6" << "8.0.0.0/5" << "16.0.0.0/4" << "32.0.0.0/3" << "64.0.0.0/2" << "128.0.0.0/1");
+                }
+                iface->StopRoutingIpv6();
+    #ifdef Q_OS_WIN
+                iface->updateResolvers("tun2", dnsAddr);
+    #endif
+                setConnectionState(Vpn::ConnectionState::Connected);
+            }
+    #if !defined(Q_OS_MACOS)
+            if (vpnState == Vpn::ConnectionState::Disconnected) {
+                setConnectionState(Vpn::ConnectionState::Disconnected);
+                iface->deleteTun("tun2");
+                iface->StartRoutingIpv6();
+                iface->clearSavedRoutes();
+            }
+#endif
+        });
+    });
+
+    return ErrorCode::NoError;
 }
 
 void XrayProtocol::stop()
@@ -70,177 +102,43 @@ void XrayProtocol::stop()
     qDebug() << "XrayProtocol::stop()";
 
     IpcClient::withInterface([](QSharedPointer<IpcInterfaceReplica> iface) {
-        auto disableKillSwitch = iface->disableKillSwitch();
-        if (!disableKillSwitch.waitForFinished() || !disableKillSwitch.returnValue())
-            qWarning() << "Failed to disable killswitch";
+#ifdef AMNEZIA_DESKTOP
+        QRemoteObjectPendingReply<bool> StartRoutingIpv6Resp = iface->StartRoutingIpv6();
+        if (!StartRoutingIpv6Resp.waitForFinished(1000)) {
+            qWarning() << "XrayProtocol::stop(): Failed to start routing ipv6";
+        }
 
-        auto StartRoutingIpv6 = iface->StartRoutingIpv6();
-        if (!StartRoutingIpv6.waitForFinished() || !StartRoutingIpv6.returnValue())
-            qWarning() << "Failed to start routing ipv6";
+        QRemoteObjectPendingReply<bool> restoreResolvers = iface->restoreResolvers();
+        if (!restoreResolvers.waitForFinished(1000)) {
+            qWarning() << "XrayProtocol::stop(): Failed to restore resolvers";
+        }
 
-        auto restoreResolvers = iface->restoreResolvers();
-        if (!restoreResolvers.waitForFinished() || !restoreResolvers.returnValue())
-            qWarning() << "Failed to restore resolvers";
-
-        auto deleteTun = iface->deleteTun(tunName);
-        if (!deleteTun.waitForFinished() || !deleteTun.returnValue())
-            qWarning() << "Failed to delete tun";
-
-        auto xrayStop = iface->xrayStop();
-        if (!xrayStop.waitForFinished() || !xrayStop.returnValue())
-            qWarning() << "Failed to stop xray";
+    #if !defined(Q_OS_MACOS)
+        QRemoteObjectPendingReply<bool> deleteTunResp = iface->deleteTun("tun2");
+        if (!deleteTunResp.waitForFinished(1000)) {
+            qWarning() << "XrayProtocol::stop(): Failed to delete tun";
+        }
+    #endif
+#endif
+        iface->xrayStop();
     });
 
-    if (m_tun2socksProcess) {
-        m_tun2socksProcess->blockSignals(true);
-
-#ifndef Q_OS_WIN
-        m_tun2socksProcess->terminate();
-        auto waitForFinished = m_tun2socksProcess->waitForFinished(1000);
-        if (!waitForFinished.waitForFinished() || !waitForFinished.returnValue()) {
-            qWarning() << "Failed to terminate tun2socks. Killing the process...";
-            m_tun2socksProcess->kill();
-        }
-#else
-        // terminate does not do anything useful on Windows
-        // so just kill the process
-        m_tun2socksProcess->kill();
-#endif
-
-        m_tun2socksProcess->close();
-        m_tun2socksProcess.reset();
+    if (m_t2sProcess) {
+        m_t2sProcess->stop();
+        QThread::msleep(200);
     }
 
     setConnectionState(Vpn::ConnectionState::Disconnected);
 }
 
-ErrorCode XrayProtocol::startTun2Socks()
+void XrayProtocol::readXrayConfiguration(const QJsonObject &configuration)
 {
-    m_tun2socksProcess = IpcClient::CreatePrivilegedProcess();
-    if (!m_tun2socksProcess->waitForSource()) {
-        return ErrorCode::AmneziaServiceConnectionFailed;
+    QJsonObject xrayConfiguration = configuration.value(ProtocolProps::key_proto_config_data(Proto::Xray)).toObject();
+    if (xrayConfiguration.isEmpty()) {
+        xrayConfiguration = configuration.value(ProtocolProps::key_proto_config_data(Proto::SSXray)).toObject();
     }
-
-    m_tun2socksProcess->setProgram(PermittedProcess::Tun2Socks);
-    m_tun2socksProcess->setArguments({"-device", QString("tun://%1").arg(tunName), "-proxy", "socks5://127.0.0.1:10808" });
-
-    connect(m_tun2socksProcess.data(), &IpcProcessInterfaceReplica::readyReadStandardOutput, this, [this]() {
-        auto readAllStandardOutput = m_tun2socksProcess->readAllStandardOutput();
-        if (!readAllStandardOutput.waitForFinished()) {
-            qWarning() << "Failed to read output from tun2socks";
-            return;
-        }
-
-        const QString line = readAllStandardOutput.returnValue();
-
-        if (!line.contains("[TCP]") && !line.contains("[UDP]"))
-            qDebug() << "[tun2socks]:" << line;
-        
-        if (line.contains("[STACK] tun://") && line.contains("<-> socks5://127.0.0.1")) {
-            disconnect(m_tun2socksProcess.data(), &IpcProcessInterfaceReplica::readyReadStandardOutput, this, nullptr);
-
-            if (ErrorCode res = setupRouting(); res != ErrorCode::NoError) {
-                stop();
-                setLastError(res);
-            } else {
-                setConnectionState(Vpn::ConnectionState::Connected);
-            }
-        }
-    }, Qt::QueuedConnection);
-
-    connect(m_tun2socksProcess.data(), &IpcProcessInterfaceReplica::finished, this, [this](int exitCode, QProcess::ExitStatus exitStatus) {
-        if (exitStatus == QProcess::ExitStatus::CrashExit) {
-            qCritical() << "Tun2socks process crashed!";
-        } else {
-            qCritical() << QString("Tun2socks process was closed with %1 exit code").arg(exitCode);
-        }
-        stop();
-        setLastError(ErrorCode::Tun2SockExecutableCrashed);
-    }, Qt::QueuedConnection);
-
-    m_tun2socksProcess->start();
-    return ErrorCode::NoError;
-}
-
-ErrorCode XrayProtocol::setupRouting() {
-    return IpcClient::withInterface([this](QSharedPointer<IpcInterfaceReplica> iface) -> ErrorCode {
-#ifdef Q_OS_WIN
-        const int inetAdapterIndex = NetworkUtilities::AdapterIndexTo(QHostAddress(m_remoteAddress));
-#endif
-        auto createTun = iface->createTun(tunName, amnezia::protocols::xray::defaultLocalAddr);
-        if (!createTun.waitForFinished() || !createTun.returnValue()) {
-            qCritical() << "Failed to assign IP address for TUN";
-            return ErrorCode::InternalError;
-        }
-
-        auto updateResolvers = iface->updateResolvers(tunName, m_dnsServers);
-        if (!updateResolvers.waitForFinished() || !updateResolvers.returnValue()) {
-            qCritical() << "Failed to set DNS resolvers for TUN";
-            return ErrorCode::InternalError;
-        }
-
-#ifdef Q_OS_WIN
-        int vpnAdapterIndex = -1;
-        QList<QNetworkInterface> netInterfaces = QNetworkInterface::allInterfaces();
-        for (auto& netInterface : netInterfaces) {
-            for (auto& address : netInterface.addressEntries()) {
-                if (m_vpnLocalAddress == address.ip().toString())
-                    vpnAdapterIndex = netInterface.index();
-            }
-        }
-#else
-        static const int vpnAdapterIndex = 0;
-#endif
-        const bool killSwitchEnabled = QVariant(m_rawConfig.value(config_key::killSwitchOption).toString()).toBool();
-        if (killSwitchEnabled) {
-            if (vpnAdapterIndex != -1) {
-                QJsonObject config = m_rawConfig;
-                config.insert("vpnServer", m_remoteAddress);
-
-                auto enableKillSwitch = IpcClient::Interface()->enableKillSwitch(config, vpnAdapterIndex);
-                if (!enableKillSwitch.waitForFinished() || !enableKillSwitch.returnValue()) {
-                    qCritical() << "Failed to enable killswitch";
-                    return ErrorCode::InternalError;
-                }
-            } else
-                qWarning() << "Failed to get vpnAdapterIndex. Killswitch disabled";
-        }
-
-        if (m_routeMode == Settings::RouteMode::VpnAllSites) {
-            static const QStringList subnets = { "1.0.0.0/8", "2.0.0.0/7", "4.0.0.0/6", "8.0.0.0/5", "16.0.0.0/4", "32.0.0.0/3", "64.0.0.0/2", "128.0.0.0/1" };
-
-            auto routeAddList =  iface->routeAddList(m_vpnGateway, subnets);
-            if (!routeAddList.waitForFinished() || routeAddList.returnValue() != subnets.count()) {
-                qCritical() << "Failed to set routes for TUN";
-                return ErrorCode::InternalError;
-            }
-        }
-
-        auto StopRoutingIpv6 = iface->StopRoutingIpv6();
-        if (!StopRoutingIpv6.waitForFinished() || !StopRoutingIpv6.returnValue()) {
-            qCritical() << "Failed to disable IPv6 routing";
-            return ErrorCode::InternalError;
-        }
-
-#ifdef Q_OS_WIN
-        if (inetAdapterIndex != -1 && vpnAdapterIndex != -1) {
-            QJsonObject config = m_rawConfig;
-            config.insert("inetAdapterIndex", inetAdapterIndex);
-            config.insert("vpnAdapterIndex", vpnAdapterIndex);
-            config.insert("vpnGateway", m_vpnGateway);
-            config.insert("vpnServer", m_remoteAddress);
-
-            auto enablePeerTraffic = iface->enablePeerTraffic(config);
-            if (!enablePeerTraffic.waitForFinished() || !enablePeerTraffic.returnValue()) {
-                qCritical() << "Failed to enable peer traffic";
-                return ErrorCode::InternalError;
-            }
-        } else
-            qWarning() << "Failed to get adapter indexes. Split-tunneling disabled";
-#endif
-        return ErrorCode::NoError;
-    },
-    [] () {
-        return ErrorCode::AmneziaServiceConnectionFailed;
-    });
+    m_xrayConfig = xrayConfiguration;
+    m_routeMode = static_cast<Settings::RouteMode>(configuration.value(amnezia::config_key::splitTunnelType).toInt());
+    m_primaryDNS = configuration.value(amnezia::config_key::dns1).toString();
+    m_secondaryDNS = configuration.value(amnezia::config_key::dns2).toString();
 }

client/protocols/xrayprotocol.h

@@ -6,7 +6,6 @@
 #include "core/ipcclient.h"
 #include "vpnprotocol.h"
 #include "settings.h"
-#include <QtCore/qsharedpointer.h>
 
 class XrayProtocol : public VpnProtocol
 {
@@ -15,18 +14,19 @@ public:
     virtual ~XrayProtocol() override;
 
     ErrorCode start() override;
+    ErrorCode startTun2Sock();
     void stop() override;
 
 private:
-    ErrorCode setupRouting();
-    ErrorCode startTun2Socks();
-
+    void readXrayConfiguration(const QJsonObject &configuration);
+    
     QJsonObject m_xrayConfig;
     Settings::RouteMode m_routeMode;
-    QList<QHostAddress> m_dnsServers;
-    QString m_remoteAddress;
-
-    QSharedPointer<IpcProcessInterfaceReplica> m_tun2socksProcess;
+    QString m_primaryDNS;
+    QString m_secondaryDNS;
+#ifndef Q_OS_IOS
+    QSharedPointer<IpcProcessTun2SocksReplica> m_t2sProcess;
+#endif
 };
 
 #endif // XRAYPROTOCOL_H

client/resources.qrc

@@ -129,13 +129,11 @@
         <file>ui/qml/Components/AdLabel.qml</file>
         <file>ui/qml/Components/ConnectButton.qml</file>
         <file>ui/qml/Components/ConnectionTypeSelectionDrawer.qml</file>
-        <file>ui/qml/Components/GamepadLoader.qml</file>
         <file>ui/qml/Components/HomeContainersListView.qml</file>
         <file>ui/qml/Components/HomeSplitTunnelingDrawer.qml</file>
         <file>ui/qml/Components/InstalledAppsDrawer.qml</file>
         <file>ui/qml/Components/QuestionDrawer.qml</file>
         <file>ui/qml/Components/SelectLanguageDrawer.qml</file>
-        <file>ui/qml/Components/SubscriptionExpiredDrawer.qml</file>
         <file>ui/qml/Components/ServersListView.qml</file>
         <file>ui/qml/Components/SettingsContainersListView.qml</file>
         <file>ui/qml/Components/TransportProtoSelector.qml</file>

client/secure_qsettings.cpp

@@ -35,12 +35,13 @@ SecureQSettings::SecureQSettings(const QString &organization, const QString &app
             }
         }
         m_settings.setValue("Conf/encrypted", true);
+        m_settings.sync();
     }
 }
 
 QVariant SecureQSettings::value(const QString &key, const QVariant &defaultValue) const
 {
-    QMutexLocker locker(&m_mutex);
+    QMutexLocker locker(&mutex);
 
     if (m_cache.contains(key)) {
         return m_cache.value(key);
@@ -84,7 +85,7 @@ QVariant SecureQSettings::value(const QString &key, const QVariant &defaultValue
 
 void SecureQSettings::setValue(const QString &key, const QVariant &value)
 {
-    QMutexLocker locker(&m_mutex);
+    QMutexLocker locker(&mutex);
 
     if (encryptionRequired() && encryptedKeys.contains(key)) {
         if (!getEncKey().isEmpty() && !getEncIv().isEmpty()) {
@@ -106,20 +107,26 @@ void SecureQSettings::setValue(const QString &key, const QVariant &value)
     }
 
     m_cache.insert(key, value);
+    sync();
 }
 
 void SecureQSettings::remove(const QString &key)
 {
-    QMutexLocker locker(&m_mutex);
+    QMutexLocker locker(&mutex);
 
     m_settings.remove(key);
     m_cache.remove(key);
+
+    sync();
+}
+
+void SecureQSettings::sync()
+{
+    m_settings.sync();
 }
 
 QByteArray SecureQSettings::backupAppConfig() const
 {
-    QMutexLocker locker(&m_mutex);
-
     QJsonObject cfg;
 
     const auto needToBackup = [this](const auto &key) {
@@ -154,8 +161,6 @@ QByteArray SecureQSettings::backupAppConfig() const
 
 bool SecureQSettings::restoreAppConfig(const QByteArray &json)
 {
-    QMutexLocker locker(&m_mutex);
-
     QJsonObject cfg = QJsonDocument::fromJson(json).object();
     if (cfg.isEmpty())
         return false;
@@ -168,16 +173,10 @@ bool SecureQSettings::restoreAppConfig(const QByteArray &json)
         setValue(key, cfg.value(key).toVariant());
     }
 
+    sync();
     return true;
 }
 
-void SecureQSettings::clearSettings()
-{
-    QMutexLocker locker(&m_mutex);
-    m_settings.clear();
-    m_cache.clear();
-}
-
 QByteArray SecureQSettings::encryptText(const QByteArray &value) const
 {
     QSimpleCrypto::QBlockCipher cipher;
@@ -295,3 +294,11 @@ void SecureQSettings::setSecTag(const QString &tag, const QByteArray &data)
         qCritical() << "SecureQSettings::setSecTag Error:" << job->errorString();
     }
 }
+
+void SecureQSettings::clearSettings()
+{
+    QMutexLocker locker(&mutex);
+    m_settings.clear();
+    m_cache.clear();
+    sync();
+}

client/secure_qsettings.h

@@ -16,16 +16,14 @@ public:
     explicit SecureQSettings(const QString &organization, const QString &application = QString(),
                              QObject *parent = nullptr);
 
-    QVariant value(const QString &key, const QVariant &defaultValue = QVariant()) const;
-    void setValue(const QString &key, const QVariant &value);
+    Q_INVOKABLE QVariant value(const QString &key, const QVariant &defaultValue = QVariant()) const;
+    Q_INVOKABLE void setValue(const QString &key, const QVariant &value);
     void remove(const QString &key);
+    void sync();
 
     QByteArray backupAppConfig() const;
     bool restoreAppConfig(const QByteArray &json);
 
-    void clearSettings();
-
-private:
     QByteArray encryptText(const QByteArray &value) const;
     QByteArray decryptText(const QByteArray &ba) const;
 
@@ -37,6 +35,9 @@ private:
     static QByteArray getSecTag(const QString &tag);
     static void setSecTag(const QString &tag, const QByteArray &data);
 
+    void clearSettings();
+
+private:
     QSettings m_settings;
 
     mutable QHash<QString, QVariant> m_cache;
@@ -52,7 +53,7 @@ private:
 
     const QByteArray magicString { "EncData" }; // Magic keyword used for mark encrypted QByteArray
 
-    mutable QRecursiveMutex m_mutex;
+    mutable QMutex mutex;
 };
 
 #endif // SECUREQSETTINGS_H

client/server_scripts/install_docker.sh

@@ -21,5 +21,4 @@ if [ "$(systemctl is-active docker)" != "active" ]; then \
   sleep 5; sudo systemctl start docker; sleep 5;\
 fi;\
 if ! command -v sudo > /dev/null 2>&1; then echo "Failed to install sudo, command not found"; exit 1; fi;\
-docker --version;\
-uname -sr
+docker --version

client/settings.cpp

@@ -14,17 +14,18 @@ namespace
     const char cloudFlareNs1[] = "1.1.1.1";
     const char cloudFlareNs2[] = "1.0.0.1";
 
-    constexpr char gatewayEndpoint[] = "http://gw.amnezia.org:80/";
+    //constexpr char gatewayEndpoint[] = "http://localhost:80/";
+    constexpr char gatewayEndpoint[] = "http://localhost:80/";
 }
 
 Settings::Settings(QObject *parent) : QObject(parent), m_settings(ORGANIZATION_NAME, APPLICATION_NAME, this)
 {
     // Import old settings
     if (serversCount() == 0) {
-        QString user = m_settings.value("Server/userName").toString();
-        QString password = m_settings.value("Server/password").toString();
-        QString serverName = m_settings.value("Server/serverName").toString();
-        int port = m_settings.value("Server/serverPort").toInt();
+        QString user = value("Server/userName").toString();
+        QString password = value("Server/password").toString();
+        QString serverName = value("Server/serverName").toString();
+        int port = value("Server/serverPort").toInt();
 
         if (!user.isEmpty() && !password.isEmpty() && !serverName.isEmpty()) {
             QJsonObject server;
@@ -222,7 +223,7 @@ QString Settings::nextAvailableServerName() const
 
 void Settings::setSaveLogs(bool enabled)
 {
-    m_settings.setValue("Conf/saveLogs", enabled);
+    setValue("Conf/saveLogs", enabled);
 #ifndef Q_OS_ANDROID
     if (!isSaveLogs()) {
         Logger::deInit();
@@ -242,12 +243,12 @@ void Settings::setSaveLogs(bool enabled)
 
 QDateTime Settings::getLogEnableDate()
 {
-    return m_settings.value("Conf/logEnableDate").toDateTime();
+    return value("Conf/logEnableDate").toDateTime();
 }
 
 void Settings::setLogEnableDate(QDateTime date)
 {
-    m_settings.setValue("Conf/logEnableDate", date);
+    setValue("Conf/logEnableDate", date);
 }
 
 QString Settings::routeModeString(RouteMode mode) const
@@ -261,17 +262,17 @@ QString Settings::routeModeString(RouteMode mode) const
 
 Settings::RouteMode Settings::routeMode() const
 {
-    return static_cast<RouteMode>(m_settings.value("Conf/routeMode", 0).toInt());
+    return static_cast<RouteMode>(value("Conf/routeMode", 0).toInt());
 }
 
 bool Settings::isSitesSplitTunnelingEnabled() const
 {
-    return m_settings.value("Conf/sitesSplitTunnelingEnabled", false).toBool();
+    return value("Conf/sitesSplitTunnelingEnabled", false).toBool();
 }
 
 void Settings::setSitesSplitTunnelingEnabled(bool enabled)
 {
-    m_settings.setValue("Conf/sitesSplitTunnelingEnabled", enabled);
+    setValue("Conf/sitesSplitTunnelingEnabled", enabled);
 }
 
 bool Settings::addVpnSite(RouteMode mode, const QString &site, const QString &ip)
@@ -359,12 +360,12 @@ void Settings::removeAllVpnSites(RouteMode mode)
 
 QString Settings::primaryDns() const
 {
-    return m_settings.value("Conf/primaryDns", cloudFlareNs1).toString();
+    return value("Conf/primaryDns", cloudFlareNs1).toString();
 }
 
 QString Settings::secondaryDns() const
 {
-    return m_settings.value("Conf/secondaryDns", cloudFlareNs2).toString();
+    return value("Conf/secondaryDns", cloudFlareNs2).toString();
 }
 
 void Settings::clearSettings()
@@ -386,18 +387,18 @@ QString Settings::appsRouteModeString(AppsRouteMode mode) const
 
 Settings::AppsRouteMode Settings::getAppsRouteMode() const
 {
-    return static_cast<AppsRouteMode>(m_settings.value("Conf/appsRouteMode", 0).toInt());
+    return static_cast<AppsRouteMode>(value("Conf/appsRouteMode", 0).toInt());
 }
 
 void Settings::setAppsRouteMode(AppsRouteMode mode)
 {
-    m_settings.setValue("Conf/appsRouteMode", mode);
+    setValue("Conf/appsRouteMode", mode);
 }
 
 QVector<InstalledAppInfo> Settings::getVpnApps(AppsRouteMode mode) const
 {
     QVector<InstalledAppInfo> apps;
-    auto appsArray = m_settings.value("Conf/" + appsRouteModeString(mode)).toJsonArray();
+    auto appsArray = value("Conf/" + appsRouteModeString(mode)).toJsonArray();
     for (const auto &app : appsArray) {
         InstalledAppInfo appInfo;
         appInfo.appName = app.toObject().value("appName").toString();
@@ -419,42 +420,43 @@ void Settings::setVpnApps(AppsRouteMode mode, const QVector<InstalledAppInfo> &a
         appInfo.insert("appPath", app.appPath);
         appsArray.push_back(appInfo);
     }
-    m_settings.setValue("Conf/" + appsRouteModeString(mode), appsArray);
+    setValue("Conf/" + appsRouteModeString(mode), appsArray);
+    m_settings.sync();
 }
 
 bool Settings::isAppsSplitTunnelingEnabled() const
 {
-    return m_settings.value("Conf/appsSplitTunnelingEnabled", false).toBool();
+    return value("Conf/appsSplitTunnelingEnabled", false).toBool();
 }
 
 void Settings::setAppsSplitTunnelingEnabled(bool enabled)
 {
-    m_settings.setValue("Conf/appsSplitTunnelingEnabled", enabled);
+    setValue("Conf/appsSplitTunnelingEnabled", enabled);
 }
 
 bool Settings::isKillSwitchEnabled() const
 {
-    return m_settings.value("Conf/killSwitchEnabled", true).toBool();
+    return value("Conf/killSwitchEnabled", true).toBool();
 }
 
 void Settings::setKillSwitchEnabled(bool enabled)
 {
-    m_settings.setValue("Conf/killSwitchEnabled", enabled);
+    setValue("Conf/killSwitchEnabled", enabled);
 }
 
 bool Settings::isStrictKillSwitchEnabled() const
 {
-    return m_settings.value("Conf/strictKillSwitchEnabled", false).toBool();
+    return value("Conf/strictKillSwitchEnabled", false).toBool();
 }
 
 void Settings::setStrictKillSwitchEnabled(bool enabled)
 {
-    m_settings.setValue("Conf/strictKillSwitchEnabled", enabled);
+    setValue("Conf/strictKillSwitchEnabled", enabled);
 }
 
 QString Settings::getInstallationUuid(const bool needCreate)
 {
-    auto uuid = m_settings.value("Conf/installationUuid", "").toString();
+    auto uuid = value("Conf/installationUuid", "").toString();
     if (needCreate && uuid.isEmpty()) {
         uuid = QUuid::createUuid().toString();
 
@@ -475,7 +477,7 @@ QString Settings::getInstallationUuid(const bool needCreate)
 
 void Settings::setInstallationUuid(const QString &uuid)
 {
-    m_settings.setValue("Conf/installationUuid", uuid);
+    setValue("Conf/installationUuid", uuid);
 }
 
 ServerCredentials Settings::defaultServerCredentials() const
@@ -496,6 +498,28 @@ ServerCredentials Settings::serverCredentials(int index) const
     return credentials;
 }
 
+QVariant Settings::value(const QString &key, const QVariant &defaultValue) const
+{
+    QVariant returnValue;
+    if (QThread::currentThread() == QCoreApplication::instance()->thread()) {
+        returnValue = m_settings.value(key, defaultValue);
+    } else {
+        QMetaObject::invokeMethod(&m_settings, "value", Qt::BlockingQueuedConnection, Q_RETURN_ARG(QVariant, returnValue),
+                                  Q_ARG(const QString &, key), Q_ARG(const QVariant &, defaultValue));
+    }
+    return returnValue;
+}
+
+void Settings::setValue(const QString &key, const QVariant &value)
+{
+    if (QThread::currentThread() == QCoreApplication::instance()->thread()) {
+        m_settings.setValue(key, value);
+    } else {
+        QMetaObject::invokeMethod(&m_settings, "setValue", Qt::BlockingQueuedConnection, Q_ARG(const QString &, key),
+                                  Q_ARG(const QVariant &, value));
+    }
+}
+
 void Settings::resetGatewayEndpoint()
 {
     m_gatewayEndpoint = gatewayEndpoint;
@@ -518,50 +542,50 @@ QString Settings::getGatewayEndpoint(bool isTestPurchase)
 
 bool Settings::isDevGatewayEnv(bool isTestPurchase)
 {
-    return isTestPurchase ? true : m_settings.value("Conf/devGatewayEnv", false).toBool();
+    return isTestPurchase ? true : value("Conf/devGatewayEnv", false).toBool();
 }
 
 void Settings::toggleDevGatewayEnv(bool enabled)
 {
-    m_settings.setValue("Conf/devGatewayEnv", enabled);
+    setValue("Conf/devGatewayEnv", enabled);
 }
 
 bool Settings::isHomeAdLabelVisible()
 {
-    return m_settings.value("Conf/homeAdLabelVisible", true).toBool();
+    return value("Conf/homeAdLabelVisible", true).toBool();
 }
 
 void Settings::disableHomeAdLabel()
 {
-    m_settings.setValue("Conf/homeAdLabelVisible", false);
+    setValue("Conf/homeAdLabelVisible", false);
 }
 
 bool Settings::isPremV1MigrationReminderActive()
 {
-    return m_settings.value("Conf/premV1MigrationReminderActive", true).toBool();
+    return value("Conf/premV1MigrationReminderActive", true).toBool();
 }
 
 void Settings::disablePremV1MigrationReminder()
 {
-    m_settings.setValue("Conf/premV1MigrationReminderActive", false);
+    setValue("Conf/premV1MigrationReminderActive", false);
 }
 
 QStringList Settings::allowedDnsServers() const
 {
-    return m_settings.value("Conf/allowedDnsServers").toStringList();
+    return value("Conf/allowedDnsServers").toStringList();
 }
 
 void Settings::setAllowedDnsServers(const QStringList &servers)
 {
-    m_settings.setValue("Conf/allowedDnsServers", servers);
+    setValue("Conf/allowedDnsServers", servers);
 }
 
 QStringList Settings::readNewsIds() const
 {
-    return m_settings.value("News/readIds").toStringList();
+    return value("News/readIds").toStringList();
 }
 
 void Settings::setReadNewsIds(const QStringList &ids)
 {
-    m_settings.setValue("News/readIds", ids);
+    setValue("News/readIds", ids);
 }

client/settings.h

@@ -29,11 +29,11 @@ public:
 
     QJsonArray serversArray() const
     {
-        return QJsonDocument::fromJson(m_settings.value("Servers/serversList").toByteArray()).array();
+        return QJsonDocument::fromJson(value("Servers/serversList").toByteArray()).array();
     }
     void setServersArray(const QJsonArray &servers)
     {
-        m_settings.setValue("Servers/serversList", QJsonDocument(servers).toJson());
+        setValue("Servers/serversList", QJsonDocument(servers).toJson());
     }
 
     // Servers section
@@ -45,11 +45,11 @@ public:
 
     int defaultServerIndex() const
     {
-        return m_settings.value("Servers/defaultServerIndex", 0).toInt();
+        return value("Servers/defaultServerIndex", 0).toInt();
     }
     void setDefaultServer(int index)
     {
-        m_settings.setValue("Servers/defaultServerIndex", index);
+        setValue("Servers/defaultServerIndex", index);
     }
     QJsonObject defaultServer() const
     {
@@ -78,34 +78,25 @@ public:
     // App settings section
     bool isAutoConnect() const
     {
-        return m_settings.value("Conf/autoConnect", false).toBool();
+        return value("Conf/autoConnect", false).toBool();
     }
     void setAutoConnect(bool enabled)
     {
-        m_settings.setValue("Conf/autoConnect", enabled);
+        setValue("Conf/autoConnect", enabled);
     }
 
     bool isStartMinimized() const
     {
-        return m_settings.value("Conf/startMinimized", false).toBool();
+        return value("Conf/startMinimized", false).toBool();
     }
     void setStartMinimized(bool enabled)
     {
-        m_settings.setValue("Conf/startMinimized", enabled);
-    }
-
-    bool isNewsNotifications() const
-    {
-        return m_settings.value("Conf/newsNotifications", true).toBool();
-    }
-    void setNewsNotifications(bool enabled)
-    {
-        m_settings.setValue("Conf/newsNotifications", enabled);
+        setValue("Conf/startMinimized", enabled);
     }
 
     bool isSaveLogs() const
     {
-        return m_settings.value("Conf/saveLogs", false).toBool();
+        return value("Conf/saveLogs", false).toBool();
     }
     void setSaveLogs(bool enabled);
 
@@ -122,18 +113,19 @@ public:
     QString routeModeString(RouteMode mode) const;
 
     RouteMode routeMode() const;
-    void setRouteMode(RouteMode mode) { m_settings.setValue("Conf/routeMode", mode); }
+    void setRouteMode(RouteMode mode) { setValue("Conf/routeMode", mode); }
 
     bool isSitesSplitTunnelingEnabled() const;
     void setSitesSplitTunnelingEnabled(bool enabled);
 
     QVariantMap vpnSites(RouteMode mode) const
     {
-        return m_settings.value("Conf/" + routeModeString(mode)).toMap();
+        return value("Conf/" + routeModeString(mode)).toMap();
     }
     void setVpnSites(RouteMode mode, const QVariantMap &sites)
     {
-        m_settings.setValue("Conf/" + routeModeString(mode), sites);
+        setValue("Conf/" + routeModeString(mode), sites);
+        m_settings.sync();
     }
     bool addVpnSite(RouteMode mode, const QString &site, const QString &ip = "");
     void addVpnSites(RouteMode mode, const QMap<QString, QString> &sites); // map <site, ip>
@@ -146,11 +138,11 @@ public:
 
     bool useAmneziaDns() const
     {
-        return m_settings.value("Conf/useAmneziaDns", true).toBool();
+        return value("Conf/useAmneziaDns", true).toBool();
     }
     void setUseAmneziaDns(bool enabled)
     {
-        m_settings.setValue("Conf/useAmneziaDns", enabled);
+        setValue("Conf/useAmneziaDns", enabled);
     }
 
     QString primaryDns() const;
@@ -159,13 +151,13 @@ public:
     // QString primaryDns() const { return m_primaryDns; }
     void setPrimaryDns(const QString &primaryDns)
     {
-        m_settings.setValue("Conf/primaryDns", primaryDns);
+        setValue("Conf/primaryDns", primaryDns);
     }
 
     // QString secondaryDns() const { return m_secondaryDns; }
     void setSecondaryDns(const QString &secondaryDns)
     {
-        m_settings.setValue("Conf/secondaryDns", secondaryDns);
+        setValue("Conf/secondaryDns", secondaryDns);
     }
 
     //    static constexpr char openNicNs5[] = "94.103.153.176";
@@ -187,16 +179,16 @@ public:
     };
     void setAppLanguage(QLocale locale)
     {
-        m_settings.setValue("Conf/appLanguage", locale.name());
+        setValue("Conf/appLanguage", locale.name());
     };
 
     bool isScreenshotsEnabled() const
     {
-        return m_settings.value("Conf/screenshotsEnabled", true).toBool();
+        return value("Conf/screenshotsEnabled", true).toBool();
     }
     void setScreenshotsEnabled(bool enabled)
     {
-        m_settings.setValue("Conf/screenshotsEnabled", enabled);
+        setValue("Conf/screenshotsEnabled", enabled);
         emit screenshotsEnabledChanged(enabled);
     }
 
@@ -254,6 +246,9 @@ signals:
     void settingsCleared();
 
 private:
+    QVariant value(const QString &key, const QVariant &defaultValue = QVariant()) const;
+    void setValue(const QString &key, const QVariant &value);
+
     void setInstallationUuid(const QString &uuid);
 
     mutable SecureQSettings m_settings;

client/tests/CMakeLists.txt

@@ -0,0 +1,81 @@
+cmake_minimum_required(VERSION 3.25.0)
+project(TransportTest)
+
+set(CLIENT_ROOT_DIR ${CMAKE_CURRENT_LIST_DIR}/..)
+
+find_package(Qt6 REQUIRED COMPONENTS Core Network Test)
+
+set(QSIMPLECRYPTO_DIR ${CLIENT_ROOT_DIR}/3rd/QSimpleCrypto/src)
+
+set(OPENSSL_ROOT_DIR "${CLIENT_ROOT_DIR}/3rd-prebuilt/3rd-prebuilt/openssl/")
+if(WIN32)
+    set(OPENSSL_INCLUDE_DIR "${OPENSSL_ROOT_DIR}/windows/include")
+    if("${CMAKE_SIZEOF_VOID_P}" STREQUAL "8")
+        set(OPENSSL_LIB_SSL "${OPENSSL_ROOT_DIR}/windows/win64/libssl.lib")
+        set(OPENSSL_LIB_CRYPTO "${OPENSSL_ROOT_DIR}/windows/win64/libcrypto.lib")
+    else()
+        set(OPENSSL_LIB_SSL "${OPENSSL_ROOT_DIR}/windows/win32/libssl.lib")
+        set(OPENSSL_LIB_CRYPTO "${OPENSSL_ROOT_DIR}/windows/win32/libcrypto.lib")
+    endif()
+elseif(APPLE AND NOT IOS)
+    set(OPENSSL_INCLUDE_DIR "${OPENSSL_ROOT_DIR}/macos/include")
+    set(OPENSSL_LIB_SSL "${OPENSSL_ROOT_DIR}/macos/lib/libssl.a")
+    set(OPENSSL_LIB_CRYPTO "${OPENSSL_ROOT_DIR}/macos/lib/libcrypto.a")
+elseif(LINUX)
+    set(OPENSSL_INCLUDE_DIR "${OPENSSL_ROOT_DIR}/linux/include")
+    set(OPENSSL_LIB_SSL "${OPENSSL_ROOT_DIR}/linux/x86_64/libssl.a")
+    set(OPENSSL_LIB_CRYPTO "${OPENSSL_ROOT_DIR}/linux/x86_64/libcrypto.a")
+endif()
+
+add_definitions(-DPROD_AGW_PUBLIC_KEY="$ENV{PROD_AGW_PUBLIC_KEY}")
+add_definitions(-DDEV_AGW_PUBLIC_KEY="$ENV{DEV_AGW_PUBLIC_KEY}")
+
+add_definitions(-DAGW_DNS_SERVER="$ENV{AGW_DNS_SERVER}")
+add_definitions(-DAGW_DNS_DOMAIN="$ENV{AGW_DNS_DOMAIN}")
+add_definitions(-DAGW_DNS_PRIMARY="$ENV{AGW_DNS_PRIMARY}")
+add_definitions(-DAGW_DNS_PORT_UDP="$ENV{AGW_DNS_PORT_UDP}")
+add_definitions(-DAGW_DNS_PORT_DOT="$ENV{AGW_DNS_PORT_DOT}")
+add_definitions(-DAGW_DNS_PORT_DOH="$ENV{AGW_DNS_PORT_DOH}")
+add_definitions(-DAGW_DNS_PORT_DOQ="$ENV{AGW_DNS_PORT_DOQ}")
+add_definitions(-DAGW_DNS_DOH_PATH="$ENV{AGW_DNS_DOH_PATH}")
+add_definitions(-DAGW_DNS_RETRY_COUNT="$ENV{AGW_DNS_RETRY_COUNT}")
+add_definitions(-DAGW_DNS_TIMEOUT_MS="$ENV{AGW_DNS_TIMEOUT_MS}")
+
+qt_add_executable(${PROJECT_NAME}
+    tst_transports.cpp
+    ${CLIENT_ROOT_DIR}/core/transport/dns/dnsResolver.cpp
+    ${CLIENT_ROOT_DIR}/core/transport/dns/dnsTunnel.cpp
+    ${CLIENT_ROOT_DIR}/core/transport/dns/dnsPacket.cpp
+    ${QSIMPLECRYPTO_DIR}/sources/QBlockCipher.cpp
+    ${QSIMPLECRYPTO_DIR}/sources/QRsa.cpp
+    ${QSIMPLECRYPTO_DIR}/sources/QX509.cpp
+    ${QSIMPLECRYPTO_DIR}/sources/QX509Store.cpp
+    ${QSIMPLECRYPTO_DIR}/sources/QAead.cpp
+)
+
+target_include_directories(${PROJECT_NAME} PRIVATE
+    ${CLIENT_ROOT_DIR}
+    ${CLIENT_ROOT_DIR}/core
+    ${CLIENT_ROOT_DIR}/core/transport
+    ${QSIMPLECRYPTO_DIR}
+    ${QSIMPLECRYPTO_DIR}/include
+    ${OPENSSL_INCLUDE_DIR}
+)
+
+target_compile_definitions(${PROJECT_NAME} PRIVATE
+    CLIENT_SOURCE_DIR="${CLIENT_ROOT_DIR}"
+)
+
+target_link_libraries(${PROJECT_NAME} PRIVATE
+    Qt6::Core
+    Qt6::Network
+    Qt6::Test
+    ${OPENSSL_LIB_SSL}
+    ${OPENSSL_LIB_CRYPTO}
+)
+
+if(WIN32)
+    target_link_libraries(${PROJECT_NAME} PRIVATE ws2_32 crypt32)
+endif()
+
+add_test(NAME TransportTest COMMAND ${PROJECT_NAME})

client/tests/tst_transports.cpp

@@ -0,0 +1,406 @@
+#include <QCoreApplication>
+#include <QDebug>
+#include <QElapsedTimer>
+#include <QEventLoop>
+#include <QHostAddress>
+#include <QHostInfo>
+#include <QNetworkAccessManager>
+#include <QNetworkReply>
+#include <QNetworkRequest>
+#include <QSslConfiguration>
+#include <QSslError>
+#include <QTest>
+#include <QUrl>
+
+#include "transport/dns/dnsResolver.h"
+#include "transport/dns/dnsTunnel.h"
+#include "QBlockCipher.h"
+#include "QRsa.h"
+
+#include <openssl/evp.h>
+#include <openssl/rsa.h>
+
+using amnezia::transport::dns::DnsProtocol;
+
+struct TransportResult {
+    QString name;
+    bool success = false;
+    int elapsedMs = 0;
+    int responseSize = 0;
+    QString error;
+    QByteArray responseBody;
+};
+
+struct TestConfig {
+    QString httpEndpoint;
+    struct DnsEntry {
+        QString name;
+        DnsProtocol type;
+        QString server;
+        QString domain;
+        quint16 port;
+        QString dohPath;
+    };
+    QList<DnsEntry> dnsTransports;
+    int timeoutMs = 15000;
+};
+
+static TestConfig buildConfigFromEnv()
+{
+    TestConfig cfg;
+
+    QString server(AGW_DNS_SERVER);
+    QString domain(AGW_DNS_DOMAIN);
+
+    cfg.httpEndpoint = QString(DEV_AGW_PUBLIC_KEY).isEmpty()
+        ? QString() : QString("http://%1/").arg(server);
+
+    int timeout = QString(AGW_DNS_TIMEOUT_MS).toInt();
+    cfg.timeoutMs = (timeout > 0) ? timeout : 15000;
+
+    if (server.isEmpty() || domain.isEmpty()) return cfg;
+
+    auto addEntry = [&](DnsProtocol type, const QString &name,
+                        const char *portDefine, quint16 defaultPort, const QString &dohPath = QString()) {
+        TestConfig::DnsEntry e;
+        e.type = type;
+        e.name = name;
+        e.server = server;
+        e.domain = domain;
+        quint16 port = QString(portDefine).toUShort();
+        e.port = (port > 0) ? port : defaultPort;
+        if (!dohPath.isEmpty()) e.dohPath = dohPath;
+        cfg.dnsTransports.append(e);
+    };
+
+    addEntry(DnsProtocol::Udp, "UDP", AGW_DNS_PORT_UDP, 5353);
+    addEntry(DnsProtocol::Tcp, "TCP", AGW_DNS_PORT_UDP, 5353);
+    addEntry(DnsProtocol::Tls, "DoT", AGW_DNS_PORT_DOT, 853);
+
+    QString dohPath = QString(AGW_DNS_DOH_PATH);
+    if (dohPath.isEmpty()) dohPath = "/dns-query";
+    addEntry(DnsProtocol::Https, "DoH", AGW_DNS_PORT_DOH, 443, dohPath);
+
+    addEntry(DnsProtocol::Quic, "DoQ", AGW_DNS_PORT_DOQ, 8853);
+
+    return cfg;
+}
+
+static QString resolveHost(const QString &host)
+{
+    QHostAddress addr(host);
+    if (!addr.isNull()) return host;
+    QHostInfo info = QHostInfo::fromName(host);
+    if (!info.addresses().isEmpty())
+        return info.addresses().first().toString();
+    return host;
+}
+
+struct EncryptedPayload {
+    QByteArray body;
+    QByteArray key;
+    QByteArray iv;
+    QByteArray salt;
+    bool ok = false;
+    QString error;
+};
+
+static EncryptedPayload encryptPayload(const QJsonObject &apiPayload, const QByteArray &rsaPubKeyPem)
+{
+    EncryptedPayload result;
+
+    QSimpleCrypto::QBlockCipher blockCipher;
+    result.key = blockCipher.generatePrivateSalt(32);
+    result.iv = blockCipher.generatePrivateSalt(32);
+    result.salt = blockCipher.generatePrivateSalt(8);
+
+    QJsonObject keyPayload;
+    keyPayload["aes_key"] = QString(result.key.toBase64());
+    keyPayload["aes_iv"] = QString(result.iv.toBase64());
+    keyPayload["aes_salt"] = QString(result.salt.toBase64());
+
+    try {
+        QSimpleCrypto::QRsa rsa;
+        QByteArray pemData = rsaPubKeyPem;
+        pemData.replace("\\n", "\n");
+        EVP_PKEY *pubKey = rsa.getPublicKeyFromByteArray(pemData);
+        if (!pubKey) {
+            result.error = "Failed to load RSA public key";
+            return result;
+        }
+
+        QByteArray encKeyPayload = rsa.encrypt(QJsonDocument(keyPayload).toJson(), pubKey, RSA_PKCS1_PADDING);
+        EVP_PKEY_free(pubKey);
+
+        QByteArray encApiPayload = blockCipher.encryptAesBlockCipher(
+            QJsonDocument(apiPayload).toJson(), result.key, result.iv, "", result.salt);
+
+        QJsonObject requestBody;
+        requestBody["key_payload"] = QString(encKeyPayload.toBase64());
+        requestBody["api_payload"] = QString(encApiPayload.toBase64());
+
+        result.body = QJsonDocument(requestBody).toJson();
+        result.ok = true;
+    } catch (const std::exception &ex) {
+        result.error = QString("Encryption failed: %1").arg(ex.what());
+    } catch (...) {
+        result.error = "Encryption failed: unknown error";
+    }
+    return result;
+}
+
+static QByteArray decryptResponse(const QByteArray &encrypted, const QByteArray &key,
+                                   const QByteArray &iv, const QByteArray &salt)
+{
+    try {
+        QSimpleCrypto::QBlockCipher blockCipher;
+        return blockCipher.decryptAesBlockCipher(encrypted, key, iv, "", salt);
+    } catch (...) {
+        return QByteArray();
+    }
+}
+
+class TransportTest : public QObject
+{
+    Q_OBJECT
+
+private:
+    TestConfig m_config;
+    QByteArray m_rsaKey;
+    bool m_hasRsaKey = false;
+    QList<TransportResult> m_results;
+
+    void logResult(const TransportResult &r) {
+        QString status = r.success ? "OK" : "FAIL";
+        qDebug().noquote() << QString("[%1] %2 | %3ms | %4 bytes | %5")
+            .arg(status, -4)
+            .arg(r.name, -20)
+            .arg(r.elapsedMs, 5)
+            .arg(r.responseSize, 6)
+            .arg(r.error.isEmpty() ? "---" : r.error);
+    }
+
+    TransportResult doHttpTransport(const QString &endpoint, const QByteArray &payload) {
+        TransportResult r;
+        r.name = "HTTP";
+        QElapsedTimer timer;
+        timer.start();
+
+        QNetworkAccessManager nam;
+        QNetworkRequest request(QUrl(endpoint));
+        request.setHeader(QNetworkRequest::ContentTypeHeader, "application/json");
+        request.setTransferTimeout(m_config.timeoutMs);
+
+        QNetworkReply *reply = nam.post(request, payload);
+
+        QEventLoop loop;
+        QObject::connect(reply, &QNetworkReply::finished, &loop, &QEventLoop::quit);
+        loop.exec();
+
+        r.elapsedMs = static_cast<int>(timer.elapsed());
+
+        if (reply->error() != QNetworkReply::NoError) {
+            r.error = QString("HTTP %1: %2")
+                .arg(reply->attribute(QNetworkRequest::HttpStatusCodeAttribute).toInt())
+                .arg(reply->errorString());
+            r.responseBody = reply->readAll();
+            r.responseSize = r.responseBody.size();
+        } else {
+            r.responseBody = reply->readAll();
+            r.responseSize = r.responseBody.size();
+            r.success = !r.responseBody.isEmpty();
+            if (!r.success) r.error = "Empty response";
+        }
+        reply->deleteLater();
+        return r;
+    }
+
+    TransportResult doDnsTransport(const TestConfig::DnsEntry &entry, const QByteArray &payload,
+                                   const QString &resolvedIp) {
+        TransportResult r;
+        r.name = QString("DNS-%1").arg(entry.name);
+        QElapsedTimer timer;
+        timer.start();
+
+        bool needsHostname = (entry.type == DnsProtocol::Https || entry.type == DnsProtocol::Tls);
+        QString serverAddr = needsHostname ? entry.server : resolvedIp;
+
+        r.responseBody = amnezia::transport::dns::DnsTunnel::send(
+            payload, "services", entry.domain,
+            serverAddr, entry.type, entry.port,
+            m_config.timeoutMs, entry.dohPath);
+
+        r.elapsedMs = static_cast<int>(timer.elapsed());
+        r.responseSize = r.responseBody.size();
+        r.success = !r.responseBody.isEmpty();
+        if (!r.success) r.error = "Empty/no response";
+        return r;
+    }
+
+private slots:
+    void initTestCase()
+    {
+        m_config = buildConfigFromEnv();
+
+        QVERIFY2(!m_config.dnsTransports.isEmpty(),
+                 "AGW_DNS_SERVER / AGW_DNS_DOMAIN not set -- cannot run transport tests");
+
+        qDebug() << "HTTP endpoint:" << m_config.httpEndpoint;
+        qDebug() << "DNS transports:" << m_config.dnsTransports.size();
+        qDebug() << "Timeout:" << m_config.timeoutMs << "ms";
+
+        QByteArray prodKey(PROD_AGW_PUBLIC_KEY);
+        QByteArray devKey(DEV_AGW_PUBLIC_KEY);
+        if (!prodKey.isEmpty()) {
+            m_rsaKey = prodKey;
+            m_hasRsaKey = true;
+            qDebug() << "Using PROD_AGW_PUBLIC_KEY for E2E tests";
+        } else if (!devKey.isEmpty()) {
+            m_rsaKey = devKey;
+            m_hasRsaKey = true;
+            qDebug() << "Using DEV_AGW_PUBLIC_KEY for E2E tests";
+        } else {
+            qWarning() << "No RSA public key found -- E2E tests will be SKIPPED";
+        }
+    }
+
+    void test_transport_http()
+    {
+        QByteArray payload = R"({"test":true})";
+        TransportResult r = doHttpTransport(m_config.httpEndpoint, payload);
+        m_results.append(r);
+        logResult(r);
+        QVERIFY2(r.success || r.responseSize > 0,
+                 qPrintable(QString("HTTP transport failed: %1").arg(r.error)));
+    }
+
+    void test_transport_dns_data()
+    {
+        QTest::addColumn<int>("transportIndex");
+        for (int i = 0; i < m_config.dnsTransports.size(); ++i) {
+            const auto &e = m_config.dnsTransports[i];
+            if (e.type == DnsProtocol::Quic) continue;
+            QTest::newRow(qPrintable(e.name)) << i;
+        }
+    }
+
+    void test_transport_dns()
+    {
+        QFETCH(int, transportIndex);
+        const auto &entry = m_config.dnsTransports[transportIndex];
+        QString resolvedIp = resolveHost(entry.server);
+        qDebug() << "Server:" << entry.server << "-> IP:" << resolvedIp
+                 << "Port:" << entry.port;
+
+        QByteArray payload = R"({"test":true})";
+        TransportResult r = doDnsTransport(entry, payload, resolvedIp);
+        m_results.append(r);
+        logResult(r);
+
+        if (!r.success) {
+            qWarning() << "DNS" << entry.name << "transport failed (server may be down):" << r.error;
+        }
+    }
+
+    void test_e2e_http()
+    {
+        if (!m_hasRsaKey) QSKIP("No RSA key -- skipping E2E");
+
+        QJsonObject apiPayload;
+        apiPayload["protocol"] = "any";
+        EncryptedPayload enc = encryptPayload(apiPayload, m_rsaKey);
+        QVERIFY2(enc.ok, qPrintable(enc.error));
+
+        TransportResult r = doHttpTransport(m_config.httpEndpoint, enc.body);
+        r.name = "E2E-HTTP";
+
+        if (r.success) {
+            QByteArray decrypted = decryptResponse(r.responseBody, enc.key, enc.iv, enc.salt);
+            if (!decrypted.isEmpty()) {
+                r.responseBody = decrypted;
+                r.responseSize = decrypted.size();
+                qDebug() << "Decrypted response:" << decrypted.left(200);
+            } else {
+                r.error = "Decryption failed (raw body size: " + QString::number(r.responseBody.size()) + ")";
+                r.success = false;
+            }
+        }
+
+        m_results.append(r);
+        logResult(r);
+        QVERIFY2(r.success, qPrintable(QString("E2E HTTP failed: %1").arg(r.error)));
+    }
+
+    void test_e2e_dns_data()
+    {
+        QTest::addColumn<int>("transportIndex");
+        for (int i = 0; i < m_config.dnsTransports.size(); ++i) {
+            const auto &e = m_config.dnsTransports[i];
+            if (e.type == DnsProtocol::Quic) continue;
+            QTest::newRow(qPrintable(QString("E2E-%1").arg(e.name))) << i;
+        }
+    }
+
+    void test_e2e_dns()
+    {
+        if (!m_hasRsaKey) QSKIP("No RSA key -- skipping E2E");
+
+        QFETCH(int, transportIndex);
+        const auto &entry = m_config.dnsTransports[transportIndex];
+        QString resolvedIp = resolveHost(entry.server);
+        qDebug() << "E2E via" << entry.name << "server:" << entry.server
+                 << "-> IP:" << resolvedIp << "port:" << entry.port;
+
+        QJsonObject apiPayload;
+        apiPayload["protocol"] = "any";
+        EncryptedPayload enc = encryptPayload(apiPayload, m_rsaKey);
+        QVERIFY2(enc.ok, qPrintable(enc.error));
+
+        TransportResult r = doDnsTransport(entry, enc.body, resolvedIp);
+        r.name = QString("E2E-%1").arg(entry.name);
+
+        if (r.success) {
+            QByteArray decrypted = decryptResponse(r.responseBody, enc.key, enc.iv, enc.salt);
+            if (!decrypted.isEmpty()) {
+                r.responseBody = decrypted;
+                r.responseSize = decrypted.size();
+                qDebug() << "Decrypted response:" << decrypted.left(200);
+            } else {
+                r.error = "Decryption failed (raw body size: " + QString::number(r.responseBody.size()) + ")";
+                r.success = false;
+            }
+        }
+
+        m_results.append(r);
+        logResult(r);
+
+        if (!r.success) {
+            qWarning() << "E2E DNS" << entry.name << "failed:" << r.error;
+        }
+    }
+
+    void cleanupTestCase()
+    {
+        qDebug() << "";
+        qDebug() << "============================================================";
+        qDebug() << "                    TRANSPORT TEST SUMMARY";
+        qDebug() << "============================================================";
+        qDebug().noquote() << QString(" %-4s | %-20s | %5s | %6s | %s")
+            .arg("", "Transport", "ms", "bytes", "Error");
+        qDebug() << "------------------------------------------------------------";
+
+        int passed = 0, failed = 0;
+        for (const auto &r : m_results) {
+            logResult(r);
+            if (r.success) ++passed; else ++failed;
+        }
+
+        qDebug() << "------------------------------------------------------------";
+        qDebug().noquote() << QString("Total: %1 passed, %2 failed, %3 total")
+            .arg(passed).arg(failed).arg(m_results.size());
+        qDebug() << "============================================================";
+    }
+};
+
+QTEST_MAIN(TransportTest)
+#include "tst_transports.moc"

client/ui/controllers/api/apiConfigsController.cpp

@@ -5,6 +5,7 @@
 #include "core/api/apiDefs.h"
 #include "core/api/apiUtils.h"
 #include "core/controllers/gatewayController.h"
+#include "core/networkUtilities.h"
 #include "core/qrCodeUtils.h"
 #include "ui/controllers/systemController.h"
 #include "version.h"
@@ -366,8 +367,6 @@ bool ApiConfigsController::fillAvailableServices()
 {
     QJsonObject apiPayload;
     apiPayload[configKey::osVersion] = QSysInfo::productType();
-    apiPayload[configKey::appVersion] = QString(APP_VERSION);
-    apiPayload[apiDefs::key::cliName] = QString(APPLICATION_NAME);
     apiPayload[apiDefs::key::appLanguage] = m_settings->getAppLanguage().name().split("_").first();
 
     QByteArray responseBody;
@@ -384,51 +383,6 @@ bool ApiConfigsController::fillAvailableServices()
     }
 
     QJsonObject data = QJsonDocument::fromJson(responseBody).object();
-    
-#if defined(Q_OS_IOS) || defined(MACOS_NE)
-    QEventLoop waitProducts;
-    bool productsFetched = false;
-    QString productPrice;
-    QString productCurrency;
-    
-    IosController::Instance()->fetchProducts(QStringList() << QStringLiteral("amnezia_premium_6_month"),
-                                             [&](const QList<QVariantMap> &products,
-                                                 const QStringList &invalidIds,
-                                                 const QString &errorString) {
-                                                 if (!errorString.isEmpty() || products.isEmpty()) {
-                                                     qWarning().noquote() << "[IAP] Failed to fetch product price:" << errorString;
-                                                 } else {
-                                                     const auto &product = products.first();
-                                                     productPrice = product.value("price").toString();
-                                                     productCurrency = product.value("currencyCode").toString();
-                                                     productsFetched = true;
-                                                     qInfo().noquote() << "[IAP] Fetched product price:" << productPrice << productCurrency;
-                                                 }
-                                                 waitProducts.quit();
-                                             });
-    waitProducts.exec();
-    
-    if (productsFetched && !productPrice.isEmpty()) {
-        QJsonArray services = data.value("services").toArray();
-        for (int i = 0; i < services.size(); ++i) {
-            QJsonObject service = services[i].toObject();
-            if (service.value(configKey::serviceType).toString() == serviceType::amneziaPremium) {
-                QJsonObject serviceInfo = service.value(configKey::serviceInfo).toObject();
-                QString formattedPrice = productPrice;
-                if (!productCurrency.isEmpty()) {
-                    formattedPrice += " " + productCurrency;
-                }
-                serviceInfo["price"] = formattedPrice;
-                service[configKey::serviceInfo] = serviceInfo;
-                services[i] = service;
-                data["services"] = services;
-                qInfo().noquote() << "[IAP] Updated premium service price in data:" << formattedPrice;
-                break;
-            }
-        }
-    }
-#endif
-    
     m_apiServicesModel->updateModel(data);
     if (m_apiServicesModel->rowCount() > 0) {
         m_apiServicesModel->setServiceIndex(0);
@@ -449,7 +403,7 @@ bool ApiConfigsController::importService()
             importSerivceFromAppStore();
             return true;
         }
-    } else if (m_apiServicesModel->getSelectedServiceType() == serviceType::amneziaFree) {
+    } else {
         importServiceFromGateway();
         return true;
     }
@@ -723,7 +677,6 @@ bool ApiConfigsController::updateServiceFromGateway(const int serverIndex, const
     }
 
     bool isTestPurchase = apiConfig.value(apiDefs::key::isTestPurchase).toBool(false);
-    bool wasSubscriptionExpired = m_serversModel->data(serverIndex, ServersModel::IsSubscriptionExpiredRole).toBool();
     QByteArray responseBody;
     ErrorCode errorCode = executeRequest(QString("%1v1/config"), apiPayload, responseBody, isTestPurchase);
 
@@ -750,11 +703,6 @@ bool ApiConfigsController::updateServiceFromGateway(const int serverIndex, const
             newServerConfig.insert(config_key::nameOverriddenByUser, true);
         }
         m_serversModel->editServer(newServerConfig, serverIndex);
-
-        if (wasSubscriptionExpired) {
-            emit subscriptionRefreshNeeded();
-        }
-
         if (reloadServiceConfig) {
             emit reloadServerFromApiFinished(tr("API config reloaded"));
         } else if (newCountryName.isEmpty()) {
@@ -764,11 +712,7 @@ bool ApiConfigsController::updateServiceFromGateway(const int serverIndex, const
         }
         return true;
     } else {
-        if (errorCode == ErrorCode::ApiSubscriptionExpiredError) {
-            emit subscriptionExpiredOnServer();
-        } else {
-            emit errorOccurred(errorCode);
-        }
+        emit errorOccurred(errorCode);
         return false;
     }
 }
@@ -780,9 +724,6 @@ bool ApiConfigsController::updateServiceFromTelegram(const int serverIndex)
     QThread::msleep(10);
 #endif
 
-    GatewayController gatewayController(m_settings->getGatewayEndpoint(), m_settings->isDevGatewayEnv(), apiDefs::requestTimeoutMsecs,
-                                        m_settings->isStrictKillSwitchEnabled());
-
     auto serverConfig = m_serversModel->getServerConfig(serverIndex);
     auto installationUuid = m_settings->getInstallationUuid(true);
 
@@ -798,7 +739,17 @@ bool ApiConfigsController::updateServiceFromTelegram(const int serverIndex)
     apiPayload[configKey::apiEndpoint] = serverConfig.value(configKey::apiEndpoint).toString();
 
     QByteArray responseBody;
-    ErrorCode errorCode = gatewayController.post(QString("%1v1/proxy_config"), apiPayload, responseBody);
+    QString endpoint = QString("%1v1/proxy_config");
+    
+    // Use GatewayController with parallel transports
+    GatewayController gatewayController(m_settings->getGatewayEndpoint(), 
+                                        m_settings->isDevGatewayEnv(), 
+                                        apiDefs::requestTimeoutMsecs,
+                                        m_settings->isStrictKillSwitchEnabled());
+    
+    gatewayController.setTransportsConfig(GatewayController::buildTransportsConfig());
+    
+    ErrorCode errorCode = gatewayController.post(endpoint, apiPayload, responseBody);
 
     if (errorCode == ErrorCode::NoError) {
         errorCode = fillServerConfig(serviceProtocol, protocolData, responseBody, serverConfig);
@@ -1005,7 +956,12 @@ ErrorCode ApiConfigsController::importServiceFromBilling(const QByteArray &respo
 ErrorCode ApiConfigsController::executeRequest(const QString &endpoint, const QJsonObject &apiPayload, QByteArray &responseBody,
                                                bool isTestPurchase)
 {
-    GatewayController gatewayController(m_settings->getGatewayEndpoint(isTestPurchase), m_settings->isDevGatewayEnv(isTestPurchase),
-                                        apiDefs::requestTimeoutMsecs, m_settings->isStrictKillSwitchEnabled());
+    GatewayController gatewayController(m_settings->getGatewayEndpoint(isTestPurchase), 
+                                        m_settings->isDevGatewayEnv(isTestPurchase),
+                                        apiDefs::requestTimeoutMsecs, 
+                                        m_settings->isStrictKillSwitchEnabled());
+    
+    gatewayController.setTransportsConfig(GatewayController::buildTransportsConfig());
+    
     return gatewayController.post(endpoint, apiPayload, responseBody);
 }

client/ui/controllers/api/apiConfigsController.h

@@ -43,8 +43,6 @@ public slots:
 
 signals:
     void errorOccurred(ErrorCode errorCode);
-    void subscriptionExpiredOnServer();
-    void subscriptionRefreshNeeded();
 
     void installServerFromApiFinished(const QString &message);
     void changeApiCountryFinished(const QString &message);

client/ui/controllers/api/apiNewsController.cpp

@@ -1,6 +1,8 @@
 #include "apiNewsController.h"
 
 #include "core/api/apiUtils.h"
+#include "core/controllers/gatewayController.h"
+#include "core/networkUtilities.h"
 #include <QJsonDocument>
 #include <QJsonObject>
 
@@ -31,8 +33,6 @@ void ApiNewsController::fetchNews(bool showError)
         return;
     }
 
-    auto gatewayController = QSharedPointer<GatewayController>::create(m_settings->getGatewayEndpoint(), m_settings->isDevGatewayEnv(),
-                                                                       apiDefs::requestTimeoutMsecs, m_settings->isStrictKillSwitchEnabled());
     QJsonObject payload;
     payload.insert("locale", m_settings->getAppLanguage().name().split("_").first());
 
@@ -44,26 +44,35 @@ void ApiNewsController::fetchNews(bool showError)
         payload.insert(configKey::serviceType, stacksJson.value(configKey::serviceType));
     }
 
-    auto future = gatewayController->postAsync(QString("%1v1/news"), payload);
-    future.then(this, [this, showError, gatewayController](QPair<ErrorCode, QByteArray> result) {
-        auto [errorCode, responseBody] = result;
-        if (errorCode != ErrorCode::NoError) {
-            emit errorOccurred(errorCode, showError);
-            return;
+    QString endpoint = QString("%1v1/news");
+    
+    // Use GatewayController with parallel transports
+    GatewayController gatewayController(m_settings->getGatewayEndpoint(), 
+                                        m_settings->isDevGatewayEnv(),
+                                        apiDefs::requestTimeoutMsecs, 
+                                        m_settings->isStrictKillSwitchEnabled());
+    
+    gatewayController.setTransportsConfig(GatewayController::buildTransportsConfig());
+    
+    QByteArray responseBody;
+    ErrorCode errorCode = gatewayController.post(endpoint, payload, responseBody);
+    
+    if (errorCode != ErrorCode::NoError) {
+        emit errorOccurred(errorCode, showError);
+        return;
+    }
+    
+    // Parse response
+    QJsonDocument doc = QJsonDocument::fromJson(responseBody);
+    QJsonArray newsArray;
+    if (doc.isArray()) {
+        newsArray = doc.array();
+    } else if (doc.isObject()) {
+        QJsonObject obj = doc.object();
+        if (obj.value("news").isArray()) {
+            newsArray = obj.value("news").toArray();
         }
-
-        QJsonDocument doc = QJsonDocument::fromJson(responseBody);
-        QJsonArray newsArray;
-        if (doc.isArray()) {
-            newsArray = doc.array();
-        } else if (doc.isObject()) {
-            QJsonObject obj = doc.object();
-            if (obj.value("news").isArray()) {
-                newsArray = obj.value("news").toArray();
-            }
-        }
-
-        m_newsModel->updateModel(newsArray);
-        emit fetchNewsFinished();
-    });
+    }
+    m_newsModel->updateModel(newsArray);
+    emit fetchNewsFinished();
 }

client/ui/controllers/api/apiSettingsController.cpp

@@ -1,12 +1,15 @@
 #include "apiSettingsController.h"
 
 #include <QEventLoop>
-#include <QJsonDocument>
 #include <QTimer>
 
+#include "core/api/apiDefs.h"
 #include "core/api/apiUtils.h"
 #include "core/controllers/gatewayController.h"
+#include "core/networkUtilities.h"
+#ifdef Q_OS_IOS
 #include "platforms/ios/ios_controller.h"
+#endif
 #include "version.h"
 
 namespace
@@ -57,8 +60,6 @@ bool ApiSettingsController::getAccountInfo(bool reload)
     auto authData = serverConfig.value(configKey::authData).toObject();
 
     bool isTestPurchase = apiConfig.value(apiDefs::key::isTestPurchase).toBool(false);
-    GatewayController gatewayController(m_settings->getGatewayEndpoint(isTestPurchase), m_settings->isDevGatewayEnv(isTestPurchase),
-                                        requestTimeoutMsecs, m_settings->isStrictKillSwitchEnabled());
 
     QJsonObject apiPayload;
     apiPayload[configKey::userCountryCode] = apiConfig.value(configKey::userCountryCode).toString();
@@ -68,8 +69,18 @@ bool ApiSettingsController::getAccountInfo(bool reload)
     apiPayload[apiDefs::key::appLanguage] = m_settings->getAppLanguage().name().split("_").first();
 
     QByteArray responseBody;
-
-    ErrorCode errorCode = gatewayController.post(QString("%1v1/account_info"), apiPayload, responseBody);
+    QString endpoint = QString("%1v1/account_info");
+    
+    // Use GatewayController with parallel transports
+    GatewayController gatewayController(m_settings->getGatewayEndpoint(isTestPurchase), 
+                                        m_settings->isDevGatewayEnv(isTestPurchase),
+                                        requestTimeoutMsecs, 
+                                        m_settings->isStrictKillSwitchEnabled());
+    
+    gatewayController.setTransportsConfig(GatewayController::buildTransportsConfig());
+    
+    ErrorCode errorCode = gatewayController.post(endpoint, apiPayload, responseBody);
+    
     if (errorCode != ErrorCode::NoError) {
         emit errorOccurred(errorCode);
         return false;
@@ -78,13 +89,6 @@ bool ApiSettingsController::getAccountInfo(bool reload)
     QJsonObject accountInfo = QJsonDocument::fromJson(responseBody).object();
     m_apiAccountInfoModel->updateModel(accountInfo, serverConfig);
 
-    QString subscriptionEndDate = accountInfo.value(apiDefs::key::subscriptionEndDate).toString();
-    if (!subscriptionEndDate.isEmpty()) {
-        apiConfig.insert(apiDefs::key::subscriptionEndDate, subscriptionEndDate);
-        serverConfig.insert(configKey::apiConfig, apiConfig);
-        m_serversModel->editServer(serverConfig, processedIndex);
-    }
-
     if (reload) {
         updateApiCountryModel();
         updateApiDevicesModel();
@@ -93,42 +97,6 @@ bool ApiSettingsController::getAccountInfo(bool reload)
     return true;
 }
 
-void ApiSettingsController::getRenewalLink()
-{
-    auto processedIndex = m_serversModel->getProcessedServerIndex();
-    auto serverConfig = m_serversModel->getServerConfig(processedIndex);
-    auto apiConfig = serverConfig.value(configKey::apiConfig).toObject();
-    auto authData = serverConfig.value(configKey::authData).toObject();
-
-    bool isTestPurchase = apiConfig.value(apiDefs::key::isTestPurchase).toBool(false);
-    auto gatewayController = QSharedPointer<GatewayController>::create(m_settings->getGatewayEndpoint(isTestPurchase),
-                                                                       m_settings->isDevGatewayEnv(isTestPurchase),
-                                                                       requestTimeoutMsecs,
-                                                                       m_settings->isStrictKillSwitchEnabled());
-
-    QJsonObject apiPayload;
-    apiPayload[configKey::userCountryCode] = apiConfig.value(configKey::userCountryCode).toString();
-    apiPayload[configKey::serviceType] = apiConfig.value(configKey::serviceType).toString();
-    apiPayload[configKey::authData] = authData;
-    apiPayload[apiDefs::key::cliVersion] = QString(APP_VERSION);
-    apiPayload[apiDefs::key::appLanguage] = m_settings->getAppLanguage().name().split("_").first();
-
-    auto future = gatewayController->postAsync(QString("%1v1/renewal_link"), apiPayload);
-    future.then(this, [this, gatewayController](QPair<ErrorCode, QByteArray> result) {
-        auto [errorCode, responseBody] = result;
-        if (errorCode != ErrorCode::NoError) {
-            emit errorOccurred(errorCode);
-            return;
-        }
-
-        QJsonObject responseJson = QJsonDocument::fromJson(responseBody).object();
-        QString url = responseJson.value("renewal_url").toString();
-        if (!url.isEmpty()) {
-            emit renewalLinkReceived(url);
-        }
-    });
-}
-
 void ApiSettingsController::updateApiCountryModel()
 {
     m_apiCountryModel->updateModel(m_apiAccountInfoModel->getAvailableCountries(), "");

client/ui/controllers/api/apiSettingsController.h

@@ -21,11 +21,9 @@ public slots:
     bool getAccountInfo(bool reload);
     void updateApiCountryModel();
     void updateApiDevicesModel();
-    void getRenewalLink();
 
 signals:
     void errorOccurred(ErrorCode errorCode);
-    void renewalLinkReceived(const QString &url);
 
 private:
     QSharedPointer<ServersModel> m_serversModel;

client/ui/controllers/exportController.cpp

@@ -7,6 +7,7 @@
 #include <QFileInfo>
 #include <QImage>
 #include <QStandardPaths>
+
 #include "core/controllers/vpnConfigurationController.h"
 #include "core/qrCodeUtils.h"
 #include "core/serialization/serialization.h"
@@ -169,7 +170,8 @@ void ExportController::generateWireGuardConfig(const QString &clientName)
         m_config.append(line + "\n");
     }
 
-    m_qrCodes = qrCodeUtils::generateQrCodeImageSeries(m_config.toUtf8());
+    auto qr = qrCodeUtils::generateQrCode(m_config.toUtf8());
+    m_qrCodes << qrCodeUtils::svgToBase64(QString::fromStdString(toSvgString(qr, 1)));
 
     emit exportConfigChanged();
 }
@@ -189,7 +191,8 @@ void ExportController::generateAwgConfig(const QString &clientName)
         m_config.append(line + "\n");
     }
 
-    m_qrCodes = qrCodeUtils::generateQrCodeImageSeries(m_config.toUtf8());
+    auto qr = qrCodeUtils::generateQrCode(m_config.toUtf8());
+    m_qrCodes << qrCodeUtils::svgToBase64(QString::fromStdString(toSvgString(qr, 1)));
 
     emit exportConfigChanged();
 }

client/ui/controllers/importController.cpp

@@ -291,8 +291,6 @@ void ImportController::processNativeWireGuardConfig()
         clientProtocolConfig[config_key::cookieReplyPacketJunkSize] = "0";
         clientProtocolConfig[config_key::transportPacketJunkSize] = "0";
 
-        clientProtocolConfig[config_key::specialJunk1] = protocols::awg::defaultSpecialJunk1;
-
         clientProtocolConfig[config_key::isObfuscationEnabled] = true;
 
         serverProtocolConfig[config_key::last_config] = QString(QJsonDocument(clientProtocolConfig).toJson());

client/ui/controllers/installController.cpp

@@ -83,8 +83,8 @@ void InstallController::install(DockerContainer container, int port, TransportPr
 
                 int s1 = QRandomGenerator::global()->bounded(15, 150);
                 int s2 = QRandomGenerator::global()->bounded(15, 150);
-                int s3 = QRandomGenerator::global()->bounded(1, 64);
-                int s4 = QRandomGenerator::global()->bounded(1, 20);
+                int s3 = QRandomGenerator::global()->bounded(0, 64);
+                int s4 = QRandomGenerator::global()->bounded(0, 20);
 
                 // Ensure all values are unique and don't create equal packet sizes
                 QSet<int> usedValues;
@@ -97,12 +97,12 @@ void InstallController::install(DockerContainer container, int port, TransportPr
 
                 while (usedValues.contains(s3) || s1 + AwgConstant::messageInitiationSize == s3 + AwgConstant::messageCookieReplySize
                        || s2 + AwgConstant::messageResponseSize == s3 + AwgConstant::messageCookieReplySize) {
-                    s3 = QRandomGenerator::global()->bounded(1, 64);
+                    s3 = QRandomGenerator::global()->bounded(0, 64);
                 }
                 usedValues.insert(s3);
 
                 while (usedValues.contains(s4)) {
-                    s4 = QRandomGenerator::global()->bounded(1, 20);
+                    s4 = QRandomGenerator::global()->bounded(0, 20);
                 }
 
                 QString initPacketJunkSize = QString::number(s1);
@@ -987,94 +987,79 @@ void InstallController::addEmptyServer()
     emit installServerFinished(tr("Server added successfully"));
 }
 
-void InstallController::validateConfig()
+bool InstallController::isConfigValid()
 {
     int serverIndex = m_serversModel->getDefaultServerIndex();
     QJsonObject serverConfigObject = m_serversModel->getServerConfig(serverIndex);
 
     if (apiUtils::isServerFromApi(serverConfigObject)) {
-        emit configValidated(true);
-        return;
+        return true;
     }
 
     if (!m_serversModel->data(serverIndex, ServersModel::Roles::HasInstalledContainers).toBool()) {
         emit noInstalledContainers();
-        emit configValidated(false);
-        return;
+        return false;
     }
 
     DockerContainer container = qvariant_cast<DockerContainer>(m_serversModel->data(serverIndex, ServersModel::Roles::DefaultContainerRole));
 
     if (container == DockerContainer::None) {
         emit installationErrorOccurred(ErrorCode::NoInstalledContainersError);
-        emit configValidated(false);
-        return;
+        return false;
     }
 
+    QSharedPointer<ServerController> serverController(new ServerController(m_settings));
+    VpnConfigurationsController vpnConfigurationController(m_settings, serverController);
+
     QJsonObject containerConfig = m_containersModel->getContainerConfig(container);
     ServerCredentials credentials = m_serversModel->getServerCredentials(serverIndex);
-    QSharedPointer<ServerController> serverController(new ServerController(m_settings));
 
-    auto isProtocolConfigExists = [](const QJsonObject &containerConfig, const DockerContainer container) {
-        for (Proto protocol : ContainerProps::protocolsForContainer(container)) {
-            QString protocolConfig =
-                    containerConfig.value(ProtocolProps::protoToString(protocol)).toObject().value(config_key::last_config).toString();
+    QFutureWatcher<ErrorCode> watcher;
 
-            if (protocolConfig.isEmpty()) {
-                return false;
+    QFuture<ErrorCode> future = QtConcurrent::run([this, container, &credentials, &containerConfig, &serverController]() {
+        ErrorCode errorCode = ErrorCode::NoError;
+
+        auto isProtocolConfigExists = [](const QJsonObject &containerConfig, const DockerContainer container) {
+            for (Proto protocol : ContainerProps::protocolsForContainer(container)) {
+                QString protocolConfig =
+                        containerConfig.value(ProtocolProps::protoToString(protocol)).toObject().value(config_key::last_config).toString();
+
+                if (protocolConfig.isEmpty()) {
+                    return false;
+                }
+            }
+            return true;
+        };
+
+        if (!isProtocolConfigExists(containerConfig, container)) {
+            VpnConfigurationsController vpnConfigurationController(m_settings, serverController);
+            errorCode = vpnConfigurationController.createProtocolConfigForContainer(credentials, container, containerConfig);
+            if (errorCode != ErrorCode::NoError) {
+                return errorCode;
+            }
+            m_serversModel->updateContainerConfig(container, containerConfig);
+
+            errorCode = m_clientManagementModel->appendClient(container, credentials, containerConfig,
+                                                              QString("Admin [%1]").arg(QSysInfo::prettyProductName()), serverController);
+            if (errorCode != ErrorCode::NoError) {
+                return errorCode;
             }
         }
-        return true;
-    };
+        return errorCode;
+    });
 
-    if (isProtocolConfigExists(containerConfig, container)) {
-        emit configValidated(true);
-        return;
+    QEventLoop wait;
+    connect(&watcher, &QFutureWatcher<ErrorCode>::finished, &wait, &QEventLoop::quit);
+    watcher.setFuture(future);
+    wait.exec();
+
+    ErrorCode errorCode = watcher.result();
+
+    if (errorCode != ErrorCode::NoError) {
+        emit installationErrorOccurred(errorCode);
+        return false;
     }
-
-    struct ValidationResult {
-        ErrorCode errorCode = ErrorCode::NoError;
-        QJsonObject containerConfig;
-    };
-
-    QFuture<ValidationResult> future =
-            QtConcurrent::run([settings = m_settings, serverController, credentials, containerConfig, container]() mutable {
-                ValidationResult result;
-                result.containerConfig = containerConfig;
-
-                VpnConfigurationsController vpnConfigurationController(settings, serverController);
-                result.errorCode = vpnConfigurationController.createProtocolConfigForContainer(credentials, container,
-                                                                                               result.containerConfig);
-                return result;
-            });
-
-    auto *watcher = new QFutureWatcher<ValidationResult>(this);
-    connect(watcher, &QFutureWatcher<ValidationResult>::finished, this,
-            [this, watcher, container, credentials, serverController]() {
-                auto result = watcher->result();
-                watcher->deleteLater();
-
-                if (result.errorCode != ErrorCode::NoError) {
-                    emit installationErrorOccurred(result.errorCode);
-                    emit configValidated(false);
-                    return;
-                }
-
-                m_serversModel->updateContainerConfig(container, result.containerConfig);
-
-                ErrorCode appendError = m_clientManagementModel->appendClient(
-                        container, credentials, result.containerConfig,
-                        QString("Admin [%1]").arg(QSysInfo::prettyProductName()), serverController);
-
-                if (appendError != ErrorCode::NoError) {
-                    emit installationErrorOccurred(appendError);
-                    emit configValidated(false);
-                    return;
-                }
-
-                emit configValidated(true);
-            });
-    watcher->setFuture(future);
+    return true;
 }
 
 bool InstallController::isUpdateDockerContainerRequired(const DockerContainer container, const QJsonObject &oldConfig,
@@ -1085,7 +1070,7 @@ bool InstallController::isUpdateDockerContainerRequired(const DockerContainer co
     const QJsonObject &oldProtoConfig = oldConfig.value(ProtocolProps::protoToString(mainProto)).toObject();
     const QJsonObject &newProtoConfig = newConfig.value(ProtocolProps::protoToString(mainProto)).toObject();
 
-    if (ContainerProps::isAwgContainer(container)) {
+    if (container == DockerContainer::Awg2) {
         const AwgConfig oldConfig(oldProtoConfig);
         const AwgConfig newConfig(newProtoConfig);
 

client/ui/controllers/installController.h

@@ -50,10 +50,9 @@ public slots:
 
     void addEmptyServer();
 
-    void validateConfig();
+    bool isConfigValid();
 
 signals:
-    void configValidated(bool isValid);
     void installContainerFinished(const QString &finishMessage, bool isServiceInstall);
     void installServerFinished(const QString &finishMessage);
 

client/ui/controllers/settingsController.cpp

@@ -45,8 +45,6 @@ SettingsController::SettingsController(const QSharedPointer<ServersModel> &serve
         emit safeAreaBottomMarginChanged();
         emit safeAreaTopMarginChanged();
     });
-    connect(AndroidController::instance(), &AndroidController::activityPaused, this, &SettingsController::activityPaused);
-    connect(AndroidController::instance(), &AndroidController::activityResumed, this, &SettingsController::activityResumed);
 #endif
 
     m_isDevModeEnabled = m_settings->isDevGatewayEnv();
@@ -180,11 +178,12 @@ void SettingsController::backupAppConfig(const QString &fileName)
 
 void SettingsController::restoreAppConfig(const QString &fileName)
 {
-    QByteArray data;
-    if (!SystemController::readFile(fileName, data)) {
-        emit changeSettingsErrorOccurred(tr("Can't open file: %1").arg(fileName));
-        return;
-    }
+    QFile file(fileName);
+
+    file.open(QIODevice::ReadOnly);
+
+    QByteArray data = file.readAll();
+
     restoreAppConfigFromData(data);
 }
 
@@ -309,15 +308,6 @@ void SettingsController::toggleStartMinimized(bool enable)
     emit startMinimizedChanged();
 }
 
-bool SettingsController::isNewsNotificationsEnabled()
-{
-    return m_settings->isNewsNotifications();
-}
-void SettingsController::toggleNewsNotificationsEnabled(bool enable)
-{
-    m_settings->setNewsNotifications(enable);
-}
-
 bool SettingsController::isScreenshotsEnabled()
 {
     return m_settings->isScreenshotsEnabled();

client/ui/controllers/settingsController.h

@@ -73,9 +73,6 @@ public slots:
     bool isStartMinimizedEnabled();
     void toggleStartMinimized(bool enable);
 
-    bool isNewsNotificationsEnabled();
-    void toggleNewsNotificationsEnabled(bool enable);
-
     bool isScreenshotsEnabled();
     void toggleScreenshotsEnabled(bool enable);
 
@@ -141,9 +138,6 @@ signals:
     void safeAreaTopMarginChanged();
     void safeAreaBottomMarginChanged();
 
-    void activityPaused();
-    void activityResumed();
-
     void isHomeAdLabelVisibleChanged(bool visible);
     void startMinimizedChanged();
 

client/ui/controllers/sitesController.cpp

@@ -7,8 +7,10 @@
 #include "systemController.h"
 #include "core/networkUtilities.h"
 
-SitesController::SitesController(const std::shared_ptr<Settings> &settings, const QSharedPointer<SitesModel> &sitesModel, QObject *parent)
-    : QObject(parent), m_settings(settings), m_sitesModel(sitesModel)
+SitesController::SitesController(const std::shared_ptr<Settings> &settings,
+                                 const QSharedPointer<VpnConnection> &vpnConnection,
+                                 const QSharedPointer<SitesModel> &sitesModel, QObject *parent)
+    : QObject(parent), m_settings(settings), m_vpnConnection(vpnConnection), m_sitesModel(sitesModel)
 {
 }
 
@@ -32,20 +34,32 @@ void SitesController::addSite(QString hostname)
         hostname = hostname.split("/", Qt::SkipEmptyParts).first();
     }
 
-    const auto &resolveCallback = [this](const QHostInfo &hostInfo) {
+    const auto &processSite = [this](const QString &hostname, const QString &ip) {
+        m_sitesModel->addSite(hostname, ip);
+
+        if (!ip.isEmpty()) {
+            QMetaObject::invokeMethod(m_vpnConnection.get(), "addRoutes", Qt::QueuedConnection,
+                                      Q_ARG(QStringList, QStringList() << ip));
+        } else if (NetworkUtilities::ipAddressWithSubnetRegExp().exactMatch(hostname)) {
+            QMetaObject::invokeMethod(m_vpnConnection.get(), "addRoutes", Qt::QueuedConnection,
+                                      Q_ARG(QStringList, QStringList() << hostname));
+        }
+    };
+
+    const auto &resolveCallback = [this, processSite](const QHostInfo &hostInfo) {
         const QList<QHostAddress> &addresses = hostInfo.addresses();
         for (const QHostAddress &addr : hostInfo.addresses()) {
             if (addr.protocol() == QAbstractSocket::NetworkLayerProtocol::IPv4Protocol) {
-                m_sitesModel->addSite(hostInfo.hostName(), addr.toString());
+                processSite(hostInfo.hostName(), addr.toString());
                 break;
             }
         }
     };
 
     if (NetworkUtilities::ipAddressWithSubnetRegExp().exactMatch(hostname)) {
-        m_sitesModel->addSite(hostname, "");
+        processSite(hostname, "");
     } else {
-        m_sitesModel->addSite(hostname, "");
+        processSite(hostname, "");
         QHostInfo::lookupHost(hostname, this, resolveCallback);
     }
 
@@ -58,6 +72,9 @@ void SitesController::removeSite(int index)
     auto hostname = m_sitesModel->data(modelIndex, SitesModel::Roles::UrlRole).toString();
     m_sitesModel->removeSite(modelIndex);
 
+    QMetaObject::invokeMethod(m_vpnConnection.get(), "deleteRoutes", Qt::QueuedConnection,
+                              Q_ARG(QStringList, QStringList() << hostname));
+
     emit finished(tr("Site removed: %1").arg(hostname));
 }
 
@@ -111,6 +128,8 @@ void SitesController::importSites(const QString &fileName, bool replaceExisting)
 
     m_sitesModel->addSites(sites, replaceExisting);
 
+    QMetaObject::invokeMethod(m_vpnConnection.get(), "addRoutes", Qt::QueuedConnection, Q_ARG(QStringList, ips));
+
     emit finished(tr("Import completed"));
 }
 

client/ui/controllers/sitesController.h

@@ -11,8 +11,9 @@ class SitesController : public QObject
 {
     Q_OBJECT
 public:
-    explicit SitesController(const std::shared_ptr<Settings> &settings, const QSharedPointer<SitesModel> &sitesModel,
-                             QObject *parent = nullptr);
+    explicit SitesController(const std::shared_ptr<Settings> &settings,
+                             const QSharedPointer<VpnConnection> &vpnConnection,
+                             const QSharedPointer<SitesModel> &sitesModel, QObject *parent = nullptr);
 
 public slots:
     void addSite(QString hostname);
@@ -30,6 +31,8 @@ signals:
 
 private:
     std::shared_ptr<Settings> m_settings;
+
+    QSharedPointer<VpnConnection> m_vpnConnection;
     QSharedPointer<SitesModel> m_sitesModel;
 };
 

client/ui/models/api/apiAccountInfoModel.cpp

@@ -1,6 +1,5 @@
 #include "apiAccountInfoModel.h"
 
-#include <QDateTime>
 #include <QJsonObject>
 
 #include "core/api/apiUtils.h"
@@ -33,7 +32,7 @@ QVariant ApiAccountInfoModel::data(const QModelIndex &index, int role) const
         }
 
         return apiUtils::isSubscriptionExpired(m_accountInfoData.subscriptionEndDate) ? tr("<p><a style=\"color: #EB5757;\">Inactive</a>")
-                                                                                      : tr("<p><a style=\"color: #28c840;\">Active</a>");
+                                                                                      : tr("Active");
     }
     case EndDateRole: {
         if (m_accountInfoData.configType == apiDefs::ConfigType::AmneziaFreeV3) {
@@ -53,9 +52,7 @@ QVariant ApiAccountInfoModel::data(const QModelIndex &index, int role) const
     }
     case IsComponentVisibleRole: {
         return m_accountInfoData.configType == apiDefs::ConfigType::AmneziaPremiumV2
-                || m_accountInfoData.configType == apiDefs::ConfigType::AmneziaTrialV2
-                || m_accountInfoData.configType == apiDefs::ConfigType::ExternalPremium
-                || m_accountInfoData.configType == apiDefs::ConfigType::ExternalTrial;
+                || m_accountInfoData.configType == apiDefs::ConfigType::ExternalPremium;
     }
     case HasExpiredWorkerRole: {
         for (int i = 0; i < m_issuedConfigsInfo.size(); i++) {
@@ -76,18 +73,6 @@ QVariant ApiAccountInfoModel::data(const QModelIndex &index, int role) const
         }
         return false;
     }
-    case IsSubscriptionExpiredRole: {
-        if (m_accountInfoData.configType == apiDefs::ConfigType::AmneziaFreeV3) return false;
-        if (m_accountInfoData.subscriptionEndDate.isEmpty()) return false;
-        return apiUtils::isSubscriptionExpired(m_accountInfoData.subscriptionEndDate);
-    }
-    case IsSubscriptionExpiringSoonRole: {
-        if (m_accountInfoData.configType == apiDefs::ConfigType::AmneziaFreeV3) return false;
-        if (m_accountInfoData.subscriptionEndDate.isEmpty()) return false;
-        if (apiUtils::isSubscriptionExpired(m_accountInfoData.subscriptionEndDate)) return false;
-        QDateTime endDate = QDateTime::fromString(m_accountInfoData.subscriptionEndDate, Qt::ISODateWithMs);
-        return endDate <= QDateTime::currentDateTimeUtc().addDays(10);
-    }
     }
 
     return QVariant();
@@ -179,8 +164,6 @@ QHash<int, QByteArray> ApiAccountInfoModel::roleNames() const
     roles[IsComponentVisibleRole] = "isComponentVisible";
     roles[HasExpiredWorkerRole] = "hasExpiredWorker";
     roles[IsProtocolSelectionSupportedRole] = "isProtocolSelectionSupported";
-    roles[IsSubscriptionExpiredRole] = "isSubscriptionExpired";
-    roles[IsSubscriptionExpiringSoonRole] = "isSubscriptionExpiringSoon";
 
     return roles;
 }

client/ui/models/api/apiAccountInfoModel.h

@@ -19,9 +19,7 @@ public:
         EndDateRole,
         IsComponentVisibleRole,
         HasExpiredWorkerRole,
-        IsProtocolSelectionSupportedRole,
-        IsSubscriptionExpiredRole,
-        IsSubscriptionExpiringSoonRole
+        IsProtocolSelectionSupportedRole
     };
 
     explicit ApiAccountInfoModel(QObject *parent = nullptr);
@@ -33,6 +31,7 @@ public:
 public slots:
     void updateModel(const QJsonObject &accountInfoObject, const QJsonObject &serverConfig);
     QVariant data(const QString &roleString);
+
     QJsonArray getAvailableCountries();
     QJsonArray getIssuedConfigsInfo();
 

client/ui/models/api/apiServicesModel.cpp

@@ -41,7 +41,6 @@ namespace
     {
         constexpr char amneziaFree[] = "amnezia-free";
         constexpr char amneziaPremium[] = "amnezia-premium";
-        constexpr char amneziaTrial[] = "amnezia-trial";
     }
 }
 
@@ -70,7 +69,7 @@ QVariant ApiServicesModel::data(const QModelIndex &index, int role) const
     }
     case CardDescriptionRole: {
         auto speed = apiServiceData.serviceInfo.speed;
-        if (serviceType == serviceType::amneziaPremium || serviceType == serviceType::amneziaTrial) {
+        if (serviceType == serviceType::amneziaPremium) {
             return apiServiceData.serviceInfo.cardDescription.arg(speed);
         } else if (serviceType == serviceType::amneziaFree) {
             QString description = apiServiceData.serviceInfo.cardDescription;
@@ -113,11 +112,7 @@ QVariant ApiServicesModel::data(const QModelIndex &index, int role) const
         if (price == "free") {
             return tr("Free");
         }
-#if defined(Q_OS_IOS) || defined(MACOS_NE)
-        return tr("%1 $").arg(price);
-#else
         return tr("%1 $/month").arg(price);
-#endif
     }
     case EndDateRole: {
         return QDateTime::fromString(apiServiceData.subscription.endDate, Qt::ISODate).toLocalTime().toString("d MMM yyyy");
@@ -125,10 +120,8 @@ QVariant ApiServicesModel::data(const QModelIndex &index, int role) const
     case OrderRole: {
         if (serviceType == serviceType::amneziaPremium) {
             return 0;
-        } else if (serviceType == serviceType::amneziaTrial) {
-            return 1;
         } else if (serviceType == serviceType::amneziaFree) {
-            return 2;
+            return 1;
         }
     }
     }

client/ui/models/protocols/awgConfigModel.cpp

@@ -141,12 +141,10 @@ void AwgConfigModel::updateModel(const QJsonObject &config)
             serverProtocolConfig.value(config_key::initPacketJunkSize).toString(protocols::awg::defaultInitPacketJunkSize);
     m_serverProtocolConfig[config_key::responsePacketJunkSize] =
             serverProtocolConfig.value(config_key::responsePacketJunkSize).toString(protocols::awg::defaultResponsePacketJunkSize);
-    if (protocolVersion == protocols::awg::awgV2) {
-        m_serverProtocolConfig[config_key::cookieReplyPacketJunkSize] =
-                serverProtocolConfig.value(config_key::cookieReplyPacketJunkSize).toString(protocols::awg::defaultCookieReplyPacketJunkSize);
-        m_serverProtocolConfig[config_key::transportPacketJunkSize] =
-                serverProtocolConfig.value(config_key::transportPacketJunkSize).toString(protocols::awg::defaultTransportPacketJunkSize);
-    }
+    m_serverProtocolConfig[config_key::cookieReplyPacketJunkSize] =
+            serverProtocolConfig.value(config_key::cookieReplyPacketJunkSize).toString(protocols::awg::defaultCookieReplyPacketJunkSize);
+    m_serverProtocolConfig[config_key::transportPacketJunkSize] =
+            serverProtocolConfig.value(config_key::transportPacketJunkSize).toString(protocols::awg::defaultTransportPacketJunkSize);
     m_serverProtocolConfig[config_key::initPacketMagicHeader] =
             serverProtocolConfig.value(config_key::initPacketMagicHeader).toString(protocols::awg::defaultInitPacketMagicHeader);
     m_serverProtocolConfig[config_key::responsePacketMagicHeader] =

client/ui/models/servers_model.cpp

@@ -179,20 +179,6 @@ QVariant ServersModel::data(const QModelIndex &index, int role) const
     case AdEndpointRole: {
         return apiConfig.value(apiDefs::key::serviceInfo).toObject().value(apiDefs::key::adEndpoint).toString();
     }
-    case IsSubscriptionExpiredRole: {
-        if (configVersion != apiDefs::ConfigSource::AmneziaGateway) return false;
-        QString endDate = apiConfig.value(apiDefs::key::subscriptionEndDate).toString();
-        if (endDate.isEmpty()) return false;
-        return apiUtils::isSubscriptionExpired(endDate);
-    }
-    case IsSubscriptionExpiringSoonRole: {
-        if (configVersion != apiDefs::ConfigSource::AmneziaGateway) return false;
-        QString endDate = apiConfig.value(apiDefs::key::subscriptionEndDate).toString();
-        if (endDate.isEmpty()) return false;
-        if (apiUtils::isSubscriptionExpired(endDate)) return false;
-        QDateTime endDateTime = QDateTime::fromString(endDate, Qt::ISODateWithMs);
-        return endDateTime <= QDateTime::currentDateTimeUtc().addDays(10);
-    }
     }
 
     return QVariant();
@@ -457,9 +443,6 @@ QHash<int, QByteArray> ServersModel::roleNames() const
     roles[AdDescriptionRole] = "adDescription";
     roles[AdEndpointRole] = "adEndpoint";
 
-    roles[IsSubscriptionExpiredRole] = "isSubscriptionExpired";
-    roles[IsSubscriptionExpiringSoonRole] = "isSubscriptionExpiringSoon";
-
     return roles;
 }
 

client/ui/models/servers_model.h

@@ -52,9 +52,6 @@ public:
         AdDescriptionRole,
         AdEndpointRole,
 
-        IsSubscriptionExpiredRole,
-        IsSubscriptionExpiringSoonRole,
-
         HasAmneziaDns
     };
 

client/ui/qml/Components/GamepadLoader.qml

@@ -1,38 +0,0 @@
-import QtQuick
-import QtGamepadLegacy
-
-Item {
-    id: root
-    
-    property alias gamepad: gamepad
-    property alias gamepadKeyNav: gamepadKeyNav
-    
-    Gamepad {
-        id: gamepad
-        deviceId: GamepadManager.connectedGamepads.length > 0 ? GamepadManager.connectedGamepads[0] : -1
-
-        onButtonStartChanged: {
-            if (buttonStart) {
-                ServersModel.setProcessedServerIndex(ServersModel.defaultIndex)
-                ConnectionController.connectButtonClicked()
-            }
-        }
-    }
-
-    GamepadKeyNavigation {
-        id: gamepadKeyNav
-        gamepad: gamepad
-        active: true
-    }
-
-    Connections {
-        target: GamepadManager
-        function onConnectedGamepadsChanged() {
-            if (GamepadManager.connectedGamepads.length > 0) {
-                gamepad.deviceId = GamepadManager.connectedGamepads[0]
-            } else {
-                gamepad.deviceId = -1
-            }
-        }
-    }
-}

client/ui/qml/Components/ServersListView.qml

@@ -126,18 +126,6 @@ ListViewType {
                 }
             }
 
-            CaptionTextType {
-                visible: isServerFromGatewayApi && (isSubscriptionExpired || isSubscriptionExpiringSoon)
-
-                Layout.fillWidth: true
-                Layout.leftMargin: 64
-                Layout.bottomMargin: 8
-
-                text: isSubscriptionExpired ? qsTr("Subscription expired. Please renew.") : qsTr("Subscription expiring soon.")
-                color: isSubscriptionExpired ? AmneziaStyle.color.vibrantRed : AmneziaStyle.color.goldenApricot
-                wrapMode: Text.WordWrap
-            }
-
             DividerType {
                 Layout.fillWidth: true
                 Layout.leftMargin: 0

client/ui/qml/Components/SubscriptionExpiredDrawer.qml

@@ -1,93 +0,0 @@
-pragma ComponentBehavior: Bound
-
-import QtQuick
-import QtQuick.Controls
-import QtQuick.Layouts
-import PageEnum 1.0
-import Style 1.0
-
-import "../Controls2"
-import "../Controls2/TextTypes"
-
-DrawerType2 {
-    id: root
-
-    expandedStateContent: ColumnLayout {
-        id: content
-
-        anchors.top: parent.top
-        anchors.left: parent.left
-        anchors.right: parent.right
-
-        spacing: 0
-
-        onImplicitHeightChanged: {
-            root.expandedHeight = content.implicitHeight + 32 + SettingsController.safeAreaBottomMargin
-        }
-
-        Item {
-            Layout.fillWidth: true
-            Layout.topMargin: 24
-            Layout.rightMargin: 16
-            Layout.leftMargin: 16
-            implicitHeight: titleText.implicitHeight
-
-            Header2TextType {
-                id: titleText
-                anchors.left: parent.left
-                anchors.right: parent.right
-
-                text: qsTr("Amnezia Premium subscription has expired")
-                horizontalAlignment: Text.AlignLeft
-            }
-        }
-
-        ParagraphTextType {
-            Layout.fillWidth: true
-            Layout.topMargin: 8
-            Layout.rightMargin: 16
-            Layout.leftMargin: 16
-
-            text: qsTr("Renew your subscription to continue using VPN")
-            horizontalAlignment: Text.AlignLeft
-        }
-
-        BasicButtonType {
-            Layout.fillWidth: true
-            Layout.topMargin: 16
-            Layout.rightMargin: 16
-            Layout.leftMargin: 16
-
-            text: qsTr("Renew")
-
-            defaultColor: AmneziaStyle.color.paleGray
-            hoveredColor: AmneziaStyle.color.lightGray
-            pressedColor: AmneziaStyle.color.mutedGray
-            textColor: AmneziaStyle.color.midnightBlack
-
-            clickedFunc: function() {
-                ApiSettingsController.getRenewalLink()
-            }
-        }
-
-        BasicButtonType {
-            Layout.alignment: Qt.AlignHCenter
-            Layout.topMargin: 8
-            Layout.bottomMargin: 8
-
-            implicitHeight: 25
-
-            defaultColor: AmneziaStyle.color.transparent
-            hoveredColor: AmneziaStyle.color.translucentWhite
-            pressedColor: AmneziaStyle.color.sheerWhite
-            textColor: AmneziaStyle.color.goldenApricot
-
-            text: qsTr("Support")
-
-            clickedFunc: function() {
-                root.closeTriggered()
-                PageController.goToPage(PageEnum.PageSettingsApiSupport)
-            }
-        }
-    }
-}

client/ui/qml/Controls2/BasicButtonType.qml

@@ -111,11 +111,11 @@ Button {
                 color: {
                     if (root.enabled) {
                         if (root.pressed) {
-                            return root.pressedColor
+                            return pressedColor
                         }
-                        return root.hovered ? root.hoveredColor : root.defaultColor
+                        return root.hovered ? hoveredColor : defaultColor
                     } else {
-                        return root.disabledColor
+                        return disabledColor
                     }
                 }
 

client/ui/qml/Controls2/DrawerType2.qml

@@ -49,55 +49,6 @@ Item {
         return drawerContent.state === stateName
     }
 
-    function isDrawerType2(obj) {
-        return obj && typeof obj.drawerExpandedStateName !== "undefined" && 
-               typeof obj.drawerCollapsedStateName !== "undefined"
-    }
-
-    function isDescendantOfDrawer(obj) {
-        var current = obj
-        while (current && current !== root.parent) {
-            if (isDrawerType2(current)) {
-                return true
-            }
-            current = current.parent
-        }
-        return false
-    }
-
-    function findComponent(obj, typeCtor) {
-        if (!obj)
-            return null
-
-        if (isDrawerType2(obj) || isDescendantOfDrawer(obj))
-            return null
-
-        if (obj instanceof typeCtor)
-            return obj
-
-        if (obj.children && obj.children.length > 0) {
-            for (var i = 0; i < obj.children.length; i++) {
-                var matchingChildren = findComponent(obj.children[i], typeCtor)
-                if (matchingChildren) return matchingChildren
-            }
-        }
-
-        if (obj.contentItem) {
-            var matchingContentItem = findComponent(obj.contentItem, typeCtor)
-            if (matchingContentItem) return matchingContentItem
-        }
-
-        return null
-    }
-
-    function setParentInteractive(value) {
-        var flickableType = findComponent(root.parent, Flickable)
-        var listViewType = findComponent(root.parent, ListView)
-
-        if (flickableType) flickableType.interactive = value
-        if (listViewType) listViewType.interactive = value
-    }
-
     Connections {
         target: Qt.application
 
@@ -142,8 +93,6 @@ Item {
 
             aboutToHide()
 
-            setParentInteractive(true)
-
             closed()
         }
 
@@ -169,8 +118,6 @@ Item {
 
             root.aboutToShow()
 
-            setParentInteractive(false)
-
             root.opened()
         }
 

client/ui/qml/Controls2/LabelWithButtonType.qml

@@ -1,7 +1,6 @@
 import QtQuick
 import QtQuick.Controls
 import QtQuick.Layouts
-import Qt5Compat.GraphicalEffects
 
 import Style 1.0
 
@@ -38,7 +37,6 @@ Item {
     property int borderFocusedWidth: 1
 
     property string rightImageColor: AmneziaStyle.color.paleGray
-    property string leftImageColor: ""
 
     property bool descriptionOnTop: false
     property bool hideDescription: true
@@ -73,8 +71,6 @@ Item {
     implicitHeight: content.implicitHeight + content.anchors.leftMargin + content.anchors.rightMargin
 
     MouseArea {
-        id: mouseArea
-
         anchors.fill: parent
         cursorShape: Qt.PointingHandCursor
         hoverEnabled: root.enabled
@@ -142,14 +138,6 @@ Item {
 
                 anchors.centerIn: parent
                 source: leftImageSource
-                visible: leftImageColor === ""
-            }
-
-            ColorOverlay {
-                anchors.fill: leftImage
-                source: leftImage
-                color: leftImageColor
-                visible: leftImageColor !== ""
             }
         }
 
@@ -308,13 +296,13 @@ Item {
     }
 
     Keys.onEnterPressed: {
-        if (!rightImageSource && clickedFunction && typeof clickedFunction === "function") {
+        if (clickedFunction && typeof clickedFunction === "function") {
             clickedFunction()
         }
     }
 
     Keys.onReturnPressed: {
-        if (!rightImageSource && clickedFunction && typeof clickedFunction === "function") {
+        if (clickedFunction && typeof clickedFunction === "function") {
             clickedFunction()
         }
     }

client/ui/qml/Controls2/PageType.qml

@@ -8,10 +8,9 @@ Item {
     id: root
 
     property StackView stackView: StackView.view
-    property bool enableTimer: true
 
     onVisibleChanged: {
-        if (visible && enableTimer) {
+        if (visible) {
             timer.start()
         }
     }
@@ -25,6 +24,6 @@ Item {
             FocusController.setFocusOnDefaultItem()
         }
         repeat: false // Stop the timer after one trigger
-        running: enableTimer // Start the timer
+        running: true // Start the timer
     }
 }

client/ui/qml/Controls2/TextFieldWithHeaderType.qml

@@ -19,6 +19,9 @@ Item {
 
     property string buttonText
     property string buttonImageSource
+    property string buttonImageColor: AmneziaStyle.color.midnightBlack
+    property string buttonBackgroundColor: AmneziaStyle.color.paleGray
+    property string buttonHoveredColor: AmneziaStyle.color.lightGray
     property var clickedFunc
 
     property alias textField: textField
@@ -67,7 +70,7 @@ Item {
             border.width: 1
 
             Behavior on border.color {
-                PropertyAnimation { duration: 200 }
+                PropertyAnimation { duration: 100 }
             }
 
             RowLayout {
@@ -121,7 +124,7 @@ Item {
 
                         background: Rectangle {
                             anchors.fill: parent
-                            color: root.backgroundDisabledColor
+                            color: root.enabled ? root.backgroundColor : root.backgroundDisabledColor
                         }
 
                         onTextChanged: {
@@ -186,6 +189,14 @@ Item {
         focusPolicy: Qt.NoFocus
         text: root.buttonText
         leftImageSource: root.buttonImageSource
+        leftImageColor: root.buttonImageColor
+
+        defaultColor: root.buttonBackgroundColor
+        hoveredColor: root.buttonHoveredColor
+        pressedColor: root.buttonHoveredColor
+        disabledColor: AmneziaStyle.color.transparent
+
+        borderWidth: 0
 
         anchors.top: content.top
         anchors.bottom: content.bottom
@@ -193,7 +204,7 @@ Item {
 
         height: content.implicitHeight
         width: content.implicitHeight
-        squareLeftSide: true
+        squareLeftSide: false
 
         clickedFunc: function() {
             if (root.clickedFunc && typeof root.clickedFunc === "function") {