Fix: No permission to share/transfer a client host issue

Add a per-client TLS transport toggle controlled from the server, using the
presence of the client's trust-anchor certificate in the registry as the
single source of truth (no separate tls_enable flag).

- Client reports its TLS status via a new RES_TLS token (cert present -> 1)
  appended to LOGIN_INFOR's reserved field.
- Server online list gains a "TLS" column after the permission column.
- The "experimental features" right-click menu gains "TLS传输" / "取消TLS"
  with confirmation and a guard that prompts (instead of sending) when the
  server has no TLS certificate ready.
- New COMMAND_TLS_ENABLE / COMMAND_TLS_DISABLE (166/167): the server pushes
  its cert PEM into the client registry settings\tls_cert (enable) or deletes
  it (disable). The client picks this up on next startup via the existing
  ReadTrustAnchor logic, so the switch is non-live by design.
- Icons and en_US/zh_TW/de_DE translations for the new menu items.

Co-Authored-By: deepseek-v4-pro

client/ClientDll.cpp

@@ -610,7 +610,7 @@ DWORD WINAPI StartClient(LPVOID lParam)
     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);
+            auto a = NewClientStartArg(addr.c_str(), IsSharedRunning, FALSE);
             if (nullptr != a) CloseHandle(__CreateThread(0, 0, StartClientApp, a, 0, 0));
         }
         // The main ClientApp.

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;

client/LoginServer.cpp

@@ -412,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 + 归一化路径
+        // V2 ID 算法：MachineGuid + 主机名 + 归一化路径
-        //   - 同机同程序路径永远同 ID（不依赖 IP/PCName/OS/CPU 漂移）
+        //   - 主机名兜底区分同镜像克隆机：MachineGuid 相同、路径相同仍能靠主机名区分。
-        //   - 局域网多机即便同镜像（sysprep 会让 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 });
@@ -444,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/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>

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,
 };
 

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	},
+    {"IP",				120	},
-    {"端口",			60	},
+    {"端口",			55	},
     {"地理位置",		140	},
     {"计算机名/备注",	140	},
-    {"操作系统",		120	},
+    {"操作系统",		135	},
-    {"CPU",				80	},
+    {"CPU",				75},
-    {"摄像头",			60	},
+    {"摄像头",			55	},
-    {"RTT",				60	},
+    {"RTT",				55	},
     {"版本",			90	},
     {"安装时间",        130 },
-    {"活动窗口",		130 },
+    {"活动窗口",		145 },
     {"类型",			50 },
     {"",                0   },
     {"",                0   },
     {"",                0   },
     {"",                0   },
     {"权限",			60	},
+    {"TLS",             50  },
 };
 
 // 缩略图列号常量 + 列号→数据槽映射。负返回值代表"该列无数据槽"。
@@ -737,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;
@@ -1059,12 +1064,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)
@@ -1323,6 +1331,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 同时存在于子菜单与顶层时，
@@ -1661,10 +1680,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 重算更稳定）。
@@ -1735,6 +1755,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);
                 // 网络抖动导致客户端用新连接重复上线：这里不立即替换/关闭旧连接，
                 // 否则旧连接被关会触发客户端反复重连抖动（更新前就一直在"替换旧连接"）。
@@ -4517,6 +4553,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("发送授权"));
 
@@ -4689,6 +4727,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,
@@ -11556,6 +11641,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()

server/2015Remote/2015RemoteDlg.h

@@ -441,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;
@@ -531,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();
@@ -696,6 +698,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/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/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)) {
+    TlsHandshakeParam* p = (TlsHandshakeParam*)lParam;
-        // 先减少引用计数，再调用 RemoveStaleContext (#215)
+    IOCPServer* This = p->server;
-        // RemoveStaleContext 完成后对象会被移到空闲池，不能再访问
+    CONTEXT_OBJECT* ctx = p->ctx;
-        ContextObject->IoRefCount.fetch_sub(1);
+    std::vector<BYTE> initial = std::move(p->initial);
-        RemoveStaleContext(ContextObject);
+    delete p;
-        return -2;  // 特殊返回值：告诉 HandleIO 不要再减少引用计数
+
+    // 若上下文已被移除（服务端关停竞态），直接释放引用退出。
+    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);
+        // 单向 TLS：只加密新追加的明文尾部，产出密文后与前缀旧密文拼接，使缓冲区始终保持
-        BOOL bOk = PostQueuedCompletionStatus(m_hCompletionPort, 0, (ULONG_PTR)ContextObject, &OverlappedPlus->m_ol);
+        // 一串合法 TLS 记录；之后 IOWrite / OnClientPostSending 完全不变（见设计文档 §5.5）。
-        if ( (!bOk && GetLastError() != ERROR_IO_PENDING) ) { //如果投递失败
+        if (tlsReady) {
-            int a = GetLastError();
+            ULONG totalLen = ContextObject->OutCompressedBuffer.GetBufferLength();
-            Mprintf("!!! OnClientPreSending 投递消息失败\n");
+            ULONG plainLen = totalLen - oldLen;
-            RemoveStaleContext(ContextObject);
+            if (plainLen > 0) {
-            SAFE_DELETE(OverlappedPlus);
+                std::vector<BYTE> wire;
-            return FALSE;
+                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/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/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/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/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/lang/de_DE.ini

@@ -2069,3 +2069,21 @@ JPEG
 %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 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

server/2015Remote/lang/en_US.ini

@@ -2084,3 +2084,21 @@ 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

server/2015Remote/lang/zh_TW.ini

@@ -2075,3 +2075,21 @@ 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 憑證失敗，無法下發

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
@@ -1011,6 +1013,7 @@
 #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 +1021,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
@@ -1114,8 +1119,8 @@
 //
 #ifdef APSTUDIO_INVOKED
 #ifndef APSTUDIO_READONLY_SYMBOLS
-#define _APS_NEXT_RESOURCE_VALUE        410
+#define _APS_NEXT_RESOURCE_VALUE        412
-#define _APS_NEXT_COMMAND_VALUE         33093
+#define _APS_NEXT_COMMAND_VALUE         33096
 #define _APS_NEXT_CONTROL_VALUE         2620
 #define _APS_NEXT_SYMED_VALUE           105
 #endif

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/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,12 +29,13 @@ import (
 
 // MyHandler implements the server.Handler interface
 type MyHandler struct {
-	log        *logger.Logger
+	log         *logger.Logger
-	auth       *auth.Authenticator
+	auth        *auth.Authenticator
-	srv        *server.Server
+	srv         *server.Server
-	hub        *hub.Hub
+	hub         *hub.Hub
-	signer     licensing.Signer // CMD_MASTERSETTING signer (local / remote / noop)
+	signer      licensing.Signer    // CMD_MASTERSETTING signer (local / remote / noop)
-	loginLimit *wsauth.RateLimiter // per-IP TOKEN_AUTH throttle
+	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
@@ -154,12 +158,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
+// When the operator supplied YAMA_CONN_AUTH_KEY, the packet's HMAC-SHA256
-// treats verification failures as soft (logs and still allows commands),
+// signature and timestamp are verified first (see verifyConnAuth); a bad
-// and the signing primitive lives in a vendored component out of scope
+// packet is answered with a non-OK status and the sub-conn is dropped.
-// for this server, so we always reply OK and let TOKEN_BITMAPINFO carry
+// Without a key we keep the legacy behavior: always reply OK and let
-// the device ID via offset 41 when the screen sub-conn proceeds.
+// 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
@@ -188,6 +205,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
@@ -920,6 +992,31 @@ func main() {
 		}
 	}()
 
+	// 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 {
@@ -928,18 +1025,21 @@ func main() {
 		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)),
+			log:         log.WithPrefix(fmt.Sprintf("Handler:%d", port)),
-			auth:       authenticator,
+			auth:        authenticator,
-			srv:        srv,
+			srv:         srv,
-			hub:        deviceHub,
+			hub:         deviceHub,
-			signer:     signer,
+			signer:      signer,
-			loginLimit: authLoginLimit,
+			loginLimit:  authLoginLimit,
+			connAuthKey: connAuthKey,
 		}
 		srv.SetHandler(handler)
 
@@ -983,6 +1083,14 @@ 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
@@ -1002,6 +1110,7 @@ func main() {
 		LoginUserLimit:    wsauth.NewRateLimiter(5, 15*time.Minute),
 		TrustForwardedFor: trustProxy,
 		BasePath:          basePath,
+		BrandName:         brandName,
 		SSO:               ssoDetector,
 	}
 

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/protocol/commands.go

@@ -140,11 +140,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.
+	// ConnAuthTimestampToleranceSec bounds |server - client| clock skew in
-	ConnAuthStatusOK byte = 0
+	// 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"
@@ -40,6 +41,13 @@ type Config struct {
 	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
@@ -75,6 +83,10 @@ type Server struct {
 	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
 	ctx     context.Context
@@ -234,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 {
@@ -360,7 +378,10 @@ func (s *Server) acceptLoop() {
 }
 
 // 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)
 

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.Info("wrapTLS: TLS peer %s first6=%x", conn.RemoteAddr(), hdr)
+		return tls.Server(bc, s.tlsCfg)
+	}
+	s.logger.Info("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,12 +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"
@@ -33,6 +36,7 @@ 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
@@ -64,6 +68,11 @@ 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.
@@ -85,6 +94,7 @@ 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
 }
@@ -182,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
@@ -210,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)
@@ -273,15 +292,36 @@ func (s *Server) manifestJSON() []byte {
 	if s.basePath != "" {
 		start = s.basePath + "/"
 	}
-	return []byte(fmt.Sprintf(`{
+	name := s.displayName()
-  "name": "SimpleRemoter",
+	shortName := "Remoter"
-  "short_name": "Remoter",
+	if s.isWhiteLabel() {
-  "start_url": "%s",
+		shortName = name
-  "display": "standalone",
+	}
-  "orientation": "any",
+	// Marshal via encoding/json so an operator-supplied brand name containing
-  "background_color": "#1a1a2e",
+	// quotes or backslashes can't produce invalid JSON.
-  "theme_color": "#1a1a2e"
+	manifest := struct {
-}`, start))
+		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) {
@@ -290,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/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>