feat: macos full feature conan build, except ss and cloak

client/cmake/3rdparty.cmake

@@ -8,76 +8,6 @@ include(${CLIENT_ROOT_DIR}/cmake/QSimpleCrypto.cmake)
 
 include(${CLIENT_ROOT_DIR}/3rd/qrcodegen/qrcodegen.cmake)
 
-set(LIBSSH_ROOT_DIR "${CLIENT_ROOT_DIR}/3rd-prebuilt/3rd-prebuilt/libssh/")
-set(OPENSSL_ROOT_DIR "${CLIENT_ROOT_DIR}/3rd-prebuilt/3rd-prebuilt/openssl/")
-
-set(OPENSSL_LIBRARIES_DIR "${OPENSSL_ROOT_DIR}/lib")
-
-if(WIN32)
-    set(OPENSSL_INCLUDE_DIR "${OPENSSL_ROOT_DIR}/windows/include")
-    if("${CMAKE_SIZEOF_VOID_P}" STREQUAL "8")
-        set(LIBSSH_LIB_PATH "${LIBSSH_ROOT_DIR}/windows/x86_64/ssh.lib")
-        set(LIBSSH_INCLUDE_DIR "${LIBSSH_ROOT_DIR}/windows/x86_64")
-        set(OPENSSL_LIB_SSL_PATH "${OPENSSL_ROOT_DIR}/windows/win64/libssl.lib")
-        set(OPENSSL_LIB_CRYPTO_PATH "${OPENSSL_ROOT_DIR}/windows/win64/libcrypto.lib")
-    else()
-        set(LIBSSH_LIB_PATH "${LIBSSH_ROOT_DIR}/windows/x86/ssh.lib")
-        set(LIBSSH_INCLUDE_DIR "${LIBSSH_ROOT_DIR}/windows/x86")
-        set(OPENSSL_LIB_SSL_PATH "${OPENSSL_ROOT_DIR}/windows/win32/libssl.lib")
-        set(OPENSSL_LIB_CRYPTO_PATH "${OPENSSL_ROOT_DIR}/windows/win32/libcrypto.lib")
-    endif()
-elseif(APPLE AND NOT IOS)
-    if(MACOS_NE)
-        set(LIBSSH_LIB_PATH "${LIBSSH_ROOT_DIR}/macos/universal2/libssh.a")
-        set(ZLIB_LIB_PATH "${LIBSSH_ROOT_DIR}/macos/universal2/libz.a")
-        set(LIBSSH_INCLUDE_DIR "${LIBSSH_ROOT_DIR}/macos/universal2")
-    else()
-        set(LIBSSH_LIB_PATH "${LIBSSH_ROOT_DIR}/macos/x86_64/libssh.a")
-        set(ZLIB_LIB_PATH "${LIBSSH_ROOT_DIR}/macos/x86_64/libz.a")
-        set(LIBSSH_INCLUDE_DIR "${LIBSSH_ROOT_DIR}/macos/x86_64")
-    endif()
-    set(OPENSSL_INCLUDE_DIR "${OPENSSL_ROOT_DIR}/macos/include")
-    set(OPENSSL_LIB_SSL_PATH "${OPENSSL_ROOT_DIR}/macos/lib/libssl.a")
-    set(OPENSSL_LIB_CRYPTO_PATH "${OPENSSL_ROOT_DIR}/macos/lib/libcrypto.a")    
-elseif(IOS)
-    set(LIBSSH_INCLUDE_DIR "${LIBSSH_ROOT_DIR}/ios/arm64")
-    set(LIBSSH_LIB_PATH "${LIBSSH_ROOT_DIR}/ios/arm64/libssh.a")
-    set(ZLIB_LIB_PATH "${LIBSSH_ROOT_DIR}/ios/arm64/libz.a")
-    set(OPENSSL_INCLUDE_DIR "${OPENSSL_ROOT_DIR}/ios/iphone/include")
-    set(OPENSSL_LIB_SSL_PATH "${OPENSSL_ROOT_DIR}/ios/iphone/lib/libssl.a")
-    set(OPENSSL_LIB_CRYPTO_PATH "${OPENSSL_ROOT_DIR}/ios/iphone/lib/libcrypto.a")
-elseif(ANDROID)
-    set(abi ${CMAKE_ANDROID_ARCH_ABI})
-    set(LIBSSH_INCLUDE_DIR "${LIBSSH_ROOT_DIR}/android/${abi}")
-    set(LIBSSH_LIB_PATH "${LIBSSH_ROOT_DIR}/android/${abi}/libssh.so")
-    set(OPENSSL_INCLUDE_DIR "${OPENSSL_ROOT_DIR}/android/include")
-    set(OPENSSL_LIB_SSL_PATH "${OPENSSL_ROOT_DIR}/android/${abi}/libssl.a")
-    set(OPENSSL_LIB_CRYPTO_PATH "${OPENSSL_ROOT_DIR}/android/${abi}/libcrypto.a")
-    set(OPENSSL_LIBRARIES_DIR "${OPENSSL_ROOT_DIR}/android/${abi}")
-elseif(LINUX)
-    set(LIBSSH_INCLUDE_DIR "${LIBSSH_ROOT_DIR}/linux/x86_64")
-    set(ZLIB_LIB_PATH "${LIBSSH_ROOT_DIR}/linux/x86_64/libz.a")
-    set(LIBSSH_LIB_PATH "${LIBSSH_ROOT_DIR}/linux/x86_64/libssh.a")
-    set(OPENSSL_INCLUDE_DIR "${OPENSSL_ROOT_DIR}/linux/include")
-    set(OPENSSL_LIB_SSL_PATH "${OPENSSL_ROOT_DIR}/linux/x86_64/libssl.a")
-    set(OPENSSL_LIB_CRYPTO_PATH "${OPENSSL_ROOT_DIR}/linux/x86_64/libcrypto.a")
-endif()
-
-file(COPY ${OPENSSL_LIB_SSL_PATH} ${OPENSSL_LIB_CRYPTO_PATH}
-        DESTINATION ${OPENSSL_LIBRARIES_DIR})
-
-set(OPENSSL_USE_STATIC_LIBS TRUE)
-  
-set(LIBS ${LIBS} 
-    ${LIBSSH_LIB_PATH} 
-    ${ZLIB_LIB_PATH}
-)
-  
-set(LIBS ${LIBS}
-    ${OPENSSL_LIB_SSL_PATH}
-    ${OPENSSL_LIB_CRYPTO_PATH}
-)
-
 add_compile_definitions(_WINSOCKAPI_)
 
 set(BUILD_SHARED_LIBS OFF CACHE BOOL "" FORCE)
@@ -106,12 +36,13 @@ endif()
 set(LIBS ${LIBS} qt6keychain)
 
 include_directories(
-    ${OPENSSL_INCLUDE_DIR}
-    ${LIBSSH_INCLUDE_DIR}/include
-    ${LIBSSH_ROOT_DIR}/include
-    ${CLIENT_ROOT_DIR}/3rd/libssh/include
     ${CLIENT_ROOT_DIR}/3rd/QSimpleCrypto/src/include
     ${CLIENT_ROOT_DIR}/3rd/qtkeychain/qtkeychain
     ${CMAKE_CURRENT_BINARY_DIR}/3rd/qtkeychain
-    ${CMAKE_CURRENT_BINARY_DIR}/3rd/libssh/include
 )
+
+find_package(openssl REQUIRED)
+list(APPEND LIBS OpenSSL::SSL OpenSSL::Crypto)
+
+find_package(libssh REQUIRED)
+list(APPEND LIBS ssh::ssh)

client/cmake/android.cmake

@@ -42,18 +42,22 @@ set(SOURCES ${SOURCES}
     ${CMAKE_CURRENT_SOURCE_DIR}/core/installedAppsImageProvider.cpp
 )
 
-foreach(abi IN ITEMS ${QT_ANDROID_ABIS})
+# foreach(abi IN ITEMS ${QT_ANDROID_ABIS})
-    set_property(TARGET ${PROJECT} PROPERTY QT_ANDROID_EXTRA_LIBS
+#     set_property(TARGET ${PROJECT} PROPERTY QT_ANDROID_EXTRA_LIBS
-        ${CMAKE_CURRENT_SOURCE_DIR}/3rd-prebuilt/3rd-prebuilt/amneziawg/android/${abi}/libwg-go.so
+#         ${CMAKE_CURRENT_SOURCE_DIR}/3rd-prebuilt/3rd-prebuilt/amneziawg/android/${abi}/libwg-go.so
-        ${CMAKE_CURRENT_SOURCE_DIR}/3rd-prebuilt/3rd-prebuilt/openvpn/android/${abi}/libck-ovpn-plugin.so
+#         ${CMAKE_CURRENT_SOURCE_DIR}/3rd-prebuilt/3rd-prebuilt/openvpn/android/${abi}/libck-ovpn-plugin.so
-        ${CMAKE_CURRENT_SOURCE_DIR}/3rd-prebuilt/3rd-prebuilt/openvpn/android/${abi}/libovpn3.so
+#         ${CMAKE_CURRENT_SOURCE_DIR}/3rd-prebuilt/3rd-prebuilt/openvpn/android/${abi}/libovpn3.so
-        ${CMAKE_CURRENT_SOURCE_DIR}/3rd-prebuilt/3rd-prebuilt/openvpn/android/${abi}/libovpnutil.so
+#         ${CMAKE_CURRENT_SOURCE_DIR}/3rd-prebuilt/3rd-prebuilt/openvpn/android/${abi}/libovpnutil.so
-        ${CMAKE_CURRENT_SOURCE_DIR}/3rd-prebuilt/3rd-prebuilt/openvpn/android/${abi}/librsapss.so
+#         ${CMAKE_CURRENT_SOURCE_DIR}/3rd-prebuilt/3rd-prebuilt/openvpn/android/${abi}/librsapss.so
-        ${CMAKE_CURRENT_SOURCE_DIR}/3rd-prebuilt/3rd-prebuilt/openssl/android/${abi}/libcrypto_3.so
+#         ${CMAKE_CURRENT_SOURCE_DIR}/3rd-prebuilt/3rd-prebuilt/openssl/android/${abi}/libcrypto_3.so
-        ${CMAKE_CURRENT_SOURCE_DIR}/3rd-prebuilt/3rd-prebuilt/openssl/android/${abi}/libssl_3.so
+#     )
-        ${CMAKE_CURRENT_SOURCE_DIR}/3rd-prebuilt/3rd-prebuilt/libssh/android/${abi}/libssh.so
+# endforeach()
-    )
-endforeach()
 
-file(COPY ${CMAKE_CURRENT_SOURCE_DIR}/3rd-prebuilt/3rd-prebuilt/xray/android/libxray.aar
+find_package(awg-android REQUIRED)
-        DESTINATION ${CMAKE_CURRENT_SOURCE_DIR}/android/xray/libXray)
+set(LIBS ${LIBS} amnezia::awg-android)
+
+# file(COPY ${CMAKE_CURRENT_SOURCE_DIR}/3rd-prebuilt/3rd-prebuilt/xray/android/libxray.aar
+#         DESTINATION ${CMAKE_CURRENT_SOURCE_DIR}/android/xray/libXray)
+
+find_package(amnezia-libxray REQUIRED)
+file(COPY ${AMNEZIA_LIBXRAY_PATH} DESTINATION ${CMAKE_CURRENT_SOURCE_DIR}/android/xray/libXray)

client/platforms/linux/daemon/wireguardutilslinux.cpp

@@ -80,7 +80,7 @@ bool WireguardUtilsLinux::addInterface(const InterfaceConfig& config) {
 
     QDir appPath(QCoreApplication::applicationDirPath());
     QStringList wgArgs = {"-f", "amn0"};
-    m_tunnel.start(appPath.filePath("../../client/bin/wireguard-go"), wgArgs);
+    m_tunnel.start(appPath.filePath("../../client/bin/amneziawg-go"), wgArgs);
     if (!m_tunnel.waitForStarted(WG_TUN_PROC_TIMEOUT)) {
         logger.error() << "Unable to start tunnel process due to timeout";
         m_tunnel.kill();

client/platforms/macos/daemon/wireguardutilsmacos.cpp

@@ -79,7 +79,7 @@ bool WireguardUtilsMacos::addInterface(const InterfaceConfig& config) {
 
   QDir appPath(QCoreApplication::applicationDirPath());
   QStringList wgArgs = {"-f", "utun"};
-  m_tunnel.start(appPath.filePath("wireguard-go"), wgArgs);
+  m_tunnel.start(appPath.filePath("amneziawg-go"), wgArgs);
   if (!m_tunnel.waitForStarted(WG_TUN_PROC_TIMEOUT)) {
     logger.error() << "Unable to start tunnel process due to timeout";
     m_tunnel.kill();

client/protocols/xrayprotocol.cpp

@@ -124,14 +124,14 @@ ErrorCode XrayProtocol::startTun2Socks()
     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]() {
+    connect(m_tun2socksProcess.data(), &IpcProcessInterfaceReplica::readyReadStandardError, this, [this]() {
-        auto readAllStandardOutput = m_tun2socksProcess->readAllStandardOutput();
+        auto readAllStandardError = m_tun2socksProcess->readAllStandardError();
-        if (!readAllStandardOutput.waitForFinished()) {
+        if (!readAllStandardError.waitForFinished()) {
             qWarning() << "Failed to read output from tun2socks";
             return;
         }
 
-        const QString line = readAllStandardOutput.returnValue();
+        const QString line = readAllStandardError.returnValue();
 
         if (!line.contains("[TCP]") && !line.contains("[UDP]"))
             qDebug() << "[tun2socks]:" << line;

conanfile.py

@@ -2,15 +2,31 @@ from conan import ConanFile
 
 class AmneziaVPN(ConanFile):
     settings = "os", "compiler", "build_type", "arch"
-    generators = "CMakeDeps"
+    generators = "CMakeConfigDeps"
 
     def requirements(self):
         os = str(self.settings.os)
         arch = str(self.settings.arch)
 
-        if os == "Windows" or os == "Linux" or (os == "Macos" and arch == "x86_64"):
+        has_service = os == "Windows" or os == "Linux" or (os == "Macos" and arch == "x86_64")
-            self.requires("amnezia-xray-bindings/1.1.0")
+        has_network_extension = os == "iOS" or (os == "Macos" and not has_service)
-            self.requires("awg-go/0.2.16")
 
-        if os == "iOS" or (os == "Macos" and arch == "arm64"):
+        if has_service:
+            if os == "Windows":
+                self.requires("awg-windows/1.0.0")
+            else:
+                self.requires("awg-go/0.2.16")
+
+            self.requires("amnezia-xray-bindings/1.1.0")
+            self.requires("tun2socks/2.6.0")
+            self.requires("openvpn/2.7.0")
+
+        if has_network_extension:
             self.requires("awg-apple/2.0.1")
+
+        if os == "Android":
+            self.requires("amnezia-libxray/1.0.0")
+            self.requires("awg-android/1.1.7")
+
+        self.requires("libssh-local/0.11.3")
+        self.requires("openssl/3.5.5")

recipes/amnezia-libxray/conanfile.py

@@ -0,0 +1,47 @@
+from conan import ConanFile
+from conan.tools.files import get, copy
+from conan.tools.layout import basic_layout
+from conan.errors import ConanInvalidConfiguration
+from conan.tools.env import VirtualBuildEnv
+
+import os
+import stat
+
+class AmneziaLibxray(ConanFile):
+    name = "amnezia-libxray"
+    version = "1.0.0"
+
+    settings = "os", "arch"
+
+    def layout(self):
+        basic_layout(self, build_folder=".")
+
+    def build_requirements(self):
+        self.tool_requires("go/1.26.0")
+    
+    def validate(self):
+        if self.settings.os != "Android":
+            raise ConanInvalidConfiguration(f"{self.name} v{self.version} does not support {self.settings.os}")
+
+    def source(self):
+        get(self, "https://github.com/amnezia-vpn/amnezia-libxray/archive/refs/tags/v1.0.0.zip",
+            sha256="0c50c5acd5063a9fc3cfbb5b3e11481d30cfa3762b3cb1d72130248ff498e9df", strip_root=True
+        )
+
+    def generate(self):
+        env = VirtualBuildEnv(self)
+
+    def _patch_sources(self):
+        build_path = os.path.join(self.build_folder, "build.sh")
+        build_stat = os.stat(build_path)
+        os.chmod(build_path, build_stat.st_mode | stat.S_IEXEC)
+
+    def build(self):
+        self._patch_sources()
+        self.run("./build.sh android")
+
+    def package(self):
+        copy(self, "libxray.aar", src=self.build_folder, dst=os.path.join(self.package_folder, "aar"))
+
+    def package_info(self):
+        self.env_info["AMNEZIA_LIBXRAY_PATH"] = os.path.join(self.package_folder, "aar", "libxray.aar")

recipes/amnezia-xray-bindings/conanfile.py

@@ -18,7 +18,6 @@ class AmneziaXrayBindings(ConanFile):
         "Macos": "macos",
         "Windows": "windows"
     }
-
     _arch_map = {
         "x86": "386",
         "x86_64": "amd64",
@@ -26,24 +25,26 @@ class AmneziaXrayBindings(ConanFile):
     }
 
     def validate(self):
-        os = str(self.settings.os)
+        self._goos = self._os_map.get(str(self.settings.os))
-        if os not in self._os_map:
+        if not self._goos:
             raise ConanInvalidConfiguration(
-                f"{self.name} v{self.version} does not support {os}"
+                f"{self.name} v{self.version} does not support {self._goos}"
             )
         
-        arch = str(self.settings.arch)
+        self._goarch = self._arch_map.get(str(self.settings.arch))
-        if arch not in self._arch_map:
+        if not self._goarch:
             raise ConanInvalidConfiguration(
-                f"{self.name} v{self.version} does not support {arch}"
+                f"{self.name} v{self.version} does not support {self._goarch}"
             )
 
     def layout(self):
-        basic_layout(self, build_folder=os.path.join(self.folders.source, "build"))
+        basic_layout(self, build_folder=".")
 
     def build_requirements(self):
         self.tool_requires("go/1.26.0")
-        if self.settings.os != "Windows":
+        if self.settings.os == "Windows":
+            self.tool_requires("mingw-builds/15.1.0")
+        else:
             self.build_requires("make/4.4.1")
 
     def source(self):
@@ -51,17 +52,9 @@ class AmneziaXrayBindings(ConanFile):
             sha256="6ea768ec7002cedd422a39aea17704b888acaf794432aa5937cfc92fb6d80eb5", strip_root=True)
 
     def build(self):
-        os = self._os_map.get(str(self.settings.os))
+        self.run(f"ARCH={self._goarch} OS={self._goos} make -C {self.source_folder}")
-        arch = self._arch_map.get(str(self.settings.arch))
-
-        self.run(f"ARCH={arch} OS={os} make -C {self.source_folder}")
-
-    def package(self):        
-        copy(self, "*.h", src=self.build_folder, dst=os.path.join(self.package_folder, "include"))
-        copy(self, "*.a", src=self.build_folder, dst=os.path.join(self.package_folder, "lib"))
-        copy(self, "*.dll", src=self.build_folder, dst=os.path.join(self.package_folder, "lib"))
-        copy(self, "*.lib", src=self.build_folder, dst=os.path.join(self.package_folder, "lib"))
 
+    def _rename_libs(self):
         # workaround of bad naming strategy in amnezia-xray-bindings
         # TODO: change it and kick out the code below
         lib_dir = os.path.join(self.package_folder, "lib")
@@ -71,6 +64,13 @@ class AmneziaXrayBindings(ConanFile):
                 dst = os.path.join(lib_dir, "lib" + fname)
                 os.rename(src, dst)
 
+    def package(self):
+        copy(self, "*.h", src=self.build_folder, dst=os.path.join(self.package_folder, "include"), keep_path=False)
+        copy(self, "*.a", src=self.build_folder, dst=os.path.join(self.package_folder, "lib"), keep_path=False)
+        copy(self, "*.dll", src=self.build_folder, dst=os.path.join(self.package_folder, "lib"), keep_path=False)
+        copy(self, "*.lib", src=self.build_folder, dst=os.path.join(self.package_folder, "lib"), keep_path=False)
+        self._rename_libs()
+
     def package_info(self):
         self.cpp_info.set_property("cmake_target_name", "amnezia::xray-bindings")
         self.cpp_info.libs = collect_libs(self)

recipes/awg-android/conanfile.py

@@ -0,0 +1,72 @@
+from conan import ConanFile
+from conan.tools.cmake import cmake_layout, CMake, CMakeToolchain
+from conan.tools.files import copy, collect_libs, replace_in_file
+from conan.errors import ConanInvalidConfiguration
+from conan.tools.scm import Git
+
+import os
+import platform
+
+class AwgAndroid(ConanFile):
+    name = "awg-android"
+    version = "1.1.7"
+    source_buildenv = True
+    settings = "os", "arch", "build_type", "compiler"
+
+    def layout(self):
+        cmake_layout(self)
+
+    def validate(self):
+        if self.settings.os != "Android":
+            raise ConanInvalidConfiguration(f"{self.name} v{self.version} does not support {self.settings.os}")
+
+    def source(self):
+        git = Git(self)
+        git.clone(
+            url="https://github.com/amnezia-vpn/amneziawg-android.git",
+            target=".",
+            args=["--recurse-submodules", "--branch", f"v{self.version}"]
+        )
+
+    def generate(self):
+        tc = CMakeToolchain(self)
+        tc.variables["GRADLE_USER_HOME"] = os.path.join(self.build_folder, "gradle_user_home")
+        tc.variables["CMAKE_LIBRARY_OUTPUT_DIRECTORY"] = os.path.join(self.build_folder, "out")
+        tc.generate()
+
+    def _patch_sources(self):
+        if platform.system() == 'Darwin':
+            replace_in_file(self,
+                os.path.join(self.source_folder, "tunnel", "tools", "libwg-go", "Makefile"),
+                'flock "$@.lock" -c \' \\\n',
+                "",
+            )
+            replace_in_file(self,
+                os.path.join(self.source_folder, "tunnel", "tools", "libwg-go", "Makefile"),
+                'mv "$@.tmp" "$@"\'',
+                'mv "$@.tmp" "$@"',
+            )
+            replace_in_file(self,
+                os.path.join(self.source_folder, "tunnel", "tools", "libwg-go", "Makefile"),
+                'touch "$@"\'',
+                'touch "$@"',
+            )
+            replace_in_file(self,
+                os.path.join(self.source_folder, "tunnel", "tools", "libwg-go", "Makefile"),
+                'sha256sum -c',
+                'shasum -a 256 -c'
+            )
+
+    def build(self):
+        self._patch_sources()
+        cmake = CMake(self)
+        cmake.configure(build_script_folder=os.path.join(self.source_folder, "tunnel", "tools"))
+        cmake.build(target=["libwg-go.so", "libwg.so", "libwg-quick.so"])
+
+    def package(self):
+        copy(self, "libwg-go.h", src=os.path.join(self.build_folder, "out"), dst=os.path.join(self.package_folder, "include"))
+        copy(self, "libwg*.so", src=os.path.join(self.build_folder, "out"), dst=os.path.join(self.package_folder, "lib"))
+
+    def package_info(self):
+        self.cpp_info.set_property("cmake_target_name", "amnezia::awg-android")
+        self.cpp_info.libs = collect_libs(self)

recipes/awg-apple/conanfile.py

@@ -23,20 +23,22 @@ class AwgApple(ConanFile):
 
     def build_requirements(self):
         self.tool_requires("go/1.26.0")
-        if self.settings.os != "Windows":
+        if self.settings.os == "Windows":
+            self.tool_requires("mingw-builds/15.1.0")
+        else:
             self.build_requires("make/4.4.1")
 
-    def validate(self):
+    def configure(self):
-        os = str(self.settings.os)
+        self._goos = self._os_map.get(str(self.settings.os))
-        if os not in self._os_map:
+        if not self._goos:
             raise ConanInvalidConfiguration(
-                f"{self.name} v{self.version} does not support {os}"
+                f"{self.name} v{self.version} does not support {self._goos}"
             )
         
-        arch = str(self.settings.arch)
+        self._goarch = self._arch_map.get(str(self.settings.arch))
-        if arch not in self._arch_map:
+        if not self._goarch:
             raise ConanInvalidConfiguration(
-                f"{self.name} v{self.version} does not support {arch}"
+                f"{self.name} v{self.version} does not support {self._goarch}"
             )
 
     def layout(self):
@@ -48,10 +50,7 @@ class AwgApple(ConanFile):
         )
 
     def build(self):
-        os = self._os_map.get(str(self.settings.os))
+        self.run(f"ARCHS={self._goarch} PLATFORM_NAME={self._goos} make")
-        arch = self._arch_map.get(str(self.settings.arch))
-
-        self.run(f"ARCHS={arch} PLATFORM_NAME={os} make")
 
     def package(self):
         copy(self, "wireguard.h", src=self.build_folder, dst=os.path.join(self.package_folder, "include"))

recipes/awg-go/conanfile.py

@@ -8,6 +8,7 @@ import os
 class AwgGo(ConanFile):
     name = "awg-go"
     version = "0.2.16"
+    package_type = "application"
 
     settings = "os", "arch"
 
@@ -16,26 +17,32 @@ class AwgGo(ConanFile):
         "Macos": "darwin",
         "Windows": "windows"
     }
-
     _arch_map = {
         "x86": "386",
         "x86_64": "amd64",
         "armv8": "arm64",
     }
 
+    def build_requirements(self):
+        self.tool_requires("go/1.26.0")
+        if self.settings.os == "Windows":
+            self.tool_requires("mingw-builds/15.1.0")
+        else:
+            self.build_requires("make/4.4.1")
+
     def validate(self):
         os = str(self.settings.os)
         if os not in self._os_map:
             raise ConanInvalidConfiguration(
                 f"{self.name} v{self.version} does not support {os}"
             )
-        
+
         arch = str(self.settings.arch)
         if arch not in self._arch_map:
             raise ConanInvalidConfiguration(
                 f"{self.name} v{self.version} does not support {arch}"
             )
-        
+
     def source(self):
         get(self, f"https://github.com/amnezia-vpn/amneziawg-go/archive/refs/tags/v{self.version}.zip",
             sha256="34da7d4189f215f3930de441548bc2a0c89d54d347a4fb85cb9c715fce6413aa", strip_root=True
@@ -49,9 +56,12 @@ class AwgGo(ConanFile):
         arch = self._arch_map[str(self.settings.arch)]
 
         self.run(f"GOOS={os} GOARCH={arch} make")
-    
+
     def package(self):
-        copy(self, "amneziawg-go", src=self.build_folder, dst=os.path.join(self.package_folder, "bin"))
+        copy(self, "amneziawg-go", src=self.build_folder, dst=self.package_folder)
 
     def package_info(self):
+        self.cpp_info.exe = True
+        self.cpp_info.location = os.path.join(self.package_folder, "amneziawg-go")
+
         self.cpp_info.set_property("cmake_target_name", "amnezia::awg-go")

recipes/domain-list-community/conanfile.py

@@ -0,0 +1,5 @@
+from conan import ConanFile
+
+class PackageConan(ConanFile):
+    name = "domain-list-community"
+    version = "20260227093604"

recipes/go/conanfile.py

@@ -1,6 +1,5 @@
 from conan import ConanFile
 from conan.tools.files import get, copy
-from conan.tools.cmake import cmake_layout
 
 import os
 
@@ -9,10 +8,6 @@ class Golang(ConanFile):
     version = "1.26.0"
     
     settings = "os", "arch"
-
-    def build_requirements(self):
-        if self.settings.os == "Windows":
-            self.tool_requires("mingw-builds/15.1.0")
     
     def build(self):
         get(self, **self.conan_data["sources"][str(self.version)][str(self.settings.os)][str(self.settings.arch)])

recipes/hev-socks5-tunnel/conanfile.py

@@ -0,0 +1,5 @@
+from conan import ConanFile
+
+class HevSocks5Tunnel(ConanFile):
+    name = "hev-socks5-tunnel"
+    version = "1.0.0"

recipes/libssh-local/conanfile.py

@@ -0,0 +1,132 @@
+from conan import ConanFile
+from conan.errors import ConanInvalidConfiguration
+from conan.tools.cmake import CMakeToolchain, CMake, cmake_layout, CMakeDeps
+from conan.tools.files import copy, get, rmdir
+from conan.tools.microsoft import is_msvc_static_runtime, is_msvc
+from conan.tools.scm import Version
+import os
+
+
+required_conan_version = ">=2.21"
+
+
+class LibsshLocal(ConanFile):
+    name = "libssh-local"
+    version = "0.11.3"
+    license = "LGPL-2.1"
+    homepage = "https://www.libssh.org/"
+    description = "multiplatform C library implementing the SSHv2 protocol on client and server side"
+    topics = ("ssh", "shell", "ssh2", "connection")
+    package_type = "library"
+    settings = "os", "compiler", "build_type", "arch"
+    options = {
+        "shared": [True, False],
+        "fPIC": [True, False],
+        "with_zlib": [True, False],
+        "crypto_backend": ["openssl", "gcrypt", "mbedtls"],
+        "with_symbol_versioning": [True, False],
+    }
+    default_options = {
+        "shared": False,
+        "fPIC": True,
+        "with_zlib": True,
+        "crypto_backend": "openssl",
+        "with_symbol_versioning": True,
+    }
+
+    def config_options(self):
+        if self.settings.os == "Windows":
+            del self.options.fPIC
+            del self.options.with_symbol_versioning
+
+    def configure(self):
+        if self.options.shared:
+            self.options.rm_safe("fPIC")
+        self.settings.rm_safe("compiler.libcxx")
+        self.settings.rm_safe("compiler.cppstd")
+
+    def layout(self):
+        cmake_layout(self, src_folder="src")
+
+    def requirements(self):
+        if self.options.with_zlib:
+            self.requires("zlib/[>=1.2.11 <2]")
+        if self.options.crypto_backend =="openssl":
+            self.requires("openssl/[>=1.1 <4]")
+        elif self.options.crypto_backend == "gcrypt":
+            self.requires("libgcrypt/[>=1.8.4 <2]")
+        elif self.options.crypto_backend == "mbedtls":
+            self.requires("mbedtls/3.6.0")
+
+    def validate(self):
+        if self.options.crypto_backend == "mbedtls" and not self.dependencies["mbedtls"].options.enable_threading:
+            raise ConanInvalidConfiguration(f"{self.ref} requires '-o mbedtls/*:enable_threading=True' when using '-o libssh/*:crypto_backend=mbedtls'")
+
+    def source(self):
+        get(self, "https://www.libssh.org/files/0.11/libssh-0.11.3.tar.xz",
+            sha256="7d8a1361bb094ec3f511964e78a5a4dba689b5986e112afabe4f4d0d6c6125c3", strip_root=True
+        )
+
+    def generate(self):
+        tc = CMakeToolchain(self)
+        tc.cache_variables["CLIENT_TESTING"] = False
+        tc.cache_variables["SERVER_TESTING"] = False
+        tc.cache_variables["WITH_EXAMPLES"] = False
+        tc.cache_variables["WITH_GCRYPT"] = self.options.crypto_backend == "gcrypt"
+        tc.cache_variables["WITH_GSSAPI"] = False
+        tc.cache_variables["WITH_MBEDTLS"] = self.options.crypto_backend == "mbedtls"
+        tc.cache_variables["WITH_NACL"] = False
+        tc.cache_variables["WITH_SYMBOL_VERSIONING"] = self.options.get_safe("with_symbol_versioning", True)
+        tc.variables["WITH_ZLIB"] = self.options.with_zlib
+        if is_msvc(self):
+            tc.cache_variables["USE_MSVC_RUNTIME_LIBRARY_DLL"] = not is_msvc_static_runtime(self)
+        tc.cache_variables["CMAKE_POLICY_DEFAULT_CMP0077"] = "NEW"
+        tc.cache_variables["CMAKE_TRY_COMPILE_CONFIGURATION"] = str(self.settings.build_type)
+        if self.settings.os == "Android":
+            if Version(self.settings.get_safe("os.api_level")) < 24:
+                tc.cache_variables["HAVE_IFADDRS_H"] = False
+            tc.preprocessor_definitions["S_IWRITE"] = "S_IRUSR"
+            tc.preprocessor_definitions["S_IWRITE"] = "S_IWUSR"
+            tc.preprocessor_definitions["S_IEXEC"] = "S_IXUSR"
+        tc.generate()
+
+        deps = CMakeDeps(self)
+        deps.set_property("libgcrypt", "cmake_file_name", "GCrypt")
+        deps.set_property("libgcrypt", "cmake_additional_variables_prefixes", ["GCRYPT"])
+        deps.set_property("libgcrypt", "cmake_extra_variables", {"GCRYPT_FOUND": "TRUE"})
+        deps.set_property("mbedtls", "cmake_additional_variables_prefixes", ["MBEDTLS"])
+        deps.set_property("mbedtls", "cmake_extra_variables", {"MBEDTLS_FOUND": "TRUE"})
+        deps.generate()
+
+    def build(self):
+        cmake = CMake(self)
+        cmake.configure()
+        cmake.build()
+
+    def package(self):
+        copy(self, pattern="COPYING", dst=os.path.join(self.package_folder, "licenses"), src=self.source_folder)
+        cmake = CMake(self)
+        cmake.install()
+        rmdir(self, os.path.join(self.package_folder, "lib", "cmake"))
+        rmdir(self, os.path.join(self.package_folder, "lib", "pkgconfig"))
+
+    def package_info(self):
+        self.cpp_info.libs = ["ssh"]
+        if not self.options.shared:
+            self.cpp_info.defines.append("LIBSSH_STATIC=ON")
+        if self.settings.os == "Windows":
+            self.cpp_info.system_libs.extend(["ws2_32", "iphlpapi"])
+
+        self.cpp_info.set_property("cmake_file_name", "libssh")
+        # target and alias names defined at:
+        # ssh         https://git.libssh.org/projects/libssh.git/tree/src/CMakeLists.txt?h=libssh-0.10.6#n351
+        # ssh::ssh    https://git.libssh.org/projects/libssh.git/tree/src/CMakeLists.txt?h=libssh-0.10.6#n371
+        # ssh-static  https://git.libssh.org/projects/libssh.git/tree/src/CMakeLists.txt?h=libssh-0.10.6#n413
+        # ssh::static https://git.libssh.org/projects/libssh.git/tree/src/CMakeLists.txt?h=libssh-0.10.6#n428
+        self.cpp_info.set_property("cmake_target_name", "ssh::ssh")
+        self.cpp_info.set_property(
+            "cmake_target_aliases",
+            ["ssh"] if self.options.shared else ["ssh", "ssh-static", "ssh::static"],
+        )
+        # pkg-config defined at https://git.libssh.org/projects/libssh.git/tree/CMakeLists.txt?h=libssh-0.10.6#n124
+        self.cpp_info.set_property("pkg_config_name", "libssh")

recipes/openvpn/conanfile.py

@@ -0,0 +1,49 @@
+from conan import ConanFile
+from conan.tools.files import get, copy
+from conan.tools.gnu import Autotools, AutotoolsToolchain, AutotoolsDeps
+from conan.tools.layout import basic_layout
+
+import os
+
+class Openvpn(ConanFile):
+    name = "openvpn"
+    version = "2.7.0"
+    package_type = "application"
+
+    settings = "os", "build_type", "arch"
+
+    def layout(self):
+        basic_layout(self)
+
+    def build_requirements(self):
+        self.tool_requires("libtool/2.4.7")
+        self.tool_requires("automake/1.16.5")
+
+    def requirements(self):
+        self.requires("openssl/[>=1.1.0]", visible=False)
+        self.requires("lz4/[>=1.7.1]", visible=False)
+        self.requires("lzo/2.10", visible=False)
+
+    def source(self):
+        get(self, f"https://github.com/OpenVPN/openvpn/archive/refs/tags/v{self.version}.zip",
+            sha256="1a65d8587f932c13d55b1f175ff2e1d61d795d9092788662e888054854d4ee3d", strip_root=True
+        )
+
+    def generate(self):
+        tc = AutotoolsToolchain(self)
+        tc.generate()
+        deps = AutotoolsDeps(self)
+        deps.generate()
+
+    def build(self):
+        at = Autotools(self)
+        at.autoreconf()
+        at.configure()
+        at.make()
+
+    def package(self):
+        copy(self, "openvpn", src=os.path.join(self.build_folder, "src", "openvpn"), dst=self.package_folder)
+
+    def package_info(self):
+        self.cpp_info.exe = True
+        self.cpp_info.location = os.path.join(self.package_folder, "openvpn")

recipes/tun2socks/conanfile.py

@@ -0,0 +1,74 @@
+from conan import ConanFile
+from conan.tools.layout import basic_layout
+from conan.tools.files import get, copy
+from conan.errors import ConanInvalidConfiguration
+
+import os
+
+class Tun2Socks(ConanFile):
+    name = "tun2socks"
+    version = "2.6.0"
+
+    settings = "os", "arch"
+
+    _os_map = {
+        "Linux": "linux",
+        "Macos": "darwin",
+        "Windows": "windows"
+    }
+    _arch_map = {
+        "x86": "386",
+        "x86_64": "amd64",
+        "armv8": "arm64",
+    }
+
+    def build_requirements(self):
+        self.tool_requires("go/1.26.0")
+        if self.settings.os == "Windows":
+            self.tool_requires("mingw-builds/15.1.0")
+        else:
+            self.build_requires("make/4.4.1")
+
+    def source(self):
+        #TODO: get tunnel.dll for windows
+        get(self, f"https://github.com/xjasonlyu/tun2socks/archive/refs/tags/v{self.version}.zip",
+            sha256="a7ef9cec1c30dfe9971af89a8aac767fd3d2a4df833e92b635642c2f0204c701", strip_root=True
+        )
+        
+
+    def configure(self):
+        self._goos = self._os_map.get(str(self.settings.os))
+        if not self._goos:
+            raise ConanInvalidConfiguration(
+                f"{self.name} v{self.version} does not support {self._goos}"
+            )
+
+        self._goarch = self._arch_map.get(str(self.settings.arch))
+        if not self._goarch:
+            raise ConanInvalidConfiguration(
+                f"{self.name} v{self.version} does not support {self._goarch}"
+            )
+        
+        self._ext = ".exe" if self.settings.os == "Windows" else ""
+
+    def layout(self):
+        basic_layout(self, build_folder=".")
+
+    def build(self):
+        self.run(f"make {self._goos}-{self._goarch}")
+
+    def package(self):
+        src_name = f"tun2socks-{self._goos}-{self._goarch}{self._ext}"
+        dst_name = f"tun2socks{self._ext}"
+
+        copy(self, src_name, src=os.path.join(self.build_folder, "build"), dst=self.package_folder)
+        os.rename(
+            os.path.join(self.package_folder, src_name),
+            os.path.join(self.package_folder, dst_name)
+        )
+
+    def package_info(self):
+        self.cpp_info.exe = True
+        self.cpp_info.location = os.path.join(self.package_folder, f"tun2socks{self._ext}")
+
+        self.cpp_info.set_property("cmake_target_name", "xjasonlyu::tun2socks")

recipes/wintun/conanfile.py

@@ -0,0 +1,5 @@
+from conan import ConanFile
+
+class PackageConan(ConanFile):
+    name = "wintun"
+    version = "1.0.0"

service/server/CMakeLists.txt

@@ -9,45 +9,11 @@ set(CMAKE_CXX_STANDARD_REQUIRED ON)
 find_package(Qt6 REQUIRED COMPONENTS DBus Core Network Widgets RemoteObjects Core5Compat Concurrent)
 qt_standard_project_setup()
 
-find_package(amnezia-xray-bindings REQUIRED)
-
 configure_file(${CMAKE_SOURCE_DIR}/version.h.in ${CMAKE_CURRENT_BINARY_DIR}/version.h)
 
 set(QSIMPLECRYPTO_DIR ${CMAKE_CURRENT_LIST_DIR}/../../client/3rd/QSimpleCrypto/src)
 
-
-set(OPENSSL_ROOT_DIR "${CMAKE_CURRENT_LIST_DIR}/../../client/3rd-prebuilt/3rd-prebuilt/openssl/")
-set(OPENSSL_LIBRARIES_DIR "${OPENSSL_ROOT_DIR}/lib")
-
-set(OPENSSL_INCLUDE_DIR "${OPENSSL_ROOT_DIR}/windows/include")
-if("${CMAKE_SIZEOF_VOID_P}" STREQUAL "8")
-    set(OPENSSL_LIB_SSL_PATH "${OPENSSL_ROOT_DIR}/windows/win64/libssl.lib")
-    set(OPENSSL_LIB_CRYPTO_PATH "${OPENSSL_ROOT_DIR}/windows/win64/libcrypto.lib")
-else()
-    set(OPENSSL_LIB_SSL_PATH "${OPENSSL_ROOT_DIR}/windows/win32/libssl.lib")
-    set(OPENSSL_LIB_CRYPTO_PATH "${OPENSSL_ROOT_DIR}/windows/win32/libcrypto.lib")
-endif()
-
-
-if(WIN32)
-    set(OPENSSL_INCLUDE_DIR "${OPENSSL_ROOT_DIR}/windows/include")
-    if("${CMAKE_SIZEOF_VOID_P}" STREQUAL "8")
-        set(OPENSSL_LIB_CRYPTO_PATH "${OPENSSL_ROOT_DIR}/windows/win64/libcrypto.lib")
-    else()
-        set(OPENSSL_LIB_CRYPTO_PATH "${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_CRYPTO_PATH "${OPENSSL_ROOT_DIR}/macos/lib/libcrypto.a")
-elseif(LINUX)
-    set(OPENSSL_INCLUDE_DIR "${OPENSSL_ROOT_DIR}/linux/include")
-    set(OPENSSL_LIB_CRYPTO_PATH "${OPENSSL_ROOT_DIR}/linux/x86_64/libcrypto.a")
-endif()
-
-set(OPENSSL_USE_STATIC_LIBS TRUE)
-
 include_directories(
-    ${OPENSSL_INCLUDE_DIR}
     ${QSIMPLECRYPTO_DIR}
 )
 
@@ -223,7 +189,6 @@ if(WIN32)
         gdi32
         Advapi32
         Kernel32
-        ${OPENSSL_LIB_CRYPTO_PATH}
         qt6keychain
     )
 
@@ -272,7 +237,6 @@ if(APPLE)
 
     set(LIBS
         resolv
-        ${OPENSSL_LIB_CRYPTO_PATH}
         qt6keychain
     )
 
@@ -332,9 +296,14 @@ include_directories(
 
 add_executable(${PROJECT} ${SOURCES} ${HEADERS} ${RESOURCES})
 target_link_libraries(${PROJECT} PRIVATE Qt6::Core Qt6::Widgets Qt6::Network Qt6::RemoteObjects Qt6::Core5Compat Qt6::DBus Qt6::Concurrent ${LIBS})
-target_link_libraries(${PROJECT} PRIVATE amnezia::xray-bindings)
 target_compile_definitions(${PROJECT} PRIVATE "MZ_$<UPPER_CASE:${MZ_PLATFORM_NAME}>")
 
+find_package(amnezia-xray-bindings REQUIRED)
+target_link_libraries(${PROJECT} PRIVATE amnezia::xray-bindings)
+
+find_package(openssl REQUIRED)
+target_link_libraries(${PROJECT} PRIVATE OpenSSL::SSL OpenSSL::Crypto)
+
 if(CMAKE_BUILD_TYPE STREQUAL "Debug")
     target_compile_definitions(${PROJECT} PRIVATE "MZ_DEBUG")
 endif()
@@ -389,10 +358,33 @@ add_custom_command(
     $<TARGET_FILE_DIR:${PROJECT}>
     COMMAND_EXPAND_LISTS
 )
-add_custom_command(
+# add_custom_command(
-    TARGET ${PROJECT} POST_BUILD
+#     TARGET ${PROJECT} POST_BUILD
-    COMMAND ${CMAKE_COMMAND} -E $<IF:$<CONFIG:Debug>,copy_directory,true>
+#     COMMAND ${CMAKE_COMMAND} -E $<IF:$<CONFIG:Debug>,copy_directory,true>
-    ${CMAKE_SOURCE_DIR}/client/3rd-prebuilt/deploy-prebuilt/${DEPLOY_PLATFORM_PATH}
+#     ${CMAKE_SOURCE_DIR}/client/3rd-prebuilt/deploy-prebuilt/${DEPLOY_PLATFORM_PATH}
-    $<TARGET_FILE_DIR:${PROJECT}>
+#     $<TARGET_FILE_DIR:${PROJECT}>
-    COMMAND_EXPAND_LISTS
+#     COMMAND_EXPAND_LISTS
+# )
+
+if(NOT WIN32)
+    find_package(awg-go REQUIRED)
+    add_custom_command(TARGET ${PROJECT} POST_BUILD
+        COMMAND ${CMAKE_COMMAND} -E copy_if_different
+            $<TARGET_FILE:amnezia::awg-go>
+            $<TARGET_FILE_DIR:${PROJECT}>
+    )
+endif()
+
+find_package(openvpn REQUIRED)
+add_custom_command(TARGET ${PROJECT} POST_BUILD
+    COMMAND ${CMAKE_COMMAND} -E copy_if_different
+        $<TARGET_FILE:openvpn::openvpn>
+        $<TARGET_FILE_DIR:${PROJECT}>
+)
+
+find_package(tun2socks REQUIRED)
+add_custom_command(TARGET ${PROJECT} POST_BUILD
+    COMMAND ${CMAKE_COMMAND} -E copy_if_different
+        $<TARGET_FILE:xjasonlyu::tun2socks>
+        $<TARGET_FILE_DIR:${PROJECT}>
 )