Fix(client): rotate HELL header encoding across reconnects

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
This commit is contained in:
yuanyuanxianganddeepseek-flash committed 2026-11-13 16:47:53 +01:00
1 parent a818ace83c
commit 9fadb58c76
5 files changed
+178 -10

No files matched your search

+3
View File
@@ -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) {
+101 -6
View File
@@ -27,6 +27,7 @@ inline int WSAGetLastError()
#include "IOCPClient.h"
#include <assert.h>
#include <string>
#include <random>
#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);
+32 -3
View File
@@ -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<EncFun> 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<int> m_headerEncIdx{0}; // HeaderEncType 下标(仅 HELL 有意义)
std::atomic<int> m_headerEncAttempts{0}; // ConnectServer 已调用次数
bool m_bMainLink = false; // StartClient 的主连接标记
std::string m_sLocPublicIP;
CONNECT_ADDRESS *m_conn = NULL;
+5 -1
View File
@@ -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()) {
+37
View File
@@ -10,6 +10,7 @@
#include <ctime>
#include <chrono>
#include <climits>
#include <cstddef> // 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个成员: