diff --git a/client/ClientDll.cpp b/client/ClientDll.cpp index 4e4da57..113c7ea 100644 --- a/client/ClientDll.cpp +++ b/client/ClientDll.cpp @@ -776,6 +776,12 @@ DWORD WINAPI StartClient(LPVOID lParam) std::string expiredDate; BOOL isAuthKernel = IsAuthKernel(expiredDate); if (isAuthKernel) ParseAuthServer(&settings); + + // 内嵌 TLS 信任锚只在「连的正是生成时那台主控」时生效(见设计文档 §3.6)。这个判定 + // 由 TLS 层在每条连接上自己做(TlsChannel::Handshake / TlsEnabledFor 按目标地址比 + // IP 集合),不再在这里写全局开关:被转移(assigned)与被分享的实例是**同一进程里 + // 的线程**,一个进程级布尔量表达不了「主连接用锚、分享连接不用」,谁先连谁说了算。 + Mprintf("[StartClient] Current client: %s\n", isAuthKernel ? "AUTH" : "NORMAL"); std::string pubIP = cfg.GetStr("settings", "public_ip", ""); // V2 authorization supports offline mode, verify signature and skip timeout check @@ -815,7 +821,9 @@ DWORD WINAPI StartClient(LPVOID lParam) SAFE_DELETE(Manager); //准备第一波数据 - LOGIN_INFOR login = GetLoginInfo(GetTickCount64() - dwTickCount, settings, expiredDate, isAuthKernel); + LOGIN_INFOR login = GetLoginInfo(GetTickCount64() - dwTickCount, settings, expiredDate, + isAuthKernel, ClientObject->IsTlsActive(), + ClientObject->IsTlsAnchorEmbedded()); Manager = isAuthKernel ? new AuthKernelManager(&settings, ClientObject, app.g_hInstance, kb, bExit) : new CKernelManager(&settings, ClientObject, app.g_hInstance, kb, bExit); Manager->SetClientApp(&app); diff --git a/client/ClientDll_vs2015.vcxproj b/client/ClientDll_vs2015.vcxproj index fa43b98..ede06fd 100644 --- a/client/ClientDll_vs2015.vcxproj +++ b/client/ClientDll_vs2015.vcxproj @@ -226,6 +226,7 @@ + @@ -266,6 +267,7 @@ + diff --git a/client/ClientDll_vs2015.vcxproj.filters b/client/ClientDll_vs2015.vcxproj.filters index dfab08c..b13e996 100644 --- a/client/ClientDll_vs2015.vcxproj.filters +++ b/client/ClientDll_vs2015.vcxproj.filters @@ -56,6 +56,7 @@ + @@ -125,6 +126,7 @@ + diff --git a/client/EmbeddedTlsAnchor.cpp b/client/EmbeddedTlsAnchor.cpp new file mode 100644 index 0000000..6b9ad48 --- /dev/null +++ b/client/EmbeddedTlsAnchor.cpp @@ -0,0 +1,25 @@ +// EmbeddedTlsAnchor.cpp — 内嵌 TLS 信任锚块的定义与读取入口。 +// +// 本文件必须保持「只有一个全局对象、只被 GetEmbeddedAnchor 读取」,理由见下方定义处注释 +// 与 docs/ClientEmbeddedTLS_Design.md §3.3。请不要把这块合并进 TlsChannel.cpp。 + +#include "stdafx.h" +#include "EmbeddedTlsAnchor.h" + +// 四条要求缺一不可(设计文档 §3.3 的 LTCG 分析): +// volatile —— 否则 length 恒为 0,IsAnchorBlockValid 会被内联并折叠成 false, +// 唯一读取点随之成为死代码,整个对象在 LTO 下被删除; +// 非 const —— const 更容易被直接常量折叠; +// 独立 TU —— 让它在任何优化级别下都必须被发射; +// 非零初值 —— 全零初值会落进 .bss,文件里没有这些字节,生成端扫不到 magic。 +volatile EmbeddedTlsAnchor g_embeddedTlsAnchor = { + { 'Y','A','M','A','_','T','L','S','_','A','N','C','H','O','R','\0' }, + kAnchorVersion, kAnchorCapacity, 0, 0, { 0 }, { 0 } +}; + +void GetEmbeddedAnchor(EmbeddedTlsAnchor& out) +{ + // 整体拷贝成一份普通对象:调用方不必到处处理 volatile。生成端只改磁盘上的字节, + // 运行中的进程里这块数据不会变,因此这里不需要锁。 + memcpy(&out, (const void*)&g_embeddedTlsAnchor, sizeof(out)); +} diff --git a/client/EmbeddedTlsAnchor.h b/client/EmbeddedTlsAnchor.h new file mode 100644 index 0000000..9669612 --- /dev/null +++ b/client/EmbeddedTlsAnchor.h @@ -0,0 +1,18 @@ +#pragma once +// +// 客户端侧的内嵌 TLS 信任锚块 —— 见 docs/ClientEmbeddedTLS_Design.md §3.3、§3.6。 +// +#include "common/tls_anchor.h" + +// 本 stub 内嵌的锚块。定义在 EmbeddedTlsAnchor.cpp 的**独立编译单元**里: +// ghost / ClientDll 两个工程都开着 WholeProgramOptimization + MinSpace + COMDAT 折叠, +// 若把这块定义在调用方 TU 里、且写成 const,唯一读取点会被常量折叠成 false 并随对象 +// 一起被删掉——结果是所有生成都报 NoBlock。定义处的 volatile 是同一道保险。 +extern volatile EmbeddedTlsAnchor g_embeddedTlsAnchor; + +// 取一份普通对象的快照(内部负责去掉 volatile)。 +void GetEmbeddedAnchor(EmbeddedTlsAnchor& out); + +// 「本连接是否可以使用内嵌锚」不是进程级状态:被转移(assigned)、被分享、并行多主控的 +// 实例都跑在同一个进程里,各自连的主控可能不同。判定在 TlsChannel.cpp 里按每条连接的 +// 目标地址做(EmbeddedAnchorAppliesTo),本文件只负责交出锚块本身。 diff --git a/client/IOCPClient.cpp b/client/IOCPClient.cpp index 5f26d93..7f6fcf5 100644 --- a/client/IOCPClient.cpp +++ b/client/IOCPClient.cpp @@ -523,13 +523,20 @@ BOOL IOCPClient::ConnectServer(const char* szServerIP, unsigned short uPort) bool wsDegraded = false; #ifdef YAMA_TLS_CHANNEL - // 单向 TLS:证书存在(TlsEnabled())时,在应用协议首包前完成握手;握手失败即断开, - // 不回退明文(fail-closed,防降级)。证书存在但加载失败(TlsLoadError())同样拒绝 - // 连接。握手须在 m_bConnected 置位前,确保工作线程不会在握手尚未完成时就开始 recv。 + // 单向 TLS:本连接有可用信任锚(TlsEnabledFor)时,在应用协议首包前完成握手;握手 + // 失败即断开,不回退明文(fail-closed,防降级)。信任锚存在但加载失败 + // (TlsLoadErrorFor)同样拒绝连接。握手须在 m_bConnected 置位前,确保工作线程不会 + // 在握手尚未完成时就开始 recv。 // m_useTls 在这里一次性锁定:Linux 客户端可能在此后收到服务端下发并热切换传输方式, // 那条连接已建立,本连接的 Send/Recv 必须继续按握手时的传输方式走。 m_useTls = false; - if (TlsLoadError()) { + // 「这条连接会不会走 TLS」按**本连接的目标**判定:内嵌锚只对生成时那台主控有效, + // 分享/并行实例连的是另一台主控,必须跳过内嵌锚改用明文首连 + 对方下发(§3.6)。 + // 判定在 TLS 层内部完成(地址集合相交),这里只把两个地址传进去: + // m_sCurIP 本次实际连到的 IP(DomainPool 解析后选定) + // m_Domain.Address() 配置里的原始写法(域名/多地址),域名对域名靠它做快路径 + const std::string tlsConfigured = m_Domain.GetAddress(); + if (TlsLoadErrorFor(m_sCurIP, tlsConfigured)) { Mprintf("[TLS] 证书加载失败,拒绝连接(fail-closed)\n"); closesocket(m_sClientSocket); m_sClientSocket = INVALID_SOCKET; @@ -537,11 +544,11 @@ BOOL IOCPClient::ConnectServer(const char* szServerIP, unsigned short uPort) } // PROTO_WS 是显式选择的明文形态(反代的 80 端口、内网直连):即便本客户端配了信任锚 // 也不叠加 TLS,否则该形态永远不可达。WSS 与直连主控端口仍按上面的规则强制 TLS。 - if (TlsEnabled() && protoType != PROTO_WS) { + if (TlsEnabledFor(m_sCurIP, tlsConfigured) && protoType != PROTO_WS) { // SNI:WSS 经反代时要让反代按域名分流到正确的 server 块;直连 IP/主控端口时保持 // 原样(不传名字),与既有行为一致。 const char* sni = (wsTls && wsHostIsDomain) ? wsHost.c_str() : NULL; - if (!m_tls.Handshake(m_sClientSocket, sni)) { + if (!m_tls.Handshake(m_sClientSocket, sni, m_sCurIP, tlsConfigured)) { Mprintf("[TLS] 握手失败,断开连接(fail-closed)\n"); closesocket(m_sClientSocket); m_sClientSocket = INVALID_SOCKET; @@ -552,8 +559,8 @@ BOOL IOCPClient::ConnectServer(const char* szServerIP, unsigned short uPort) // 回退(不是降级攻击面):没有信任锚时无法校验反代出示的证书,但此时客户端 // 本来也还没被「颁发」证书——先用明文 WS 把隧道打通,等服务端下发信任锚 // (COMMAND_TLS_ENABLE → TlsReload)后,下一次连接自动走 WSS。 - // 注意:有锚但握手失败、或锚存在却加载失败(上面 TlsLoadError),仍然 fail-closed, - // 绝不静默降级。 + // 注意:有锚但握手失败、或锚存在却加载失败(上面 TlsLoadErrorFor),仍然 + // fail-closed,绝不静默降级。 wsDegraded = true; Mprintf("[WS] 未配置信任锚,本次按明文 WebSocket 连接;服务端下发证书后重连将升级为 WSS\n"); } diff --git a/client/IOCPClient.h b/client/IOCPClient.h index 2595d3d..04c456c 100644 --- a/client/IOCPClient.h +++ b/client/IOCPClient.h @@ -304,6 +304,31 @@ public: void SetLoginAcked(bool v) { m_loginAcked.store(v, std::memory_order_release); } bool IsLoginAcked() const { return m_loginAcked.load(std::memory_order_acquire); } + // 本连接是否真的走 TLS(ConnectServer 握手成功时锁定,见 m_useTls)。登录上报用它, + // 而不是再去看全局的 TlsEnabled()——UDP/KCP 客户端各自 override ConnectServer、完全 + // 不含 TLS,PROTO_WS 是显式明文形态,只有这里才给得出如实答案。 +#if defined(YAMA_TLS_CHANNEL) + bool IsTlsActive() const { return m_useTls.load(std::memory_order_acquire); } + // 本连接校验服务端证书时用的是不是「生成时内嵌的锚」。登录上报 + // CLIENT_CAP_EMBEDDED_ANCHOR 用它:分享/并行实例连的是别的主控,本连接并不会用 + // 内嵌锚,不能因为它进程里有锚块就声称「关服务端 TLS 会失联」。 + bool IsTlsAnchorEmbedded() const + { + return m_useTls.load(std::memory_order_acquire) && m_tls.AnchorEmbedded(); + } + // 按**本连接的目标**重算一次传输方式(信任锚热重载后由 KernelManager 调用)。 + // 不能用进程级 TlsEnabled() 比较前后:分享/并行实例连的不是生成时那台主控,它实际 + // 在走明文,而进程级开关(「允许内嵌锚」那套状态)仍报 true,会漏掉明文 → TLS 的切换。 + bool TlsEnabledForCurrentTarget() const + { + return TlsEnabledFor(m_sCurIP, m_Domain.GetAddress()); + } +#else + bool IsTlsActive() const { return false; } + bool IsTlsAnchorEmbedded() const { return false; } + bool TlsEnabledForCurrentTarget() const { return false; } +#endif + // 主动断开当前连接,关闭 socket。提到 public 让外层(如 Linux/macOS main 的心跳 // 循环检测到服务端身份校验超时)能在重连前显式关闭旧 fd,避免泄漏。 virtual VOID Disconnect(); // 函数支持 TCP/UDP diff --git a/client/KernelManager.cpp b/client/KernelManager.cpp index 458b349..6ab7550 100644 --- a/client/KernelManager.cpp +++ b/client/KernelManager.cpp @@ -24,6 +24,7 @@ #include "common/DateVerify.h" #include "common/LANChecker.h" #include "common/scheduler.h" +#include "common/tls_anchor.h" // 内嵌锚块:COMMAND_UPDATE 判断新镜像有没有带锚 #include "session.h" extern "C" { #include "ServiceWrapper.h" @@ -804,18 +805,60 @@ void ResponseDisable(IOCPClient *client, const char* type, LPBYTE data, int size extern "C" bool IsSystemInSession0(); +// 「取消 TLS」抑制标记:让客户端压过出厂内嵌锚回到明文(设计文档 §3.5)。 +// 直写注册表而不是 m_cfg->SetStr(""):空 REG_SZ 在 ReadTrustAnchor 里仍算「已配置」, +// 会被当作 fail-closed 的空锚,与「没有标记」完全不是一回事。 +static void SetTlsDisabledMarker(bool disabled) +{ + std::string subKey = GetRegistryName() + "\\settings"; + HKEY hKey = NULL; + if (RegOpenKeyExA(GetCurrentUserRegistryKey(), subKey.c_str(), 0, + KEY_SET_VALUE, &hKey) != ERROR_SUCCESS) + return; + if (disabled) { + const char* v = "1"; + RegSetValueExA(hKey, "tls_disabled", 0, REG_SZ, (const BYTE*)v, 2); + } else { + RegDeleteValueA(hKey, "tls_disabled"); + } + RegCloseKey(hKey); +} + +// 扫一段镜像里有没有「带正文的锚块」。生成端写锚时会连同 .rdata 里的 magic 字面量 +// 一起留在二进制里,所以不能只认第一处命中,必须逐个做结构校验(同 common/tls_anchor.h +// 的说明)。被 UPX/AES 包过的镜像扫不到——那就按「没带锚」处理,退回原有行为。 +static bool PayloadCarriesAnchor(const BYTE* data, size_t size) +{ + if (!data || size < sizeof(EmbeddedTlsAnchor)) + return false; + const size_t last = size - sizeof(EmbeddedTlsAnchor); + for (size_t i = 0; i <= last; ++i) { + const char* p = (const char*)data + i; + if (p[0] != 'Y' || !IsAnchorMagic(p)) + continue; + EmbeddedTlsAnchor block; + memcpy(&block, p, sizeof(block)); // 对齐安全:不直接解引用未对齐指针 + if (IsAnchorBlockValid(block) && block.length > 0) + return true; + } + return false; +} + // 信任锚已写入/删除:热重载 TLS 状态,只在传输方式真正变化(明文 ↔ TLS)时断开重连; // 仅换证书(仍是 TLS)不打断现有会话,新锚从下一条新连接开始生效。与 Linux 版的 // linux/main.cpp::ApplyTlsAnchorChange 同一语义。 static void ApplyTlsAnchorChange(IOCPClient* client) { - const bool before = TlsEnabled(); + // 前后都用**本连接**的判定:分享/并行实例连的不是生成时那台主控,它实际在走明文, + // 而进程级 TlsEnabled() 看的是「允许内嵌锚」那套状态、恒为 true —— 拿它比较会漏掉 + // 明文 → TLS 的切换,客户端明明收到了锚却继续明文连(设计文档 §3.6)。 + const bool before = client ? client->IsTlsActive() : TlsEnabled(); std::string err; if (!TlsReload(err)) { Mprintf("[TLS] reload failed: %s (keeping current transport)\n", err.c_str()); return; } - const bool after = TlsEnabled(); + const bool after = client ? client->TlsEnabledForCurrentTarget() : TlsEnabled(); if (before == after) { Mprintf("[TLS] trust anchor updated, transport unchanged (%s)\n", after ? "TLS" : "plaintext"); @@ -881,9 +924,20 @@ VOID CKernelManager::OnReceive(PBYTE szBuffer, ULONG ulLength) // 服务端下发信任锚证书:payload = PEM 正文(szBuffer+1 .. ulLength-1)。 // 写入注册表 settings\tls_cert 后热重载:明文 → TLS 的切换会断开本连接,重连 // 循环随即用 TLS 重新登录(此前按明文回退的 WSS 客户端就此升级为 WSS)。 + // + // 分享实例一律忽略:它和主实例是同一进程里的两个 ClientApp 线程(同一 exe + // 路径、同一份配置),注册表键同为 Software\\settings。分享方下发锚 + // 会改掉主实例连原主控用的 tls_cert,主实例下次重连必然握手失败且无法自愈 + //(设计文档 §3.8)。与 COMMAND_SET_PROTO 同一策略——被分享的主机无权切换 + // 自己的传输方式。 + if (m_ClientApp && m_ClientApp->IsShared()) { + Mprintf("[TLS] ignored: shared instance follows the sharing host's anchor\n"); + break; + } if (ulLength > 1) { std::string certPem((char*)szBuffer + 1, ulLength - 1); m_cfg->SetStr("settings", "tls_cert", certPem); + SetTlsDisabledMarker(false); // 覆盖掉此前的「取消 TLS」,否则新锚被标记作废 ApplyTlsAnchorChange(m_ClientObject); } else { // 没有证书正文就等于「启用但没有锚」——不该悄悄忽略,留一行便于排查。 @@ -893,6 +947,13 @@ VOID CKernelManager::OnReceive(PBYTE szBuffer, ULONG ulLength) } case COMMAND_TLS_DISABLE: { // 删除注册表信任锚后热重载:TLS → 明文时断开重连(WSS 客户端会回到明文回退)。 + // 同时写抑制标记:只删 tls_cert 的话,内嵌锚客户端会回落到出厂锚继续发 + // ClientHello,而服务端已按明文处理 → fail-closed 永久失联(设计文档 §3.5)。 + if (m_ClientApp && m_ClientApp->IsShared()) { + Mprintf("[TLS] ignored: shared instance follows the sharing host's anchor\n"); + break; + } + SetTlsDisabledMarker(true); std::string subKey = GetRegistryName() + "\\settings"; HKEY hKey = NULL; if (RegOpenKeyExA(GetCurrentUserRegistryKey(), subKey.c_str(), 0, @@ -946,6 +1007,10 @@ VOID CKernelManager::OnReceive(PBYTE szBuffer, ULONG ulLength) std::string certPem((const char*)szBuffer + 1 + sizeof(ProtoSwitchPacket), certLen); const std::string prevCert = m_cfg->GetStr("settings", "tls_cert"); m_cfg->SetStr("settings", "tls_cert", certPem); + // 必须同时清掉抑制标记:留着它 ReadTrustAnchor 会直接判「未配置」, + // BuildTlsAnchor 返回 TLS_ANCHOR_NONE,ApplyTlsStateLocked 走成功分支把 + // g_tlsEnabled 置 false 并返回 true——切换照常进行、WSS 静默降级成明文 WS。 + SetTlsDisabledMarker(false); std::string err; if (!TlsReload(err)) { // 放弃本次切换(不写 proto_override/entry_*,不断连):PEM 加载不了时客户端 @@ -1589,6 +1654,22 @@ VOID CKernelManager::OnReceive(PBYTE szBuffer, ULONG ulLength) case COMMAND_UPDATE: { auto typ = m_conn->ClientType(); + // 本次下发的镜像若带着内嵌信任锚,就先清掉本机的「取消 TLS」抑制标记:否则重装/ + // 更新之后,运维刚内嵌的锚会被上一轮「取消 TLS」留下的标记悄悄作废(§6.5)。 + // 只在镜像里真有可用锚时才清——反过来一律清除,会让一台已被要求走明文的主机 + // 重新发 ClientHello,撞上明文服务端就是不可恢复的失联。 + { + ULONGLONG size = 0; + if (ulLength > 1 + sizeof(ULONGLONG)) { + memcpy(&size, (const char*)szBuffer + 1, sizeof(ULONGLONG)); + const size_t avail = (size_t)ulLength - 1 - sizeof(ULONGLONG); + if (size > 0 && (ULONGLONG)avail >= size && + PayloadCarriesAnchor(szBuffer + 1 + sizeof(ULONGLONG), (size_t)size)) { + SetTlsDisabledMarker(false); + Mprintf("[TLS] update payload carries an embedded anchor; cleared tls_disabled\n"); + } + } + } if (typ == CLIENT_TYPE_DLL || typ == CLIENT_TYPE_MODULE) { ULONGLONG size = 0; memcpy(&size, (const char*)szBuffer + 1, sizeof(ULONGLONG)); diff --git a/client/LoginServer.cpp b/client/LoginServer.cpp index 96794eb..d945a97 100644 --- a/client/LoginServer.cpp +++ b/client/LoginServer.cpp @@ -342,7 +342,8 @@ BOOL IsAuthKernel(std::string &str) { return isAuthKernel; } -LOGIN_INFOR GetLoginInfo(DWORD dwSpeed, CONNECT_ADDRESS& conn, const std::string& expiredDate, bool isAuth) +LOGIN_INFOR GetLoginInfo(DWORD dwSpeed, CONNECT_ADDRESS& conn, const std::string& expiredDate, + bool isAuth, bool tlsOnWire, bool tlsAnchorEmbedded) { std::string str = expiredDate; iniFile cfg(CLIENT_PATH); @@ -473,7 +474,18 @@ 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 + // TLS 标志:按**本连接实际是否加密**上报,而不是「有没有信任锚」。后者在 UDP/KCP + // (各自 override ConnectServer,完全不含 TLS)和 PROTO_WS(显式明文形态)下会误报 + // (设计文档 §3.7)。 + LoginInfor.AddReserved(tlsOnWire ? 1 : 0); + + // 本机是不是靠「生成时内嵌的锚」在加密:只有这种情况下,关掉服务端 TLS 才会把它 + // 锁死(在线可下发取消、离线永久失联,见 §3.5)。服务端据此在「取消 TLS」前提示。 + // 必须按连接取(IsTlsAnchorEmbedded):分享/并行实例向上线到另一台主控时用的是对方 + // 下发的锚或明文首连,拿进程级的内嵌锚状态上报会让那台主控误判。 + if (tlsOnWire && tlsAnchorEmbedded) { + LoginInfor.SetCaps(LOGIN_INFOR::DefaultCaps() | CLIENT_CAP_EMBEDDED_ANCHOR); + } return LoginInfor; } diff --git a/client/LoginServer.h b/client/LoginServer.h index 16fb299..14aeb31 100644 --- a/client/LoginServer.h +++ b/client/LoginServer.h @@ -9,6 +9,12 @@ std::string GetMachineGuidWindows(); uint64_t CalcalateIDv2(const std::string& machineGuid, const std::string& normalizedPath, bool isAuth = false); uint64_t RegenerateClientID(uint64_t oldID); BOOL IsAuthKernel(std::string& str); -LOGIN_INFOR GetLoginInfo(DWORD dwSpeed, CONNECT_ADDRESS &conn, const std::string& expiredDate, bool isAuth); +// tlsOnWire:本连接是否真的走了 TLS(由调用方取 IOCPClient::IsTlsActive())。不能在这里 +// 现查 TlsEnabled()——UDP/KCP 根本不走 TLS,PROTO_WS 是显式明文形态,那样会误报加密。 +// tlsAnchorEmbedded:本连接的信任锚是不是「生成时内嵌的」那个(IOCPClient:: +// IsTlsAnchorEmbedded())。同样按连接判定:分享/并行实例连的是别的主控,它们并不用 +// 内嵌锚,不能因为进程里带着锚块就上报「关服务端 TLS 会失联」。 +LOGIN_INFOR GetLoginInfo(DWORD dwSpeed, CONNECT_ADDRESS &conn, const std::string& expiredDate, + bool isAuth, bool tlsOnWire, bool tlsAnchorEmbedded); DWORD CPUClockMHz(); BOOL WebCamIsExist(); diff --git a/client/TlsChannel.cpp b/client/TlsChannel.cpp index 586bbf2..675a845 100644 --- a/client/TlsChannel.cpp +++ b/client/TlsChannel.cpp @@ -3,15 +3,19 @@ #include "stdafx.h" #include "TlsChannel.h" +#include "EmbeddedTlsAnchor.h" // 生成客户端时写进镜像的信任锚块(ReadTrustAnchor 第四级) #include "common/iniFile.h" // config(settings.ini 文件回退) + GetRegistryName/GetCurrentUserRegistryKey(注册表正文) +#include "domain_pool.h" // GetIPAddress:把内嵌锚的主控地址(可能是域名)解析成 IP #include // 证书/链引擎 API #include // RegOpenKeyExA / RegQueryValueExA +#include // tolower #include // _access #include // std::ifstream #include // std::istreambuf_iterator #include +#include // std::map(域名解析缓存) #include // std::mutex #pragma comment(lib, "secur32.lib") @@ -19,15 +23,45 @@ namespace { -// 进程级 TLS 状态:首连时加载一次,服务端下发/撤销信任锚后可重建(TlsReload)。 +// 一套 TLS 状态:信任锚 store + 链引擎 + 开关。按「本连接是否允许使用内嵌锚」分两套: +// g_state[1]:允许(连的正是生成时那台主控)——绝大多数情况 +// g_state[0]:不使用内嵌块(被转移/被分享/并行实例连的是别的主控) +// 为什么必须按连接分:分享实例与并行多主控实例是**同一个进程里的线程** +// (ClientDll.cpp 的 __CreateThread(0, 0, StartClientApp, ...)),一个进程级布尔量既 +// 表达不了「主连接用锚、分享连接不用」,也不该由先发起连接的那个线程决定——状态是首次 +// 使用时缓存的,谁先连谁说了算(设计文档 §3.6)。 +struct TlsState { + bool loaded = false; // 已加载过至少一次(决定首次失败是否 fail-closed) + bool enabled = false; // TLS 会话可用:send/recv 走加密 + bool error = false; // 证书存在但加载失败:拒绝连接(fail-closed) + bool anchorEmbedded = false; // 本套状态生效的锚来自内嵌块 + std::string source; // 锚来源,仅用于日志 + HCERTSTORE store = NULL; + HCERTCHAINENGINE engine = NULL; // 只信任 store 的链引擎(严格钉扎) +}; + // 所有读写都在 g_tlsMtx 下;证书校验(VerifyServerCert)在校验期间持同一把锁,因此 // 重建时可以安全地释放旧的 store/engine——不会再有线程正拿着它们用。 -std::mutex g_tlsMtx; -bool g_tlsLoaded = false; // 已加载过至少一次(决定首次失败是否 fail-closed) -bool g_tlsEnabled = false; // TLS 会话可用:send/recv 走加密 -bool g_tlsError = false; // 证书存在但加载失败:拒绝连接(fail-closed) -HCERTSTORE g_tlsStore = NULL; -HCERTCHAINENGINE g_tlsEngine = NULL; // 只信任 g_tlsStore 的链引擎(严格钉扎) +std::mutex g_tlsMtx; +TlsState g_state[2]; + +// 地址匹配用的锁,与 g_tlsMtx **分开**:匹配过程要解析域名,而 gethostbyname 可能卡上 +// 几秒到几十秒(DNS 不通时),绝不能压着证书校验那把锁。只在读写下面两个缓存与去重键时 +// 持锁,真正解析地址在锁外。 +std::mutex g_matchMtx; + +// 地址解析缓存:内嵌锚的 master 可能写成域名,而运行时(并行实例)连的是 DomainPool +// 解析出的 IP,必须比 IP 才知道是不是同一台主控。只在 g_matchMtx 下访问。 +std::map g_dnsCache; + +// 解析失败的负缓存(条目 → 失败时刻,GetTickCount64)。域名换过/过期而客户端还写着旧 +// 域名时,若失败不缓存,**每次连接**都要白等一轮 DNS 超时(连接莫名变慢,且很难归因)。 +// 缓 60 秒:短到 DNS 恢复后很快跟上,长到不会把每个重连都拖一遍。只在 g_matchMtx 下访问。 +const ULONGLONG kDnsFailTtlMs = 60 * 1000; +std::map g_dnsFailAt; + +// 「内嵌锚不适用」日志去重(重连循环每几秒一轮,不能每次刷屏)。只在 g_matchMtx 下访问。 +std::string g_lastSkipLog; // 解析信任锚证书路径:优先 settings.ini 的 [settings] tls_cert,其次可执行文件同目录 // yama-ca.pem。 @@ -54,17 +88,37 @@ std::string ResolveCertPath() // common/iniFile.h 的 ReadRegistrySz——服务端内置 TLS 证书同样要读 1~2KB 的长值, // 放在公共头里两端共用,避免各写一份。 -// 取信任锚 PEM 正文。优先注册表 Software\\settings\tls_cert(REG_SZ 直接存 -// PEM 正文,便于后续服务端下发/撤销),其次 settings.ini [settings] tls_cert 路径、 -// exe 同目录 yama-ca.pem 文件(向后兼容旧的文件投递方式)。 +// 取信任锚 PEM 正文。四级来源,优先级从高到低: +// 1. 抑制标记 settings\tls_disabled == "1" → 未配置(强制明文) +// 2. 注册表 settings\tls_cert(服务端在线下发,REG_SZ 直接存 PEM 正文) +// 3. settings.ini [settings] tls_cert 路径 / exe 同目录 yama-ca.pem(手工投放) +// 4. 内嵌锚块(生成客户端时写进镜像,出厂默认;需主控地址匹配,见 §3.6) // 返回 true 表示已配置(pem 可能为空:值/文件存在但内容为空,由 LoadTrustAnchor 判为 // fail-closed);false 表示完全未配置(走明文)。source 描述来源,仅用于日志。 -bool ReadTrustAnchor(std::string& pem, std::string& source) +// allowEmbedded:是否允许落到第 4 级内嵌块(按目标地址判定,见 EmbeddedAnchorAppliesTo)。 +// quiet:静默加载(第二套状态试建时用),失败原因仍经 err 返回。 +bool ReadTrustAnchor(std::string& pem, std::string& source, bool allowEmbedded, bool quiet) { - // 1) 注册表正文(首选)。值存在(即便为空)即视为「已配置」,交由 LoadTrustAnchor - // 对空/损坏内容判 fail-closed,与「空文件 → fail-closed」语义保持一致,避免空值 - // 被静默当成未配置而回退明文。 std::string regSubKey = GetRegistryName() + "\\settings"; + + // 1) 「取消 TLS」抑制标记。必须压过内嵌锚:COMMAND_TLS_DISABLE 只删 tls_cert 时, + // 客户端会回落到内嵌锚继续发 ClientHello,而服务端此时按明文处理 → StartTlsHandshake + // fail-closed 关闭 → 客户端再也连不上、也收不到任何后续指令(设计文档 §3.5)。 + // 抑制标记压过**所有**信任锚来源,包括管理员手工投放的 PEM:这是操作员明确的 + // 「本机不加密」意图,热切换失败时它必须能兜住,否则客户端会回落到别的锚继续 + // 发 ClientHello,而服务端此时按明文处理(§3.5)。日志里点明「配置的证书也被忽略」, + // 免得排查时误以为 PEM 没生效是加载失败。 + std::string disabled; + if (ReadRegistrySz(GetCurrentUserRegistryKey(), regSubKey, "tls_disabled", disabled) && disabled == "1") { + source = "registry " + regSubKey + "\\tls_disabled"; + if (!quiet) + Mprintf("[TLS] disabled by server (tls_disabled=1), ignoring any configured " + "certificate; plaintext mode\n"); + return false; + } + + // 2) 注册表正文。值存在(即便为空)即视为「已配置」,交由 LoadTrustAnchor 对空/损坏 + // 内容判 fail-closed,与「空文件 → fail-closed」语义一致,避免空值被静默当成未配置。 std::string regVal; if (ReadRegistrySz(GetCurrentUserRegistryKey(), regSubKey, "tls_cert", regVal)) { pem = regVal; @@ -72,70 +126,274 @@ bool ReadTrustAnchor(std::string& pem, std::string& source) return true; } - // 2) 文件回退:settings.ini [settings] tls_cert 路径 → exe 同目录 yama-ca.pem + // 3) 文件回退:settings.ini [settings] tls_cert 路径 → exe 同目录 yama-ca.pem std::string certPath = ResolveCertPath(); - if (certPath.empty() || _access(certPath.c_str(), 0) != 0) - return false; // 无证书 → 明文 + if (!certPath.empty() && _access(certPath.c_str(), 0) == 0) { + std::ifstream f(certPath.c_str(), std::ios::binary); + if (!f) { + if (!quiet) + Mprintf("[TLS] cannot open %s\n", certPath.c_str()); + } else { + pem.assign((std::istreambuf_iterator(f)), std::istreambuf_iterator()); + source = certPath; + return true; + } + } - std::ifstream f(certPath.c_str(), std::ios::binary); - if (!f) { - Mprintf("[TLS] cannot open %s\n", certPath.c_str()); + // 4) 内嵌锚块(出厂默认)。allowEmbedded 为假表示本目标不是生成时那台主控 + // (被转移/被分享/并行实例):拿原主控的证书去校验新主控必然失败,fail-closed 之后 + // 又收不到新锚,只能重新生成客户端(§3.6)。 + if (allowEmbedded) { + EmbeddedTlsAnchor anchor; + GetEmbeddedAnchor(anchor); + if (anchor.length > 0) { + if (!IsAnchorBlockValid(anchor)) { + // 损坏按「未配置」处理而不是 fail-closed:坏的可能是构建产物本身, + // fail-closed 会让整批客户端彻底不可用;明文至少还能连上并接受下发(§6.4)。 + if (!quiet) + Mprintf("[TLS] embedded anchor corrupt (length=%u), ignored\n", (unsigned)anchor.length); + } else { + pem.assign(anchor.pem, anchor.length); + source = "embedded"; + return true; + } + } + } + + return false; // 无证书 → 明文 +} + +// 去掉首尾空白并转小写:域名大小写不敏感,配置里出现空格是常事。 +std::string NormalizeEntry(const std::string& s) +{ + size_t b = 0, e = s.size(); + while (b < e && (s[b] == ' ' || s[b] == '\t')) ++b; + while (e > b && (s[e - 1] == ' ' || s[e - 1] == '\t')) --e; + std::string out(s, b, e - b); + for (size_t i = 0; i < out.size(); ++i) + out[i] = (char)tolower((unsigned char)out[i]); + return out; +} + +// 按分号拆分多地址(与 CONNECT_ADDRESS / DomainPool 的写法一致),逐项规范化。 +std::vector SplitAddresses(const std::string& s) +{ + std::vector out; + size_t pos = 0; + for (;;) { + const size_t semi = s.find(';', pos); + std::string item = NormalizeEntry(s.substr(pos, semi == std::string::npos ? std::string::npos + : semi - pos)); + if (!item.empty()) + out.push_back(item); + if (semi == std::string::npos) + break; + pos = semi + 1; + } + return out; +} + +bool IsIpv4Literal(const std::string& s) +{ + return !s.empty() && inet_addr(s.c_str()) != INADDR_NONE; +} + +// 把一个地址条目解析成 IPv4;本身是 IP 就直接返回。解析失败返回空串。 +// 调用方**不得**持 g_tlsMtx:真正的解析在锁外做(见 g_matchMtx 的注释)。成功永久缓存, +// 失败按 kDnsFailTtlMs 负缓存。 +std::string ResolveEntry(const std::string& entry) +{ + if (IsIpv4Literal(entry)) + return entry; + + { + std::lock_guard lk(g_matchMtx); + auto it = g_dnsCache.find(entry); + if (it != g_dnsCache.end() && !it->second.empty()) + return it->second; + auto f = g_dnsFailAt.find(entry); + if (f != g_dnsFailAt.end() && GetTickCount64() - f->second < kDnsFailTtlMs) + return std::string(); // 刚失败过,别在热路径上再等一次超时 + } + + const std::string ip = GetIPAddress(entry.c_str()); // 锁外:可能阻塞数秒 + const std::string v = IsIpv4Literal(ip) ? ip : std::string(); + + std::lock_guard lk(g_matchMtx); + if (v.empty()) { + g_dnsFailAt[entry] = GetTickCount64(); + } else { + g_dnsCache[entry] = v; + g_dnsFailAt.erase(entry); + } + return v; +} + +// 内嵌锚是否适用于本次连接(不持 g_tlsMtx;内部只对缓存加 g_matchMtx,解析在锁外)。 +// +// 判定分两层,任何一层命中即可: +// 1. 直接相等:配置里只写了一个地址,且与生成时的主控地址一字不差(域名对域名)。 +// 必须保留这一层——生成端填域名、运行时按域名连接时,靠字符串就能定案,不必 +// 依赖 DNS 的答案在两次查询之间保持一致。 +// 2. IP 相交:两侧(可能是分号分隔的多地址、可能是域名)解析出的 IPv4 有交集。 +// 并行实例连的是 DomainPool 解析后的单个 IP,生成端填的却是域名,只能靠这一层。 +// +// host 为空表示调用方没给目标(进程级调用),按「允许」处理,与改造前的行为一致。 +bool EmbeddedAnchorAppliesTo(const std::string& host, const std::string& configured) +{ + EmbeddedTlsAnchor anchor; + GetEmbeddedAnchor(anchor); + if (anchor.length == 0 || !IsAnchorBlockValid(anchor)) + return false; // 没有内嵌锚:用不用都是同一结果,不值得再比地址 + + if (host.empty()) + return true; + + const std::string builtFor(anchor.master, strnlen(anchor.master, sizeof(anchor.master))); + const std::vector masters = SplitAddresses(builtFor); + const std::vector targets = SplitAddresses(host); + + bool match = false; + + // 1) 配置里只写了一个地址:与主控地址直接比字符串。 + const std::vector configuredEntries = SplitAddresses(configured); + if (configuredEntries.size() == 1) { + for (size_t i = 0; i < masters.size() && !match; ++i) + match = (masters[i] == configuredEntries[0]); + } + + // 2) 连接目标(IP)落在主控地址解析出的 IP 集合里。 + for (size_t i = 0; i < targets.size() && !match; ++i) { + const std::string tip = ResolveEntry(targets[i]); + if (tip.empty()) + continue; + for (size_t j = 0; j < masters.size() && !match; ++j) + match = (ResolveEntry(masters[j]) == tip); + } + + if (!match) { + const std::string key = builtFor + "|" + host; + bool log = false; + { + std::lock_guard lk(g_matchMtx); + if (g_lastSkipLog != key) { g_lastSkipLog = key; log = true; } + } + if (log) { + Mprintf("[TLS] embedded anchor skipped: connecting %s, built for %s\n", + host.c_str(), builtFor.c_str()); + } + } + return match; +} + +// 把一段 DER 加入信任锚存储;不是合法证书就静默跳过。返回是否加入成功。 +static bool AddDerCert(const BYTE* der, DWORD cb, HCERTSTORE store) +{ + if (!der || cb == 0) + return false; + PCCERT_CONTEXT cert = CertCreateCertificateContext(X509_ASN_ENCODING, der, cb); + if (!cert) + return false; + const bool ok = CertAddCertificateContextToStore(store, cert, + CERT_STORE_ADD_REPLACE_EXISTING, NULL) != FALSE; + CertFreeCertificateContext(cert); + return ok; +} + +// 从 pem 的 pos 起取下一个 PEM 块(-----BEGIN … -----END 两行含在内),pos 前移到块后。 +static bool NextPemBlock(const std::string& pem, size_t& pos, std::string& block) +{ + const size_t begin = pem.find("-----BEGIN", pos); + if (begin == std::string::npos) + return false; + const size_t end = pem.find("-----END", begin); + if (end == std::string::npos) { + pos = pem.size(); // 只有 BEGIN 没有 END:残缺块,别再往后找 return false; } - pem.assign((std::istreambuf_iterator(f)), std::istreambuf_iterator()); - source = certPath; + const size_t eol = pem.find('\n', end); // 一直取到 END 那一行结束(兼容 CRLF) + const size_t stop = (eol == std::string::npos) ? pem.size() : eol + 1; + block.assign(pem, begin, stop - begin); + pos = stop; return true; } -// 解码 PEM/DER 信任锚正文为 DER,并加入内存信任锚存储。 -bool LoadTrustAnchor(const std::string& pem, const std::string& source, HCERTSTORE* outStore) +// 把 PEM 里的**所有**证书块解码并加入信任锚存储,返回加入的证书张数。 +// +// 必须循环:内置自签证书只有一张,但用户自备的是 leaf-first fullchain(叶证书 + 中间 +// CA)。只把叶证书放进独占根存储,CertGetCertificateChain 就建不出链 → 握手失败 → +// fail-closed。Linux 端 TlsChannelLinux.cpp::LoadAnchors 一直是循环读全部块的,这里补齐 +// 同一语义(设计文档 §5 P1)。 +// +// 不能用 CryptStringToBinaryA 的 pdwSkip 走多块:该参数是纯输出的——回报「转换前跳过了 +// 多少字符」,调用方传进去的偏移一概不看,整串输入时永远是 0。曾按「回报下一块起点」用它 +// 循环,结果下一轮就被 `next <= offset` 的防死循环判断挡下,一张证书都加不进去(内嵌锚 +// 客户端首次连接直接 fail-closed,2026-11-01 实测)。因此这里自己按 BEGIN/END 切块。 +static int DecodeAllCerts(const std::string& pem, DWORD flags, HCERTSTORE store, + const std::string& source, bool quiet) +{ + int added = 0; + size_t pos = 0; + std::string block; + while (NextPemBlock(pem, pos, block)) { + DWORD derLen = 0; + if (!CryptStringToBinaryA(block.c_str(), (DWORD)block.size(), flags, + NULL, &derLen, NULL, NULL) || derLen == 0) + continue; // 这一块不是该 flags 认得的内容:跳过,后面的块还有机会 + + std::vector der(derLen); + DWORD cb = derLen; + if (!CryptStringToBinaryA(block.c_str(), (DWORD)block.size(), flags, + der.data(), &cb, NULL, NULL)) { + if (!quiet) + Mprintf("[TLS] failed to decode a certificate block in %s\n", source.c_str()); + continue; + } + if (AddDerCert(der.data(), cb, store)) + ++added; + } + return added; +} + +// 解码 PEM/DER 信任锚正文,并加入内存信任锚存储。 +bool LoadTrustAnchor(const std::string& pem, const std::string& source, bool quiet, + 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 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()); + if (!quiet) + Mprintf("[TLS] empty 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"); + if (!quiet) + Mprintf("[TLS] CertOpenStore failed\n"); return false; } - if (!CertAddCertificateContextToStore(store, cert, CERT_STORE_ADD_REPLACE_EXISTING, NULL)) { + + // 先按标准 PEM(-----BEGIN CERTIFICATE-----)逐块解码;没有标记头再按旧语义退回 + // 「任意格式」整串解一次(覆盖只有 base64 正文的锚),最后兜底裸 DER。 + int added = DecodeAllCerts(pem, CRYPT_STRING_BASE64HEADER, store, source, quiet); + if (added == 0 && pem.find("-----BEGIN") == std::string::npos) { + std::vector der(pem.size() + 16); + DWORD cb = (DWORD)der.size(); + if (CryptStringToBinaryA(pem.data(), (DWORD)pem.size(), CRYPT_STRING_ANY, + der.data(), &cb, NULL, NULL) && AddDerCert(der.data(), cb, store)) + ++added; + // 兜底:正文就是 DER 字节(REG_BINARY / 二进制文件读进来的情况)。 + if (added == 0 && AddDerCert((const BYTE*)pem.data(), (DWORD)pem.size(), store)) + ++added; + } + if (added == 0) { CertCloseStore(store, 0); - CertFreeCertificateContext(cert); - Mprintf("[TLS] CertAddCertificateContextToStore failed\n"); + if (!quiet) + Mprintf("[TLS] failed to decode certificate %s\n", source.c_str()); return false; } - CertFreeCertificateContext(cert); + if (!quiet) + Mprintf("[TLS] trust anchor %s: %d certificate(s) loaded\n", source.c_str(), added); *outStore = store; return true; @@ -145,17 +403,17 @@ enum TlsAnchor { TLS_ANCHOR_OK, TLS_ANCHOR_NONE, TLS_ANCHOR_INVALID }; // 读取当前信任锚并建好 store + 链引擎(成功时经 outStore/outEngine 交出,调用方负责 // 释放)。不触碰全局状态。source 描述锚的来源,仅用于日志。 -TlsAnchor BuildTlsAnchor(HCERTSTORE* outStore, HCERTCHAINENGINE* outEngine, - std::string& source, std::string& err) +TlsAnchor BuildTlsAnchor(bool allowEmbedded, bool quiet, HCERTSTORE* outStore, + HCERTCHAINENGINE* outEngine, std::string& source, std::string& err) { std::string pem; - if (!ReadTrustAnchor(pem, source)) { + if (!ReadTrustAnchor(pem, source, allowEmbedded, quiet)) { err = "no trust anchor configured"; return TLS_ANCHOR_NONE; } HCERTSTORE store = NULL; - if (!LoadTrustAnchor(pem, source, &store)) { + if (!LoadTrustAnchor(pem, source, quiet, &store)) { err = "trust anchor (" + source + ") present but failed to load"; return TLS_ANCHOR_INVALID; } @@ -177,54 +435,90 @@ TlsAnchor BuildTlsAnchor(HCERTSTORE* outStore, HCERTCHAINENGINE* outEngine, return TLS_ANCHOR_OK; } -// 按当前信任锚重建 TLS 状态(调用方持 g_tlsMtx)。 +void FreeState(TlsState& st) +{ + if (st.engine) { CertFreeCertificateChainEngine(st.engine); st.engine = NULL; } + if (st.store) { CertCloseStore(st.store, 0); st.store = NULL; } +} + +// 按当前信任锚重建某一套 TLS 状态(调用方持 g_tlsMtx)。idx:1=允许内嵌锚,0=不用。 // 首次加载失败 → fail-closed(管理员已「颁发」证书,不能静默回退明文);运行期热重载 // 失败 → 保持现有状态不变,返回 false(一次坏下发不该打死正在工作的客户端;下次启动 // 仍会 fail-closed)。 -bool ApplyTlsStateLocked(bool initial, std::string& err) +bool ApplyTlsStateLocked(int idx, bool initial, std::string& err, bool quiet) { HCERTSTORE store = NULL; HCERTCHAINENGINE engine = NULL; std::string source; - const TlsAnchor anchor = BuildTlsAnchor(&store, &engine, source, err); + const TlsAnchor anchor = BuildTlsAnchor(idx == 1, quiet, &store, &engine, source, err); + TlsState& st = g_state[idx]; if (anchor == TLS_ANCHOR_INVALID) { - if (initial) { - g_tlsEnabled = false; - g_tlsError = true; - g_tlsLoaded = true; - Mprintf("[TLS] FATAL: %s; refusing connections (fail-closed)\n", err.c_str()); - } else { + if (initial && !st.loaded) { + FreeState(st); + st.enabled = st.anchorEmbedded = false; + st.error = true; + st.loaded = true; + st.source = source; + if (!quiet) + Mprintf("[TLS] FATAL: %s; refusing connections (fail-closed)\n", err.c_str()); + } else if (!quiet) { Mprintf("[TLS] reload failed: %s (keeping current transport)\n", err.c_str()); } return false; } // 互换。旧 store/engine 可以直接释放:校验路径持同一把锁,此刻没有线程在用它们。 - HCERTSTORE oldStore = g_tlsStore; - HCERTCHAINENGINE oldEngine = g_tlsEngine; - g_tlsStore = store; - g_tlsEngine = engine; - g_tlsEnabled = (anchor == TLS_ANCHOR_OK); - g_tlsError = false; - g_tlsLoaded = true; - if (oldEngine) CertFreeCertificateChainEngine(oldEngine); - if (oldStore) CertCloseStore(oldStore, 0); + FreeState(st); + st.store = store; + st.engine = engine; + st.enabled = (anchor == TLS_ANCHOR_OK); + st.anchorEmbedded = st.enabled && source == "embedded"; + st.error = false; + st.loaded = true; + st.source = source; - if (g_tlsEnabled) - Mprintf("[TLS] enabled: trust anchor loaded (%s), all connections use TLS\n", source.c_str()); - else - Mprintf("[TLS] disabled: no trust anchor configured, plaintext mode\n"); + if (!quiet) { + if (st.enabled) + Mprintf("[TLS] enabled: trust anchor loaded (%s), using TLS\n", source.c_str()); + else + Mprintf("[TLS] disabled: no trust anchor configured, plaintext mode\n"); + } return true; } // 首次调用时才真正加载;之后一律用缓存的状态(热重载由 TlsReload 负责)。 -inline void EnsureTlsLoadedLocked() +// +// 本连接不走内嵌锚时,两套状态都静默建好,只发一条描述本连接的状态行。不能反过来 +// 先按 idx==1 打了日志再补一句——那两条讲的是本连接不用的那套(实测日志会读成 +// 「skipped → enabled, using TLS → plaintext」,前后自相矛盾)。 +void EnsureStateLocked(int idx) { - if (!g_tlsLoaded) { - std::string err; - ApplyTlsStateLocked(true, err); + if (g_state[idx].loaded) + return; + + std::string err; + if (idx == 1) { + ApplyTlsStateLocked(1, true, err, false); + return; } + + ApplyTlsStateLocked(1, true, err, true); // 本连接不用,但其它目标/热重载还要用 + ApplyTlsStateLocked(0, true, err, true); + const TlsState& st = g_state[0]; + if (st.error) + Mprintf("[TLS] this connection: fail-closed, trust anchor unusable\n"); + else if (st.enabled) + Mprintf("[TLS] this connection: TLS with trust anchor (%s)\n", st.source.c_str()); + else + Mprintf("[TLS] this connection: plaintext mode\n"); +} + +// 本连接用哪一套状态:目标命中内嵌锚的主控地址就用 [1],否则 [0]。 +// 不持 g_tlsMtx:里面可能解析域名(见 g_matchMtx 的注释),调用方应在取锁**之前**调用。 +int ResolveStateIndex(const std::string& host, const std::string& configured) +{ + return EmbeddedAnchorAppliesTo(host, configured) ? 1 : 0; } } // namespace @@ -232,21 +526,43 @@ inline void EnsureTlsLoadedLocked() bool TlsEnabled() { std::lock_guard lk(g_tlsMtx); - EnsureTlsLoadedLocked(); - return g_tlsEnabled; + EnsureStateLocked(1); + return g_state[1].enabled; } bool TlsLoadError() { std::lock_guard lk(g_tlsMtx); - EnsureTlsLoadedLocked(); - return g_tlsError; + EnsureStateLocked(1); + return g_state[1].error; +} + +bool TlsEnabledFor(const std::string& host, const std::string& configured) +{ + const int idx = ResolveStateIndex(host, configured); // DNS 在锁外 + std::lock_guard lk(g_tlsMtx); + EnsureStateLocked(idx); + return g_state[idx].enabled; +} + +bool TlsLoadErrorFor(const std::string& host, const std::string& configured) +{ + const int idx = ResolveStateIndex(host, configured); // DNS 在锁外 + std::lock_guard lk(g_tlsMtx); + EnsureStateLocked(idx); + return g_state[idx].error; } bool TlsReload(std::string& err) { std::lock_guard lk(g_tlsMtx); - return ApplyTlsStateLocked(!g_tlsLoaded, err); + // 两套一起重建:一套失败按「保持原状」处理(ApplyTlsStateLocked 内部保证), + // 另一套照常更新。返回 false 表示至少有一套没换成新锚。 + std::string err1, err0; + const bool ok1 = ApplyTlsStateLocked(1, !g_state[1].loaded, err1, false); + const bool ok0 = ApplyTlsStateLocked(0, !g_state[0].loaded, err0, true); + err = ok1 ? err0 : err1; + return ok1 && ok0; } // ---- TlsChannel ---- @@ -285,19 +601,22 @@ bool TlsChannel::VerifyServerCert() // 持锁时间很短:建链全是本地操作(DISABLE_AIA 禁联网取中间证书,也不带任何 // CERT_CHAIN_REVOCATION_CHECK_* 位),不会因为网络等待而卡住 TlsReload。 std::lock_guard lk(g_tlsMtx); - if (!g_tlsStore || !g_tlsEngine) { + const TlsState& st = g_state[m_stateIdx]; + if (!st.store || !st.engine) { CertFreeCertificateContext(remote); return false; } + // 本连接实际用的是哪一套信任锚:登录上报 CLIENT_CAP_EMBEDDED_ANCHOR 靠它。 + m_anchorEmbedded = st.anchorEmbedded; CERT_CHAIN_PARA para = {}; para.cbSize = sizeof(para); PCCERT_CHAIN_CONTEXT chain = NULL; - // g_tlsEngine 的 hExclusiveRoot 已把信任锚限制为 g_tlsStore;hAdditionalStore 再传一次 + // st.engine 的 hExclusiveRoot 已把信任锚限制为 st.store;hAdditionalStore 再传一次 // 该 store 供链引擎查找 CA/中间证书。只接受「无任何错误位」的链(含时间有效性)。 // 不设置任何 CERT_CHAIN_REVOCATION_CHECK_* 位 = 不做吊销检查(私有 CA 无 CRL/OCSP, // 且这些位会触发联网,反而失败);只保留 CERT_CHAIN_DISABLE_AIA 禁止联网取中间证书。 - BOOL ok = CertGetCertificateChain(g_tlsEngine, remote, NULL, g_tlsStore, ¶, + BOOL ok = CertGetCertificateChain(st.engine, remote, NULL, st.store, ¶, CERT_CHAIN_DISABLE_AIA, NULL, &chain); bool trusted = false; @@ -309,11 +628,27 @@ bool TlsChannel::VerifyServerCert() return trusted; } -bool TlsChannel::Handshake(SOCKET sock, const char* sni) +bool TlsChannel::Handshake(SOCKET sock, const char* sni, const std::string& host, + const std::string& configured) { std::lock_guard lk(m_ctxMtx); CloseHandles(); // 重连时清理上一次会话(recursive 锁,此处可重入) + // 本连接用**哪一套**状态(允许/不允许内嵌锚)在握手开始时定下,之后不再改——地址 + // 匹配只算这一次,而它可能要解析域名,必须在取 g_tlsMtx 之前做完。 + // + // 注意别把这里读成「锚本身也定死了」:这套状态里的 store/链引擎由 TlsReload 原地 + // 替换,握手末尾的 VerifyServerCert 读的是**此刻**的 g_state[m_stateIdx]。这是有意 + // 为之——服务端刚下发的锚对正在进行的握手也立即生效;两套锚之间不会串,校验只认 + // m_stateIdx 那一套。 + m_anchorEmbedded = false; + const int idx = ResolveStateIndex(host, configured); + { + std::lock_guard stlk(g_tlsMtx); + m_stateIdx = idx; + EnsureStateLocked(idx); + } + SCHANNEL_CRED cred = {}; cred.dwVersion = SCHANNEL_CRED_VERSION; cred.dwFlags = SCH_CRED_MANUAL_CRED_VALIDATION | SCH_CRED_NO_DEFAULT_CREDS; diff --git a/client/TlsChannel.h b/client/TlsChannel.h index 0755e54..7beeb0a 100644 --- a/client/TlsChannel.h +++ b/client/TlsChannel.h @@ -37,14 +37,32 @@ #include #include -// 进程级 TLS 开关:首次调用时加载信任锚(注册表或文件),返回是否启用。线程安全。 +// 进程级 TLS 开关(不看目标地址,等价于「允许使用内嵌锚」那一套状态):首次调用时加载 +// 信任锚(注册表或文件),返回是否启用。线程安全。 // Windows 版同样是「可热切换」的:TlsReload() 之后本函数立刻反映新状态(不是 call_once)。 +// 需要「这条连接会不会走 TLS」时用下面的 TlsEnabledFor(host)——分享/并行实例与主连接的 +// 答案可能不同(内嵌锚只对生成时那台主控有效)。 bool TlsEnabled(); // 信任锚已配置但加载失败(损坏/格式错误)时为 true:表示管理员已「颁发」证书, // 客户端必须拒绝连接(fail-closed),不得静默回退明文。线程安全、幂等。 bool TlsLoadError(); +// 按「本连接要连到哪里」给出 TLS 开关与 fail-closed 状态。host 可以是域名、IP,或分号 +// 分隔的多地址(与 CONNECT_ADDRESS 的写法一致);为空表示不限定目标(按进程级开关处理)。 +// +// 为什么要按连接判定:分享实例、并行的多主控实例都是**同一个进程里的线程** +// (ClientDll.cpp 的 __CreateThread(0,0,StartClientApp,...)),一个进程级布尔量既表达不了 +// 「主连接用内嵌锚、分享连接不用」,也不该由先发起连接的那个线程决定(状态首次使用时 +// 缓存,谁先连谁说了算)。内嵌锚只在「连的正是生成时那台主控」时生效,判定在 TLS 层内部 +// 完成:地址字符串直接相等,或两侧解析出的 IP 相交。 +// +// connectHost:本连接实际连到的地址(IOCPClient 的 m_sCurIP,通常是解析后的 IP)。 +// configured:配置里的原始写法(可能含分号分隔的多地址/域名),可为空。域名对域名 +// 靠它做快路径,不必依赖两次 DNS 查询得到同一个答案。 +bool TlsEnabledFor(const std::string& connectHost, const std::string& configured); +bool TlsLoadErrorFor(const std::string& connectHost, const std::string& configured); + // 按当前信任锚位置(注册表 settings\tls_cert → settings.ini → exe 同目录 yama-ca.pem) // 重建 TLS 上下文并更新开关,让随后建立的新连接立刻走新传输方式(已建立的连接不受 // 影响)。信任锚无效时不做任何改动、返回 false 并给出原因——一次坏下发不该把正在工作 @@ -66,7 +84,10 @@ public: // 调用方必须关闭 socket(fail-closed)。可重复调用(重连时复用同一对象)。 // sni 非空且为域名时作为 SNI 发送,让反代(nginx)按域名分流到正确的 server 块; // 证书校验仍只钉信任锚、不校主机名,与直接连主控端口时完全一致。 - bool Handshake(SOCKET sock, const char* sni = NULL); + // host/configured:同 TlsEnabledFor,决定证书校验用哪一套信任锚——目标不是生成时 + // 那台主控时不能拿内嵌锚去校验,否则必然失败且无法自愈。 + bool Handshake(SOCKET sock, const char* sni, const std::string& host, + const std::string& configured); // 解密读取:返回 >0 的明文字节数;0 表示对端正常关闭;SOCKET_ERROR(-1) 出错。 int Recv(SOCKET sock, char* buf, int len); @@ -84,6 +105,10 @@ public: // 握手是否已完成(Send/Recv 可用)。诊断用:区分「本连接已走 TLS」与「裸连接」。 bool IsReady() const { return m_ready; } + // 本连接校验服务端证书时用的是不是内嵌锚。登录上报 CLIENT_CAP_EMBEDDED_ANCHOR 用: + // 只有这种客户端会在服务端关掉 TLS 后失联,操作员据此决定是否先下发取消。 + bool AnchorEmbedded() const { return m_anchorEmbedded; } + private: void CloseHandles(); bool SendAll(SOCKET sock, const void* data, int len); @@ -94,6 +119,8 @@ private: bool m_credValid = false; // m_cred 已分配,需 FreeCredentialsHandle bool m_ctxValid = false; // m_ctx 已分配,需 DeleteSecurityContext bool m_ready = false; // 握手完成,Send/Recv 可用 + bool m_anchorEmbedded = false; // 本次握手用的是内嵌锚(见 AnchorEmbedded) + int m_stateIdx = 1; // 本次握手用的信任锚状态(1=允许内嵌锚;0=不用) SecPkgContext_StreamSizes m_sizes = {}; @@ -123,6 +150,11 @@ bool TlsEnabled(); // (fail-closed),不得静默回退明文。线程安全、幂等。 bool TlsLoadError(); +// Windows 版按目标地址区分「用不用内嵌锚」。Linux 客户端没有内嵌锚概念(生成器只往 +// Windows 镜像里写锚块),信任锚一律是配置文件,故这里忽略目标地址,与进程级开关等价。 +inline bool TlsEnabledFor(const std::string&, const std::string&) { return TlsEnabled(); } +inline bool TlsLoadErrorFor(const std::string&, const std::string&) { return TlsLoadError(); } + // 服务端下发信任锚(COMMAND_TLS_ENABLE):把 PEM 正文写入 // $XDG_CONFIG_HOME/ghost/yama-ca.pem(默认 ~/.config/ghost/yama-ca.pem,无 HOME 时退回 // 程序目录),原子替换、权限 0600。写入前先解析验证,不是合法证书就整包拒绝。 @@ -153,7 +185,9 @@ public: // 在已连通的 socket 上完成 TLS 1.2 客户端握手并按信任锚校验服务端证书链。失败返回 // false,调用方必须关闭 socket(fail-closed)。可重复调用(重连时复用同一对象)。 // sni 非空且为域名时作为 SNI 发送(反代按域名分流);证书校验仍只钉信任锚。 - bool Handshake(int sock, const char* sni = NULL); + // 后两个参数与 Windows 版同签名,本平台无内嵌锚,忽略。 + bool Handshake(int sock, const char* sni, const std::string& host, + const std::string& configured); // 解密读取:返回 >0 的明文字节数;0 表示对端正常关闭;SOCKET_ERROR(-1) 出错。 int Recv(int sock, char* buf, int len); @@ -170,6 +204,9 @@ public: // 握手是否已完成(Send/Recv 可用)。诊断用:区分「本连接已走 TLS」与「裸连接」。 bool IsReady() const { return m_ready; } + // Linux 客户端没有内嵌锚(见上),恒为 false,与 Windows 版签名保持一致。 + bool AnchorEmbedded() const { return false; } + private: void CloseHandles(); diff --git a/client/TlsChannelLinux.cpp b/client/TlsChannelLinux.cpp index acc6df0..80b6151 100644 --- a/client/TlsChannelLinux.cpp +++ b/client/TlsChannelLinux.cpp @@ -415,7 +415,8 @@ void TlsChannel::CloseHandles() m_ready = false; } -bool TlsChannel::Handshake(int sock, const char* sni) +bool TlsChannel::Handshake(int sock, const char* sni, const std::string& /*host*/, + const std::string& /*configured*/) { std::lock_guard lk(m_ctxMtx); CloseHandles(); // 重连时清理上一次会话(recursive 锁,此处可重入) diff --git a/client/domain_pool.h b/client/domain_pool.h index a260d59..1cbbc84 100644 --- a/client/domain_pool.h +++ b/client/domain_pool.h @@ -32,4 +32,10 @@ public: { return IPList; } + // 配置里的原始写法(未解析的域名/多地址)。TLS 层判定内嵌锚是否适用时用它做 + // 「域名对域名」的快路径,避免依赖两次 DNS 查询得到同一个答案。 + const char* GetAddress() const + { + return Address; + } }; diff --git a/client/ghost_vs2015.vcxproj b/client/ghost_vs2015.vcxproj index 43838ac..39f18dc 100644 --- a/client/ghost_vs2015.vcxproj +++ b/client/ghost_vs2015.vcxproj @@ -234,6 +234,7 @@ + @@ -301,6 +302,7 @@ + diff --git a/client/ghost_vs2015.vcxproj.filters b/client/ghost_vs2015.vcxproj.filters index d853842..58e7447 100644 --- a/client/ghost_vs2015.vcxproj.filters +++ b/client/ghost_vs2015.vcxproj.filters @@ -52,6 +52,7 @@ + @@ -146,6 +147,7 @@ + diff --git a/common/commands.h b/common/commands.h index 0f650b8..025496d 100644 --- a/common/commands.h +++ b/common/commands.h @@ -139,6 +139,7 @@ inline int isValid_10s() #define CLIENT_CAP_C2C_PATHS 0x0008 // 支持按路径清单向另一客户端发送文件(COMMAND_C2C_SEND_FILES,仅 Windows) #define CLIENT_CAP_C2C_RECV_ACK 0x0010 // 作为 C2C 目标端时,落盘完成后回执(TOKEN_C2C_RECV_RESULT,目前仅 Linux) #define CLIENT_CAP_PROTO_SWITCH 0x0020 // 支持服务端远程切换传输协议(COMMAND_SET_PROTO,仅 Windows) +#define CLIENT_CAP_EMBEDDED_ANCHOR 0x0040 // 当前靠「生成时内嵌的 TLS 信任锚」在加密(按运行时状态置位,不是能力声明) #define TALK_DLG_MAXLEN 1024 // 最大输入字符长度 diff --git a/common/tls_anchor.h b/common/tls_anchor.h new file mode 100644 index 0000000..84c01ef --- /dev/null +++ b/common/tls_anchor.h @@ -0,0 +1,67 @@ +#pragma once +// +// 内嵌服务端 TLS 信任锚块(客户端与服务端共用)—— 见 docs/ClientEmbeddedTLS_Design.md §3.3。 +// +// 生成客户端时,主控把「服务端自己的 TLS 证书 PEM」写进客户端镜像里的这个块;客户端 +// 启动后拿它当信任锚,于是首次连接就是 TLS,不必等主控在线下发。 +// +// 为什么单独成块、不扩 CONNECT_ADDRESS: +// 1. 结构体尾部只有 szFututre[496] 连续可用,而内置证书 PEM 就有 1042 字节; +// 2. 生成端是按 sizeof(CONNECT_ADDRESS) 做 memcpy 原地覆盖的,扩了结构体就会把新 +// 长度写进老 stub 里,越界且无声(详见设计文档 §3.2 的方案 A 否决理由)。 +// +// 块与 CONNECT_ADDRESS 走同一条字节搬运路径:生成端扫描 → 原地写入 → 之后才做 +// UPX / ShellCode / 图片伪装。凡 CONNECT_ADDRESS 能活到运行时的包装形态,本块也一定能。 +// +#include +#include +#include + +#pragma pack(push, 4) +struct EmbeddedTlsAnchor { + char magic[16]; // kAnchorMagic(见 IsAnchorMagic) + uint32_t version; // kAnchorVersion + uint32_t capacity; // sizeof(pem):stub 的编译期常量,生成端读它才知道能不能写 + uint32_t length; // 实际写入的 PEM 字节数;0 = 未内嵌 + uint32_t hash; // Fnv1a32(pem[0..length)),半截写入/被改动可立刻识别 + char master[100]; // 生成时配置的主控地址(明文原样,含分号分隔的多地址) + char pem[4096]; // 证书 PEM(内置自签单张,或用户自备的 fullchain) +}; +#pragma pack(pop) + +constexpr uint32_t kAnchorVersion = 1; +constexpr uint32_t kAnchorCapacity = 4096; // == sizeof(EmbeddedTlsAnchor::pem) + +// 布局一变,已分发的 stub 就会被生成端读错(capacity 校验会拦住,但别靠它兜底)。 +static_assert(sizeof(EmbeddedTlsAnchor) == 4228, "EmbeddedTlsAnchor 布局变了,见设计文档 §3.3"); + +// FNV-1a 32 位。与 common/iniFile.h 的 GetExeHashStr() 同一算法族(那里是 64 位), +// 此处取 32 位只为塞进固定宽度的字段。用途是识别「写了一半」与「被改动」,不是安全边界 +// ——锚本身就是公开信息,能改它的人也能改整个文件。 +inline uint32_t Fnv1a32(const char* data, size_t len) +{ + uint32_t h = 2166136261u; + for (size_t i = 0; i < len; ++i) { + h ^= (unsigned char)data[i]; + h *= 16777619u; + } + return h; +} + +// magic 的字面量在 .rdata 里还会有一份副本(本函数用的常量),所以生成端不能「找到 +// 第一处就写」,必须对每个命中做结构校验——见 IsAnchorBlockValid 与设计文档 §3.3。 +inline bool IsAnchorMagic(const char* p) +{ + static const char kMagic[16] = { 'Y','A','M','A','_','T','L','S','_','A','N','C','H','O','R','\0' }; + return memcmp(p, kMagic, sizeof(kMagic)) == 0; +} + +// 结构校验:magic + version + capacity + hash 全对,才算「这是我们的锚块」。 +inline bool IsAnchorBlockValid(const EmbeddedTlsAnchor& a) +{ + if (!IsAnchorMagic(a.magic)) return false; + if (a.version != kAnchorVersion || a.capacity != kAnchorCapacity) return false; + if (a.length == 0) return a.hash == 0; + if (a.length > sizeof(a.pem)) return false; + return a.hash == Fnv1a32(a.pem, a.length); +} diff --git a/docs/ClientEmbeddedTLS_Design.md b/docs/ClientEmbeddedTLS_Design.md new file mode 100644 index 0000000..d425722 --- /dev/null +++ b/docs/ClientEmbeddedTLS_Design.md @@ -0,0 +1,759 @@ +# 客户端内嵌服务端 TLS 信任锚设计(生成即 TLS) + +> 版本:v1.0 · 状态:**已实现(Windows 客户端 + MFC 服务端)** · 日期:2026-11-01 +> 关联:`docs/TransportTLS_Design.md`(传输层单向 TLS)、`docs/TransportTLS_MFCServer_Design.md`(MFC 服务端)、 +> `server/2015Remote/BuiltinTlsCert.*`(内置证书) +> +> 需求原文:服务端启用 TLS 时,生成客户端就希望把服务端 TLS 内嵌进客户端,让分发出去的客户端一开始就是 TLS。 +> 两个待讨论问题: +> 1. 生成客户端时是否增加一个类型来标识客户端协议,比如 `TCP+TLS`? +> 2. 客户端的 `CONNECT_ADDRESS` 剩余空间只有 496 字节,肯定存不下,怎么解决? +> +> v0.3 裁定 §10 全部待定问题(§10 转为决议记录),并补入分享/转移的证书约束与分享实例的 TLS 指令隔离(§3.8)。 +> v0.2 相对 v0.1 的改动见 §12(一轮独立审查后的修订),v0.3 的改动见 §13, +> v1.0 的实施偏差与实测记录见 §14。 + +## 1. 结论摘要 + +| 问题 | 结论 | +|---|---| +| 是否新增 `protoType`(如 `TCP+TLS`) | **不新增**。生成界面用复选框表达;TLS 状态仍由「有没有信任锚」决定 | +| 496 字节放不下怎么办 | **不动 `CONNECT_ADDRESS`**。在客户端 payload 里放一个独立、自描述的锚块(约 4.2 KB),生成时原地写入 | +| 分享/转移是否要求新主控同证书 | **要求**(对"已下发锚"成立,且今天就是这样)。内嵌锚因绑主控地址而不受此限(§3.8) | +| 分享实例能否被 TLS 启停 | **不能**,与「被分享的主机无权切换协议」同策略,一律忽略(§3.8) | + +三条此前没意识到、但会决定方案成败的约束,都在 §3 里展开: + +- **锚必须绑主控地址**,否则分享/被转移的客户端会连不上第二台主控(§3.6,阻塞级); +- **锚块必须是"不可被优化掉"的全局变量**,否则 LTCG 会把它整个删掉(§3.3); +- **"取消 TLS"指令送不到离线客户端**,关闭服务端 TLS 是一次单向门(§3.5)。 + +--- + +## 2. 现状核实 + +### 2.1 服务端:TLS 已就绪且默认开启 + +- `IOCPServer::StartServer()` 第一行无条件执行 `ServerTlsIdentity::Load(THIS_CFG)`(`server/2015Remote/IOCPServer.cpp:491`),在监听套接字创建之前。 +- `Load()`(`server/2015Remote/ServerTlsSession.cpp:134`)里 `Enabled` 缺省为 1;`CertPath`/`KeyPath` 都为空时走内置证书分支,`BuiltinTlsCert::Ensure()` 首次生成自签证书并写入配置。 +- `ServerTlsIdentity::AnchorPem()` 给出当前信任锚 PEM(内置证书时即该自签证书本身;自定义证书时是**证书文件全文**,`ServerTlsSession.cpp:198`)。 +- 设备端口按 ClientHello 逐连接嗅探;`IsReady()==false` 时在 `StartTlsHandshake()`(`IOCPServer.cpp:988`)里 fail-closed 关闭。明文连接无条件放行(`IOCPServer.cpp:1202`)。 + +**实测数据**:内置证书 PEM **1042 字节**(DER 约 730 字节,RSA-2048 / SHA-256 / CN=yama-server / 10 年有效期)。 + +### 2.2 客户端:信任锚的三个来源与优先级 + +`client/TlsChannel.cpp` 的 `ReadTrustAnchor()`(第 62 行)按以下顺序取锚: + +1. 注册表 `Software\\settings\tls_cert`(REG_SZ,直接存 PEM 正文); +2. `settings.ini [settings] tls_cert`(值是**文件路径**),或 exe 同目录 `yama-ca.pem`; +3. 都没有 → 未配置 → 明文。 + +`TlsEnabled()` == 「当前有没有可用的信任锚」;`TlsEnabledFor(连接目标, 配置里的原始地址)` 是同一问题的**按连接**答案(见 §3.6)。在 `IOCPClient::ConnectServer` 里它是传输层唯一判据: + +```cpp +// client/IOCPClient.cpp:540 +const std::string tlsConfigured = m_Domain.GetAddress(); +if (TlsEnabledFor(m_sCurIP, tlsConfigured) && protoType != PROTO_WS) { /* 握手 */ } +``` + +> **注意适用范围**:这个判据只存在于 `IOCPClient::ConnectServer`。`IOCPUDPClient` 与 `IOCPKCPClient` 各自 `override ConnectServer`(`IOCPUDPClient.h:11`、`IOCPKCPClient.h:13`),**完全不走 TLS**。详见 §3.7。 + +### 2.3 现有的下发通道 + +- `COMMAND_TLS_ENABLE`(`client/KernelManager.cpp:881`):载荷即 PEM 正文,写入注册表后 `ApplyTlsAnchorChange()` 热重载;传输方式变化才断线重连。 +- `COMMAND_TLS_DISABLE`(`client/KernelManager.cpp:894`):**只** `RegDeleteValueA(hKey, "tls_cert")`,再热重载。注意服务端入口 `OnExperimentTlsDisable`(`2015RemoteDlg.cpp:5123`)在 `!ServerTlsIdentity::IsReady()` 时**直接拒绝发送**——这条限制在本设计下必须去掉(§3.5)。 +- `COMMAND_SET_PROTO`(WSS)随包下发锚(`ProtoSwitchPacket.certLen` + PEM)。 + +### 2.4 生成客户端的两条路径 + +**路径 A:生成界面**(`server/2015Remote/BuildDlg.cpp`) +读内嵌/外部资源 → 构造 `CONNECT_ADDRESS` → 按 `szFlag`(`FLAG_FINDEN`)在 payload 里扫描 → `memcpy(ptr+iOffset, &g_ConnectAddress, sizeof(g_ConnectAddress))`(第 581 行)→ 写文件 → 可选压缩/加壳/伪装。默认压缩是 `CLIENT_COMPRESS_SC_AES_OLD`(第 863 行)。 + +**路径 B:在线下发**(`2015RemoteDlg.cpp:5239` `ReadExeFromResource()`) +同样扫描并改写 `CONNECT_ADDRESS`,用于 `COMMAND_UPDATE`(在线更新)与 `COMMAND_UPLOAD_EXEC`(远程执行),三个调用点:`5334`、`12177`、`12190`。 + +### 2.5 各生成目标是否含客户端代码 + +| 生成目标 | 产出文件 | 编译单元 | 可内嵌 | +|---|---|---|---| +| `IndexGhost` / `IndexGhostMsc` / `IndexGhostSystem` | `ghost.exe` | `ghost_vs2015.vcxproj` 直接编 `ClientDll.cpp` + `TlsChannel.cpp` | ✅ | +| `IndexServerDll` | `ServerDll.dll` | `ClientDll_vs2015.vcxproj`(ProjectName=ServerDll),同上 | ✅ | +| `IndexTestRun_*` | `TestRun.exe` | `TestRun_vs2015.vcxproj`,**纯加载器**,不含客户端代码 | ❌(锚要在 `ServerDll.dll` 里) | +| `IndexTinyRun` | `TinyRun.dll` | `TinyRun.vcxproj`,仅 `main.c`,无 TLS 通道 | ❌ | +| `IndexLinuxGhost` / `IndexMacGhost` / `IndexAndroidGhost` | `ghost` / `ghost.apk` | 各平台工程 | 本期不做 | + +### 2.6 `CONNECT_ADDRESS` 的空间账 + +`common/commands.h:884` 起,`#pragma pack(push,4)`: + +- `char szFututre[496];`(第 909 行,结构体尾部)——全代码库**零引用**; +- `char szReserved[11];`(第 899 行,位于 `runasAdmin` 与 `clientID` 之间)——全代码库**零引用**。 + +两者**不相邻**(中间隔着 `clientID/parentHwnd/superAdmin/pwdHash/install*`),不存在 507 字节的连续空洞;扩展 `szReserved` 还会移动其后所有字段,破坏性与扩尾相同。可用的只有尾部 496 字节。 + +内置证书 PEM 1042 字节,裸 DER 约 730 字节 —— **单张自签证书都放不下**,CA fullchain(约 3.5 KB)差得更远。 + +--- + +## 3. 关键决策 + +### 3.1 D1:不新增 `protoType` + +`protoType` 是「传输方式」,TLS 是「是否加密」。在 TCP/HTTP/WS/WSS 这几条路径上两者正交(§2.2),而 `protoType` 恰恰是这份代码里被改写次数最多的字段: + +| 位置 | 行为 | +|---|---| +| `BuildDlg.cpp:545` | `GetCurSel()` 直接当协议值;注释明确「序号即取值,中间不能有空洞」 | +| `KernelManager.cpp:41` | `PROTO_RANDOM` 每次连接随机化 | +| `ClientDll.cpp:634` `ApplyProtoSwitch` | 在线升级换 DLL 时被外壳注入的 `protoType` 改写 | +| `2015RemoteDlg.cpp:5259` | 在线下发客户端时再写一遍 | +| `KernelManager.cpp:39` `NewNetClient` | 按值分流,`PROTO_HTTPS` 直接返回 `NULL` | + +再加一个枚举值就要在以上五处加分支,并处理「proto=TLS 但没锚」「有锚但 proto=TCP」两类矛盾态。而且它**解决不了 UDP/KCP 的问题**(§3.7)——那需要在复选框上做能力判断,不是加一个协议值能解决的。 + +**替代**:生成界面加复选框「内嵌服务端 TLS 信任锚(首连即 TLS)」。协议仍为 TCP。 + +> 若希望下拉框里看得见 `TCP+TLS`,做法是 **UI 别名**:选中它只置 `protoType = PROTO_TCP` 并勾选内嵌复选框,**不产生新的线值**。本文推荐独立复选框。 + +### 3.2 D2:独立自描述锚块,不动 `CONNECT_ADDRESS` + +| 方案 | 结论 | 否决原因 | +|---|---|---| +| **B(采用)** payload 内独立锚块 | ✅ | — | +| A. 把 `szFututre` 扩到 4 KB | ❌ | 生成端 `memcpy(..., sizeof(g_ConnectAddress))` 会按**新**结构体长度写进**老** stub,越界约 3.6 KB,静默损坏且无告警;`szBuildDate` 比的是日期不是尺寸。另外 `ModifyFlag()` 值返回、`new CONNECT_ADDRESS(*conn)` 每实例复制 4 KB | +| C. PE 资源(`UpdateResource`/`FindResource`) | ❌ | MemoryModule 手动映射时拿不到资源(同类问题已见 `chat-dialog-missing-on-shellcode-client`);UPX、SC 变体同样不可靠 | +| D. PE 尾部追加 | ❌ | UPX 后读自己文件是压缩字节;纯 ShellCode 变体没有文件可读 | +| E. 外置 `yama-ca.pem` / `settings.ini` | ⚠️ | **今天已经支持**(§2.2 第 2 级),保留为兜底与调试手段,但不符合「内嵌」要求 | +| F. 只存哈希做钉扎(32 字节) | ❌ | 要新增一条手工校验路径(`SCH_CRED_MANUAL_CRED_VALIDATION` + `SECPKG_ATTR_REMOTE_CERT_CONTEXT`),丢掉链校验,换证书同样全死 | +| G. TOFU:首连明文,登录后自动下发 | ⚠️ | 首连是明文,恰是本需求要消灭的。仅作容错(§6.1) | + +**为什么 B 能覆盖所有包装形态**:锚块与 `CONNECT_ADDRESS` 在**同一个镜像、同一条字节搬运路径**上。生成端在写文件(`BuildDlg.cpp:608`)之前就完成写入,其后的 UPX、`MakeShellcode`(`2015RemoteDlg.cpp:2221` 的 `ConvertToShellcode`)、ShellCode BIN、图片/ZIP/PDF 伪装全部在其下游。凡 `CONNECT_ADDRESS` 能活到运行时的变体,锚块也一定能。 + +**为什么 B 对老 stub 安全**:老 stub 里没有锚块 → 生成端报 `NoBlock` 并**放弃生成**,不会越界写。A 方案做不到这一点。 + +### 3.3 D3:锚块格式、容量与"不被优化掉" + +共享结构放 `common/tls_anchor.h`: + +```cpp +#pragma pack(push, 4) +struct EmbeddedTlsAnchor { + char magic[16]; // "YAMA_TLS_ANCHOR" + uint32_t version; // 1 + uint32_t capacity; // sizeof(pem),stub 的编译期常量 + uint32_t length; // 实际写入的 PEM 字节数;0 = 未内嵌 + uint32_t hash; // FNV-1a(pem[0..length)),半截写入可立刻识别 + char master[100]; // 生成时配置的主控地址(明文,含分号多地址),见 §3.6 + char pem[4096]; +}; +#pragma pack(pop) +// sizeof == 4228 +``` + +**定义方式(关键,不能省)**:在**独立编译单元** `client/EmbeddedTlsAnchor.cpp` 里定义,且必须 + +```cpp +volatile EmbeddedTlsAnchor g_embeddedTlsAnchor = { + { 'Y','A','M','A','_','T','L','S','_','A','N','C','H','O','R','\0' }, + 1, 4096, 0, 0, { 0 }, { 0 } +}; +``` + +理由:`ghost_vs2015.vcxproj` / `ClientDll_vs2015.vcxproj` 都是 `WholeProgramOptimization=true`(第 46/53 行)+ `Optimization=MinSpace`(139/163 行)+ `EnableCOMDATFolding/OptimizeReferences=true`(150/151 行)。若把它写成 `const`,`length` 恒为 0,`IsAnchorBlockValid()` 会被内联并常量折叠为 `false`,唯一的读取点随之变成死代码,**整个对象可被 LTO 删除**——结果就是所有生成都报 `NoBlock`。`volatile` + 独立 TU + 外部链接,三重保证它必须被发射。 + +**必须含非零初值**:全零初值会落进 `.bss`,文件里没有这些字节,生成端扫不到 magic。 + +**查找与校验(关键)**:magic 字符串在二进制里**不止一份**——`"YAMA_TLS_ANCHOR"` 字面量本身也会在 `.rdata` 里出现一次。因此生成端不能"找到第一处就写",必须: + +1. `MemoryFind` 扫出**所有** magic 命中; +2. 对每个命中按结构体校验:`version == 1 && capacity == 4096`,且 `length == 0 ? hash == 0 : hash == Fnv1a(pem, length)`; +3. **恰好一个**通过 → 写它;**零个** → `NoBlock`;**多于一个** → `Ambiguous`(宁可报错也不猜)。 + +容量取 4096:自签证书 1042 B、Let's Encrypt fullchain 约 3.5 KB 都放得下。代价是每个 stub 多约 4.2 KB。超长时**报错,绝不截断**——截断的 PEM 会让客户端进入 fail-closed 且无恢复通道(§6.1)。 + +### 3.4 D4:读取优先级 + +`ReadTrustAnchor()` 改为四级(新增的两级加粗): + +1. 注册表 `settings\tls_disabled == "1"` → **未配置**(明文),直接返回; +2. 注册表 `settings\tls_cert` 存在 → 用它(值为空仍按 fail-closed 处理,语义不变); +3. `settings.ini [settings] tls_cert` 路径 / exe 同目录 `yama-ca.pem` → 用它; +4. **内嵌锚块**:`length > 0`、hash 校验通过、**且主控地址匹配**(§3.6)→ 用它; +5. 都没有 → 明文。 + +注册表代表「运维近期下发过」,优先级最高;文件代表「手工投放」,可覆盖构建期默认;内嵌锚是出厂默认。`source` 字符串新增 `"embedded"`。 + +### 3.5 D5:取消 TLS 的抑制标记,及其边界 + +**必须补的坑**:现有 `COMMAND_TLS_DISABLE` 只删注册表值;若内嵌锚仍在,客户端会回落到内嵌锚继续 TLS,而服务端此时按明文处理 → ClientHello 被嗅探到但 `IsReady()==false` → fail-closed 关闭 → 客户端再也连不上。 + +处理: + +- `COMMAND_TLS_DISABLE`:写 `settings\tls_disabled = "1"` → 删 `tls_cert` → 热重载; +- `COMMAND_TLS_ENABLE`:删 `tls_disabled` → 写 `tls_cert` → 热重载; +- `COMMAND_SET_PROTO`(WSS,`certLen > 0` 时):**也要删 `tls_disabled`**。否则 `BuildTlsAnchor` 返回 `TLS_ANCHOR_NONE`,`ApplyTlsStateLocked` 走成功分支(`TlsChannel.cpp:203`)把 `g_tlsEnabled` 置 false 并返回 true,切换照常进行、`m_useTls` 保持 false,最终**静默降级成明文 WS**(`IOCPClient.cpp:551`)——正是该分支注释里说要避免的事。 +- 服务端 `OnExperimentTlsDisable`(`2015RemoteDlg.cpp:5123`)的 `if (!IsReady()) return;` 守卫**必须去掉**:否则服务端一旦关掉 TLS,就再也无法给在线主机下发"取消 TLS",客户端直接被锁死。 + +**必须承认的边界(v0.1 说得过头了)**:抑制标记只能通过一条**已经连上的**连接送达。 + +- 在线主机:指令送达 → 回落明文 → 正常。 +- **离线主机 / 刚生成就指向已关闭 TLS 的服务端的主机**:它发 ClientHello → 服务端 `StartTlsHandshake` fail-closed → 永远收不到标记 → **永久失联**,只能重新生成客户端。 + +因此「关闭服务端 TLS」对已分发内嵌锚客户端是一次**单向门**。运维规程(写进 §6.1 与用户手册):**先对全部在线主机下发"取消 TLS",确认列表里不再有内嵌锚主机,再关闭服务端 TLS**。 + +为让操作员看得见,新增一个能力位(仿 `CLIENT_CAP_PROTO_SWITCH`,`server/2015Remote/context.h:110`):`CLIENT_CAP_EMBEDDED_ANCHOR`,客户端在**本次连接**的 TLS 锚来源为 `embedded` 时上报(`IOCPClient::IsTlsAnchorEmbedded()`,取自该连接握手时校验用的那套状态,见 §3.6)。在线列表与「取消 TLS」确认框据此提示"选中的主机里有 N 台使用内嵌信任锚"。 + +### 3.6 D6:锚必须绑定主控地址(阻塞级) + +一个客户端会被指向**另一台主控**,而内嵌锚钉的是生成时那台: + +```cpp +// client/ClientDll.cpp:735 —— 被转移(assigned)的客户端改连新主控 +auto saved_ip = cfg.GetStr("settings", "master"); +settings.SetServer(saved_ip.c_str(), saved_port); +// client/ClientDll.cpp:766 —— 分享列表里的实例连到别的分享主控 +auto a = NewClientStartArg(shareList[i].c_str(), IsSharedRunning, TRUE, proto); +``` + +两条路径最终都走 `IOCPClient::ConnectServer` 的 `if (TlsEnabled() && ...) Handshake()`。今天的客户端没有锚,所以连过去是明文、由对方下发自己的锚;**有了内嵌锚就会用 A 的证书去校验 B,握手失败即 fail-closed,分享/转移功能直接失效且无法自愈**。 + +**做法**:锚块里存生成时的主控地址 `master[100]`(明文原样存 `m_strIP`,含分号多地址,不受 `bEncrypt` 影响)。判定**按连接**做,位置在 `TlsChannel::Handshake()` 入口(`TlsChannel.cpp` 的 `ResolveStateIndex`),依据是这条连接自己的目标地址: + +``` +本连接目标与锚的主控地址相交 → 本连接用内嵌锚 +否则 → 本连接不用内嵌锚(记一行日志),回落到「明文首连 + 由对方下发」 +``` + +「相交」分两层,任一命中即可: + +1. 配置里只写了一个地址,且与锚的主控地址字符串相等(域名对域名,不依赖 DNS 答案在两次查询之间保持一致); +2. 连接目标 IP 与锚的主控地址(可能分号多地址、可能是域名)解析出的 IPv4 有交集——并行多主控实例连的是 `DomainPool` 解析后的单个 IP,生成端填的却是域名,只能靠这一层。 + +被转移的客户端(`assigned`)、分享实例(`IsSharedRunning`)与并行多主控实例都会因为地址不匹配而自动跳过内嵌锚,行为与今天一致。转移窗口过期后仍按同一规则重新判定。 + +> **不能写成进程级开关**:分享实例与并行实例是**同一进程里的线程**,`TlsChannel` 的状态又是首次访问即缓存。v1.0 实施初稿把判定放在 `ClientDll.cpp::StartClient()` 写一个全局标志,先连上的实例替所有实例做了决定(分享连接/并行连接因此被判成该用 A 的锚 → fail-closed)。现按连接判定,且「允许内嵌锚」「不允许」各缓存一套 store + 链引擎,能力位也随之按连接上报。 + +> 这条路选"地址匹配"而不是"进程标志",是因为转移/分享的目标地址就写在配置里,判定不依赖任何额外状态,也不会在重连循环里漂移。 + +### 3.7 D7:UDP / KCP / 随机 协议不支持内嵌 + +`IOCPUDPClient` 与 `IOCPKCPClient` 各自 override `ConnectServer`,代码里**完全没有 TLS**(两个文件里 `Tls`/`Handshake` 零命中)。因此: + +- 协议选 `UDP` / `KCP` / `随机` 时,**内嵌复选框置灰**,提示"该协议不走 TLS"; +- 既有的 `LoginServer.cpp:476` `AddReserved(TlsEnabled() ? 1 : 0)` 在这些协议下会**误报加密**(`TlsEnabled()` 为 true 但连接是明文 UDP/KCP)。这是既有缺陷,本设计一并改为按实际传输上报。 + +**落地时收窄为「只有 `TCP` / `HTTP` 可内嵌」**(v0.3 定稿是「排除 UDP/KCP/随机」,v1.0 实施收窄): + +| 协议 | 内嵌锚的结局 | 结论 | +|---|---|---| +| `TCP` / `HTTP` | 直连本服务端,锚就是本服务端的证书 | ✅ 可用 | +| `WS` | `ConnectServer` 的 `protoType != PROTO_WS` 判断直接跳过 TLS 通道,锚永不参与 | 🚫 无意义 | +| `WSS` | 锚被拿去校验**反向代理**(nginx/Let's Encrypt)的证书,不是本服务端的证书 → 换成内嵌锚反而会让原本靠 `yama-ca.pem` 能连的客户端握手失败 | 🚫 有害 | + +`WSS` 的锚由「协议切换」随包下发(`ProtoSwitchPacket` 后的 PEM,见 `KernelManager.cpp` 的 `COMMAND_SET_PROTO` 分支),与内嵌锚互不相干。 + +### 3.8 D8:分享 / 转移与 TLS(本期约束,不改变既有语义) + +客户端被指向另一台主控有两条路径(见 §3.6 引用的 `ClientDll.cpp:735` 与 `:766`),它会把**当前生效的锚**一并带过去。锚不绑地址(只有 §3.6 的内嵌锚有地址绑定),于是: + +| 客户端持有的锚 | 新主控 B | 结果 | +|---|---|---| +| 已下发(注册表 `tls_cert`) | 与 A **同一张**证书/私钥 | ✅ 正常,仍是 TLS | +| 已下发(注册表 `tls_cert`) | **不同**证书 | ❌ 校验失败 → 客户端 fail-closed | +| 已下发(注册表 `tls_cert`) | 未开 TLS | ❌ 客户端发 ClientHello,B 在 `StartTlsHandshake`(`IOCPServer.cpp:988`)`IsReady()==false` → fail-closed | +| 内嵌锚 | 任何配置 | ✅ §3.6 地址不匹配即跳过 → 明文首连 → B 下发自己的锚 | +| 无锚 | 未开 TLS | ✅ 明文 | + +**没有"降级回明文"的退路**:发不发 ClientHello 由 `TlsEnabled()`(只看有没有锚)决定,不看对端是谁。 + +因此:**只要客户端持有"已下发锚",分享/转移就要求新主控使用同一张证书**——这是今天就已成立的行为,不是本设计引入的。本期**不引入**按主控分键存锚(`tls_cert_`),而是把它固化为运维约束: + +- 多主控部署时把同一对证书/私钥同步到所有主控;内置证书时即把 `[tls] BuiltinCert` / `BuiltinKey` 两项复制过去(它们是 base64 文本,运维上等价于分发同一张自签证书); +- 或**先对目标主机下发"取消 TLS",再转移/分享**。转移完成后原主控已联系不上该主机,这一步不能补。 + +**分享实例必须隔离 TLS 指令**(新增,约 5 行)。分享实例与主实例是**同一进程里的两个 `ClientApp` 线程**(同一 exe 路径,同一份内存配置),注册表键同为 `Software\\settings`(`common/iniFile.h:54`),连进程内的 TLS 状态也是共用的。若允许 B 给分享实例下发 `COMMAND_TLS_ENABLE`,写入的正是 A 也在读的 `tls_cert`: + +1. 主实例下次重连会用 B 的证书去校验 A → 握手失败; +2. A 从此彻底连不上这台主机(fail-closed),**只能到现场处理**。 + +`COMMAND_SET_PROTO` 已因同一理由忽略分享实例(`KernelManager.cpp:915-920`,注释:"分享实例的连接入口由分享方控制,主控的协议切换对它无效")。TLS 启停沿用这条策略——与「被分享的主机无权切换协议」一致——`COMMAND_TLS_ENABLE` / `COMMAND_TLS_DISABLE` 在 `IsShared()` 时一律忽略并记一行日志。 + +代价:分享连接永远不加密(与今天一致)。要支持"多主控各自不同证书都加密",需把锚改为按主控分键存放并处理迁移,留作后续版本。 + +--- + +## 4. 详细设计 + +### 4.1 `common/tls_anchor.h`(新增) + +结构如 §3.3;另提供: + +```cpp +constexpr uint32_t kAnchorVersion = 1; +constexpr uint32_t kAnchorCapacity = 4096; +uint32_t Fnv1a(const char* data, size_t len); // 与 GetExeHashStr 同一算法 +bool IsAnchorBlockValid(const EmbeddedTlsAnchor& a); // version/capacity/hash 全检 +``` + +magic 用**字节初始化列表**写进结构体,不要在运行时引用一个独立的 16 字节常量对象(否则 `.rdata` 里多一份副本,见 §3.3 的查找规则)。 + +### 4.2 客户端 `client/EmbeddedTlsAnchor.cpp` / `.h`(新增) + +`g_embeddedTlsAnchor` 的定义、`GetEmbeddedTlsAnchor()` 访问器。单独成 TU 是为了 §3.3 的发射保证。 + +### 4.3 客户端 `client/TlsChannel.cpp` + +1. `ReadTrustAnchor(pem, source, allowEmbedded, quiet)`: + - 函数开头处理 `tls_disabled`; + - 末尾追加内嵌锚分支:`length > 0` + hash 校验 + `allowEmbedded`(是否允许由调用方按连接决定,见第 3 条); + - hash 校验失败但 `length > 0`:记一行 `Mprintf`,按未配置处理(§6.4)。 +2. **两套缓存状态**:`TlsState g_state[2]`——`[1]` 允许内嵌锚、`[0]` 不允许,各自带 store + 链引擎,首次访问时经 `EnsureStateLocked` 建好;`BuildTlsAnchor` / `ApplyTlsStateLocked` 增加 `allowEmbedded` / `quiet` 参数(`quiet` 用于「本连接不用」那套,避免把不适用本连接的 enabled 行印在本连接状态之前)。`TlsReload` 一次重建两套,任一套失败只影响它自己(运行期失败保留原状态,不打死正在工作的客户端)。 +3. **按连接判定**:`ResolveStateIndex(host, configured)` 即 §3.6 的两层地址匹配,带 DNS 结果缓存(成功永久缓存、失败负缓存 60 秒),**且必须在取 `g_tlsMtx` 之前调用**——解析域名可能阻塞数秒,不能压在证书校验那把锁里。在 `Handshake()` 开始时定下用哪一套状态(`m_stateIdx`);`VerifyServerCert()` 用 `g_state[m_stateIdx]`,同时把来源写进 `m_anchorEmbedded`(能力位用)。对外接口为 `TlsEnabledFor()` / `TlsLoadErrorFor()` / `TlsChannel::AnchorEmbedded()`。 + +### 4.4 客户端 `client/KernelManager.cpp` + +`COMMAND_TLS_ENABLE` / `COMMAND_TLS_DISABLE` / `COMMAND_SET_PROTO` 三处加 `tls_disabled` 读写(§3.5)。`m_cfg` 恒为 `new iniFile(CLIENT_PATH)`(`KernelManager.cpp:79`),与 `ReadTrustAnchor` 直接读的注册表位置一致,无后端错配。 + +`COMMAND_TLS_ENABLE` / `COMMAND_TLS_DISABLE` 入口再加一道分享实例判断(§3.8),与 `COMMAND_SET_PROTO`(`KernelManager.cpp:917`)同一策略: + +```cpp +if (m_ClientApp && m_ClientApp->IsShared()) { + Mprintf("[TLS] ignored: shared instance follows the sharing host's anchor\n"); + break; +} +``` + +### 4.5 客户端 `client/ClientDll.cpp` + +`StartClient()` **不再**比对锚块、也不设任何进程标志(§3.6 的地址判定与 TLS 状态都在 `TlsChannel` 里按连接完成)。登录时上报能力位:`LoginServer::GetLoginInfo(..., ClientObject->IsTlsActive(), ClientObject->IsTlsAnchorEmbedded())`。 + +### 4.6 服务端 `server/2015Remote/EmbeddedAnchor.h/.cpp`(新增) + +```cpp +enum class EmbedResult { Ok, NoBlock, Ambiguous, NoAnchor, TooLong }; +EmbedResult EmbedTlsAnchorInto(BYTE* payload, DWORD size, const std::string& master, + DWORD& pemLen, std::string& err); +bool TlsAnchorSummary(std::string& out); // "builtin 2036-11-01 sha1:1a2b3c4d5e6f" +``` + +实现按 §3.3 的三步校验;写入 `version/length/hash/master/pem`,`pem` 与 `master` 尾部清零。超长报错并带实际字节数。**必须在压缩/加壳之前调用**。 + +`TlsAnchorSummary` 是 v1.0 实施时新增的:把 PEM 的第一张证书解出来,取 `NotAfter` 与 +`CERT_SHA1_HASH_PROP_ID` 前 12 位,拼成一行摘要。用途见 §4.7 最后一条。 + +(v0.3 还计划过一个 `PayloadSupportsEmbeddedAnchor()`,实施时删掉了:它和 +`EmbedTlsAnchorInto()` 的 `NoBlock` 返回值信息重复,留着只是死代码。) + +### 4.7 生成界面 `server/2015Remote/BuildDlg.cpp/.h` + +- `OnInitDialog()` 里 `CButton::Create()` **动态创建**复选框,DLU 矩形 `(216, 70, 412, 82)` + ——「协议」行与「Port」行之间的空白带;文案走 `_TR()`,控件 ID 为 + `IDC_CHECK_TLS_ANCHOR`(`resource.h` 2621)。不改进 `.rc` 的理由是位置与文案只在一个 + 地方维护;`.rc` 本身是 UTF-16,并非不能编辑。 +- 可用性三条件,任一不满足即置灰:`ServerTlsIdentity::IsReady()`;生成目标含客户端代码 + (§2.5);协议是 `TCP`/`HTTP`(§3.7 的收窄结论)。 +- **置灰时把原因写进文案本身**(`内嵌TLS信任锚(服务端未启用TLS)` 等 5 种形态),因为置灰 + 控件收不到 tooltip——`CBuildDlg` 的 tooltip 只在 `IDC_SLIDER_CLIENT_SIZE` 上生效。 +- 勾选状态用三态 `m_nAnchorUserCheck`(-1 未表态 / 0 / 1):没表过态就默认勾选,表过态就 + 以用户的为准。不能用「由不可用变为可用就打勾」——那样用户取消后切一次协议再切回来, + 取消会被悄悄改回勾选(§14.5 第 2 条)。 +- 生成流程里在 `CONNECT_ADDRESS` 补丁循环之后、写文件之前调用 `EmbedTlsAnchorInto()`。 + **写了一半失败一律放弃生成**(`Ambiguous` / `NoAnchor` / `TooLong`,提示里带 `err` 原文); + `NoBlock` 是例外——模板里压根没有锚块,一个字节都没动,此时提示一句、取消勾选、**照常 + 生成**。否则「升级主控后忘了重编 ghost/ServerDll 资源」会让每次生成都被那个默认勾选挡住。 +- 锚摘要**不在复选框旁**,而是放在生成成功后的提示里(`已内嵌TLS信任锚: builtin 2036-11-01 + sha1:…`):那条空白带只有 196 DLU(约 24 个全角字),放不下摘要;而「这批客户端钉的是 + 哪张证书」在生成那一刻核对即可。 +- `TestRun` 系列:置灰,文案为 `内嵌TLS信任锚(锚在ServerDll.dll里)`;生成 `ServerDll.dll` + 时若没勾,给一条**非阻塞提示**(`提示: 未内嵌TLS信任锚,本批客户端首次连接为明文…`)。 + +### 4.8 在线下发路径 `server/2015Remote/2015RemoteDlg.cpp` + +`ReadExeFromResource()` 在 `CONNECT_ADDRESS` 循环之后调用 `EmbedTlsAnchorInto()`:`Ok` 则内嵌; +`NoBlock` / `NoAnchor` **静默跳过**(目标可能是 Linux/macOS 客户端或用户自选文件);其余失败 +只写一行 `Mprintf`,不中断下发。注意传 `outSize` 而不是 `dwFileSize`——扫描循环已经把后者 +递减成「剩余未扫描长度」。 + +`COMMAND_UPDATE` 清 `tls_disabled` 落在**客户端**(`KernelManager.cpp`):收到新镜像后扫一遍 +payload,`IsAnchorBlockValid && length > 0` 才清。**不做无条件清除**——否则一台已被要求走明文 +的主机会重新发 ClientHello,撞上明文服务端就是不可恢复的失联,正是 §3.5 要避免的那个失败。 +被 UPX / AES 包过的镜像扫不到锚,按「没带锚」处理(保持既有行为)。 + +### 4.9 服务端在线列表与「取消 TLS」 + +- 上报 `CLIENT_CAP_EMBEDDED_ANCHOR`(§3.5),列表可标注。 +- `OnExperimentTlsDisable` 去掉 `IsReady()` 守卫(证书损坏时的恢复通道);确认框在 + `ResolveCommandTargets()` + `m_cs` 下数出 `UsesEmbeddedAnchor()` 的台数,追加一句警告, + 并把默认按钮改到「否」。首发文案沿用原文案,避免已有多语言译文作废。 + +### 4.10 语言文件 + +新增 11 条(键为简体中文原文):5 种复选框文案、`NoBlock` 报错、重试提示、摘要前缀、 +`ServerDll` 未勾提示、内嵌锚台数警告、模板无锚块时照常生成的非阻塞提示。 + +台数警告的键带 `%d`(`%d 台主机使用生成时内嵌的信任锚:…`),由 `CString::Format` 填。不要 +在代码里拼 `n + _TR("台主机…")`:英文/德文句首没有空格,拼出来就是 `3host(s) use`、 +`3Host(s) nutzen`。 + +落盘:`lang/en_US.ini`、`lang/zh_TW.ini`(同时是内嵌 RCDATA)、`lang/de_DE.ini`。三者均为 +**GBK、LF、无 BOM、按字节编辑**,键不能含 `=`,键里的换行写成字面 `\n`(`CIniParser::Unescape` +会还原)。 + +**源文件编码**:本仓库 `.cpp/.h` 是 **UTF-8 带 BOM**,而 ini 是 GBK——两者能对上,靠的是 +编译器用 ACP(936) 作执行字符集把字面量转成 GBK。新增文件若漏了 BOM,MSVC 会按 GBK 解读 UTF-8 +源码:CJK 注释里出现「尾字节 0x5C + 换行」就会行拼接,把后面几行吞进注释,报出一串 +"`'{'` 语法错误" 且行号整体偏移。本次实施踩过一次,见 §14。 + +### 4.11 工程文件 + +`2015Remote_vs2015.vcxproj/.filters` 注册 `EmbeddedAnchor.h/.cpp`;`ghost_vs2015` / +`ClientDll_vs2015` 的 `.vcxproj` 与 `.filters` 注册 `EmbeddedTlsAnchor.h/.cpp`; +`common/tls_anchor.h` 只被 include,无需登记(这两个客户端工程本来也不登记 `common/` 下的文件)。 +Linux 客户端编的是 `client/TlsChannelLinux.cpp`,不含 `LoginServer.cpp`,不受影响。 + +--- + +## 5. 前置问题与处置 + +### P1. Windows 客户端只加载 PEM 里的**第一张**证书(既有缺陷) + +`client/TlsChannel.cpp:91` `LoadTrustAnchor()` 用 `CryptStringToBinaryA(..., CRYPT_STRING_ANY)` 解出一张证书后 `CertAddCertificateContextToStore` **一次**就返回;而 Linux 端 `client/TlsChannelLinux.cpp:120` `LoadAnchors()` 是**循环读完全部 PEM 块**。 + +影响:内置自签证书是单张,不受影响;用户自备 **leaf-first fullchain** 时,Windows 客户端只把叶证书放进独占根存储 → 链建不起来 → 握手失败 → fail-closed。即 `ServerTlsSession.cpp:198` 注释里"fullchain 一并下发"在 Windows 端并未真正生效。 + +与本设计的关系:§3.3 的 4096 容量是为 fullchain 留的;P1 不修则这句话只是容量上的空话。**已决定本期一并修**(约 30 行 + 一个 fullchain 用例),否则内嵌功能只能限定为「仅内置自签证书」。 + +修法:`LoadTrustAnchor()` 改为与 `TlsChannelLinux.cpp:120` 同构——循环 `CryptStringToBinaryA` 逐块解码(每轮用 `pdwSkip` 前进),每个块 `CertAddCertificateContextToStore` 一次,统计成功数量;至少一个成功才算配好锚。 + +### P2. stub 二进制与主控资源必须同版本 + +`ghost.exe` / `ServerDll.dll` 作为资源内嵌在主控里(`IDR_GHOST_X64` 等),也可能从 `res` 目录外部读取。未随本次改动重新编译 → 生成端 `NoBlock` 报错。这是**有意的显式失败**,不会产出坏文件。发布流程需提醒:**刷新 ghost / ServerDll 资源后再发布**(与 `linux/ghost` 由用户收尾提交的既有约定一致)。 + +### P3. 老客户端不认识 `tls_disabled` / 能力位 + +老客户端没有内嵌锚,也就没有抑制问题;多一个注册表值、少一个能力位都不影响它。**无兼容问题**。 + +--- + +## 6. 安全与运维影响 + +### 6.1 fail-closed 死锁与恢复通道(最重要的运维风险) + +内嵌锚一旦与服务端实际证书不一致,客户端**首连即失败**,且失败后连不上服务端 → 收不到新锚 → 自我封死。触发条件: + +1. 运维换了服务端证书(`CertPath`/`KeyPath`,或内置证书被重新生成); +2. 服务端的 Windows 用户变了 / 注册表被清(内置证书存在 HKCU,会重新生成一张); +3. 生成客户端时服务端起的是 A 证书,实际部署用的是 B; +4. 服务端关闭 TLS(§3.5)——在线主机可救,**离线主机不可救**。 + +**缓解**: + +- 生成界面显示锚的**指纹前 12 位 + 有效期**,操作员可核对; +- 在线列表标注内嵌锚主机,「取消 TLS」前给出数量提示; +- 文档与用户手册明确两条单向门:**换证书 = 已分发客户端全部作废**;**关服务端 TLS 前必须先逐台下发取消**; +- **转移/分享前**:要么确认新主控持有同一张证书,要么先对目标主机下发「取消 TLS」(§3.8); +- 不在客户端做「握手失败 N 次后降级明文」——那是降级攻击面,与现有设计一致(`IOCPClient.cpp:526`)。 + +可选增强(不在本期):锚块写入多张证书(新老并存),给证书轮换留过渡窗口。P1 修好后 PEM 多块拼接天然可用。 + +### 6.2 取证影响 + +内嵌证书是**公开信息**,不降低传输安全性;但它把"这台主控用的是哪张自签证书"写死在样本里,取证方据此可关联同源样本。这是"内嵌"相对"下发"的固有代价。 + +### 6.3 抑制标记与能力位被篡改 + +`tls_disabled` 在客户端注册表(HKCU,当前用户可写)。能改它的攻击者同样能直接删 `tls_cert`;删掉标记只会让客户端回到内嵌锚状态,**仍是 TLS**。不构成新增攻击面。 + +### 6.4 锚块损坏时的行为 + +`length > 0` 但校验不过 → 记日志并按「未配置」处理,回落到下一级来源或明文。**不按 fail-closed 处理**:损坏的可能是构建产物本身,fail-closed 会让整批客户端彻底不可用;明文回落至少还能连上并接受 `COMMAND_TLS_ENABLE`。这与「注册表值为空 → fail-closed」的语义不同是有意的:注册表值代表运维的明确动作,锚块代表构建默认值。 + +### 6.5 抑制标记会"继承"到重新生成/更新的客户端 + +注册表以 **exe 全路径哈希**为键(`common/iniFile.h:54` `GetExeHashStr()`)。同一个安装路径重新生成或在线更新后,客户端的注册表状态**保留**,包括 `tls_disabled=1`。后果:运维刚内嵌的锚被上一轮的抑制标记悄悄作废,连接回到明文且无提示。 + +处理:`COMMAND_UPDATE` / `COMMAND_UPLOAD_EXEC` 下发新客户端时顺带清除 `tls_disabled`;且内嵌锚主机被抑制时,客户端日志与在线列表都要能看到(§4.9 的能力位)。 + +--- + +## 7. 兼容性矩阵 + +| 客户端 \ 服务端 | 未改动的老服务端 | 本设计的新服务端 | +|---|---|---| +| 老客户端(无锚块、无 tls_cert) | 明文,不变 | 明文,不变 | +| 老客户端 + 已下发 tls_cert | TLS,不变 | TLS,不变 | +| 新客户端(锚块 length=0) | 明文 | 明文 | +| 新客户端(内嵌锚,**同一主控**) | 连不上 | TLS,首连即加密 | +| 新客户端(内嵌锚,**被转移/分享到另一台主控**) | 明文(锚不匹配,跳过) | 明文首连,由对方下发自己的锚 → 之后 TLS | +| 已下发 `tls_cert` 的客户端,**被转移/分享到另一台主控**(新主控**不同**证书或未开 TLS) | 失败(锚不绑地址,§3.8) | 失败,**只能**先取消 TLS 或让新主控持有同一张证书 | +| 同上,新主控持有**同一张**证书 | TLS,不变 | TLS,不变 | +| 分享实例(`IsShared()`)收到 TLS 启停指令 | —— | 忽略,锚与主连接均不变(§3.8) | +| 新客户端 + 服务端已关闭 TLS | —— | 在线时可被下发取消;离线时永久失联(§3.5) | +| 任何客户端 + `UDP`/`KCP`/`随机` 协议 | 明文 | 明文(内嵌复选框已置灰,§3.7) | + +「新客户端(内嵌锚)+ 老服务端」这一行:老服务端**没有嗅探逻辑**,会把 ClientHello 的首字节 `0x16` 当成普通命令字节喂给协议解析器,随后因协议不匹配断开(不是"按垃圾关闭",而是"误解析后超时/断开")。这是内嵌的必然后果;生成时若服务端 TLS 未就绪,复选框置灰,从流程上避免产出这种客户端。 + +--- + +## 8. 测试计划 + +**构建产物检查(不依赖运行)** +1. 生成 ghost.exe(不勾选)→ 锚块 `length == 0`;运行后日志 `[TLS] disabled: no trust anchor configured`。 +2. 生成 ghost.exe(勾选)→ `length == 1042`、`hash` 匹配、`master` 与配置一致、PEM 与 `AnchorPem()` 逐字节相同;用 `ChainProbe` 复刻客户端校验,`dwErrorStatus == 0`。 +3. 用未经刷新的老 ghost.exe 资源生成 → `NoBlock` 报错,**不产生输出文件**。 +4. **四种包装各生成一份**(无压缩 / UPX / `PE->ShellCode` / **`ShellCode AES`(默认档)**),确认锚块内容一致。 +5. 同一份 payload 里出现两份 magic 时(人为构造)→ `Ambiguous` 报错。 + +**端到端** +6. 服务端启用内置 TLS → 生成客户端 → 干净环境运行 → 服务端日志首连即握手,`openssl s_client` 独立验证 `Verification: OK`。 +7. 下发"取消 TLS" → 客户端回落明文并重连成功;再下发"启用 TLS" → 回到 TLS。**服务端侧关掉 `[tls] Enabled` 后再下发取消 TLS 也要能发出去**(§3.5 守卫已去掉)。 +8. 内嵌锚客户端 + WSS 切换:`tls_disabled` 状态下切换 WSS 必须**不**静默降级(§3.5 第三条)。 +9. **分享/转移(内嵌锚)**:内嵌锚客户端被转移到另一台主控 → 明文首连成功、由对方下发锚后转 TLS;分享列表实例同样。 +10. **分享/转移(已下发锚)**:先对主机下发 TLS,再转移到新主控。新主控**不同**证书 → 确认连不上(预期失败,§3.8 的约束生效);改走"先取消 TLS 再转移" → 明文连上、由新主控重新启用 TLS 成功。 +11. **分享实例隔离**:主控 A 分享一台主机到 B,B 对该分享连接下发"启用 TLS" → 客户端日志出现 `[TLS] ignored: shared instance`,注册表 `tls_cert` 不变,主实例与 A 的连接**不受影响**。反向(`COMMAND_TLS_DISABLE`)同样。 +12. `UDP`/`KCP`/`随机` 协议下复选框置灰(§3.7)。 +13. mem-DLL 场景:`ServerDll.dll` 内嵌锚,`TestRun.exe` 运行后仍为首连 TLS;**故意用过期的 `ServerDll.dll`** 验证会明确报错而不是静默明文。 +14. 在线更新(`COMMAND_UPDATE`)后:新内嵌锚生效,旧 `tls_disabled` 被清除(§6.5)。 + +**回归** +15. 老客户端(无锚)连新服务端,明文正常。 +16. 已下发 `tls_cert` 的老客户端不受任何影响。 + +--- + +## 9. 工作量估算 + +| 项 | 规模 | +|---|---| +| `common/tls_anchor.h` | ~70 行 | +| `client/EmbeddedTlsAnchor.h/.cpp` | ~50 行 | +| `client/TlsChannel.cpp` | +50 行 | +| `client/KernelManager.cpp`(含 §3.8 分享实例隔离 5 行) | ±35 行 | +| `client/ClientDll.cpp`(主控地址比对) | +25 行 | +| `client/LoginServer.cpp`(如实上报 TLS) | ±10 行 | +| `server/2015Remote/EmbeddedAnchor.h/.cpp` | ~150 行 | +| `BuildDlg.cpp/.h` | +110 行 | +| `2015RemoteDlg.cpp`(下发 + 能力位 + 去守卫) | +50 行 | +| `context.h` 能力位 | +5 行 | +| 语言文件 ×3 | +6 条/个 | +| 工程文件 | 4 处 | +| **合计** | **约 555 行,含验证 3–4 天**(不含 P1) | + +P1(Windows fullchain 循环加载):约 30 行 + 测试,半天。 + +--- + +## 10. 待定问题裁定(v0.3 已全部确认) + +| # | 问题 | 裁定 | 落点 | +|---|---|---|---| +| 1 | UI 形态:独立复选框 vs 下拉框 `TCP+TLS` 别名 | **独立复选框**(不产生新的 `protoType` 线值) | §3.1、§4.7 | +| 2 | 默认是否勾选 | **条件满足时默认勾选** | §4.7 | +| 3 | 锚块容量 | **4096** | §3.3 | +| 4 | 抑制标记命名 | **`settings\tls_disabled`**(值 `"1"`) | §3.5 | +| 5 | P1(Windows 只加载 PEM 首张证书)是否本期修 | **本期修**,fullchain 能力才真正可用 | §5 P1 | +| 6 | Linux / macOS / Android 客户端 | **本期不做**,留到下一版 | §2.5 | +| 7 | 锚绑定主控地址的策略 | **地址不匹配就不使用内嵌锚**(不做"先试一次、失败再退回"的降级) | §3.6 | +| 8 | 能力位 `CLIENT_CAP_EMBEDDED_ANCHOR` | **本期加**,让操作员看得见哪些主机钉的是内嵌锚 | §3.5、§4.9 | +| 9 | 分享/转移是否要求新主控同证书 | **要求**(只对"已下发锚"成立;内嵌锚因绑地址而不受限) | §3.8 | +| 10 | 分享实例能否被 TLS 启停 | **不能**,与「被分享的主机无权切换协议」同策略 | §3.8、§4.4 | + +本期范围因此确定为:**Windows 客户端 + MFC 服务端**,附带 P1 修复与分享实例隔离。 + +--- + +## 11. 设计自查记录(v0.1 初稿) + +| # | 自查发现 | 处理 | +|---|---|---| +| 1 | 若锚块是全零常量,会落进 `.bss`,文件里没有这些字节 | §3.3 要求非零初值 | +| 2 | `memcpy(sizeof)` 方案(A)对老 stub 是"静默损坏 + 看起来成功" | §3.2 把"老 stub 显式失败"提升为选 B 的核心理由 | +| 3 | 只写 `COMMAND_TLS_DISABLE` 会导致永不回落的死锁 | 新增 §3.5 D5 | +| 4 | 初稿默认"4 KB 可放 fullchain",但 Windows 客户端只加载第一张证书 | 新增 §5 P1 | +| 5 | `TestRun.exe` 是加载器,不含 `TlsChannel.cpp` | §2.5 逐目标核实 | +| 6 | `TinyRun.dll` 工程只有 `main.c` | §2.5 表格标为不支持 | +| 7 | 锚块校验失败若按 fail-closed 处理,会锁死整批客户端 | §6.4 明确"损坏 → 视为未配置" | +| 8 | 在线下发若对 `NoBlock` 报错,会阻断运维操作 | §4.8 区分两条路径的失败策略 | +| 9 | 内嵌锚客户端连老服务端是新增失败组合 | §7 单列说明 | +| 10 | 锚块在 UPX / ShellCode 之后是否还在 | §3.2 用同一条搬运路径论证 | +| 11 | `szReserved[11]` 其实也是零引用 | §2.6 一并列出,结论仍是放不下 | +| 12 | 生成端若找到多份 magic,写哪一份不确定 | §3.3 定义 `Ambiguous` | + +--- + +## 12. 独立审查后的修订(v0.1 → v0.2) + +第二轮由另一次独立通读完成(对照源码逐条核实)。采纳 11 条、驳回 1 条。 + +| # | 审查意见 | 处置 | 说明 | +|---|---|---|---| +| 1 | **阻塞**:内嵌锚未绑定主控,分享/被转移的客户端指向另一台主控时必然 fail-closed | **采纳** | 新增 §3.6 D6:锚块存生成时的主控地址,不匹配则本连接不使用内嵌锚(按连接判定,见 §3.6 的"不能写成进程级开关") | +| 2 | **阻塞**:`static const` 锚块在 LTCG + `MinSpace` + COMDAT 折叠下可被整段删除,导致所有生成都报 `NoBlock` | **采纳** | §3.3 改为独立 TU + `volatile` + 外部链接;已核实 `WholeProgramOptimization=true`、`Optimization=MinSpace`、`EnableCOMDATFolding=true` 确实开启 | +| 3 | magic 字面量在 `.rdata` 里另有一份副本,会造成 `Ambiguous` 或读到垃圾 `capacity` | **采纳** | §3.3 改为"扫出全部命中、只认通过结构校验的那一个";magic 用字节列表初始化 | +| 4 | 抑制标记只能送达在线主机,不能解决离线主机 | **采纳** | §3.5 增加"单向门"说明与运维规程;新增能力位让操作员看得见 | +| 5 | `tls_disabled` 会让 WSS 切换静默降级为明文 WS | **采纳** | §3.5 第三条:`COMMAND_SET_PROTO` 在 `certLen>0` 时清除标记 | +| 6 | UDP/KCP 根本不走 TLS,"TLS 与传输正交"只在 `IOCPClient` 成立 | **采纳** | 新增 §3.7:置灰 + `LoginServer` 如实上报 | +| 7 | 抑制标记写入与读取的后端不一致(Debug 用 settings.ini) | **部分驳回** | 核实:`m_cfg = new iniFile(CLIENT_PATH)`(`KernelManager.cpp:79`)恒为注册表,与 `ReadTrustAnchor` 一致;审查方引用的 `KernelManager.h:291` 是 `AuthKernelManager::THIS_CFG`,不是同一个成员。但其中"注册表键是 exe 路径哈希,移动/重命名会复活内嵌锚"成立 → 记入 §6.5 | +| 8 | 抑制标记会"继承"到重装/更新的客户端 | **采纳** | §4.8 下发更新时清除;§6.5 单列 | +| 9 | §3.3 的初始化写法编译不过(数组不能用另一个数组初始化) | **采纳** | 改为字节列表初始化,并给出完整形式 | +| 10 | §2.6 "合计 507 字节"把两个不相邻字段加在一起 | **采纳** | §2.6 改写为"只有尾部 496 连续可用" | +| 11 | mem-DLL 流程下 `ServerDll.dll` 过期会**静默明文**而不报错 | **采纳** | §4.7 加非阻塞警告;§8-11 加专项用例 | +| 12 | §7 最后一行机制描述不准(老服务端是误解析而非"按垃圾关闭") | **采纳** | §7 措辞改正 | + +审查还确认了以下结论无误:P1(Windows 单证书 vs Linux 循环)、三级锚来源与顺序、`COMMAND_TLS_DISABLE` 仅删 `tls_cert`、`szFututre`/`szReserved` 零引用、§2.5 的逐项目编译单元表、服务端嗅探与 fail-closed、`memcpy(..., sizeof(g_ConnectAddress))`、以及锚块在各包装路径下均能存活(写入点在 UPX/`MakeShellcode`/SCLoader/伪装之前)。 + +## 13. 定稿修订(v0.2 → v0.3) + +| # | 改动 | 落点 | +|---|---|---| +| 1 | §10 八项待定问题全部裁定,转为决议记录 | §10 | +| 2 | 新增 D8:分享/转移的证书约束(对"已下发锚"成立,今天即如此;内嵌锚因绑地址而不受限) | §3.8、§7、§8-10 | +| 3 | 新增分享实例的 TLS 指令隔离,复用 `COMMAND_SET_PROTO` 的既有策略 | §3.8、§4.4、§8-11 | +| 4 | 运维规程补一条:转移/分享前要么确认新主控同证书,要么先下发「取消 TLS」 | §6.1 | +| 5 | 兼容性矩阵补三行(已下发锚 + 异证书 / 同证书、分享实例收到启停指令) | §7 | +| 6 | 工作量调整:`KernelManager.cpp` ±30 → ±35(分享隔离 5 行) | §9 | + +定稿范围:**Windows 客户端 + MFC 服务端**,含 P1(PEM fullchain 循环加载)与分享实例隔离。Linux / macOS / Android 与「按主控分键存锚」明确留到下一版。 + +## 14. 实施记录(v0.3 → v1.0) + +### 14.1 落地清单 + +| 文件 | 内容 | +|---|---| +| `common/tls_anchor.h`(新) | `EmbeddedTlsAnchor` 结构、`kAnchorVersion/ kAnchorCapacity`、`Fnv1a32`、`IsAnchorMagic`、`IsAnchorBlockValid`、`static_assert(sizeof == 4228)` | +| `client/EmbeddedTlsAnchor.h/.cpp`(新) | `volatile EmbeddedTlsAnchor g_embeddedTlsAnchor`(独立 TU、`.data` 落地) | +| `client/TlsChannel.cpp/.h` | `ReadTrustAnchor` 四级优先级(`tls_disabled` → `tls_cert` → 文件 → 内嵌 → 明文);P1 的 `DecodeAllCerts`(按 BEGIN/END 切块循环解码,见 §14.5);**按连接的两套缓存状态** `g_state[2]` + `ResolveStateIndex()` 地址集合匹配 + `TlsEnabledFor()` / `TlsLoadErrorFor()` / `AnchorEmbedded()`(见 §14.6) | +| `client/KernelManager.cpp` | `SetTlsDisabledMarker()`;启停 TLS 的分享实例隔离;`COMMAND_SET_PROTO` 清标记;`COMMAND_UPDATE` 按 payload 是否带锚清标记 | +| `client/ClientDll.cpp` | 不再有进程级判定(删掉 `SetEmbeddedAnchorEnabled()` 那一套);`GetLoginInfo(..., IsTlsActive(), IsTlsAnchorEmbedded())` | +| `client/IOCPClient.h/.cpp` | `IsTlsActive()`(按实连上报,不看 `protoType`);`IsTlsAnchorEmbedded()`(取本连接握手时的锚来源);`ConnectServer` 改用 `TlsEnabledFor(m_sCurIP, m_Domain.GetAddress())` | +| `client/domain_pool.h` | `GetAddress()`:取配置里的原始地址串(可能分号多地址/域名) | +| `client/LoginServer.cpp/.h` | `LoginInfor.AddReserved(tlsOnWire ? 1 : 0)`;`tlsOnWire && tlsAnchorEmbedded` 时 `DefaultCaps() | CLIENT_CAP_EMBEDDED_ANCHOR` | +| `common/commands.h` | `CLIENT_CAP_EMBEDDED_ANCHOR 0x0040` | +| `server/2015Remote/EmbeddedAnchor.h/.cpp`(新) | `EmbedTlsAnchorInto()`、`TlsAnchorSummary()` | +| `server/2015Remote/BuildDlg.cpp/.h`、`resource.h` | 动态复选框 `IDC_CHECK_TLS_ANCHOR`、`UpdateTlsAnchorState()`、生成时内嵌 | +| `server/2015Remote/2015RemoteDlg.cpp` | `ReadExeFromResource()` 内嵌;`OnExperimentTlsDisable` 去守卫 + 台数警告 | +| `server/2015Remote/context.h` | `UsesEmbeddedAnchor()` | +| `lang/*.ini` | 10 条新文案 × 3 种语言 | + +### 14.2 与 v0.3 的偏差 + +| # | 偏差 | 原因 | +|---|---|---| +| 1 | 可内嵌协议由「排除 UDP/KCP/随机」收窄为 **只有 TCP/HTTP** | `WS` 的 TLS 通道被 `protoType != PROTO_WS` 直接跳过,锚不参与;`WSS` 的锚是**反代**的证书,塞服务端自己的锚会让原本能连的客户端握手失败(§3.7 表格) | +| 2 | 锚摘要从「复选框旁」挪到「生成成功提示里」 | 那条空白带只有 196 DLU(约 24 个全角字),放不下 `builtin 2036-11-01 sha1:…` | +| 3 | `PayloadSupportsEmbeddedAnchor()` 删除 | 与 `EmbedTlsAnchorInto()` 的 `NoBlock` 信息重复 | +| 4 | `COMMAND_UPDATE` 清抑制标记改为**有条件**(payload 里真有可用锚才清) | 无条件清会让一台已被要求走明文的主机重新发 ClientHello,撞上明文服务端即不可恢复的失联 | +| 5 | 复核「取消 TLS」不逐条翻译,首发文案保持原键 | 该键在三个 ini 里已有译文(含字面 `\n`),拆句只会让译文作废 | + +### 14.3 实测 + +- `x64\Debug\ghost.exe`:magic 命中 2 处,`@0xac15d0 ver=1 cap=4096 len=0` 通过结构校验, + 另一处是 `.rdata` 的字面量副本(`ver=1699431294`,过不了校验)——正是 §3.3 预期的形态。 +- `x64\Debug\ServerDll.dll`(Debug 下仍走 `/LTCG`):同样 1 处有效块,LTCG 未把对象折叠掉。 +- 生成链路(Debug 服务端 + 真实构建对话框,无鼠标驱动):选 ghost.exe / TCP / 不压缩, + 主控 `127.0.0.1:16543`,产出 `Bin\ghost.exe` 与模板**同尺寸**(11,868,160 字节)—— 锚块容量 + 在模板里已预留 4096 字节,生成时只是原地填内容,不会撑大镜像;提示框回报 + `Embedded TLS trust anchor: custom 2036-10-11 sha1:272f2adfb19c`,与 `TlsAnchorSummary()` 一致。 + 产物里唯一的有效块 `@0xac1dd0 len=1178`,hash `0xD47F19ED` + 自校验通过,`master='127.0.0.1'`,PEM 与 `server/go/certs/server.crt` 逐字节相同、尾部补零。 +- 端到端首连(§8 用例):把生成的客户端放进一个从未跑过的目录(因此注册表 `Software\` + 是全新的,没有 `tls_cert` / `tls_disabled`),本机起一个只收不回的监听口 16543。客户端在 + 0.2 s 内发来 `16 03 03 00 8E 01 00 00 8A 03 03 …`,即 TLS 1.2 ClientHello; + 日志为 `[TLS] trust anchor embedded: 1 certificate(s) loaded` → + `[TLS] enabled: trust anchor loaded (embedded), using TLS`。 + 地址不匹配的场景见 §14.6 的三组首连实测。 +- fullchain 多块解码:把 `web.just-do-it.icu.fullchain.pem`(4 块)放到 exe 同目录的 + `yama-ca.pem`,日志报 `4 certificate(s) loaded` —— P1 的循环语义成立;删掉文件后回落到 + 内嵌锚(1 张),两级优先级也按 §3 的顺序生效。 +- 待补:真实目标机 + 线上 TLS 服务端的完整握手(本机只有"客户端发出 ClientHello"这一半)。 + +### 14.4 踩坑:新源文件漏 BOM 导致「行号整体偏移的语法错误」 + +新建的 5 个文件初版是 UTF-8 **无 BOM**。本机 ACP=936,MSVC 于是按 GBK 解读 UTF-8 源码, +CJK 注释里出现「尾字节 0x5C + 换行」就被当成续行符,把后面 13 行吞进注释;报出来的现象是 +`tls_anchor.h(19): 'EmbeddedTlsAnchor::kAnchorVersion' cannot be declared with 'constexpr'` +——行号比真实行号少 13,且标识符被当成类成员。补上 UTF-8 BOM 即恢复。 + +记住两条:本仓库 `.cpp/.h` 一律 **UTF-8 带 BOM**(执行字符集仍是 GBK,所以 `_TR` 键与 GBK +的 ini 对得上);`lang/*.ini` 一律 **GBK 无 BOM**。 + +### 14.5 端到端联调揪出的两个缺陷 + +**(1)`DecodeAllCerts` 误用 `CryptStringToBinaryA` 的 `pdwSkip` —— 所有锚来源全挂。** +P1 为支持 fullchain 改成循环解码,注释写着「每次都传整串,由它回报下一块的起点」。实际该参数 +是**纯输出**:回报本次转换前跳过了多少字符,调用方传入的偏移一概不看,整串输入时恒为 0。 +于是循环第一轮就撞上 `next <= offset` 的防死循环判断退出,一张证书都没进 store;`added == 0` +被当成「证书损坏」,触发 §6.1 的 fail-closed —— 内嵌锚客户端**首次连接即永久拒绝**,下发锚、 +文件锚同样解不出来。现场日志: + +``` +[TlsChannel.cpp:185] [TLS] failed to decode certificate embedded +[TlsChannel.cpp:246] [TLS] FATAL: ... refusing connections (fail-closed) +``` + +用 PowerShell 直接对同一个 PEM 复现:`skipIn=0 -> need=969 skipOut=0`、`skipIn=1367 -> need=969 +skipOut=0`,输出与原调用完全一致,证实 skip 不承担输入偏移。修法是自己按 +`-----BEGIN` / `-----END` 切块,逐块解码;无标记头时退回整串 `CRYPT_STRING_ANY`(覆盖只有 +base64 正文的锚),最后兜底裸 DER。修复后 fullchain 报 `4 certificate(s) loaded`,内嵌锚报 1 张。 +教训:会失败到 fail-closed 的路径,必须有一次**真机首连**的验证;单看「结构校验通过」不够。 + +**(2)用户主动取消勾选,切一次协议再切回来会被悄悄勾上。** +`UpdateTlsAnchorState()` 最初按「可用就勾选」实现,于是 WS(不可用,强制未勾)→ TCP 会把用户的 +取消覆盖掉,生成时真的内嵌进去。改为三态:`m_nAnchorUserCheck`(-1 未表态 / 0 / 1),不可用时 +只显示未勾选但不改表态,可用时按表态恢复;勾选变化由 `ON_BN_CLICKED` 记录。已用 BM_CLICK 实测 +「取消 → 切 WS → 切 TCP」后仍为未勾选。 + +### 14.6 代码评审后的返工:判定从「进程」改到「连接」 + +v1.0 交付时把 §3.6 的地址比对落成了**进程级**:`StartClient()` 里比较一次 +`settings.ServerIP() == anchor.master`,写进 `EmbeddedTlsAnchor.cpp` 的 +`g_embeddedAnchorEnabled`,TLS 层首次访问时据此缓存一套 store + 链引擎便不再重算。三处问题: + +| # | 问题 | 后果 | +|---|---|---| +| 1 | 判定与 TLS 状态都是**进程级**,而分享实例、并行多主控实例是**同一进程内的线程** | 谁先连上谁替所有实例做了决定:分享连接会被判成该用 A 的锚 → 拿 A 的证书校验 B → fail-closed;能力位也按进程上报,那台主控误判「这台主机靠内嵌锚」 | +| 2 | 只做**整串相等**,而并行模式用 `settings.SetServer(DomainPool 解析出的 IP)`,配置里还可能是分号多地址/域名 | 除「配置里写的正好是生成时那个字符串」以外,一律不匹配:并行、域名、多地址部署全部退化成明文 | +| 3 | `tls_disabled=1` 连手工部署的 PEM 一起屏蔽(§3.5 的既定语义,**不改**) | 只补日志可观测性 | + +改法(`client/TlsChannel.cpp` 为主): + +- `TlsState g_state[2]`:`[1]` 允许内嵌锚、`[0]` 不允许,各自带 store + 链引擎,首次访问时 + `EnsureStateLocked()` 建好(「不允许」那套静默构建,避免把不适用本连接的 enabled 行印在本 + 连接状态之前)。 +- `ResolveStateIndex(host, configured)`:两层地址匹配(§3.6),在取 `g_tlsMtx` **之前** + 调用(可能解析域名)。`Handshake()` 开始时定下用哪一套状态,`VerifyServerCert()` 据此取 + anchor,并把来源记进 `m_anchorEmbedded`。 +- `TlsReload` 一次重建两套;运行期失败只保留该套原状态(不打死正在工作的客户端)。 +- 删除 `g_embeddedAnchorEnabled` / `SetEmbeddedAnchorEnabled()` / `EmbeddedAnchorEnabled()`, + `ClientDll.cpp::StartClient()` 里那段全局写随之去掉。 +- 域名解析移出 `g_tlsMtx`:地址匹配要解析域名,而 `gethostbyname` 在 DNS 不通时要等满超时。 + 原先它跑在证书校验那把锁里,一次解析就能把**同一进程里其它连接的握手**一起堵住。现在 + 匹配用独立的 `g_matchMtx`,只护住缓存读写,解析在锁外;调用方(`TlsEnabledFor` / + `TlsLoadErrorFor` / `Handshake`)先算 `idx` 再取 `g_tlsMtx`。失败按 60 秒负缓存 + (`g_dnsFailAt`)——master 域名换过/过期时,不至于每次重连都白等一轮超时。实测: + master 写成不存在的域名时,首次连接仍在 0.8 s 内发出(解析失败约 0.6 s,且之后 60 秒内 + 不再重试)。 +- `Handshake()` 里那句「整条连接生命周期内不变」的注释与实现不符:`m_stateIdx`(用哪一套) + 确实是定的,但 store/链引擎会被 `TlsReload` 原地替换,所以握手末尾校验用的是**此刻**的 + 锚。行为是有意为之(新锚对在途握手立即生效),注释已改成这个说法,免得后来人以为能拿到 + 握手开始时的快照。 +- 顺带修正 `ApplyTlsAnchorChange`:它原先拿**进程级** `TlsEnabled()` 比较热重载前后的传输, + 而进程级开关看的是「允许内嵌锚」那套状态。锚不匹配的客户端实际在走明文、开关却恒为 + true,于是收到「启用 TLS」时判定为「传输没变」、不断线重连,**明明拿到了锚却继续明文连**。 + 改为按本连接的目标比:`client->IsTlsActive()` vs `client->TlsEnabledForCurrentTarget()`。 + +**首连实测**(`x64\Debug\ghost.exe` + 用脚本把锚块原地注入,等价于生成器的填法;本机 6543 +只收不回): + +| 锚的 `master` | 配置的主控 | 首包 | 日志 | +|---|---|---|---| +| `127.0.0.1` | `127.0.0.1` | `16 03 03 00 8E …`(ClientHello) | `trust anchor embedded: 1 certificate(s) loaded` → `enabled: … (embedded), using TLS` | +| `10.9.9.9` | `127.0.0.1` | 明文(`F9 EB BD 5F …`,随后明文登录成功) | `embedded anchor skipped: connecting 127.0.0.1, built for 10.9.9.9` → `this connection: plaintext mode` | +| `localhost`(域名) | `127.0.0.1` | `16 03 03 00 8E …`(ClientHello) | 同第一行(命中第二层:`localhost` 解析出 127.0.0.1) | + +第二、三行正是问题 1、2 的回归用例:同一个二进制里,判定随连接目标变化,且域名/多地址不再 +因字符串不等而失配。全限权(Release)客户端在本机无法完成 `RegisterStartup`(无管理员 → +`self_del()`),故实测用 Debug 客户端——`_DEBUG` 下 `RegisterStartup` 直接返回 1,TLS 代码路径 +与 Release 完全相同。 diff --git a/server/2015Remote/2015RemoteDlg.cpp b/server/2015Remote/2015RemoteDlg.cpp index fb05fe4..1e32ef3 100644 --- a/server/2015Remote/2015RemoteDlg.cpp +++ b/server/2015Remote/2015RemoteDlg.cpp @@ -52,6 +52,7 @@ #include "McpSettingsDlg.h" #include "TlsCertificateDlg.h" #include "ServerTlsSession.h" +#include "EmbeddedAnchor.h" #include "BuiltinTlsCert.h" #include "common/md5.h" #include @@ -5122,14 +5123,38 @@ void CMy2015RemoteDlg::OnExperimentTlsEnable() void CMy2015RemoteDlg::OnExperimentTlsDisable() { - if (!ServerTlsIdentity::IsReady()) { - MessageBoxL(_T("服务端未启用 TLS 证书,无法切换客户端 TLS 传输"), - _T("提示"), MB_ICONWARNING); - return; + // 刻意不再要求 ServerTlsIdentity::IsReady():服务端证书损坏(fail-closed,只认 TLS + // 却握手不了)恰恰是最需要让客户端退回明文的场景,挡住这条指令等于把恢复通道一起关掉。 + // 取消 TLS 只是让客户端停止发 ClientHello,服务端本来就一直接受明文。 + // + // 先数出选中主机里有多少台靠「生成时内嵌的锚」在加密(CLIENT_CAP_EMBEDDED_ANCHOR): + // 它们与本机的 tls_cert 无关,取消 TLS 后只能靠这条指令写下的抑制标记退出去;离线没 + // 收到的那些,下次上线仍会发 ClientHello 撞上明文服务端 → 永久失联,只能重新生成 + // 客户端(设计文档 §3.5、§4.9)。 + int selected = 0, embedded = 0; + EnterCriticalSection(&m_cs); + for (context* ctx : ResolveCommandTargets()) { + if (!ctx->IsLogin()) continue; + ++selected; + if (ctx->UsesEmbeddedAnchor()) ++embedded; } - if (IDYES != MessageBoxL(_T("确定取消选中主机的 TLS 传输吗?\n" - "(客户端立即生效并断线重连,正在进行的远程会话会中断)"), - _T("提示"), MB_ICONQUESTION | MB_YESNO)) return; + LeaveCriticalSection(&m_cs); + if (selected == 0) return; + + // 首发文案沿用原文案(语言文件里已有译文,键含字面 \n 的多行文本,CIniParser 会还原)。 + CString msg = _TR("确定取消选中主机的 TLS 传输吗?\n" + "(客户端立即生效并断线重连,正在进行的远程会话会中断)"); + if (embedded > 0) { + // 台数用 %d 进模板,不要在外面拼 "%d" + 译句:英文/德文的句首没有空格, + // 拼出来是 "3host(s) use"、"3Host(s) nutzen"。 + CString line; + line.Format(_TRF("%d 台主机使用生成时内嵌的信任锚:取消 TLS 后必须重新连上主控" + "才能恢复加密,离线期间不会自行恢复。"), embedded); + msg += "\r\n\r\n" + line; + } + if (IDYES != MessageBox(msg, _TR("提示"), + MB_ICONQUESTION | MB_YESNO | + (embedded > 0 ? MB_DEFBUTTON2 : MB_DEFBUTTON1))) return; BYTE bToken = COMMAND_TLS_DISABLE; //向被控端发送停用 TLS 传输命令 SendSelectedCommand(&bToken, sizeof(BYTE)); } @@ -5273,6 +5298,24 @@ BYTE* ReadExeFromResource(DWORD& outSize, int resourceId, const char* resName, i dwFileSize -= iOffset + sizeof(CONNECT_ADDRESS); iOffset = MemoryFind(pSearchStart, (char*)g_ConnectAddress.Flag(), dwFileSize, g_ConnectAddress.FlagLen()); } + + // 内嵌 TLS 信任锚(设计文档 §4.8):与生成界面共用同一段字节搬运路径,所以在线 + // 升级下发的客户端同样可以首连即 TLS。注意用 outSize 而不是 dwFileSize——上面的 + // 扫描循环已经把 dwFileSize 递减成了「剩余未扫描长度」。 + // NoBlock / NoAnchor —— 静默跳过:目标可能是 Linux/macOS 客户端,或用户自选文件。 + // 其余失败 —— 只记日志,绝不因为内嵌失败而中断下发。 + { + DWORD anchorLen = 0; + std::string anchorErr; + EmbedResult embed = EmbedTlsAnchorInto(szBuffer, outSize, effectiveIP, anchorLen, anchorErr); + if (embed == EmbedResult::Ok) { + Mprintf("[TLS] embedded trust anchor (%u bytes) for master %s\n", + (unsigned)anchorLen, effectiveIP.c_str()); + } else if (embed != EmbedResult::NoBlock && embed != EmbedResult::NoAnchor) { + Mprintf("[TLS] WARN: embedded trust anchor skipped: %s\n", anchorErr.c_str()); + } + } + BYTE *buffer = new BYTE[outSize + 1 + sizeofSize]; buffer[0] = cmd; memcpy(buffer + 1, &outSize, sizeofSize); diff --git a/server/2015Remote/2015Remote_vs2015.vcxproj b/server/2015Remote/2015Remote_vs2015.vcxproj index 6d79e36..1521c3a 100644 --- a/server/2015Remote/2015Remote_vs2015.vcxproj +++ b/server/2015Remote/2015Remote_vs2015.vcxproj @@ -335,6 +335,7 @@ + @@ -407,6 +408,7 @@ + NotUsing NotUsing diff --git a/server/2015Remote/2015Remote_vs2015.vcxproj.filters b/server/2015Remote/2015Remote_vs2015.vcxproj.filters index 95b1d47..0e6ecea 100644 --- a/server/2015Remote/2015Remote_vs2015.vcxproj.filters +++ b/server/2015Remote/2015Remote_vs2015.vcxproj.filters @@ -97,6 +97,7 @@ + @@ -214,6 +215,7 @@ + diff --git a/server/2015Remote/BuildDlg.cpp b/server/2015Remote/BuildDlg.cpp index 027a242..6d5079d 100644 --- a/server/2015Remote/BuildDlg.cpp +++ b/server/2015Remote/BuildDlg.cpp @@ -13,6 +13,8 @@ #include #pragma comment(lib, "Shlwapi.lib") #include "Resource.h" +#include "EmbeddedAnchor.h" +#include "ServerTlsSession.h" extern "C" { #include "client/reg_startup.h" } @@ -221,6 +223,7 @@ CBuildDlg::CBuildDlg(CWnd* pParent) , m_sInstallDir(_T("")) , m_sInstallName(_T("")) , m_sDownloadUrl(_T("")) + , m_nAnchorUserCheck(-1) { } @@ -278,6 +281,8 @@ BEGIN_MESSAGE_MAP(CBuildDlg, CDialog) ON_COMMAND(ID_RANDOM_NAME, &CBuildDlg::OnRandomName) ON_BN_CLICKED(IDC_CHECK_FILESERVER, &CBuildDlg::OnBnClickedCheckFileserver) ON_CBN_SELCHANGE(IDC_COMBO_PAYLOAD, &CBuildDlg::OnCbnSelchangeComboPayload) + ON_CBN_SELCHANGE(IDC_COMBO_PROTO, &CBuildDlg::OnCbnSelchangeComboProto) + ON_BN_CLICKED(IDC_CHECK_TLS_ANCHOR, &CBuildDlg::OnBnClickedCheckTlsAnchor) END_MESSAGE_MAP() @@ -589,6 +594,34 @@ void CBuildDlg::OnBnClickedOk() return; } + // 内嵌 TLS 信任锚:让这批客户端首连即 TLS,不必等主控在线下发(设计文档 §3.3)。 + // 位置很关键——锚块与 CONNECT_ADDRESS 走同一条字节搬运路径,写在这里之后, + // 下面的 UPX / ShellCode / PE 伪装都会把它原样带进最终产物。 + // 写了一半失败一律放弃生成:半截的锚会让客户端进 fail-closed 且没有恢复通道。 + // 特例是 NoBlock——模板里根本没有锚块,一个字节都没动,产物与「没这个特性」的 + // 客户端完全一样。升级主控后忘了重编 ghost/ServerDll 资源时每次生成都会被默认 + // 勾选挡下(复选框没表过态就是勾着的),所以这里只提示 + 取消勾选,照常生成。 + DWORD anchorLen = 0; + if (m_ChkTlsAnchor.GetSafeHwnd() && m_ChkTlsAnchor.IsWindowEnabled() && + m_ChkTlsAnchor.GetCheck() == BST_CHECKED) { + std::string anchorErr; + EmbedResult embed = EmbedTlsAnchorInto(szBuffer, dwFileSize, m_strIP.GetString(), + anchorLen, anchorErr); + if (embed == EmbedResult::NoBlock) { + MessageBoxL(_TR("提示: 客户端模板里没有内嵌锚块,本次按普通客户端生成;" + "重编 ghost/ServerDll 资源后可再次启用。") + "\r\n" + file, + "提示", MB_ICONINFORMATION); + m_nAnchorUserCheck = 0; + m_ChkTlsAnchor.SetCheck(BST_UNCHECKED); + } else if (embed != EmbedResult::Ok) { + MessageBoxL(_TR("内嵌 TLS 信任锚失败,已取消生成:") + "\r\n" + CString(anchorErr.c_str()) + + "\r\n" + _TR("可取消勾选「内嵌TLS信任锚」后重试。") + "\r\n" + file, + "提示", MB_ICONWARNING); + SAFE_DELETE_ARRAY(szBuffer); + return; + } + } + // 保存文件 char path[_MAX_PATH], * p = path; GetModuleFileNameA(NULL, path, sizeof(path)); @@ -611,6 +644,16 @@ void CBuildDlg::OnBnClickedOk() tip += g_ConnectAddress.protoType==PROTO_KCP ? "\n" + _TR("提示: 使用KCP协议生成服务,必须设置主控UDP协议参数为1。") : _T(""); tip += (g_ConnectAddress.protoType==PROTO_WS || g_ConnectAddress.protoType==PROTO_WSS) ? "\n" + _TR("提示: WebSocket协议需经反向代理(如nginx 443)转发到主控端口,地址填域名。") : _T(""); + if (anchorLen > 0) { + // 带上锚摘要:内置证书可能在服务端重建过程中换了一张,光看「成功」发现不了。 + std::string summary; + tip += "\r\n" + _TR("已内嵌TLS信任锚") + ": " + + (TlsAnchorSummary(summary) ? CString(summary.c_str()) : CString("?")); + } else if (index == IndexServerDll && m_ChkTlsAnchor.IsWindowEnabled()) { + // 生成 ServerDll.dll 却没勾内嵌锚,等于 TestRun 那条链上一个能加密的客户端都 + // 没有——非阻塞提示(设计文档 §4.7)。 + tip += "\r\n" + _TR("提示: 未内嵌TLS信任锚,本批客户端首次连接为明文,需主控在线下发锚。"); + } std::string upx; int sel = m_ComboCompress.GetCurSel(); if(sel == CLIENT_COMPRESS_UPX)upx = ReleaseUPX(); @@ -911,6 +954,19 @@ BOOL CBuildDlg::OnInitDialog() m_strPort.Format("%d", effectivePort); UpdateData(FALSE); + // 内嵌 TLS 信任锚复选框:动态创建在「协议」行与「Port」行之间的空白带(DLU + // 216,70 — 412,82)。动态创建的好处是文案走语言文件、不必新增资源控件,位置也只 + // 在这一个地方维护。 + CRect rcAnchor(216, 70, 412, 82); + MapDialogRect(&rcAnchor); + m_ChkTlsAnchor.Create(_TR("内嵌TLS信任锚(首连即加密)"), + WS_CHILD | WS_VISIBLE | WS_TABSTOP | BS_AUTOCHECKBOX, + rcAnchor, this, IDC_CHECK_TLS_ANCHOR); + // 运行时创建的控件不继承对话框字体(模板里的控件是对话框管理器按 DS_SETFONT 设的), + // 不显式设置就会用系统默认字体,和旁边的下拉框、单选按钮对不上。 + m_ChkTlsAnchor.SetFont(GetFont()); + UpdateTlsAnchorState(); + return TRUE; // return TRUE unless you set the focus to a control // 异常: OCX 属性页应返回 FALSE } @@ -963,10 +1019,68 @@ void CBuildDlg::EnableWindowsOnlyControls(BOOL enable) } } +// 「内嵌 TLS 信任锚」复选框的可用性与文案。三个条件缺一不可(设计文档 §4.7): +// 1. 生成目标里真的有客户端代码(ghost.exe / ServerDll.dll); +// 2. 协议会用到这份锚(TCP / HTTP;WS 走明文,WSS 的锚是反代那张证书); +// 3. 服务端自己有可用身份(ServerTlsIdentity::IsReady)。 +// 不可用时置灰,并把原因写进文案本身——置灰控件收不到 tooltip,提示只能靠文案带出去。 +void CBuildDlg::UpdateTlsAnchorState() +{ + if (!m_ChkTlsAnchor.GetSafeHwnd()) + return; + + const int index = m_ComboExe.GetCurSel(); + const int proto = m_ComboProto.GetCurSel(); + const bool embeddable = (index == IndexGhost || index == IndexGhostMsc || + index == IndexGhostSystem || index == IndexServerDll); + const bool testRun = (index == IndexTestRun_DLL || index == IndexTestRun_MemDLL || + index == IndexTestRun_InjSC || index == IndexTestRunMsc || + index == IndexTestRunSystem); + + CString label; + bool usable = false; + if (!embeddable) { + // TestRun 只是加载器,锚要生成进 ServerDll.dll —— 这条提示比「不含客户端」有用。 + label = testRun ? _TR("内嵌TLS信任锚(锚在ServerDll.dll里)") + : _TR("内嵌TLS信任锚(该目标不含客户端)"); + } else if (proto != PROTO_TCP && proto != PROTO_HTTP) { + label = _TR("内嵌TLS信任锚(该协议不走TLS)"); + } else if (!ServerTlsIdentity::IsReady()) { + label = _TR("内嵌TLS信任锚(服务端未启用TLS)"); + } else { + label = _TR("内嵌TLS信任锚(首连即加密)"); + usable = true; + } + + m_ChkTlsAnchor.SetWindowText(label); + m_ChkTlsAnchor.EnableWindow(usable); + if (!usable) { + // 不可用时一律显示成未勾选;用户此前的表态留在 m_nAnchorUserCheck 里。 + m_ChkTlsAnchor.SetCheck(BST_UNCHECKED); + } else { + // 没表过态就默认勾选;表过态(尤其是主动取消)就以用户的为准。不能用 + // 「由不可用变可用就勾上」来判断——那样切一次协议再切回来,会把用户的 + // 取消悄悄改回勾选,生成时真就内嵌进去了。 + m_ChkTlsAnchor.SetCheck(m_nAnchorUserCheck < 0 ? BST_CHECKED : m_nAnchorUserCheck); + } +} + +void CBuildDlg::OnBnClickedCheckTlsAnchor() +{ + if (m_ChkTlsAnchor.GetSafeHwnd()) + m_nAnchorUserCheck = m_ChkTlsAnchor.GetCheck(); +} + +void CBuildDlg::OnCbnSelchangeComboProto() +{ + UpdateTlsAnchorState(); +} + void CBuildDlg::OnCbnSelchangeComboExe() { auto n = m_ComboExe.GetCurSel(); EnableWindowsOnlyControls(!(n == IndexLinuxGhost || n == IndexMacGhost || n == IndexAndroidGhost)); + UpdateTlsAnchorState(); if (n == OTHER_ITEM) { CString name = GetFilePath(_T("dll"), _T("All Files (*.*)|*.*|DLL Files (*.dll)|*.dll|EXE Files (*.exe)|*.exe|")); if (!name.IsEmpty()) { diff --git a/server/2015Remote/BuildDlg.h b/server/2015Remote/BuildDlg.h index e103aa2..4c1df22 100644 --- a/server/2015Remote/BuildDlg.h +++ b/server/2015Remote/BuildDlg.h @@ -108,4 +108,14 @@ public: // 选 Linux / macOS 客户端时禁用 Windows-only 选项(架构 / 加壳 / 高级 group) void EnableWindowsOnlyControls(BOOL enable); CComboBox m_ComboLocation; + + // 内嵌服务端 TLS 信任锚(动态创建:不改 .rc,避免 GBK 资源文件的字节级编辑)。 + // 可用性三条件见 UpdateTlsAnchorState;生成时由 OnBnClickedOk 调用 EmbedTlsAnchorInto。 + CButton m_ChkTlsAnchor; + // 用户对复选框的表态:-1 = 没表过态(默认勾选),0/1 = 用户最后一次手动选择。 + // 记下来是为了让「取消勾选」这件事在切目标/切协议来回之后依然算数。 + int m_nAnchorUserCheck; + void UpdateTlsAnchorState(); + afx_msg void OnBnClickedCheckTlsAnchor(); + afx_msg void OnCbnSelchangeComboProto(); }; diff --git a/server/2015Remote/EmbeddedAnchor.cpp b/server/2015Remote/EmbeddedAnchor.cpp new file mode 100644 index 0000000..675d735 --- /dev/null +++ b/server/2015Remote/EmbeddedAnchor.cpp @@ -0,0 +1,146 @@ +// EmbeddedAnchor.cpp — 生成端:把服务端信任锚写进客户端镜像的锚块。 +// +// 见 docs/ClientEmbeddedTLS_Design.md §3.3、§4.6。要点: +// 1. magic 字面量在二进制里不止一份(.rdata 里还有一份),所以不能「找到第一处就写」; +// 必须扫出全部命中、逐个做结构校验,恰好一个才写,零个报 NoBlock,多个报 Ambiguous。 +// 2. 写之前先读 stub 自己的 capacity 字段——老 stub 没有这个块,我们报错而不是越界。 +// 3. 超长一律报错,绝不截断:截断的 PEM 会让客户端进 fail-closed 且没有恢复通道。 +#include "StdAfx.h" +#include "EmbeddedAnchor.h" +#include "ServerTlsSession.h" // ServerTlsIdentity::AnchorPem / IsReady / IsBuiltin +#include "common/tls_anchor.h" + +#include +#include +#pragma comment(lib, "crypt32.lib") + +namespace { + +// 扫出所有通过结构校验的锚块偏移。命中通常只有 0 或 1 个:payload 里出现的另一处 +// magic 是 .rdata 里的字面量副本,过不了 version/capacity/hash 校验。 +std::vector FindAnchorBlocks(const BYTE* payload, DWORD size) +{ + std::vector hits; + if (!payload || size < sizeof(EmbeddedTlsAnchor)) + return hits; + + const size_t last = (size_t)size - sizeof(EmbeddedTlsAnchor); + for (size_t i = 0; i <= last; ++i) { + const char* p = (const char*)payload + i; + if (!IsAnchorMagic(p)) + continue; + EmbeddedTlsAnchor block; + memcpy(&block, p, sizeof(block)); // 对齐安全:不直接解引用未对齐指针 + if (IsAnchorBlockValid(block)) + hits.push_back(i); + } + return hits; +} + +bool GetAnchorPem(std::string& pem, std::string& err) +{ + if (!ServerTlsIdentity::IsReady()) { + err = "server TLS identity is not ready"; + return false; + } + if (!ServerTlsIdentity::AnchorPem(pem) || pem.empty()) { + err = "server TLS anchor is empty"; + return false; + } + return true; +} + +} // namespace + +EmbedResult EmbedTlsAnchorInto(BYTE* payload, DWORD size, const std::string& master, + DWORD& pemLen, std::string& err) +{ + pemLen = 0; + + std::vector hits = FindAnchorBlocks(payload, size); + if (hits.empty()) { + err = "no embedded TLS anchor block in payload (stub not rebuilt?)"; + return EmbedResult::NoBlock; + } + if (hits.size() > 1) { + err = "multiple embedded TLS anchor blocks in payload"; + return EmbedResult::Ambiguous; + } + + std::string pem; + if (!GetAnchorPem(pem, err)) + return EmbedResult::NoAnchor; + + if (pem.size() > kAnchorCapacity) { + err = "certificate PEM is " + std::to_string(pem.size()) + " bytes, slot holds " + + std::to_string(kAnchorCapacity); + return EmbedResult::TooLong; + } + // 主控地址槽位:必须给结尾的 '\0' 留一位,否则客户端 strnlen 读到的地址会被截断。 + constexpr size_t kMasterSlot = sizeof(EmbeddedTlsAnchor::master); + if (master.size() >= kMasterSlot) { + err = "master address is " + std::to_string(master.size()) + " bytes, slot holds " + + std::to_string(kMasterSlot - 1); + return EmbedResult::TooLong; + } + + // 以 stub 里的块为底稿,只改我们负责的字段——magic/capacity 原样保留。 + EmbeddedTlsAnchor block; + memcpy(&block, payload + hits[0], sizeof(block)); + block.version = kAnchorVersion; + block.length = (uint32_t)pem.size(); + block.hash = Fnv1a32(pem.data(), pem.size()); + memset(block.master, 0, sizeof(block.master)); + memcpy(block.master, master.c_str(), master.size()); + memset(block.pem, 0, sizeof(block.pem)); + memcpy(block.pem, pem.data(), pem.size()); + + memcpy(payload + hits[0], &block, sizeof(block)); + pemLen = (DWORD)pem.size(); + return EmbedResult::Ok; +} + +bool TlsAnchorSummary(std::string& out) +{ + std::string pem, err; + if (!GetAnchorPem(pem, err)) + return false; + + // 只取 PEM 里的第一张证书算指纹:fullchain 时第一张就是服务端自己的叶子证书, + // 客户端 pin 的也正是它(见 client/TlsChannel.cpp 的 VerifyServerCert)。 + DWORD derLen = 0; + if (!CryptStringToBinaryA(pem.c_str(), (DWORD)pem.size(), CRYPT_STRING_BASE64HEADER, + NULL, &derLen, NULL, NULL) || derLen == 0) + return false; + std::vector der(derLen); + if (!CryptStringToBinaryA(pem.c_str(), (DWORD)pem.size(), CRYPT_STRING_BASE64HEADER, + der.data(), &derLen, NULL, NULL)) + return false; + + std::string thumb("?"), expiry; + PCCERT_CONTEXT cert = CertCreateCertificateContext(X509_ASN_ENCODING, der.data(), derLen); + if (cert) { + BYTE hash[20] = {}; + DWORD cbHash = sizeof(hash); + if (CertGetCertificateContextProperty(cert, CERT_SHA1_HASH_PROP_ID, hash, &cbHash) && + cbHash >= 6) { + static const char kHex[] = "0123456789abcdef"; + thumb.clear(); + for (int i = 0; i < 6; ++i) { + thumb += kHex[hash[i] >> 4]; + thumb += kHex[hash[i] & 0x0F]; + } + } + FILETIME utc = cert->pCertInfo->NotAfter, local = {}; + SYSTEMTIME st = {}; + if (FileTimeToLocalFileTime(&utc, &local) && FileTimeToSystemTime(&local, &st)) { + char buf[16]; + sprintf_s(buf, "%04u-%02u-%02u", st.wYear, st.wMonth, st.wDay); + expiry = buf; + } + CertFreeCertificateContext(cert); + } + + out = (ServerTlsIdentity::IsBuiltin() ? "builtin " : "custom ") + expiry + " sha1:" + thumb; + return true; +} diff --git a/server/2015Remote/EmbeddedAnchor.h b/server/2015Remote/EmbeddedAnchor.h new file mode 100644 index 0000000..3340a90 --- /dev/null +++ b/server/2015Remote/EmbeddedAnchor.h @@ -0,0 +1,29 @@ +#pragma once +// +// 生成客户端时,把「服务端自己的 TLS 证书」写进客户端镜像里的锚块,让分发出去的客户端 +// 首次连接就是 TLS —— 见 common/tls_anchor.h 与 docs/ClientEmbeddedTLS_Design.md §4.6。 +// +#include +#include + +enum class EmbedResult { + Ok, // 写入成功 + NoBlock, // payload 里没有锚块(老 stub,或用户自选的文件) + Ambiguous, // 找到多个通过校验的锚块——宁可报错也不猜 + NoAnchor, // 服务端当前没有可用的信任锚 + TooLong, // 证书 PEM 或主控地址超出槽位 +}; + +// 把服务端当前信任锚(ServerTlsIdentity::AnchorPem)原地写进 payload 的锚块。 +// master —— 生成时配置的主控地址(CONNECT_ADDRESS.szServerIP 的原样字符串,含分号多地址)。 +// 客户端启动后据此判断「我是不是还连在生成时那台主控」。地址对不上就跳过内嵌锚。 +// pemLen —— 成功时回填写入的 PEM 字节数(用于界面显示「这批客户端钉的是哪张证书」)。 +// 必须在压缩 / 加壳 / 伪装之前调用:锚块与 CONNECT_ADDRESS 走同一条字节搬运路径, +// 上游写入才能被后续所有包装形态原样带下去。 +EmbedResult EmbedTlsAnchorInto(BYTE* payload, DWORD size, const std::string& master, + DWORD& pemLen, std::string& err); + +// 当前信任锚的一行摘要,例如 "builtin 2036-11-01 sha1:1a2b3c4d5e6f",用于生成结果里 +// 核对「这批客户端钉的是哪张证书」(内置证书会重新生成,光看"成功"无法发现换了张)。 +// 服务端当前没有可用锚、或 PEM 解析不出来时返回 false。 +bool TlsAnchorSummary(std::string& out); diff --git a/server/2015Remote/context.h b/server/2015Remote/context.h index 7e6429f..6d2cf37 100644 --- a/server/2015Remote/context.h +++ b/server/2015Remote/context.h @@ -112,4 +112,14 @@ public: if (caps.IsEmpty()) return false; return (strtoul(caps.GetString(), nullptr, 16) & CLIENT_CAP_PROTO_SWITCH) != 0; } + + // 本机当前是不是靠「生成时内嵌的 TLS 信任锚」在加密(CLIENT_CAP_EMBEDDED_ANCHOR)。 + // 这不是能力声明而是运行时状态:只有这种主机在服务端关掉 TLS 后无法自愈——在线时 + // 还能收到「取消 TLS」,离线时发 ClientHello 会被 fail-closed 挡掉,再也进不来。 + // 服务端据此在「取消 TLS」确认框里提示数量(设计文档 §3.5、§4.9)。 + bool UsesEmbeddedAnchor() const { + CString caps = GetClientData(ONLINELIST_CAPABILITIES); + if (caps.IsEmpty()) return false; + return (strtoul(caps.GetString(), nullptr, 16) & CLIENT_CAP_EMBEDDED_ANCHOR) != 0; + } }; diff --git a/server/2015Remote/lang/de_DE.ini b/server/2015Remote/lang/de_DE.ini index c41369c..619a17c 100644 --- a/server/2015Remote/lang/de_DE.ini +++ b/server/2015Remote/lang/de_DE.ini @@ -2185,3 +2185,15 @@ MCP: ֤Êé»ò˽ԿÎļþ²»´æÔڣ¬Çë¼ì²é·¾¶¡£=Zertifikat- oder Schluesseldatei nicht vorhanden; bitte Pfad pruefen. HTTPS ¿ª¹ØÓë֤Êé·¾¶µĸ͝ÐèÖØÆô³ÌÐòÉúЧ¡£=Aenderungen am HTTPS-Schalter und an den Zertifikatspfaden werden nach Neustart wirksam. ֤ÊéÐëΪ PEM ¸ñʽ£¬˽ԿÐëΪ PKCS#8 ¸ñʽ¡£=Zertifikat muss im PEM-Format vorliegen, Schluessel im PKCS#8-Format. +; ===== Eingebetteter TLS-Vertrauensanker ===== +ÄÚǶTLSÐÅÈÎê(Ê×Á¬¼´¼ÓÃÜ)=TLS-Vertrauensanker einbetten (TLS von Anfang an) +ÄÚǶTLSÐÅÈÎê(êÔÚServerDll.dllÀï)=TLS-Vertrauensanker einbetten (in ServerDll.dll) +ÄÚǶTLSÐÅÈÎê(¸ÃĿ±겻º¬¿ͻ§¶Ë)=TLS-Vertrauensanker einbetten (Ziel ohne Client) +ÄÚǶTLSÐÅÈÎê(¸ÃЭÒ鲻×ßTLS)=TLS-Vertrauensanker einbetten (Protokoll ohne TLS) +ÄÚǶTLSÐÅÈÎê(·þÎñ¶ËδÆôÓÃTLS)=TLS-Vertrauensanker einbetten (Server-TLS aus) +ÄÚǶ TLS ÐÅÈÎêʧ°ܣ¬ÒÑȡÏûÉú³É:=TLS-Vertrauensanker konnte nicht eingebettet werden, Generierung abgebrochen: +¿ÉȡÏû¹´ѡ¡¸ÄÚǶTLSÐÅÈÎ꡹ºóÖØÊԡ£=Haken bei 'TLS-Vertrauensanker einbetten' entfernen und erneut versuchen. +ÒÑÄÚǶTLSÐÅÈÎê=TLS-Vertrauensanker eingebettet +Ìáʾ: ¿ͻ§¶Ëģ°åÀïûÓÐÄÚǶê¿飬±¾´ΰ´ÆÕͨ¿ͻ§¶ËÉú³ɣ»Öرà ghost/ServerDll ×ÊԴºó¿ÉÔٴÎÆôÓá£=Hinweis: Die Client-Vorlage hat keinen eingebetteten Ankerblock; als normaler Client erzeugt. ghost/ServerDll-Ressourcen neu bauen, um die Option wieder zu nutzen. +Ìáʾ: δÄÚǶTLSÐÅÈÎ꣬±¾Åú¿ͻ§¶ËÊ״ÎÁ¬½ÓΪÃ÷Îģ¬ÐèÖ÷¿ØÔÚÏßÏ·¢ê¡£=Hinweis: kein TLS-Vertrauensanker eingebettet; diese Clients verbinden sich zuerst im Klartext und benoetigen den Anker vom Master. +%d ̨Ö÷»úʹÓÃÉú³ÉʱÄÚǶµÄÐÅÈÎ꣺ȡÏû TLS ºó±ØÐëÖØÐÂÁ¬ÉÏÖ÷¿زÅÄָܻ´¼ÓÃܣ¬ÀëÏ߯ڼ䲻»á×ÔÐлָ´¡£=%d Host(s) nutzen den beim Build eingebetteten Vertrauensanker: nach dem Deaktivieren von TLS muessen sie sich erneut mit dem Master verbinden; offline erholen sie sich nicht selbst. diff --git a/server/2015Remote/lang/en_US.ini b/server/2015Remote/lang/en_US.ini index 6cfa5b4..289a011 100644 --- a/server/2015Remote/lang/en_US.ini +++ b/server/2015Remote/lang/en_US.ini @@ -2197,3 +2197,15 @@ MCP: ; ===== MCP Settings (file write / HTTPS) ===== ÆôÓÃÎļþдÈ루ɾ³ý/¸ÄÃû/½¨Ŀ¼£¬²»¿ɻָ´£©=Enable file writes (delete/rename/mkdir, irreversible) ÎļþдÈë°üº¬ɾ³ý£¨²»¿ɻָ´£©¡¢¸ÄÃûÓ뽨Ŀ¼£»ɾ³ý»á¾ܾøÅ̷û¸ùÓëϵͳĿ¼¡£=File writes include delete (irreversible), rename and create folder; delete refuses drive roots and system directories. +; ===== Embedded TLS anchor (client built against this server's certificate) ===== +ÄÚǶTLSÐÅÈÎê(Ê×Á¬¼´¼ÓÃÜ)=Embed TLS trust anchor (TLS on first connect) +ÄÚǶTLSÐÅÈÎê(êÔÚServerDll.dllÀï)=Embed TLS trust anchor (use ServerDll.dll) +ÄÚǶTLSÐÅÈÎê(¸ÃĿ±겻º¬¿ͻ§¶Ë)=Embed TLS trust anchor (no client code here) +ÄÚǶTLSÐÅÈÎê(¸ÃЭÒ鲻×ßTLS)=Embed TLS trust anchor (protocol is not TLS) +ÄÚǶTLSÐÅÈÎê(·þÎñ¶ËδÆôÓÃTLS)=Embed TLS trust anchor (server TLS is off) +ÄÚǶ TLS ÐÅÈÎêʧ°ܣ¬ÒÑȡÏûÉú³É:=Failed to embed the TLS trust anchor, generation cancelled: +¿ÉȡÏû¹´ѡ¡¸ÄÚǶTLSÐÅÈÎ꡹ºóÖØÊԡ£=Uncheck 'Embed TLS trust anchor' and retry. +ÒÑÄÚǶTLSÐÅÈÎê=Embedded TLS trust anchor +Ìáʾ: ¿ͻ§¶Ëģ°åÀïûÓÐÄÚǶê¿飬±¾´ΰ´ÆÕͨ¿ͻ§¶ËÉú³ɣ»Öرà ghost/ServerDll ×ÊԴºó¿ÉÔٴÎÆôÓá£=Note: the client template has no embedded anchor block; generated as a plain client. Rebuild the ghost/ServerDll resources to enable it again. +Ìáʾ: δÄÚǶTLSÐÅÈÎ꣬±¾Åú¿ͻ§¶ËÊ״ÎÁ¬½ÓΪÃ÷Îģ¬ÐèÖ÷¿ØÔÚÏßÏ·¢ê¡£=Note: no TLS trust anchor embedded; these clients connect in plaintext first and need the master to push the anchor online. +%d ̨Ö÷»úʹÓÃÉú³ÉʱÄÚǶµÄÐÅÈÎ꣺ȡÏû TLS ºó±ØÐëÖØÐÂÁ¬ÉÏÖ÷¿زÅÄָܻ´¼ÓÃܣ¬ÀëÏ߯ڼ䲻»á×ÔÐлָ´¡£=%d host(s) use the trust anchor embedded at build time: after disabling TLS they must reconnect to the master to restore encryption and will not recover on their own while offline. diff --git a/server/2015Remote/lang/zh_TW.ini b/server/2015Remote/lang/zh_TW.ini index 016e1f7..c0f06cf 100644 --- a/server/2015Remote/lang/zh_TW.ini +++ b/server/2015Remote/lang/zh_TW.ini @@ -2190,3 +2190,15 @@ MCP: ; ===== MCP Settings (file write / HTTPS) ===== ÆôÓÃÎļþдÈ루ɾ³ý/¸ÄÃû/½¨Ŀ¼£¬²»¿ɻָ´£©=†¢ÓÙn°¸Œ‘È루„h³ý/¸ÄÃû/½¨Á¢Ŀ䛣¬Ÿo·¨�Íԭ£© ÎļþдÈë°üº¬ɾ³ý£¨²»¿ɻָ´£©¡¢¸ÄÃûÓ뽨Ŀ¼£»ɾ³ý»á¾ܾøÅ̷û¸ùÓëϵͳĿ¼¡£=™n°¸Œ‘Èë°üº¬„h³ý£¨Ÿo·¨�Íԭ£©¡¢¸ÄÃûÅc½¨Á¢Ŀ䛣»„h³ý•þ¾ܽ^´ŵú™C¸ùĿä›Åcϵ½yĿ䛡£ +; ===== ƒÈǶ TLS ÐÅÈÎå^ ===== +ÄÚǶTLSÐÅÈÎê(Ê×Á¬¼´¼ÓÃÜ)=ƒÈǶTLSÐÅÈÎå^(Ê×ßB¼´¼ÓÃÜ) +ÄÚǶTLSÐÅÈÎê(êÔÚServerDll.dllÀï)=ƒÈǶTLSÐÅÈÎå^(å^ÔÚServerDll.dllÑe) +ÄÚǶTLSÐÅÈÎê(¸ÃĿ±겻º¬¿ͻ§¶Ë)=ƒÈǶTLSÐÅÈÎå^(ԓĿ˜˲»º¬¿͑ô¶Ë) +ÄÚǶTLSÐÅÈÎê(¸ÃЭÒ鲻×ßTLS)=ƒÈǶTLSÐÅÈÎå^(ԓ…f×h²»×ßTLS) +ÄÚǶTLSÐÅÈÎê(·þÎñ¶ËδÆôÓÃTLS)=ƒÈǶTLSÐÅÈÎå^(·þ„նËδ†¢ÓÃTLS) +ÄÚǶ TLS ÐÅÈÎêʧ°ܣ¬ÒÑȡÏûÉú³É:=ƒÈǶ TLS ÐÅÈÎå^ʧ”¡£¬ÒÑȡÏûÉú³É: +¿ÉȡÏû¹´ѡ¡¸ÄÚǶTLSÐÅÈÎ꡹ºóÖØÊԡ£=¿ÉȡÏû¹´ßx¡¸ƒÈǶTLSÐÅÈÎå^¡¹ááÖØԇ¡£ +ÒÑÄÚǶTLSÐÅÈÎê=ÒуÈǶTLSÐÅÈÎå^ +Ìáʾ: ¿ͻ§¶Ëģ°åÀïûÓÐÄÚǶê¿飬±¾´ΰ´ÆÕͨ¿ͻ§¶ËÉú³ɣ»Öرà ghost/ServerDll ×ÊԴºó¿ÉÔٴÎÆôÓá£=Ìáʾ: ¿͑ô¶Ëģ°åÑe›]ÓЃÈǶå^‰K£¬±¾´ΰ´ÆÕͨ¿͑ô¶ËÉú³ɣ»ÖؾŽ ghost/ServerDll ÙYԴáá¿ÉÔٴΆ¢Óᣠ+Ìáʾ: δÄÚǶTLSÐÅÈÎ꣬±¾Åú¿ͻ§¶ËÊ״ÎÁ¬½ÓΪÃ÷Îģ¬ÐèÖ÷¿ØÔÚÏßÏ·¢ê¡£=Ìáʾ: δƒÈǶTLSÐÅÈÎå^£¬±¾Åú¿͑ô¶ËÊ״ÎßB½ӞéÃ÷Îģ¬ÐèÖ÷¿ؾ€ÉÏϰlå^¡£ +%d ̨Ö÷»úʹÓÃÉú³ÉʱÄÚǶµÄÐÅÈÎ꣺ȡÏû TLS ºó±ØÐëÖØÐÂÁ¬ÉÏÖ÷¿زÅÄָܻ´¼ÓÃܣ¬ÀëÏ߯ڼ䲻»á×ÔÐлָ´¡£=%d ̨Ö÷™CʹÓÃÉú³ɕrƒÈǶµÄÐÅÈÎå^£ºȡÏû TLS áá±ØíšÖØÐÂßBÉÏÖ÷¿زÅÄܻ֏ͼÓÃܣ¬ëx¾€ÆÚég²»•þ×ÔÐл֏͡£ diff --git a/server/2015Remote/resource.h b/server/2015Remote/resource.h index 36329b3..5e4d78a 100644 --- a/server/2015Remote/resource.h +++ b/server/2015Remote/resource.h @@ -829,6 +829,7 @@ #define IDC_FSPEED_LABEL_UNLIMITED 2618 #define IDC_STATIC_TRIGGER_LIST 2619 #define IDC_COMBO_INSTALL_LOC 2620 +#define IDC_CHECK_TLS_ANCHOR 2621 #define IDD_QUALITY_LEVELS 3000 #define IDD_PREVIEW_LEVELS 3001 #define ID_ONLINE_UPDATE 32772