v2.11.7

Author: bernerdad

README.md

@@ -164,7 +164,7 @@ The repository contains Dockerfile to simplify building process. Skip all the ot
 ```
 - Install vcpkg:
 ```bash
-  sudo docker run --rm -v .:/w ws-builder /bin/bash -c "git clone https://github.com/Microsoft/vcpkg.git && git checkout 576379156e82da642f8d1834220876759f13534d && ./vcpkg/bootstrap-vcpkg.sh --disableMetrics"
+  sudo docker run --rm -v .:/w ws-builder /bin/bash -c "git clone https://github.com/Microsoft/vcpkg.git && cd vcpkg && git checkout 576379156e82da642f8d1834220876759f13534d && ./bootstrap-vcpkg.sh --disableMetrics"
 ```
 - Build all the dependencies:
 ```bash

backend/windows/windscribe_service/ipc/serialize_structs.h

@@ -212,5 +212,12 @@ void serialize(Archive & ar, CMD_CREATE_OPENVPN_ADAPTER & g, const unsigned int
     ar & g.useDCODriver;
 }
 
+template<class Archive>
+void serialize(Archive & ar, CMD_SSID_FROM_INTERFACE_GUID & g, const unsigned int version)
+{
+    UNREFERENCED_PARAMETER(version);
+    ar & g.interfaceGUID;
+}
+
 } // namespace serialization
 } // namespace boost

backend/windows/windscribe_service/ipc/servicecommunication.h

@@ -56,6 +56,7 @@
 #define AA_COMMAND_DISABLE_DOH_SETTINGS                     53
 #define AA_COMMAND_ENABLE_DOH_SETTINGS                      54
 #define AA_COMMAND_CONFIGURE_WIREGUARD                      55
+#define AA_COMMAND_SSID_FROM_INTERFACE_GUID                 56
 
 #include <string>
 #include <vector>
@@ -242,6 +243,11 @@ struct CMD_CREATE_OPENVPN_ADAPTER
     bool useDCODriver;
 };
 
+struct CMD_SSID_FROM_INTERFACE_GUID
+{
+    std::wstring interfaceGUID;
+};
+
 struct MessagePacketResult
 {
     __int64 id;

backend/windows/windscribe_service/process_command.cpp

@@ -838,7 +838,6 @@ MessagePacketResult disableDohSettings(boost::archive::text_iarchive &ia)
     return mpr;
 }
 
-
 MessagePacketResult enableDohSettings(boost::archive::text_iarchive &ia)
 {
     MessagePacketResult mpr;
@@ -874,3 +873,21 @@ MessagePacketResult enableDohSettings(boost::archive::text_iarchive &ia)
     Logger::instance().out(L"AA_COMMAND_ENABLE_DOH_SETTINGS");
     return mpr;
 }
+
+MessagePacketResult ssidFromInterfaceGUID(boost::archive::text_iarchive &ia)
+{
+    CMD_SSID_FROM_INTERFACE_GUID cmd;
+    ia >> cmd;
+
+    MessagePacketResult mpr;
+    try {
+        mpr.additionalString = Utils::ssidFromInterfaceGUID(cmd.interfaceGUID);
+        mpr.success = true;
+    }
+    catch (std::system_error &ex) {
+        mpr.exitCode = ex.code().value();
+        Logger::instance().out("ssidFromInterfaceGUID - %s", ex.what());
+    }
+
+    return mpr;
+}

backend/windows/windscribe_service/process_command.h

@@ -81,6 +81,7 @@ MessagePacketResult createOpenVPNAdapter(boost::archive::text_iarchive &ia);
 MessagePacketResult removeOpenVPNAdapter(boost::archive::text_iarchive &ia);
 MessagePacketResult disableDohSettings(boost::archive::text_iarchive &ia);
 MessagePacketResult enableDohSettings(boost::archive::text_iarchive &ia);
+MessagePacketResult ssidFromInterfaceGUID(boost::archive::text_iarchive &ia);
 
 static const std::map<const int, std::function<MessagePacketResult(boost::archive::text_iarchive &)>> kCommands = {
     { AA_COMMAND_FIREWALL_ON, firewallOn },
@@ -135,7 +136,8 @@ static const std::map<const int, std::function<MessagePacketResult(boost::archiv
     { AA_COMMAND_CREATE_OPENVPN_ADAPTER, createOpenVPNAdapter },
     { AA_COMMAND_REMOVE_OPENVPN_ADAPTER, removeOpenVPNAdapter },
     { AA_COMMAND_DISABLE_DOH_SETTINGS, disableDohSettings },
-    { AA_COMMAND_ENABLE_DOH_SETTINGS, enableDohSettings }
+    { AA_COMMAND_ENABLE_DOH_SETTINGS, enableDohSettings },
+    { AA_COMMAND_SSID_FROM_INTERFACE_GUID, ssidFromInterfaceGUID }
 };
 
 MessagePacketResult processCommand(int cmdId, const std::string &packet);

backend/windows/windscribe_service/utils.cpp

@@ -8,12 +8,14 @@
 #include <shlobj.h>
 #include <versionhelpers.h>
 #include <WbemIdl.h>
+#include <wlanapi.h>
 
 #include <cwctype>
 
 #include "logger.h"
 #include "utils/executable_signature/executable_signature.h"
 #include "utils/win32handle.h"
+#include "utils/wsscopeguard.h"
 
 #pragma comment(lib, "wbemuuid.lib")
 
@@ -567,4 +569,85 @@ bool isMacAddress(const std::wstring &value)
     return valid;
 }
 
+std::string ssidFromInterfaceGUID(const std::wstring &interfaceGUID)
+{
+    // This DLL is not available on default installs of Windows Server.  Dynamically load it so
+    // the app doesn't fail to launch with a "DLL not found" error.  App profiling was performed
+    // and indicated no performance degradation when dynamically loading and unloading the DLL.
+    const std::wstring dll = getSystemDir() + L"\\wlanapi.dll";
+    auto wlanDll = ::LoadLibraryEx(dll.c_str(), NULL, LOAD_LIBRARY_SEARCH_SYSTEM32);
+    if (wlanDll == NULL) {
+        throw std::system_error(::GetLastError(), std::generic_category(), "wlanapi.dll could not be loaded");
+    }
+
+    auto freeDLL = wsl::wsScopeGuard([&] {
+        ::FreeLibrary(wlanDll);
+    });
+
+    typedef DWORD (WINAPI * WlanOpenHandleFunc)(DWORD dwClientVersion, PVOID pReserved, PDWORD pdwNegotiatedVersion, PHANDLE phClientHandle);
+    typedef DWORD (WINAPI * WlanCloseHandleFunc)(HANDLE hClientHandle, PVOID pReserved);
+    typedef VOID  (WINAPI * WlanFreeMemoryFunc)(PVOID pMemory);
+    typedef DWORD (WINAPI * WlanQueryInterfaceFunc)(HANDLE hClientHandle, CONST GUID *pInterfaceGuid, WLAN_INTF_OPCODE OpCode, PVOID pReserved,
+                                                   PDWORD pdwDataSize, PVOID *ppData, PWLAN_OPCODE_VALUE_TYPE pWlanOpcodeValueType);
+
+    WlanOpenHandleFunc pfnWlanOpenHandle = (WlanOpenHandleFunc)::GetProcAddress(wlanDll, "WlanOpenHandle");
+    if (pfnWlanOpenHandle == NULL) {
+        throw std::system_error(::GetLastError(), std::generic_category(), "Failed to load WlanOpenHandle");
+    }
+
+    WlanCloseHandleFunc pfnWlanCloseHandle = (WlanCloseHandleFunc)::GetProcAddress(wlanDll, "WlanCloseHandle");
+    if (pfnWlanCloseHandle == NULL) {
+        throw std::system_error(::GetLastError(), std::generic_category(), "Failed to load WlanCloseHandle");
+    }
+
+    WlanFreeMemoryFunc pfnWlanFreeMemory = (WlanFreeMemoryFunc)::GetProcAddress(wlanDll, "WlanFreeMemory");
+    if (pfnWlanFreeMemory == NULL) {
+        throw std::system_error(::GetLastError(), std::generic_category(), "Failed to load WlanFreeMemory");
+    }
+
+    WlanQueryInterfaceFunc pfnWlanQueryInterface = (WlanQueryInterfaceFunc)::GetProcAddress(wlanDll, "WlanQueryInterface");
+    if (pfnWlanQueryInterface == NULL) {
+        throw std::system_error(::GetLastError(), std::generic_category(), "Failed to load WlanQueryInterface");
+    }
+
+    DWORD dwCurVersion = 0;
+    HANDLE hClient = NULL;
+    auto result = pfnWlanOpenHandle(2, NULL, &dwCurVersion, &hClient);
+    if (result != ERROR_SUCCESS) {
+        throw std::system_error(::GetLastError(), std::generic_category(), "WlanOpenHandle failed");
+    }
+
+    PWLAN_CONNECTION_ATTRIBUTES pConnectInfo = NULL;
+
+    auto freeWlanResources = wsl::wsScopeGuard([&] {
+        if (pConnectInfo != NULL) {
+            pfnWlanFreeMemory(pConnectInfo);
+        }
+
+        pfnWlanCloseHandle(hClient, NULL);
+    });
+
+    GUID actualGUID = guidFromString(interfaceGUID);
+
+    DWORD connectInfoSize = sizeof(WLAN_CONNECTION_ATTRIBUTES);
+    WLAN_OPCODE_VALUE_TYPE opCode = wlan_opcode_value_type_invalid;
+
+    result = pfnWlanQueryInterface(hClient, &actualGUID, wlan_intf_opcode_current_connection, NULL,
+                                   &connectInfoSize, (PVOID *) &pConnectInfo, &opCode);
+    if (result != ERROR_SUCCESS) {
+        throw std::system_error(::GetLastError(), std::generic_category(), "WlanQueryInterface failed");
+    }
+
+    std::string ssid;
+    const auto &dot11Ssid = pConnectInfo->wlanAssociationAttributes.dot11Ssid;
+    if (dot11Ssid.uSSIDLength > 0) {
+        ssid.reserve(dot11Ssid.uSSIDLength);
+        for (ULONG k = 0; k < dot11Ssid.uSSIDLength; k++) {
+            ssid.push_back(static_cast<char>(dot11Ssid.ucSSID[k]));
+        }
+    }
+
+    return ssid;
+}
+
 }

backend/windows/windscribe_service/utils.h

@@ -42,4 +42,6 @@ namespace Utils
     bool addFilterV6(HANDLE engineHandle, std::vector<UINT64> *filterId, FWP_ACTION_TYPE type, UINT8 weight,
                      GUID subLayerKey, wchar_t *subLayerName, PNET_LUID pluid = nullptr,
                      const std::vector<Ip6AddressAndPrefix> *range = nullptr, bool persistent = true);
+
+    std::string ssidFromInterfaceGUID(const std::wstring &interfaceGUID);
 };

backend/windows/wireguard_service/ServiceMain.cpp

@@ -3,7 +3,6 @@
 #include <tlhelp32.h>
 
 #include <chrono>
-#include <codecvt>
 #include <filesystem>
 #include <fstream>
 #include <iomanip>
@@ -278,12 +277,6 @@ int wmain(int argc, wchar_t *argv[])
     //    hMonitorThread.wait(5000);
     //}
 
-    // Delete the config file.
-    dwAttrib = ::GetFileAttributes(configFile.c_str());
-    if (dwAttrib != INVALID_FILE_ATTRIBUTES) {
-        ::DeleteFile(configFile.c_str());
-    }
-
     debugOut("Windscribe WireGuard service stopped");
 
     ::FreeLibrary(hTunnelDLL);

client/base/backend/backend.cpp

@@ -712,23 +712,25 @@ void Backend::abortInitialization()
 void Backend::handleNetworkChange(types::NetworkInterface networkInterface, bool manual)
 {
     bool newNetwork = true;
-
-    // find or assign friendly name before checking is network is the same as current network
-    QString friendlyName = networkInterface.networkOrSsid;
-
     QVector<types::NetworkInterface> networkListOld = PersistentState::instance().networkWhitelist();
-    for (int i = 0; i < networkListOld.size(); i++) {
-        if (networkListOld[i].networkOrSsid== networkInterface.networkOrSsid) {
-            friendlyName = networkListOld[i].friendlyName;
-            newNetwork = false;
-            break;
-        }
-    }
 
-    if (friendlyName == "") {
+    QString friendlyName;
+    if (!networkInterface.networkOrSsid.isEmpty()) {
+        // find or assign friendly name before checking is network is the same as current network
         friendlyName = networkInterface.networkOrSsid;
+        for (int i = 0; i < networkListOld.size(); i++) {
+            if (networkListOld[i].networkOrSsid== networkInterface.networkOrSsid) {
+                friendlyName = networkListOld[i].friendlyName;
+                newNetwork = false;
+                break;
+            }
+        }
+
+        if (friendlyName == "") {
+            friendlyName = networkInterface.networkOrSsid;
+        }
+        networkInterface.friendlyName = friendlyName;
     }
-    networkInterface.friendlyName = friendlyName;
 
     if (networkInterface.networkOrSsid != "") { // not a disconnect
         // Add a new network as secured

client/base/backend/preferences/preferences.cpp

@@ -257,6 +257,11 @@ const types::ConnectionSettings Preferences::networkPreferredProtocol(QString ne
     return engineSettings_.networkPreferredProtocols()[networkOrSsid];
 }
 
+const QMap<QString, types::ConnectionSettings> Preferences::networkPreferredProtocols() const
+{
+    return engineSettings_.networkPreferredProtocols();
+}
+
 bool Preferences::hasNetworkPreferredProtocol(QString networkOrSsid) const
 {
     return engineSettings_.networkPreferredProtocols().contains(networkOrSsid) &&
@@ -273,6 +278,7 @@ void Preferences::setNetworkPreferredProtocols(const QMap<QString, types::Connec
     }
 }
 
+
 void Preferences::setNetworkPreferredProtocol(QString networkOrSsid, const types::ConnectionSettings &settings)
 {
     QMap<QString, types::ConnectionSettings> map = engineSettings_.networkPreferredProtocols();