From 6bfa4294cc7b6db5f5b4776f0330a5639ecfda6e Mon Sep 17 00:00:00 2001 From: yuanyuanxiang <962914132@qq.com> Date: Wed, 28 Oct 2026 14:06:50 +0100 Subject: [PATCH] Feature: Switch a Linux client's transport TLS at runtime The server's TLS menu already wrote the trust anchor into the Windows client's registry and expected a restart. The Linux client grew the same command handling (166/167) but, like Windows, only read the anchor once at startup, so enabling or disabling TLS still meant restarting it. Both handlers now take effect immediately. TlsChannelLinux.cpp no longer initialises through std::call_once. The process-level state (context, enabled, load error) lives behind a mutex and TlsReload() rebuilds it from whatever anchor file is on disk, so TlsEnabled() reflects the new transport as soon as the anchor is written or removed. In-flight sessions survive the swap because SSL_new increments the SSL_CTX reference count; the unit test pins that down by keeping an established TLS connection open across a reload that frees the old context. A reload that hits a bad anchor keeps the previous state and only logs: one bad push should not brick a working client, and the next start is still fail-closed. The pushed PEM is parsed before it is written for the same reason -- a corrupt anchor on disk would lock the client out of the server with no way to correct it remotely. Only a real transport flip (plaintext <-> TLS) asks for a reconnect. An anchor swap alone, as in a certificate rotation, leaves the current session alone and applies to the next connection. The receive thread never closes the socket itself; it sets g_needReconnect and the main heartbeat loop disconnects so the outer reconnect loop can re-handshake, matching how the heartbeat timeout path already works. IOCPClient now latches the transport per connection (m_useTls) at handshake time instead of consulting TlsEnabled() on every send and receive. Without the latch, the second or so between the reload and the reconnect would push plaintext into an established TLS session, or the reverse, producing protocol errors for no reason. RES_TLS (szReserved[19]) is refreshed right before each login, including the resend after a group change, so the TLS column on the server flips with the transport instead of showing the value from process start. The confirmation dialogs now say what each platform does, with translations in en_US, zh_TW and de_DE; the keys carry the literal \n escape the INI parser understands. Ending a sub-connection is not an error. OpenSSL 3 classifies a peer that closes without close_notify as an unexpected-EOF protocol error, so every terminal or file transfer session logged an SSL_read failure on the real servers even though Recv promises 0 for a plain close and neither side sends close_notify. SSL_OP_IGNORE_UNEXPECTED_EOF restores the intended semantics. Verified with the reload unit test (RELOAD-OK, covering the in-flight connection across a context swap, garbage payload rejection and a broken anchor keeping TLS alive), an abrupt-close test (recv now returns 0 instead of SOCKET_ERROR) and end to end against a protocol-faithful fake server that signs MasterSettings with libsign: plaintext login, 166, TLS reconnect with RES_TLS=1, 167, plaintext reconnect with RES_TLS=0. The Linux client, the Debug Windows client and the Debug MFC server all build. The cost is inherent to taking effect immediately: a remote session in progress is dropped when the transport changes, and the MFC server briefly shows the client as a duplicate login until the old connection is reaped and the standby entry is promoted. Co-Authored-By: deepseek-flash Co-Authored-By: Claude Code --- client/IOCPClient.cpp | 21 +- client/IOCPClient.h | 26 +- client/TlsChannel.h | 110 +++++- client/TlsChannelLinux.cpp | 559 ++++++++++++++++++++++++++++ docs/TransportTLS_Design.md | 33 +- linux/CMakeLists.txt | 6 +- linux/main.cpp | 95 +++++ server/2015Remote/2015RemoteDlg.cpp | 10 +- server/2015Remote/lang/de_DE.ini | 4 +- server/2015Remote/lang/en_US.ini | 4 +- server/2015Remote/lang/zh_TW.ini | 4 +- 11 files changed, 824 insertions(+), 48 deletions(-) create mode 100644 client/TlsChannelLinux.cpp diff --git a/client/IOCPClient.cpp b/client/IOCPClient.cpp index 5baf700..a11aac7 100644 --- a/client/IOCPClient.cpp +++ b/client/IOCPClient.cpp @@ -467,10 +467,13 @@ BOOL IOCPClient::ConnectServer(const char* szServerIP, unsigned short uPort) SetKeepAliveOptions(m_sClientSocket); #endif } -#ifdef _WIN32 +#ifdef YAMA_TLS_CHANNEL // 单向 TLS:证书存在(TlsEnabled())时,在应用协议首包前完成握手;握手失败即断开, // 不回退明文(fail-closed,防降级)。证书存在但加载失败(TlsLoadError())同样拒绝 // 连接。握手须在 m_bConnected 置位前,确保工作线程不会在握手尚未完成时就开始 recv。 + // m_useTls 在这里一次性锁定:Linux 客户端可能在此后收到服务端下发并热切换传输方式, + // 那条连接已建立,本连接的 Send/Recv 必须继续按握手时的传输方式走。 + m_useTls = false; if (TlsLoadError()) { Mprintf("[TLS] 证书加载失败,拒绝连接(fail-closed)\n"); closesocket(m_sClientSocket); @@ -484,6 +487,7 @@ BOOL IOCPClient::ConnectServer(const char* szServerIP, unsigned short uPort) m_sClientSocket = INVALID_SOCKET; return FALSE; } + m_useTls = true; } #endif m_bConnected = TRUE; @@ -549,9 +553,9 @@ DWORD WINAPI IOCPClient::WorkThreadProc(LPVOID lParam) Sleep(50); continue; } -#ifdef _WIN32 +#ifdef YAMA_TLS_CHANNEL // TLS 会话里可能有已解密、尚未交付的明文(select 只看底层 socket,看不到 - // Schannel 内部缓冲),优先消费,避免被 select 卡住。 + // TLS 库内部缓冲),优先消费,避免被 select 卡住。 if (This->HasPendingData()) { if (!This->ProcessRecvData(&m_CompressedBuffer, szBuffer, MAX_RECV_BUFFER - 1, 0)) { break; @@ -665,11 +669,11 @@ VOID IOCPClient::OnServerReceiving(CBuffer* m_CompressedBuffer, char* szBuffer, for (int i = 0; i < 16 && i < (int)bufLen; ++i) { char tmp[12]; sprintf(tmp, "%02X ", (unsigned char)src[i]); buf += tmp; } -#ifdef _WIN32 - Mprintf("[ERROR] Unknown header! this=%p bufLen=%lu, first 16 bytes: %s (TlsEnabled=%d tlsReady=%d)\n", - this, bufLen, buf.c_str(), (int)TlsEnabled(), (int)m_tls.IsReady()); +#ifdef YAMA_TLS_CHANNEL + Mprintf("[ERROR] Unknown header! this=%p bufLen=%lu, first 16 bytes: %s (useTls=%d tlsReady=%d)\n", + this, bufLen, buf.c_str(), (int)m_useTls, (int)m_tls.IsReady()); #else - // 非 Windows 平台没有 TlsChannel(TLS 只在 Windows 客户端实现) + // macOS/Android 没有 TlsChannel(TLS 只在这两个平台之外的客户端实现) Mprintf("[ERROR] Unknown header! this=%p bufLen=%lu, first 16 bytes: %s\n", this, bufLen, buf.c_str()); #endif @@ -901,6 +905,9 @@ VOID IOCPClient::Disconnect() closesocket(m_sClientSocket); m_sClientSocket = INVALID_SOCKET; +#ifdef YAMA_TLS_CHANNEL + m_useTls = false; // 连接已断,Send/Recv 回到明文路径(下次 ConnectServer 重新锁定) +#endif m_bConnected = FALSE; } diff --git a/client/IOCPClient.h b/client/IOCPClient.h index 8aa6a61..5da26aa 100644 --- a/client/IOCPClient.h +++ b/client/IOCPClient.h @@ -8,10 +8,13 @@ #include "stdafx.h" #include #include -#include "TlsChannel.h" #pragma comment(lib,"ws2_32.lib") #endif +// TLS 通道:Windows 走 Schannel,Linux 走 OpenSSL;macOS/Android 下该头为空, +// 且不定义 YAMA_TLS_CHANNEL,下方代码自动退回明文。 +#include "TlsChannel.h" + #include "Buffer.h" #include "zstd/zstd.h" #include "domain_pool.h" @@ -290,8 +293,8 @@ public: protected: virtual int ReceiveData(char* buffer, int bufSize, int flags) { -#ifdef _WIN32 - if (TlsEnabled()) +#ifdef YAMA_TLS_CHANNEL + if (m_useTls) return m_tls.Recv(m_sClientSocket, buffer, bufSize - 1); #endif // TCP版本调用 recv @@ -301,18 +304,18 @@ protected: virtual bool ProcessRecvData(CBuffer* m_CompressedBuffer, char* szBuffer, int len, int flag); virtual int SendTo(const char* buf, int len, int flags) { -#ifdef _WIN32 - if (TlsEnabled()) +#ifdef YAMA_TLS_CHANNEL + if (m_useTls) return m_tls.Send(m_sClientSocket, buf, len); #endif return ::send(m_sClientSocket, buf, len, flags); } // TLS 会话里可能有已解密但尚未交付的明文(select 只能看到底层 socket 可读性, - // 看不到 Schannel 内部缓冲),接收线程在 select 前须优先消费,避免其被卡住。 + // 看不到 TLS 库内部缓冲),接收线程在 select 前须优先消费,避免其被卡住。 bool HasPendingData() const { -#ifdef _WIN32 - return m_tls.HasPending(); +#ifdef YAMA_TLS_CHANNEL + return m_useTls && m_tls.HasPending(); #else return false; #endif @@ -325,8 +328,13 @@ protected: protected: sockaddr_in m_ServerAddr; SOCKET m_sClientSocket; -#ifdef _WIN32 +#ifdef YAMA_TLS_CHANNEL TlsChannel m_tls; // TLS 会话(证书存在时才启用,见 TlsChannel.h) + // 本连接是否走 TLS:在 ConnectServer 里握手成功时置位、Disconnect 时清除,Send/Recv + // 一律按这个快照走,不再每次现查 TlsEnabled()。Linux 客户端支持服务端下发后热切换 + // 传输方式(TlsReload),若现查全局开关,切换后到重连完成之间的这一秒里会把明文塞进 + // 已建立的 TLS 会话(或反过来),白白制造协议错误。 + bool m_useTls = false; #endif BOOL m_bWorkThread; HANDLE m_hWorkThread; diff --git a/client/TlsChannel.h b/client/TlsChannel.h index d228bdd..ed22506 100644 --- a/client/TlsChannel.h +++ b/client/TlsChannel.h @@ -1,25 +1,29 @@ -// TlsChannel.h — Windows 客户端单向 TLS(Schannel)会话封装 +// TlsChannel.h — 客户端单向 TLS 会话封装(Windows: Schannel;Linux: OpenSSL) // -// 用途:为 YAMA 客户端(被控端)提供「按需开启」的传输层加密。当信任锚证书存在时 -// (注册表 Software\\settings\tls_cert,或 yama-ca.pem 文件,见 TlsChannel.cpp -// 的 InitTls),所有出站 TCP 连接在应用协议首包前先完成 TLS 握手;握手失败一律断开 +// 用途:为 YAMA 客户端(被控端)提供「按需开启」的传输层加密。当信任锚证书存在时, +// 所有出站 TCP 连接在应用协议首包前先完成 TLS 握手;握手失败一律断开 // (fail-closed,不回退明文)。 // -// 选型:Schannel(Windows 原生 SSPI),零第三方依赖;secur32.lib / crypt32.lib 为 -// 系统库。单向 TLS:客户端只校验服务端证书链到固定的信任锚,不提供客户端证书, -// 客户端身份仍由隧道内登录(V1 PwdHmac / V2 ECDSA)承担。 +// 选型: +// - Windows:Schannel(原生 SSPI),零第三方依赖;secur32.lib / crypt32.lib 为系统库。 +// - Linux:OpenSSL(构建链已因 libsign 链接 libcrypto,另加 libssl 即可)。 +// 两者都是单向 TLS:客户端只校验服务端证书链到固定的信任锚,不提供客户端证书, +// 客户端身份仍由隧道内登录(V1 PwdHmac / V2 ECDSA)承担;均不校主机名(客户端按 IP +// 连接),不做吊销检查——与 Windows 版既有语义保持一致。 // // 线程模型:Handshake 在连接建立线程上、m_bConnected 置位前调用;Send/Recv 分别在 -// 发送线程 / 接收线程上调用。上下文生命周期(Handshake/CloseHandles 释放 m_ctx)与 -// Send/Recv 对 m_ctx 的使用(EncryptMessage/DecryptMessage)由 m_ctxMtx 互斥,避免 -// 重连线程释放上下文时与使用线程产生 use-after-free。本对象作为 IOCPClient 的值成员 -// 存在,析构时释放上下文。 +// 发送线程 / 接收线程上调用。上下文生命周期(Handshake/CloseHandles 释放上下文)与 +// Send/Recv 对上下文的使用由 m_ctxMtx 互斥,避免重连线程释放上下文时与使用线程产生 +// use-after-free。本对象作为 IOCPClient 的值成员存在,析构时释放上下文。 // -// 注意:本文件仅在 _WIN32 下有效,非 Windows 构建(Linux/macOS/Android)不含任何内容, -// 客户端维持明文(TLS 接入按设计文档延后)。 +// 平台范围:_WIN32 与 Linux(非 Android)有实现;macOS / Android 不含任何内容,客户端 +// 维持明文(TLS 接入按设计文档延后)。两平台都通过 YAMA_TLS_CHANNEL 宏告知调用方 +// 「本平台有 TLS 通道」。 #pragma once -#ifdef _WIN32 +#if defined(_WIN32) + +#define YAMA_TLS_CHANNEL 1 #include @@ -91,4 +95,80 @@ private: std::vector m_pending; // 已解密、未交付给应用层的明文 }; -#endif // _WIN32 +#elif defined(__linux__) && !defined(__ANDROID__) + +#define YAMA_TLS_CHANNEL 1 + +#include +#include + +struct ssl_st; // OpenSSL 的 SSL 类型,避免头文件把 openssl/ssl.h 拖进所有翻译单元 + +// 进程级 TLS 开关:首次调用时加载信任锚文件,返回是否启用。线程安全、幂等。 +// Linux 版是「可热切换」的:TlsReload() 之后本函数立刻反映新状态(不是 call_once)。 +bool TlsEnabled(); + +// 信任锚已配置但加载失败(无法读取/格式错误/内容为空)时为 true:客户端必须拒绝连接 +// (fail-closed),不得静默回退明文。线程安全、幂等。 +bool TlsLoadError(); + +// 服务端下发信任锚(COMMAND_TLS_ENABLE):把 PEM 正文写入 +// $XDG_CONFIG_HOME/ghost/yama-ca.pem(默认 ~/.config/ghost/yama-ca.pem,无 HOME 时退回 +// 程序目录),原子替换、权限 0600。写入前先解析验证,不是合法证书就整包拒绝。 +// 落盘后用 TlsReload() 立即生效(Windows 客户端仍要重启进程)。 +bool TlsTrustAnchorSave(const std::string& pem, std::string& err); + +// 服务端撤销信任锚(COMMAND_TLS_DISABLE):删除上述配置文件(含程序目录同名文件)。 +// 返回是否删掉了至少一个文件;之后同样用 TlsReload() 立即生效。 +bool TlsTrustAnchorRemove(std::string& err); + +// 按当前信任锚文件重建 TLS 上下文并更新开关,让随后建立的新连接立刻走新传输方式 +// (已建立的连接不受影响:SSL 对象自持 SSL_CTX 引用)。信任锚无效时不做任何改动、 +// 返回 false 并给出原因——一次坏下发不该把正在工作的客户端打死(下次启动仍 fail-closed)。 +// 线程安全:与 TlsEnabled/TlsLoadError/Handshake 互斥。 +bool TlsReload(std::string& err); + +class TlsChannel +{ +public: + TlsChannel() {} + ~TlsChannel() { CloseHandles(); } + + // 持 SSL*,禁止拷贝/赋值(避免上下文被二次释放)。 + TlsChannel(const TlsChannel&) = delete; + TlsChannel& operator=(const TlsChannel&) = delete; + + // 在已连通的 socket 上完成 TLS 1.2 客户端握手并按信任锚校验服务端证书链。失败返回 + // false,调用方必须关闭 socket(fail-closed)。可重复调用(重连时复用同一对象)。 + bool Handshake(int sock); + + // 解密读取:返回 >0 的明文字节数;0 表示对端正常关闭;SOCKET_ERROR(-1) 出错。 + int Recv(int sock, char* buf, int len); + + // 加密发送 len 字节:成功返回已完整发送的明文字节数(== len);失败返回已发送的 + // 前缀字节数(>0)或 SOCKET_ERROR(一个字节都没发出去时)。 + int Send(int sock, const char* buf, int len); + + // 是否有待交付的数据(SSL 内部已缓冲)供接收线程在 select 前优先消费。OpenSSL 会在 + // 一个 TLS 记录里装多条应用数据,一次 SSL_read 只交付一部分;剩余的留在 SSL 内部, + // select 看不到,必须用 SSL_has_pending() 才能避免被 2 秒超时卡住。 + bool HasPending() const; + + // 握手是否已完成(Send/Recv 可用)。诊断用:区分「本连接已走 TLS」与「裸连接」。 + bool IsReady() const { return m_ready; } + +private: + void CloseHandles(); + + ssl_st* m_ssl = nullptr; + int m_fd = -1; + bool m_ready = false; // 握手完成,Send/Recv 可用 + + // 保护上下文生命周期:重连线程的 Handshake/CloseHandles(释放 m_ssl)与工作线程的 + // Recv(SSL_read)、发送线程的 Send(SSL_write)互斥。OpenSSL 的 SSL 对象不允许 + // 并发使用,所以 Send/Recv 也持锁——与 Windows 版同样式。 + // mutable 是因为 HasPending() 是 const 但需要持锁读 m_ssl。 + mutable std::recursive_mutex m_ctxMtx; +}; + +#endif // _WIN32 / __linux__ && !__ANDROID__ diff --git a/client/TlsChannelLinux.cpp b/client/TlsChannelLinux.cpp new file mode 100644 index 0000000..9b77070 --- /dev/null +++ b/client/TlsChannelLinux.cpp @@ -0,0 +1,559 @@ +// TlsChannelLinux.cpp — 见 TlsChannel.h 头注释。仅 Linux(非 Android)编译。 +// +// 与 Windows 的 Schannel 实现语义对齐: +// - 单向 TLS 1.2(min=max=1.2,与 SP_PROT_TLS1_2_CLIENT 及两套服务端一致); +// - 信任锚严格钉扎:证书链只按信任锚文件里的证书校验,不含系统根库; +// - 不校主机名(客户端按 IP 连接,与 Windows 版一致)、不做吊销检查; +// - 信任锚「存在即已配置」:读取/解析失败一律 TlsLoadError()=true → 调用方拒绝连接。 +// +// 与 Windows 实现的差异:OpenSSL 自己管理 TLS 记录缓冲,不需要 m_raw/m_pending; +// 一次性交付不出去的明文留在 SSL 内部,由 SSL_has_pending()/SSL_pending() 暴露给 +// 接收线程在 select 前优先消费。 +#if defined(__linux__) && !defined(__ANDROID__) + +#include "TlsChannel.h" + +#include "common/commands.h" // SOCKET_ERROR / closesocket 等 POSIX 兼容宏 +#include "common/logger.h" // Mprintf + +#include +#include +#include +#include +#include + +#include +#include +#include +#include +#include +#include +#include +#include + +#include +#include +#include +#include + +namespace { + +const char* const kAnchorName = "yama-ca.pem"; + +// 进程级 TLS 状态。与 Windows 版的 call_once 不同,这里可由 TlsReload() 热切换 +// (服务端 COMMAND_TLS_ENABLE/DISABLE 落盘后立即重建),因此用互斥量而不是 once_flag。 +std::mutex g_stateMtx; // 保护下面四项 +bool g_inited = false; // 首次加载已完成(含 fail-closed 基态) +bool g_tlsEnabled = false; // TLS 会话可用:send/recv 走加密 +bool g_tlsError = false; // 信任锚存在但加载失败:拒绝连接(fail-closed) +SSL_CTX* g_tlsCtx = nullptr; // 进程级上下文(线程安全,可被多条连接共享) +std::string g_anchorPath; // 仅用于日志 + +// 配置目录:与 LinuxConfig 相同规则($XDG_CONFIG_HOME/ghost 或 ~/.config/ghost)。 +std::string ConfigDir() +{ + const char* xdg = getenv("XDG_CONFIG_HOME"); + if (xdg && xdg[0]) + return std::string(xdg) + "/ghost"; + const char* home = getenv("HOME"); + if (!home || !home[0]) + return std::string(); + return std::string(home) + "/.config/ghost"; +} + +// 可执行文件所在目录(readlink /proc/self/exe,失败返回空)。 +std::string ExeDir() +{ + char buf[4096]; + ssize_t n = readlink("/proc/self/exe", buf, sizeof(buf) - 1); + if (n <= 0) + return std::string(); + buf[n] = '\0'; + char* slash = strrchr(buf, '/'); + if (!slash) + return std::string(); + *slash = '\0'; + return std::string(buf); +} + +// 信任锚候选路径(按优先级),只返回已经存在的那个: +// 1) $XDG_CONFIG_HOME/ghost/yama-ca.pem(默认 ~/.config/ghost/yama-ca.pem) +// 2) 可执行文件同目录 yama-ca.pem(兼容手工投递,与 Windows 的 exe 同名文件回退一致) +bool FindAnchorPath(std::string& out) +{ + std::vector cands; + std::string dir = ConfigDir(); + if (!dir.empty()) + cands.push_back(dir + "/" + kAnchorName); + std::string exed = ExeDir(); + if (!exed.empty()) + cands.push_back(exed + "/" + kAnchorName); + for (size_t i = 0; i < cands.size(); ++i) { + if (access(cands[i].c_str(), F_OK) == 0) { + out = cands[i]; + return true; + } + } + return false; +} + +// 递归 mkdir -p(已存在视为成功)。 +bool MkdirP(const std::string& path, mode_t mode) +{ + if (path.empty()) + return false; + struct stat st; + if (stat(path.c_str(), &st) == 0) + return S_ISDIR(st.st_mode); + size_t slash = path.find_last_of('/'); + if (slash != std::string::npos && slash > 0) { + if (!MkdirP(path.substr(0, slash), mode)) + return false; + } + if (mkdir(path.c_str(), mode) != 0 && errno != EEXIST) + return false; + return true; +} + +// 把 PEM(可含多张证书)或 DER 信任锚写入 store。返回加入的证书数。 +int LoadAnchors(const std::string& data, X509_STORE* store) +{ + int added = 0; + if (data.find("-----BEGIN") != std::string::npos) { + BIO* bio = BIO_new_mem_buf(data.data(), (int)data.size()); + if (bio) { + for (;;) { + X509* cert = PEM_read_bio_X509(bio, NULL, NULL, NULL); + if (!cert) + break; + if (X509_STORE_add_cert(store, cert) == 1) + ++added; + else + ERR_clear_error(); // 重复证书等:忽略该张,继续读后面的 + X509_free(cert); + } + BIO_free(bio); + } + ERR_clear_error(); + } + if (added == 0) { + // 退回 DER(单张) + const unsigned char* p = (const unsigned char*)data.data(); + X509* cert = d2i_X509(NULL, &p, (long)data.size()); + if (cert) { + if (X509_STORE_add_cert(store, cert) == 1) + ++added; + else + ERR_clear_error(); + X509_free(cert); + } + ERR_clear_error(); + } + return added; +} + +enum BuildResult +{ + BUILD_PLAINTEXT, // 没有信任锚文件 → 明文模式 + BUILD_READY, // *outCtx 为新建上下文,调用方接管所有权 + BUILD_INVALID, // 文件存在但读不了/解析不出证书(err 说明原因) +}; + +// 按当前信任锚文件构建一份新的 TLS 上下文。不读写任何全局状态,便于「先构建、成功再替换」。 +BuildResult BuildState(SSL_CTX** outCtx, std::string& anchorPath, std::string& err, int& certs) +{ + *outCtx = nullptr; + certs = 0; + anchorPath.clear(); + + std::string path; + if (!FindAnchorPath(path)) { + // 无证书 → 明文(默认,与老客户端一致) + return BUILD_PLAINTEXT; + } + anchorPath = path; + + // 证书已配置:管理员已「颁发」,必须走 TLS;读取/解析失败即拒绝连接(fail-closed), + // 不能静默回退明文。 + std::ifstream f(path.c_str(), std::ios::binary); + if (!f) { + err = "cannot open " + path + ": " + strerror(errno); + return BUILD_INVALID; + } + std::string pem((std::istreambuf_iterator(f)), std::istreambuf_iterator()); + + SSL_CTX* ctx = SSL_CTX_new(TLS_client_method()); + if (!ctx) { + err = "SSL_CTX_new failed"; + return BUILD_INVALID; + } + + // TLS 1.2 钉扎:与 Windows 客户端(SP_PROT_TLS1_2_CLIENT)及两套服务端(Schannel + // SP_PROT_TLS1_2_SERVER / Go MinVersion=TLS1.2)保持一致。 + SSL_CTX_set_min_proto_version(ctx, TLS1_2_VERSION); + SSL_CTX_set_max_proto_version(ctx, TLS1_2_VERSION); + + // SSL_VERIFY_PEER + 自定义 store = 严格钉扎到信任锚(不含系统根库),链校验在握手内 + // 完成,失败即握手失败。verify 回调传 NULL 使用默认行为(只验链,不校主机名)。 + SSL_CTX_set_verify(ctx, SSL_VERIFY_PEER, NULL); + SSL_CTX_set_verify_depth(ctx, 8); + + // 对端不打招呼就断开(不发 close_notify)在这里是常态:服务端关闭子连接时不发, + // 客户端自己也同样不发(见 CloseHandles 的说明)。OpenSSL 3.0 起这种 unexpected EOF + // 被归为 SSL_ERROR_SSL 协议错误,于是每结束一个终端/文件传输子连接都会记一条 + // 「SSL_read failed」——线上日志看着像 TLS 坏了。打开这个选项让它按正常关闭处理 + // (SSL_read 返回 0),与 Recv 的文档语义以及 Windows 版的行为一致。 +#ifdef SSL_OP_IGNORE_UNEXPECTED_EOF + SSL_CTX_set_options(ctx, SSL_OP_IGNORE_UNEXPECTED_EOF); +#endif + + X509_STORE* store = X509_STORE_new(); + certs = store ? LoadAnchors(pem, store) : 0; + if (!store || certs <= 0) { + if (store) + X509_STORE_free(store); + SSL_CTX_free(ctx); + certs = 0; + err = "trust anchor " + path + " present but empty/invalid"; + return BUILD_INVALID; + } + SSL_CTX_set_cert_store(ctx, store); // ctx 接管 store 所有权 + + *outCtx = ctx; + return BUILD_READY; +} + +// 替换全局状态并释放旧上下文(调用方持 g_stateMtx)。SSL 对象在 SSL_new 时已递增 +// SSL_CTX 的引用计数,所以已经建立的连接不会因为这里释放旧 ctx 而失效。 +void InstallStateLocked(SSL_CTX* ctx, bool enabled, bool error, const std::string& anchor) +{ + SSL_CTX* old = g_tlsCtx; + g_tlsCtx = ctx; + g_tlsEnabled = enabled; + g_tlsError = error; + g_anchorPath = anchor; + if (old) + SSL_CTX_free(old); +} + +// 首次加载(调用方持锁):锚存在但无效时置 fail-closed。 +void EnsureInitLocked() +{ + if (g_inited) + return; + g_inited = true; + + SSL_CTX* ctx = nullptr; + std::string anchor, err; + int certs = 0; + switch (BuildState(&ctx, anchor, err, certs)) { + case BUILD_PLAINTEXT: + InstallStateLocked(nullptr, false, false, anchor); + Mprintf("[TLS] disabled: no trust anchor configured, plaintext mode\n"); + break; + case BUILD_READY: + InstallStateLocked(ctx, true, false, anchor); + Mprintf("[TLS] enabled: trust anchor loaded (%s, %d cert(s)), all connections use TLS\n", + anchor.c_str(), certs); + break; + case BUILD_INVALID: + InstallStateLocked(nullptr, false, true, anchor); + Mprintf("[TLS] FATAL: %s; refusing connections (fail-closed)\n", err.c_str()); + break; + } +} + +} // namespace + +bool TlsEnabled() +{ + std::lock_guard lk(g_stateMtx); + EnsureInitLocked(); + return g_tlsEnabled; +} + +bool TlsLoadError() +{ + std::lock_guard lk(g_stateMtx); + EnsureInitLocked(); + return g_tlsError; +} + +bool TlsReload(std::string& err) +{ + std::lock_guard lk(g_stateMtx); + EnsureInitLocked(); // 未初始化就先按启动语义建立基态,保持 fail-closed 行为 + + SSL_CTX* ctx = nullptr; + std::string anchor; + int certs = 0; + BuildResult r = BuildState(&ctx, anchor, err, certs); + if (r == BUILD_INVALID) { + // 保留原状态:一次坏下发不该让正在工作的客户端失联(下次启动仍会 fail-closed)。 + Mprintf("[TLS] reload FAILED: %s; keeping current transport (%s)\n", + err.c_str(), g_tlsEnabled ? "TLS" : "plaintext"); + return false; + } + if (r == BUILD_PLAINTEXT) { + InstallStateLocked(nullptr, false, false, anchor); + Mprintf("[TLS] reloaded: no trust anchor, transport is now plaintext\n"); + return true; + } + InstallStateLocked(ctx, true, false, anchor); + Mprintf("[TLS] reloaded: trust anchor %s (%d cert(s)), transport is now TLS\n", + anchor.c_str(), certs); + return true; +} + +// ---- 信任锚下发 / 撤销(服务端 COMMAND_TLS_ENABLE / COMMAND_TLS_DISABLE)---- + +bool TlsTrustAnchorSave(const std::string& pem, std::string& err) +{ + if (pem.empty()) { + err = "empty certificate payload"; + return false; + } + + // 先验证再落盘:文件一旦写进去,下次启动就会被无条件信任,坏锚等于把客户端锁死 + // (fail-closed 连不上,也没法再从服务端改回来)。宁可拒绝一次下发。 + { + X509_STORE* probe = X509_STORE_new(); + int n = probe ? LoadAnchors(pem, probe) : 0; + if (probe) + X509_STORE_free(probe); + if (n <= 0) { + err = "payload is not a valid PEM/DER certificate"; + return false; + } + } + + std::string dir = ConfigDir(); + if (dir.empty()) { + dir = ExeDir(); // 无 HOME 的极端环境:退回程序目录 + if (dir.empty()) { + err = "cannot resolve config directory"; + return false; + } + } + if (!MkdirP(dir, 0700)) { + err = "cannot create directory " + dir + ": " + strerror(errno); + return false; + } + + std::string path = dir + "/" + kAnchorName; + std::string tmp = path + ".tmp"; + int fd = open(tmp.c_str(), O_WRONLY | O_CREAT | O_TRUNC, 0600); + if (fd < 0) { + err = "cannot create " + tmp + ": " + strerror(errno); + return false; + } + size_t off = 0; + while (off < pem.size()) { + ssize_t w = write(fd, pem.data() + off, pem.size() - off); + if (w <= 0) { + if (w < 0 && errno == EINTR) + continue; + err = "cannot write " + tmp + ": " + strerror(errno); + close(fd); + unlink(tmp.c_str()); + return false; + } + off += (size_t)w; + } + fsync(fd); + close(fd); + + // 原子替换 + 收紧权限(目录可能已由 LinuxConfig 以 0755 创建) + if (rename(tmp.c_str(), path.c_str()) != 0) { + err = "cannot replace " + path + ": " + strerror(errno); + unlink(tmp.c_str()); + return false; + } + chmod(path.c_str(), 0600); + + Mprintf("[TLS] trust anchor saved to %s\n", path.c_str()); + return true; +} + +bool TlsTrustAnchorRemove(std::string& err) +{ + std::vector paths; + std::string dir = ConfigDir(); + if (!dir.empty()) + paths.push_back(dir + "/" + kAnchorName); + std::string exed = ExeDir(); + if (!exed.empty()) + paths.push_back(exed + "/" + kAnchorName); + + bool removed = false; + for (size_t i = 0; i < paths.size(); ++i) { + if (unlink(paths[i].c_str()) == 0) { + removed = true; + Mprintf("[TLS] trust anchor removed: %s\n", paths[i].c_str()); + } else if (errno != ENOENT) { + err = "cannot remove " + paths[i] + ": " + strerror(errno); + return false; + } + } + if (!removed) { + err = "no trust anchor configured"; + return false; + } + return true; +} + +// ---- TlsChannel ---- + +void TlsChannel::CloseHandles() +{ + std::lock_guard lk(m_ctxMtx); + if (m_ssl) { + SSL_free(m_ssl); // 不发送 close_notify:与 Windows 的 DeleteSecurityContext 同语义 + m_ssl = nullptr; + } + m_fd = -1; + m_ready = false; +} + +bool TlsChannel::Handshake(int sock) +{ + std::lock_guard lk(m_ctxMtx); + CloseHandles(); // 重连时清理上一次会话(recursive 锁,此处可重入) + + // 在状态锁内取一份上下文:SSL_new 会递增 SSL_CTX 引用计数,此后即使 TlsReload() + // 把全局上下文换掉(旧 ctx 被 SSL_CTX_free),本次握手的 SSL 仍然安全。 + SSL* ssl = nullptr; + { + std::lock_guard lk(g_stateMtx); + EnsureInitLocked(); + if (g_tlsCtx) + ssl = SSL_new(g_tlsCtx); + } + if (!ssl) { + Mprintf("[TLS] handshake called but no TLS context is available\n"); + return false; + } + if (SSL_set_fd(ssl, sock) != 1) { + Mprintf("[TLS] SSL_set_fd failed\n"); + SSL_free(ssl); + return false; + } + SSL_set_connect_state(ssl); + + // 阻塞 socket:WANT_READ / WANT_WRITE 只在记录分片等极端情形出现,重试即可。 + for (;;) { + ERR_clear_error(); + int r = SSL_do_handshake(ssl); + if (r == 1) + break; + int e = SSL_get_error(ssl, r); + if (e == SSL_ERROR_WANT_READ || e == SSL_ERROR_WANT_WRITE) + continue; + + if (e == SSL_ERROR_SSL) { + unsigned long err = ERR_peek_last_error(); + char ebuf[256] = {0}; + if (err) + ERR_error_string_n(err, ebuf, sizeof(ebuf)); + Mprintf("[TLS] handshake failed: %s\n", ebuf[0] ? ebuf : "SSL error"); + } else if (e == SSL_ERROR_SYSCALL) { + Mprintf("[TLS] handshake failed: syscall error (%s)\n", strerror(errno)); + } else { + Mprintf("[TLS] handshake failed: SSL_get_error=%d (peer closed?)\n", e); + } + SSL_free(ssl); + return false; + } + + // 单向 TLS:链必须钉扎到信任锚,且服务端确实出示了证书。默认 verify 只验链不校主机名, + // 与 Windows 版(CertGetCertificateChain 只验链)行为一致。 + long vr = SSL_get_verify_result(ssl); +#if OPENSSL_VERSION_NUMBER >= 0x30000000L + X509* peer = SSL_get1_peer_certificate(ssl); +#else + X509* peer = SSL_get_peer_certificate(ssl); +#endif + if (!peer || vr != X509_V_OK) { + Mprintf("[TLS] server certificate not trusted against trust anchor (%s)\n", + X509_verify_cert_error_string(vr)); + if (peer) + X509_free(peer); + SSL_free(ssl); + return false; + } + X509_free(peer); + + m_ssl = ssl; + m_fd = sock; + m_ready = true; + Mprintf("[TLS] handshake OK (%s, server cert trusted)\n", SSL_get_version(ssl)); + return true; +} + +int TlsChannel::Recv(int sock, char* out, int outLen) +{ + std::lock_guard lk(m_ctxMtx); + if (!m_ready || outLen <= 0) { + Mprintf("[TLS] Recv called but m_ready=%d (outLen=%d), returning SOCKET_ERROR\n", + (int)m_ready, outLen); + return SOCKET_ERROR; + } + (void)sock; // SSL 已绑定 fd + + for (;;) { + ERR_clear_error(); + int n = SSL_read(m_ssl, out, outLen); + if (n > 0) + return n; + int e = SSL_get_error(m_ssl, n); + if (e == SSL_ERROR_WANT_READ || e == SSL_ERROR_WANT_WRITE) + continue; + if (e == SSL_ERROR_ZERO_RETURN) + return 0; // close_notify:对端正常关闭 + if (e == SSL_ERROR_SYSCALL && ERR_peek_last_error() == 0) + return 0; // 对端未发 close_notify 就断开(unexpected EOF),按关闭处理 + + Mprintf("[TLS] SSL_read failed: SSL_get_error=%d (%s)\n", e, strerror(errno)); + return SOCKET_ERROR; + } +} + +int TlsChannel::Send(int sock, const char* data, int len) +{ + std::lock_guard lk(m_ctxMtx); + if (!m_ready) + return SOCKET_ERROR; + if (len <= 0) + return 0; + (void)sock; // SSL 已绑定 fd + + int total = 0; + while (total < len) { + ERR_clear_error(); + int n = SSL_write(m_ssl, data + total, len - total); + if (n > 0) { + total += n; + continue; + } + int e = SSL_get_error(m_ssl, n); + if (e == SSL_ERROR_WANT_READ || e == SSL_ERROR_WANT_WRITE) + continue; + + Mprintf("[TLS] SSL_write failed: SSL_get_error=%d (%s), sent=%d/%d\n", + e, strerror(errno), total, len); + return total > 0 ? total : SOCKET_ERROR; + } + return total; +} + +bool TlsChannel::HasPending() const +{ + std::lock_guard lk(m_ctxMtx); + if (!m_ready || !m_ssl) + return false; + // SSL_pending: 已解密未交付的明文;SSL_has_pending: 内部还缓冲着未处理的记录字节。 + // 任一为真都说明 select 看不到但可以立刻读,必须优先消费。 + return SSL_pending(m_ssl) > 0 || SSL_has_pending(m_ssl) == 1; +} + +#endif // __linux__ && !__ANDROID__ diff --git a/docs/TransportTLS_Design.md b/docs/TransportTLS_Design.md index 8c1655a..88d90d9 100644 --- a/docs/TransportTLS_Design.md +++ b/docs/TransportTLS_Design.md @@ -1,8 +1,8 @@ # 传输层单向 TLS 加密设计(按需加密) -> 版本:v0.5 · 状态:**Go 服务端 + Windows 客户端已实现并验证;信任锚改存注册表;MFC 主控端(阶段 3)未施工** · 日期:2026-10-14 +> 版本:v0.7 · 状态:**Go 服务端 + Windows/Linux 客户端已实现并验证;Linux 客户端支持下发即时热切换;MFC 主控端见 `TransportTLS_MFCServer_Design.md`;macOS/Android 未接入** · 日期:2026-10-28(Linux 客户端接入 + 热切换) > 目标:让 YAMA 设备端口(TCP 6543)在继续兼容老客户端(明文/XOR)的同时,允许新客户端在拿到证书后按需开启**单向 TLS** 加密传输。 -> 本期范围:**Go 服务端(`server/go`)+ Windows 客户端**;MFC 服务端(`server/2015Remote`)延后。 +> 本期范围:**Go 服务端(`server/go`)+ Windows 客户端 + Linux 客户端**。 > > 需求原文(三点,逐一对应下文): > 1. 新客户端**默认不加密**,行为与老客户端完全一致; @@ -23,8 +23,8 @@ - 不做 **mTLS / 客户端证书**:单向 TLS 不验证客户端证书,客户端身份仍由隧道内的现有登录(`PwdHmac` V1 / `ECDSA` V2)承担。 - 不做传输层 PSK(`YAMA_TRANSPORT_KEY`)方案——本设计改用证书,更贴合「颁发证书」的运维模型。 - 不改应用层协议(flag 帧格式 / XOR / zstd),不做「TLS 内去掉 XOR」的二次精简(后续可选)。 -- 不做加密开关的运行时热切换(证书只在客户端启动时读取一次,改配置需重启——这正是需求)。 -- 不做 Linux / macOS / Android 客户端的 TLS 接入(本文以 Windows MFC 客户端为主,其余平台同样式跟进)。 +- Windows 客户端**不做**加密开关的运行时热切换(证书只在进程启动时读取一次,改配置需重启——这正是需求)。Linux 客户端例外:服务端下发 166/167 后立即重载信任锚并重连切换(§6.6),语义差异见该节。 +- macOS / Android 客户端的 TLS 接入不在本期(Linux 客户端已按同一模式接入,见 §6.6)。 - 不做 **MFC 服务端(`server/2015Remote`)的 TLS 接入**——本期只做 Go 服务端(`server/go`),MFC 主控端延后到阶段 3。 ## 2. 现状与复用 @@ -190,6 +190,8 @@ func (s *Server) wrapTLS(conn net.Conn) net.Conn { 启动时(连接前)按优先级找信任锚:① 注册表 `Software\\settings\tls_cert`(REG_SZ 存 PEM 正文)→ ② `settings.ini` `[settings] tls_cert` 路径 → ③ exe 同目录 `yama-ca.pem`。找到即走 TLS,否则明文。实现:`client/TlsChannel.cpp` 的 `ReadTrustAnchor()` + `TlsEnabled()`(`std::call_once` 惰性加载、线程安全、幂等)。 +Linux 无注册表,信任锚按:① `$XDG_CONFIG_HOME/ghost/yama-ca.pem`(默认 `~/.config/ghost/yama-ca.pem`)→ ② 程序同目录 `yama-ca.pem`。文件**存在即视为已配置**:读取/解析失败一律拒绝连接(fail-closed)。实现:`client/TlsChannelLinux.cpp`。 + ### 6.2 TLS 栈选型(已定:Schannel) - **已选 Schannel(Windows 原生 SSPI)**:零第三方依赖/零额外 DLL 部署,`secur32.lib`/`crypt32.lib` 均为系统库(`secur32.lib` 已在 `CFFmpegH264Encoder.cpp:38` 链接)。 @@ -223,6 +225,22 @@ Schannel 流模式(`ISC_REQ_STREAM`)下,`DecryptMessage` 会把输入的 `STREAM_HEADER/DATA/TRAILER` 三段布局,本就正确。这一处是联调阶段实际踩到的、唯一的方向性 不对称 bug,已修复。 +### 6.6 Linux 客户端实现(OpenSSL,2026-10-28) + +- **选型**:OpenSSL(`libssl`)。Linux 构建早已因 `libsign.a` 链接 `libcrypto`,只多链一个 `OpenSSL::SSL`,不引入新的运行时依赖包(同一 OpenSSL 3 包提供 `libcrypto.so.3` / `libssl.so.3`)。 +- **代码组织**:`client/TlsChannel.h` 按平台分派(`_WIN32` → Schannel,`__linux__ && !__ANDROID__` → OpenSSL),Windows 分支内容不变;实现文件为 `client/TlsChannelLinux.cpp`。`YAMA_TLS_CHANNEL` 宏标注「本平台有 TLS 通道」,`IOCPClient` 用它替代原先的 `#ifdef _WIN32`,因此主连接与子连接共用同一接线点。macOS/Android 不定义该宏,维持明文。 +- **语义对齐**:`TLS 1.2` 钉扎(min=max,与 `SP_PROT_TLS1_2_CLIENT` 及两套服务端一致);单向 TLS、不提供客户端证书、不校主机名、不做吊销检查;`SSL_VERIFY_PEER` + 只含信任锚的 `X509_STORE`(不含系统根库,严格钉扎),握手内完成链校验,失败即断开(fail-closed)。 +- **缓冲差异**:OpenSSL 自己管理记录缓冲,不需要 Schannel 的 `m_raw`/`m_pending`;一次 `SSL_read` 交付不完的明文留在 `SSL` 内部,接收线程在 `select` 前用 `SSL_pending() || SSL_has_pending()` 优先消费,否则剩余字节会被 2 秒 `select` 超时卡住。 +- **下发/撤销**:`COMMAND_TLS_ENABLE`(166) 的 PEM 正文写入 `~/.config/ghost/yama-ca.pem`(目录 0700、文件 0600、临时文件 + rename 原子替换);`COMMAND_TLS_DISABLE`(167) 删除该文件(含程序目录同名回退文件)。写入前先用 OpenSSL 解析一遍,不是合法证书就整包拒绝并保留原状态。 +- **热切换(与 Windows 的唯一语义差异)**:落盘后立即 `TlsReload()` 重建 `SSL_CTX` 并更新开关,然后断开主连接、由外层重连循环用新传输方式重连——**主控端菜单点下去几秒内就生效**,不需要重启客户端(Windows 客户端仍需重启进程)。 + - 状态不再是 `std::call_once`,而是 `g_stateMtx` 保护的 `{g_tlsEnabled, g_tlsError, g_tlsCtx}`;`TlsEnabled()/TlsLoadError()/TlsReload()/Handshake()` 都在这把锁下读写。 + - **已建立的连接不受影响**:`SSL_new` 会递增 `SSL_CTX` 引用计数,`TlsReload` 释放旧 ctx 后旧的 `SSL` 仍然安全(已用「连接保持打开时撤销锚」验证)。 + - **只在传输方式真的变了(明文↔TLS)时才重连**;仅换锚(例如证书轮换,仍是 TLS)不打断现有会话,新锚从下一条新连接生效。 + - 热重载遇到坏锚时**保留原状态**并记日志,不把正在工作的客户端打死(下次启动仍按 fail-closed 语义)。 + - 重连由 `DataProcess`(接收线程)只置 `g_needReconnect` 标志,由主心跳线程 `Disconnect()` 后走外层重连循环——避免在接收线程里关 socket 与主线程发送竞争。 + - **代价**:此刻若正处于远程桌面/文件传输会话,主连接重建会中断该会话(子连接随之失效)。这是「立即生效」的固有代价。 +- **上报**:登录 `szReserved[19]`(`RES_TLS`)填 `TlsEnabled() ? 1 : 0`,主控端主机信息显示 Y/N。热切换后重连会重新登录,登录前用 `RefreshLoginTls()` 刷新该字段,主控端在线列表的 TLS 列随之翻转。 + ## 7. 兼容矩阵 | 客户端 | 服务端行为 | 结果 | @@ -286,7 +304,9 @@ Set-ItemProperty -Path 'HKCU:\Software\\settings' -Name 'tls_cert' -Val 兼容旧方式:把信任锚复制到客户端目录并命名为 `yama-ca.pem`(或经 `settings.ini` `[settings] tls_cert` 指向),重启客户端。 -移除注册表值(或删除文件)并重启即退回明文。**远程下发/撤销信任锚属后续工作,本期仅支持本地写注册表。** +Linux 客户端:把信任锚放到 `~/.config/ghost/yama-ca.pem`(或程序同目录 `yama-ca.pem`),重启客户端生效。MFC 主控端的「启用/停用 TLS 传输」指令对选中主机下发时也会写/删该文件,**且 Linux 客户端会立即热切换并重连**(无需重启,见 §6.6);Windows 客户端仍需重启。 + +移除注册表值(或删除文件)并重启即退回明文。远程下发/撤销:Windows 经 `COMMAND_TLS_ENABLE/DISABLE` 写注册表(重启生效),Linux 写/删上述配置文件(立即生效)。 ## 10. 测试计划 @@ -302,6 +322,7 @@ Set-ItemProperty -Path 'HKCU:\Software\\settings' -Name 'tls_cert' -Val - **阶段 1(Go 服务端,本期优先)**:`Config` + `tls.Config` + `acceptLoop` 检测回放;明文路径零改动。可独立上线、独立验证——用 `openssl s_client` 或 Go 测试客户端即可联调 TLS 链路,无需真实客户端配合。 - **阶段 2(Windows 客户端)**:证书检测 + TLS 栈 + fail-closed。 +- **阶段 2b(Linux 客户端)**:OpenSSL 实现,复用同一接线点与协议语义(2026-10-28 完成)。 - **阶段 3(MFC 服务端 `server/2015Remote`,延后)**:与 Go 服务端同款的 TLS 检测 + 解包接入。设计稿见 `docs/TransportTLS_MFCServer_Design.md`。 - **回滚**:服务端清空 `YAMA_TLS_CERT/KEY` 即回到纯明文;客户端删除注册表 `tls_cert` 值(或 `yama-ca.pem` 文件)即回明文。 @@ -310,4 +331,4 @@ Set-ItemProperty -Path 'HKCU:\Software\\settings' -Name 'tls_cert' -Val 1. ~~客户端 TLS 栈最终选型~~ → **已定 Schannel**(见 §6.2,2026-10-13 落地)。 2. ~~信任锚文件固定名(`yama-ca.pem`)是否需可配置~~ → **已改为注册表 `tls_cert` 值优先、文件回退**(见 §6.1/§9.3,2026-10-14)。 3. 是否同步把「TLS 内去掉 XOR」列为后续精简项(当前保留 XOR,换取零协议改动)。 -4. Linux / macOS / Android 客户端的 TLS 接入排期。 +4. ~~Linux / macOS / Android 客户端的 TLS 接入排期~~ → **Linux 已接入(OpenSSL,2026-10-28)**;macOS / Android 待定(macOS 需 Security.framework 或自带 OpenSSL,Android 需在 NDK 内构建 OpenSSL)。 diff --git a/linux/CMakeLists.txt b/linux/CMakeLists.txt index 6863f3c..14c882f 100644 --- a/linux/CMakeLists.txt +++ b/linux/CMakeLists.txt @@ -28,6 +28,7 @@ set(SOURCES main.cpp ../client/Buffer.cpp ../client/IOCPClient.cpp + ../client/TlsChannelLinux.cpp # Linux 客户端单向 TLS(OpenSSL),见 client/TlsChannel.h ../client/sign_shim_unix.cpp ) add_executable(ghost ${SOURCES}) @@ -45,9 +46,10 @@ target_link_libraries(ghost PRIVATE "${CMAKE_SOURCE_DIR}/lib/libzstd.a") # 该库由 SimplePlugins 仓库本地构建后放置于 lib/,构建机需先准备好 target_link_libraries(ghost PRIVATE "${CMAKE_SOURCE_DIR}/lib/libsign.a") -# libsign.a 内部使用 OpenSSL HMAC,需要在最终可执行链接 libcrypto +# libsign.a 内部使用 OpenSSL HMAC,需要在最终可执行链接 libcrypto; +# 客户端传输层 TLS(client/TlsChannelLinux.cpp)另需 libssl。 find_package(OpenSSL REQUIRED) -target_link_libraries(ghost PRIVATE OpenSSL::Crypto) +target_link_libraries(ghost PRIVATE OpenSSL::Crypto OpenSSL::SSL) # 链接 dl 库(dlopen/dlsym 用于运行时加载 X11) target_link_libraries(ghost PRIVATE dl) diff --git a/linux/main.cpp b/linux/main.cpp index 2c41f7d..58755a3 100644 --- a/linux/main.cpp +++ b/linux/main.cpp @@ -51,6 +51,10 @@ CONNECT_ADDRESS g_SETTINGS = { FLAG_GHOST, "91.99.165.207", "443", CLIENT_TYPE_L // 全局状态 State g_bExit = S_CLIENT_NORMAL; static std::atomic g_needResendLogin(false); // 分组变更后需要重发登录信息 +// 传输层热切换(服务端 COMMAND_TLS_ENABLE/DISABLE 改了信任锚)后需要重建连接。 +// DataProcess 跑在接收线程上,直接关 socket 会和主线程的发送竞争,所以只置标志, +// 由主心跳循环择机 Disconnect 并重连。 +static std::atomic g_needReconnect(false); // 自升级(COMMAND_UPDATE):fork+execv 重启自己时需要原始命令行, // 失败回报需要主连接(DataProcess 的 user 参数为 NULL,只能靠全局)。 @@ -378,6 +382,28 @@ void* FileManagerThread(void* /*param*/) return NULL; } +// 信任锚已落盘/已删除:热重载 TLS 状态,必要时请求主循环重建连接。 +// 只在传输方式真正变化(明文↔TLS)时重连;仅换证书(仍是 TLS)不打断现有会话, +// 新锚从下一条新连接开始生效。 +static void ApplyTlsAnchorChange(void* user) +{ + bool before = TlsEnabled(); + std::string err; + if (!TlsReload(err)) { + Mprintf("** [%p] TLS reload failed: %s (keeping current transport) ***\n", user, err.c_str()); + return; + } + bool after = TlsEnabled(); + if (before == after) { + Mprintf("** [%p] TLS trust anchor updated, transport unchanged (%s) ***\n", + user, after ? "TLS" : "plaintext"); + return; + } + g_needReconnect.store(true); + Mprintf("** [%p] TLS transport switched to %s, reconnecting ***\n", + user, after ? "TLS" : "plaintext"); +} + int DataProcess(void* user, PBYTE szBuffer, ULONG ulLength) { if (szBuffer == nullptr || ulLength == 0) @@ -481,6 +507,32 @@ int DataProcess(void* user, PBYTE szBuffer, ULONG ulLength) // 标记需要重发登录信息(让服务端更新分组显示) g_needResendLogin.store(true); Mprintf("** [%p] Group changed to: %s ***\n", user, groupName.c_str()); + } else if (szBuffer[0] == COMMAND_TLS_ENABLE) { + // 服务端下发信任锚证书(载荷与 Windows 一致:szBuffer+1 起为 PEM 正文)。 + // Windows 写注册表 settings\tls_cert;Linux 写 ~/.config/ghost/yama-ca.pem。 + // 与 Windows 不同:Linux 落盘后热重载并重连,立即切换(Windows 仍需重启进程)。 + if (ulLength > 1) { + std::string pem((char*)szBuffer + 1, ulLength - 1); + std::string err; + if (TlsTrustAnchorSave(pem, err)) { + Mprintf("** [%p] TLS trust anchor received and saved ***\n", user); + ApplyTlsAnchorChange(user); + } else { + Mprintf("** [%p] TLS trust anchor save failed: %s ***\n", user, err.c_str()); + } + } else { + // 没有证书正文就等于「启用但没有锚」——不该悄悄忽略,留一行便于排查。 + Mprintf("** [%p] COMMAND_TLS_ENABLE without a certificate payload, ignored\n", user); + } + } else if (szBuffer[0] == COMMAND_TLS_DISABLE) { + // 撤销信任锚:删除配置文件并热重载,当前连接若是 TLS 就重连回明文。 + std::string err; + if (TlsTrustAnchorRemove(err)) { + Mprintf("** [%p] TLS trust anchor removed ***\n", user); + ApplyTlsAnchorChange(user); + } else { + Mprintf("** [%p] TLS trust anchor removal: %s ***\n", user, err.c_str()); + } } else if (szBuffer[0] == COMMAND_UPDATE) { // 服务端"升级程序"菜单下发新版本 ELF Mprintf("** [%p] Received 'UPDATE' command (%u bytes) ***\n", user, (unsigned)ulLength); @@ -1032,6 +1084,37 @@ static void ApplySelfUpdate(const PBYTE szBuffer, ULONG ulLength) g_bExit = S_CLIENT_UPDATE; } +// 登录信息 szReserved 里的 [19] RES_TLS 是「当前」传输状态的快照,服务端在线列表的 +// TLS 列就取这个值。热切换后重连会重新登录,必须在这里刷新,否则列里会一直显示旧值。 +// 只在主线程调用(与 SendLoginInfo 同一线程),避免和接收线程抢同一个结构体。 +static void RefreshLoginTls(LOGIN_INFOR& info) +{ + std::vector fields; + std::string s(info.szReserved); + size_t pos = 0; + for (;;) { + size_t bar = s.find('|', pos); + if (bar == std::string::npos) { + fields.push_back(s.substr(pos)); + break; + } + fields.push_back(s.substr(pos, bar - pos)); + pos = bar + 1; + } + while (fields.size() <= (size_t)RES_TLS) + fields.push_back(""); + fields[RES_TLS] = TlsEnabled() ? "1" : "0"; + + std::string joined; + for (size_t i = 0; i < fields.size(); ++i) { + if (i) + joined += '|'; + joined += fields[i]; + } + strncpy(info.szReserved, joined.c_str(), sizeof(info.szReserved) - 1); + info.szReserved[sizeof(info.szReserved) - 1] = '\0'; +} + // 用法: ./ghost [-d] [IP] [端口] // -d 后台守护进程模式 // 示例: ./ghost -d 192.168.1.100 6543 @@ -1191,6 +1274,7 @@ int main(int argc, char* argv[]) logInfo.AddReserved(std::to_string(g_myClientID).c_str()); // [16] RES_CLIENT_ID logInfo.AddReserved((int)getpid()); // [17] RES_PID logInfo.AddReserved(getFileSize(exePath).c_str()); // [18] RES_FILESIZE + logInfo.AddReserved(TlsEnabled() ? 1 : 0); // [19] RES_TLS(有信任锚即 1) // 服务端签名输入:与服务端 AddList 处签名格式一致(startTime + "|" + clientID) ClientAuth::g_loginMsg = std::string(logInfo.szStartTime) + "|" + std::to_string(g_myClientID); @@ -1210,6 +1294,8 @@ int main(int argc, char* argv[]) // 进入新连接,重置服务端身份校验状态 ClientAuth::OnNewConnection(); + // 传输方式可能已被热切换(TLS 启/停),登录上报的 RES_TLS 必须反映本次连接。 + RefreshLoginTls(logInfo); ClientObject->SendLoginInfo(logInfo.Speed(clock() - c)); // 新连接:把 ACK 看门狗喂到当前时间,避免循环刚进来就被误判为超时 @@ -1228,6 +1314,7 @@ int main(int argc, char* argv[]) strncpy(logInfo.szPCName, hostname, sizeof(logInfo.szPCName) - 1); } logInfo.szPCName[sizeof(logInfo.szPCName) - 1] = '\0'; + RefreshLoginTls(logInfo); ClientObject->SendLoginInfo(logInfo); Mprintf(">> Resent login info after group change\n"); } @@ -1235,10 +1322,18 @@ int main(int argc, char* argv[]) // 等待心跳间隔(每秒检查一次退出条件,保证及时响应) int interval = g_heartbeatInterval > 0 ? g_heartbeatInterval : 30; for (int i = 0; i < interval; ++i) { + if (g_needReconnect.load(std::memory_order_relaxed)) + break; if (!ClientObject->IsRunning() || !ClientObject->IsConnected() || g_bExit != S_CLIENT_NORMAL) break; Sleep(1000); } + // 信任锚热切换(COMMAND_TLS_ENABLE/DISABLE):断开后由外层循环用新传输方式重连。 + if (g_needReconnect.exchange(false)) { + Mprintf(">>> Reconnecting to apply the TLS transport change\n"); + ClientObject->Disconnect(); + break; + } if (!ClientObject->IsRunning() || !ClientObject->IsConnected() || g_bExit != S_CLIENT_NORMAL) break; diff --git a/server/2015Remote/2015RemoteDlg.cpp b/server/2015Remote/2015RemoteDlg.cpp index 0c8c33b..53f1bd2 100644 --- a/server/2015Remote/2015RemoteDlg.cpp +++ b/server/2015Remote/2015RemoteDlg.cpp @@ -4793,8 +4793,11 @@ void CMy2015RemoteDlg::OnExperimentTlsEnable() _T("提示"), MB_ICONWARNING); return; } - // 二次确认:避免误点就切换被控端 TLS;客户端写注册表,下次启动生效 - if (IDYES != MessageBoxL(_T("确定对选中主机启用 TLS 传输吗?(客户端下次启动生效)"), + // 二次确认:避免误点就切换被控端 TLS。 + // 生效时机因客户端而异:Windows 写注册表、下次启动生效;Linux 落盘后立即热切换并 + // 断开重连(见 client/TlsChannelLinux.cpp 的 TlsReload),正在进行的远程会话会中断。 + if (IDYES != MessageBoxL(_T("确定对选中主机启用 TLS 传输吗?\n" + "(Linux 客户端立即生效并断线重连;Windows 客户端下次启动生效)"), _T("提示"), MB_ICONQUESTION | MB_YESNO)) return; // 读取服务端证书(信任锚),随启用指令一并下发;客户端写入注册表 settings\tls_cert。 @@ -4826,7 +4829,8 @@ void CMy2015RemoteDlg::OnExperimentTlsDisable() _T("提示"), MB_ICONWARNING); return; } - if (IDYES != MessageBoxL(_T("确定取消选中主机的 TLS 传输吗?(客户端下次启动生效)"), + if (IDYES != MessageBoxL(_T("确定取消选中主机的 TLS 传输吗?\n" + "(Linux 客户端立即生效并断线重连;Windows 客户端下次启动生效)"), _T("提示"), MB_ICONQUESTION | MB_YESNO)) return; BYTE bToken = COMMAND_TLS_DISABLE; //向被控端发送停用 TLS 传输命令 SendSelectedCommand(&bToken, sizeof(BYTE)); diff --git a/server/2015Remote/lang/de_DE.ini b/server/2015Remote/lang/de_DE.ini index 24216f5..79dd8a7 100644 --- a/server/2015Remote/lang/de_DE.ini +++ b/server/2015Remote/lang/de_DE.ini @@ -2092,8 +2092,8 @@ TLS ֤Êé/˽Կ¼ÓÔØʧ°ܣ¬¼ÓÃܹ¦ÄÜδÉúЧ¡£Çë¼ì²éÎļþ·¾¶Óë¸ñʽ£¨֤Êé PEM¡¢˽Կ PKCS#8£©¡£=Zertifikat/privater Schluessel konnte nicht geladen werden; Verschluesselung ist inaktiv. Bitte Pfad und Format pruefen (PEM-Zertifikat, PKCS#8-Schluessel). TLS´«Êä=TLS-Transport ȡÏûTLS=TLS deaktivieren -ȷ¶¨¶ÔѡÖÐÖ÷»úÆôÓà TLS ´«ÊäÂ𣿣¨¿ͻ§¶ËÏ´ÎÆô¶¯ÉúЧ£©=TLS-Transport fuer die ausgewaehlten Hosts aktivieren? (wirkt nach Client-Neustart) -ȷ¶¨ȡÏûѡÖÐÖ÷»úµÄ TLS ´«ÊäÂ𣿣¨¿ͻ§¶ËÏ´ÎÆô¶¯ÉúЧ£©=TLS-Transport fuer die ausgewaehlten Hosts deaktivieren? (wirkt nach Client-Neustart) +ȷ¶¨¶ÔѡÖÐÖ÷»úÆôÓà TLS ´«ÊäÂð£¿\n£¨Linux ¿ͻ§¶ËÁ¢¼´ÉúЧ²¢¶ÏÏßÖØÁ¬£»Windows ¿ͻ§¶ËÏ´ÎÆô¶¯ÉúЧ£©=TLS-Transport fuer die ausgewaehlten Hosts aktivieren?\n(Linux-Clients wechseln sofort und verbinden sich neu; Windows-Clients erst nach dem Neustart) +ȷ¶¨ȡÏûѡÖÐÖ÷»úµÄ TLS ´«ÊäÂð£¿\n£¨Linux ¿ͻ§¶ËÁ¢¼´ÉúЧ²¢¶ÏÏßÖØÁ¬£»Windows ¿ͻ§¶ËÏ´ÎÆô¶¯ÉúЧ£©=TLS-Transport fuer die ausgewaehlten Hosts deaktivieren?\n(Linux-Clients wechseln sofort und verbinden sich neu; Windows-Clients erst nach dem Neustart) ·þÎñ¶ËδÆôÓà TLS ֤Ê飬Î޷¨Çл»¿ͻ§¶Ë TLS ´«Êä=Server-TLS-Zertifikat ist nicht aktiviert; TLS-Transport der Clients kann nicht umgeschaltet werden ¶Áȡ·þÎñ¶Ë TLS ֤Êéʧ°ܣ¬Î޷¨Ï·¢=Server-TLS-Zertifikat konnte nicht gelesen werden; Verteilung nicht moeglich °×Ãûµ¥=Whitelist diff --git a/server/2015Remote/lang/en_US.ini b/server/2015Remote/lang/en_US.ini index 015cd7e..11dc8c1 100644 --- a/server/2015Remote/lang/en_US.ini +++ b/server/2015Remote/lang/en_US.ini @@ -2111,8 +2111,8 @@ TLS ֤Êé/˽Կ¼ÓÔØʧ°ܣ¬¼ÓÃܹ¦ÄÜδÉúЧ¡£Çë¼ì²éÎļþ·¾¶Óë¸ñʽ£¨֤Êé PEM¡¢˽Կ PKCS#8£©¡£=Failed to load certificate/private key; encryption is not active. Check the file path and format (PEM certificate, PKCS#8 private key). TLS´«Êä=TLS Transport ȡÏûTLS=Disable TLS -ȷ¶¨¶ÔѡÖÐÖ÷»úÆôÓà TLS ´«ÊäÂ𣿣¨¿ͻ§¶ËÏ´ÎÆô¶¯ÉúЧ£©=Enable TLS transport for the selected host? (takes effect after the client restarts) -ȷ¶¨ȡÏûѡÖÐÖ÷»úµÄ TLS ´«ÊäÂ𣿣¨¿ͻ§¶ËÏ´ÎÆô¶¯ÉúЧ£©=Disable TLS transport for the selected host? (takes effect after the client restarts) +ȷ¶¨¶ÔѡÖÐÖ÷»úÆôÓà TLS ´«ÊäÂð£¿\n£¨Linux ¿ͻ§¶ËÁ¢¼´ÉúЧ²¢¶ÏÏßÖØÁ¬£»Windows ¿ͻ§¶ËÏ´ÎÆô¶¯ÉúЧ£©=Enable TLS transport for the selected host?\n(Linux clients switch immediately and reconnect; Windows clients apply it on next start) +ȷ¶¨ȡÏûѡÖÐÖ÷»úµÄ TLS ´«ÊäÂð£¿\n£¨Linux ¿ͻ§¶ËÁ¢¼´ÉúЧ²¢¶ÏÏßÖØÁ¬£»Windows ¿ͻ§¶ËÏ´ÎÆô¶¯ÉúЧ£©=Disable TLS transport for the selected host?\n(Linux clients switch immediately and reconnect; Windows clients apply it on next start) ·þÎñ¶ËδÆôÓà TLS ֤Ê飬Î޷¨Çл»¿ͻ§¶Ë TLS ´«Êä=Server TLS certificate is not enabled; cannot toggle client TLS transport ¶Áȡ·þÎñ¶Ë TLS ֤Êéʧ°ܣ¬Î޷¨Ï·¢=Failed to read the server TLS certificate; cannot distribute °×Ãûµ¥=Whitelist diff --git a/server/2015Remote/lang/zh_TW.ini b/server/2015Remote/lang/zh_TW.ini index 0b7fe96..bd7b5b4 100644 --- a/server/2015Remote/lang/zh_TW.ini +++ b/server/2015Remote/lang/zh_TW.ini @@ -2102,8 +2102,8 @@ TLS ֤Êé/˽Կ¼ÓÔØʧ°ܣ¬¼ÓÃܹ¦ÄÜδÉúЧ¡£Çë¼ì²éÎļþ·¾¶Óë¸ñʽ£¨֤Êé PEM¡¢˽Կ PKCS#8£©¡£=‘{×C/˽è€ÝdÈëʧ”¡£¬¼ÓÃܹ¦ÄÜδÉúЧ¡£Ո™z²é™n°¸·�½Åc¸ñʽ£¨‘{×C PEM¡¢˽è€ PKCS#8£©¡£ TLS´«Êä=TLS ‚÷ݔ ȡÏûTLS=ͣÓà TLS -ȷ¶¨¶ÔѡÖÐÖ÷»úÆôÓà TLS ´«ÊäÂ𣿣¨¿ͻ§¶ËÏ´ÎÆô¶¯ÉúЧ£©=´_¶¨Œ¦ßxȡÖ÷™C†¢Óà TLS ‚÷ݔ†᣿£¨ÓÑô¶ËÏ´Ά¢„ÓÉúЧ£© -ȷ¶¨ȡÏûѡÖÐÖ÷»úµÄ TLS ´«ÊäÂ𣿣¨¿ͻ§¶ËÏ´ÎÆô¶¯ÉúЧ£©=´_¶¨ȡÏûßxȡÖ÷™CµÄ TLS ‚÷ݔ†᣿£¨ÓÑô¶ËÏ´Ά¢„ÓÉúЧ£© +ȷ¶¨¶ÔѡÖÐÖ÷»úÆôÓà TLS ´«ÊäÂð£¿\n£¨Linux ¿ͻ§¶ËÁ¢¼´ÉúЧ²¢¶ÏÏßÖØÁ¬£»Windows ¿ͻ§¶ËÏ´ÎÆô¶¯ÉúЧ£©=´_¶¨Œ¦ßxȡÖ÷™C†¢Óà TLS ‚÷ݔ†᣿\n£¨Linux ÓÑô¶ËÁ¢¼´ÉúЧ�K”ྀÖØßB£»Windows ÓÑô¶ËÏ´Ά¢„ÓÉúЧ£© +ȷ¶¨ȡÏûѡÖÐÖ÷»úµÄ TLS ´«ÊäÂð£¿\n£¨Linux ¿ͻ§¶ËÁ¢¼´ÉúЧ²¢¶ÏÏßÖØÁ¬£»Windows ¿ͻ§¶ËÏ´ÎÆô¶¯ÉúЧ£©=´_¶¨ȡÏûßxȡÖ÷™CµÄ TLS ‚÷ݔ†᣿\n£¨Linux ÓÑô¶ËÁ¢¼´ÉúЧ�K”ྀÖØßB£»Windows ÓÑô¶ËÏ´Ά¢„ÓÉúЧ£© ·þÎñ¶ËδÆôÓà TLS ֤Ê飬Î޷¨Çл»¿ͻ§¶Ë TLS ´«Êä=ËŷþÆ÷δ†¢Óà TLS ‘{×C£¬Ÿo·¨ÇГQÓÑô¶Ë TLS ‚÷ݔ ¶Áȡ·þÎñ¶Ë TLS ֤Êéʧ°ܣ¬Î޷¨Ï·¢=×xȡËŷþÆ÷ TLS ‘{×Cʧ”¡£¬Ÿo·¨Ï°l °×Ãûµ¥=°×Ãû†Î