Feature: Embed the master's TLS certificate in generated clients

When the server has TLS enabled, the builder can now bake its certificate into
the client it produces, so a distributed client speaks TLS on its very first
connection instead of waiting for the anchor to be pushed after a plaintext
login. The dialog gets a checkbox (IDC_CHECK_TLS_ANCHOR) that is only enabled
for payloads and protocols where an embedded anchor makes sense; the choice is
remembered even when the control flips to disabled and back, so switching
protocols cannot silently undo a deliberate opt-out. Every label variant stays
short enough to fit the 196 DLU field, including the German ones. A template
that predates the anchor block no longer aborts generation: it warns, clears
the checkbox and produces a plain client, so a master upgraded without
rebuilding the ghost/ServerDll resources does not block every build.

The certificate lands in a fixed 4 KiB block (magic, version, length, FNV-1a
hash, master address, PEM) carved out of the payload at build time. The client
reads its trust anchor from four sources in order: the tls_disabled marker,
the certificate the server pushed into the registry, a PEM file next to the
executable, and finally the embedded block.

The embedded block only applies to a connection whose target matches the
master recorded at generation time, compared as an address set: an exact
string match when only one address is configured, or an intersection of
resolved IPv4 addresses otherwise. A transferred, shared or parallel instance
falls back to the old plaintext first-connect path instead of pinning itself
to a certificate it can never verify. That decision is made per connection,
not per process: shared and parallel instances are threads inside a single
client process, so a process-wide flag let whichever instance connected first
decide for all of them, and the first load of the TLS state cached that answer
for good. The TLS layer now keeps two cached states (embedded anchor allowed,
and not allowed), picks one per handshake, and reports the anchor source of
that handshake for the login capability bit. Matching by resolved address also
keeps parallel mode working, where the connection goes to the single IP the
domain pool selected while the configured master is a domain or a list.

Server side, generated and updated payloads get the block written in place;
the client reports the capability bit on login so the console can tell which
hosts are already TLS-only on first connect. Loading the anchor decodes every
PEM block in the chain rather than just the leaf, and an anchor that exists
but fails to load keeps the old fail-closed behaviour. A pushed anchor only
reconnects when the transport of the live connection actually changes, judged
against that connection's own target rather than the process-wide switch.

This was verified end to end against a freshly generated client with an empty
registry: the first connection was a TLS 1.2 ClientHello 0.2 s after start,
and a four-certificate fullchain loaded all four blocks. Re-verified after the
per-connection rework with the anchor block patched into a debug client: with
a matching master the first bytes are a ClientHello, with a foreign master the
client logs the skip and sends plaintext, and a domain master resolves to the
IP it connects to and still matches. A master domain that no longer resolves
falls back to plaintext within a second and is not looked up again for a
minute, instead of stalling every reconnect on a DNS timeout while holding the
lock the certificate verification needs.

Co-Authored-By: deepseek-flash
This commit is contained in:
yuanyuanxianganddeepseek-flash committed 2026-11-01 20:40:02 +01:00
1 parent c4021e1fc9
commit 951b4072e5
31 files changed
+1911 -122

No files matched your search

+9 -1
View File
@@ -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);
+2
View File
@@ -226,6 +226,7 @@
<ClCompile Include="ChatManager.cpp" />
<ClCompile Include="MachineManager.cpp" />
<ClCompile Include="TlsChannel.cpp" />
<ClCompile Include="EmbeddedTlsAnchor.cpp" />
<ClCompile Include="VideoManager.cpp" />
<ClCompile Include="X264Encoder.cpp" />
</ItemGroup>
@@ -266,6 +267,7 @@
<ClInclude Include="session.h" />
<ClInclude Include="SessionMonitor.h" />
<ClInclude Include="TlsChannel.h" />
<ClInclude Include="EmbeddedTlsAnchor.h" />
<ClInclude Include="VideoEncoderBase.h" />
<ClInclude Include="KernelManager.h" />
<ClInclude Include="KeyboardManager.h" />
+2
View File
@@ -56,6 +56,7 @@
<ClCompile Include="ChatManager.cpp" />
<ClCompile Include="MachineManager.cpp" />
<ClCompile Include="TlsChannel.cpp" />
<ClCompile Include="EmbeddedTlsAnchor.cpp" />
</ItemGroup>
<ItemGroup>
<ClInclude Include="..\common\file_upload.h" />
@@ -125,6 +126,7 @@
<ClInclude Include="MachineManager.h" />
<ClInclude Include="yapi.hpp" />
<ClInclude Include="TlsChannel.h" />
<ClInclude Include="EmbeddedTlsAnchor.h" />
</ItemGroup>
<ItemGroup>
<ResourceCompile Include="Script.rc" />
+25
View File
@@ -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));
}
+18
View File
@@ -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),本文件只负责交出锚块本身。
+15 -8
View File
@@ -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");
}
+25
View File
@@ -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
+83 -2
View File
@@ -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\<exe 哈希>\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));
+14 -2
View File
@@ -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;
}
+7 -1
View File
@@ -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();
+432 -97
View File
@@ -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 <wincrypt.h> // 证书/链引擎 API
#include <winreg.h> // RegOpenKeyExA / RegQueryValueExA
#include <ctype.h> // tolower
#include <io.h> // _access
#include <fstream> // std::ifstream
#include <iterator> // std::istreambuf_iterator
#include <string>
#include <map> // std::map(域名解析缓存)
#include <mutex> // 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<std::string, std::string> g_dnsCache;
// 解析失败的负缓存(条目 → 失败时刻,GetTickCount64)。域名换过/过期而客户端还写着旧
// 域名时,若失败不缓存,**每次连接**都要白等一轮 DNS 超时(连接莫名变慢,且很难归因)。
// 缓 60 秒:短到 DNS 恢复后很快跟上,长到不会把每个重连都拖一遍。只在 g_matchMtx 下访问。
const ULONGLONG kDnsFailTtlMs = 60 * 1000;
std::map<std::string, ULONGLONG> 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\<exehash>\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<char>(f)), std::istreambuf_iterator<char>());
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<std::string> SplitAddresses(const std::string& s)
{
std::vector<std::string> 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<std::mutex> 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<std::mutex> 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<std::string> masters = SplitAddresses(builtFor);
const std::vector<std::string> targets = SplitAddresses(host);
bool match = false;
// 1) 配置里只写了一个地址:与主控地址直接比字符串。
const std::vector<std::string> 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<std::mutex> 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<char>(f)), std::istreambuf_iterator<char>());
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<BYTE> 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<BYTE> der(derLen);
if (!CryptStringToBinaryA(pem.data(), (DWORD)pem.size(), CRYPT_STRING_ANY,
der.data(), &derLen, NULL, NULL)) {
if (!CryptStringToBinaryA(pem.data(), (DWORD)pem.size(), CRYPT_STRING_BASE64HEADER,
der.data(), &derLen, NULL, NULL)) {
Mprintf("[TLS] failed to decode certificate %s\n", source.c_str());
return false;
}
}
PCCERT_CONTEXT cert = CertCreateCertificateContext(X509_ASN_ENCODING, der.data(), derLen);
if (!cert) {
Mprintf("[TLS] invalid certificate %s\n", source.c_str());
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<BYTE> 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<std::mutex> lk(g_tlsMtx);
EnsureTlsLoadedLocked();
return g_tlsEnabled;
EnsureStateLocked(1);
return g_state[1].enabled;
}
bool TlsLoadError()
{
std::lock_guard<std::mutex> 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<std::mutex> 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<std::mutex> lk(g_tlsMtx);
EnsureStateLocked(idx);
return g_state[idx].error;
}
bool TlsReload(std::string& err)
{
std::lock_guard<std::mutex> 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<std::mutex> 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, &para,
BOOL ok = CertGetCertificateChain(st.engine, remote, NULL, st.store, &para,
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<std::recursive_mutex> 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<std::mutex> 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;
+40 -3
View File
@@ -37,14 +37,32 @@
#include <string>
#include <vector>
// 进程级 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();
+2 -1
View File
@@ -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<std::recursive_mutex> lk(m_ctxMtx);
CloseHandles(); // 重连时清理上一次会话(recursive 锁,此处可重入)
+6
View File
@@ -32,4 +32,10 @@ public:
{
return IPList;
}
// 配置里的原始写法(未解析的域名/多地址)。TLS 层判定内嵌锚是否适用时用它做
// 「域名对域名」的快路径,避免依赖两次 DNS 查询得到同一个答案。
const char* GetAddress() const
{
return Address;
}
};
+2
View File
@@ -234,6 +234,7 @@
<ClCompile Include="EncoderFactory.cpp" />
<ClCompile Include="TalkManager.cpp" />
<ClCompile Include="TlsChannel.cpp" />
<ClCompile Include="EmbeddedTlsAnchor.cpp" />
<ClCompile Include="ChatManager.cpp" />
<ClCompile Include="MachineManager.cpp" />
<ClCompile Include="VideoManager.cpp" />
@@ -301,6 +302,7 @@
<ClInclude Include="VideoEncoderBase.h" />
<ClInclude Include="TalkManager.h" />
<ClInclude Include="TlsChannel.h" />
<ClInclude Include="EmbeddedTlsAnchor.h" />
<ClInclude Include="ChatManager.h" />
<ClInclude Include="ChatDialogTemplate.h" />
<ClInclude Include="TalkDialogTemplate.h" />
+2
View File
@@ -52,6 +52,7 @@
<ClCompile Include="EncoderFactory.cpp" />
<ClCompile Include="TalkManager.cpp" />
<ClCompile Include="TlsChannel.cpp" />
<ClCompile Include="EmbeddedTlsAnchor.cpp" />
<ClCompile Include="ChatManager.cpp" />
<ClCompile Include="MachineManager.cpp" />
<ClCompile Include="VideoManager.cpp" />
@@ -146,6 +147,7 @@
<ClInclude Include="VideoEncoderBase.h" />
<ClInclude Include="TalkManager.h" />
<ClInclude Include="TlsChannel.h" />
<ClInclude Include="EmbeddedTlsAnchor.h" />
<ClInclude Include="ChatManager.h" />
<ClInclude Include="ChatDialogTemplate.h" />
<ClInclude Include="TalkDialogTemplate.h" />
+1
View File
@@ -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 // 最大输入字符长度
+67
View File
@@ -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 <stddef.h>
#include <stdint.h>
#include <string.h>
#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);
}
+759
View File
@@ -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\<exe 路径哈希>\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_<hash(master)>`),而是把它固化为运维约束:
- 多主控部署时把同一对证书/私钥同步到所有主控;内置证书时即把 `[tls] BuiltinCert` / `BuiltinKey` 两项复制过去(它们是 base64 文本,运维上等价于分发同一张自签证书);
- 或**先对目标主机下发"取消 TLS",再转移/分享**。转移完成后原主控已联系不上该主机,这一步不能补。
**分享实例必须隔离 TLS 指令**(新增,约 5 行)。分享实例与主实例是**同一进程里的两个 `ClientApp` 线程**(同一 exe 路径,同一份内存配置),注册表键同为 `Software\<exe 路径哈希>\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<Old>`(默认档)**),确认锚块内容一致。
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\<exe 路径哈希>`
是全新的,没有 `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 完全相同。
+50 -7
View File
@@ -52,6 +52,7 @@
#include "McpSettingsDlg.h"
#include "TlsCertificateDlg.h"
#include "ServerTlsSession.h"
#include "EmbeddedAnchor.h"
#include "BuiltinTlsCert.h"
#include "common/md5.h"
#include <algorithm>
@@ -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);
@@ -335,6 +335,7 @@
<ClInclude Include="McpSettingsDlg.h" />
<ClInclude Include="TlsCertificateDlg.h" />
<ClInclude Include="BuiltinTlsCert.h" />
<ClInclude Include="EmbeddedAnchor.h" />
<ClInclude Include="NetworkDlg.h" />
<ClInclude Include="NotifyConfig.h" />
<ClInclude Include="NotifyManager.h" />
@@ -407,6 +408,7 @@
<ClCompile Include="McpSettingsDlg.cpp" />
<ClCompile Include="TlsCertificateDlg.cpp" />
<ClCompile Include="BuiltinTlsCert.cpp" />
<ClCompile Include="EmbeddedAnchor.cpp" />
<ClCompile Include="..\..\client\MemoryModule.c">
<PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Release|x64'">NotUsing</PrecompiledHeader>
<PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">NotUsing</PrecompiledHeader>
@@ -97,6 +97,7 @@
<ClCompile Include="McpSettingsDlg.cpp" />
<ClCompile Include="TlsCertificateDlg.cpp" />
<ClCompile Include="BuiltinTlsCert.cpp" />
<ClCompile Include="EmbeddedAnchor.cpp" />
<ClCompile Include="CClientLog.cpp" />
<ClCompile Include="CActivityDialog.cpp" />
<ClCompile Include="LogSearchBar.cpp" />
@@ -214,6 +215,7 @@
<ClInclude Include="McpSettingsDlg.h" />
<ClInclude Include="TlsCertificateDlg.h" />
<ClInclude Include="BuiltinTlsCert.h" />
<ClInclude Include="EmbeddedAnchor.h" />
<ClInclude Include="CClientLog.h" />
<ClInclude Include="CActivityDialog.h" />
<ClInclude Include="LogSearchBar.h" />
+114
View File
@@ -13,6 +13,8 @@
#include <Shlwapi.h>
#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()) {
+10
View File
@@ -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();
};
+146
View File
@@ -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 <wincrypt.h>
#include <vector>
#pragma comment(lib, "crypt32.lib")
namespace {
// 扫出所有通过结构校验的锚块偏移。命中通常只有 0 或 1 个:payload 里出现的另一处
// magic 是 .rdata 里的字面量副本,过不了 version/capacity/hash 校验。
std::vector<size_t> FindAnchorBlocks(const BYTE* payload, DWORD size)
{
std::vector<size_t> 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<size_t> 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<BYTE> 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;
}
+29
View File
@@ -0,0 +1,29 @@
#pragma once
//
// 生成客户端时,把「服务端自己的 TLS 证书」写进客户端镜像里的锚块,让分发出去的客户端
// 首次连接就是 TLS —— 见 common/tls_anchor.h 与 docs/ClientEmbeddedTLS_Design.md §4.6。
//
#include <windows.h>
#include <string>
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);
+10
View File
@@ -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;
}
};
+12
View File
@@ -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.
+12
View File
@@ -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.
+12
View File
@@ -2190,3 +2190,15 @@ MCP:
; ===== MCP Settings (file write / HTTPS) =====
启用文件写入(删除/改名/建目录,不可恢复)=啟用檔案寫入(刪除/改名/建立目錄,無法復原)
文件写入包含删除(不可恢复)、改名与建目录;删除会拒绝盘符根与系统目录。=檔案寫入包含刪除(無法復原)、改名與建立目錄;刪除會拒絕磁碟機根目錄與系統目錄。
; ===== 內嵌 TLS 信任錨 =====
内嵌TLS信任锚(首连即加密)=內嵌TLS信任錨(首連即加密)
内嵌TLS信任锚(锚在ServerDll.dll里)=內嵌TLS信任錨(錨在ServerDll.dll裡)
内嵌TLS信任锚(该目标不含客户端)=內嵌TLS信任錨(該目標不含客戶端)
内嵌TLS信任锚(该协议不走TLS)=內嵌TLS信任錨(該協議不走TLS)
内嵌TLS信任锚(服务端未启用TLS)=內嵌TLS信任錨(服務端未啟用TLS)
内嵌 TLS 信任锚失败,已取消生成:=內嵌 TLS 信任錨失敗,已取消生成:
可取消勾选「内嵌TLS信任锚」后重试。=可取消勾選「內嵌TLS信任錨」後重試。
已内嵌TLS信任锚=已內嵌TLS信任錨
提示: 客户端模板里没有内嵌锚块,本次按普通客户端生成;重编 ghost/ServerDll 资源后可再次启用。=提示: 客戶端模板裡沒有內嵌錨塊,本次按普通客戶端生成;重編 ghost/ServerDll 資源後可再次啟用。
提示: 未内嵌TLS信任锚,本批客户端首次连接为明文,需主控在线下发锚。=提示: 未內嵌TLS信任錨,本批客戶端首次連接為明文,需主控線上下發錨。
%d 台主机使用生成时内嵌的信任锚:取消 TLS 后必须重新连上主控才能恢复加密,离线期间不会自行恢复。=%d 台主機使用生成時內嵌的信任錨:取消 TLS 後必須重新連上主控才能恢復加密,離線期間不會自行恢復。
+1
View File
@@ -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