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
469 lines
18 KiB
C++
469 lines
18 KiB
C++
// IOCPClient.h: interface for the IOCPClient class.
|
||
//
|
||
//////////////////////////////////////////////////////////////////////
|
||
|
||
#pragma once
|
||
|
||
#ifdef _WIN32
|
||
#include "stdafx.h"
|
||
#include <WinSock2.h>
|
||
#include <MSTcpIP.h>
|
||
#pragma comment(lib,"ws2_32.lib")
|
||
#endif
|
||
|
||
// TLS 通道:Windows 走 Schannel,Linux 走 OpenSSL;macOS/Android 下该头为空,
|
||
// 且不定义 YAMA_TLS_CHANNEL,下方代码自动退回明文。
|
||
#include "TlsChannel.h"
|
||
|
||
// WebSocket 传输(经反代 443 等受限端口接入)。头文件实现,各平台编译目标无需改动。
|
||
#include "WsChannel.h"
|
||
|
||
#include "Buffer.h"
|
||
#include "zstd/zstd.h"
|
||
#include "domain_pool.h"
|
||
#include "common/mask.h"
|
||
#include "common/header.h"
|
||
#define NO_AES
|
||
#include "common/encrypt.h"
|
||
#ifdef _WIN32
|
||
#include "SafeThread.h"
|
||
#else
|
||
#ifndef SAFE_DELETE
|
||
#define SAFE_DELETE(p) if(NULL !=(p)){ delete (p);(p) = NULL;}
|
||
#endif
|
||
#ifndef SAFE_DELETE_ARRAY
|
||
#define SAFE_DELETE_ARRAY(p) if(NULL !=(p)){ delete[] (p);(p) = NULL;}
|
||
#endif
|
||
#include <sys/socket.h>
|
||
#include <netinet/in.h>
|
||
#endif
|
||
#include "IOCPBase.h"
|
||
#include <mutex>
|
||
#include <atomic>
|
||
#include <condition_variable>
|
||
#include <chrono>
|
||
|
||
#define MAX_RECV_BUFFER 1024*32
|
||
#define MAX_SEND_BUFFER 1024*128 // 增大分块大小以提高发送效率
|
||
|
||
enum { S_STOP = 0, S_RUN, S_END };
|
||
|
||
typedef int (*DataProcessCB)(void* userData, PBYTE szBuffer, ULONG ulLength);
|
||
|
||
typedef int (*OnDisconnectCB)(void* userData);
|
||
|
||
class ProtocolEncoder
|
||
{
|
||
public:
|
||
virtual ~ProtocolEncoder() {}
|
||
virtual HeaderFlag GetHead() const
|
||
{
|
||
return "Shine";
|
||
}
|
||
virtual int GetHeadLen() const
|
||
{
|
||
return 13;
|
||
}
|
||
virtual int GetFlagLen() const
|
||
{
|
||
return 5;
|
||
}
|
||
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;
|
||
}
|
||
};
|
||
|
||
class HellEncoder : public ProtocolEncoder
|
||
{
|
||
private:
|
||
// 原子量:主连接重连时会在发送线程/接收线程可能同时使用编码器的时机更换头加密函数,
|
||
// 只换函数指针(零分配、零释放),读方永远拿到新旧之一,不会 UAF。
|
||
std::atomic<EncFun> m_HeaderEnc;
|
||
Encoder *m_BodyEnc;
|
||
public:
|
||
HellEncoder(EncFun head, Encoder *body)
|
||
{
|
||
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.load(std::memory_order_relaxed));
|
||
}
|
||
virtual int GetHeadLen() const override
|
||
{
|
||
return 16;
|
||
}
|
||
virtual int GetFlagLen() const override
|
||
{
|
||
return 8;
|
||
}
|
||
virtual void Encode(unsigned char* data, int len, unsigned char* param = 0) override
|
||
{
|
||
return m_BodyEnc->Encode(data, len, param);
|
||
}
|
||
virtual void Decode(unsigned char* data, int len, unsigned char* param = 0) override
|
||
{
|
||
return m_BodyEnc->Decode(data, len, param);
|
||
}
|
||
virtual EncFun GetHeaderEncoder() const override
|
||
{
|
||
return m_HeaderEnc;
|
||
}
|
||
};
|
||
|
||
class IOCPManager
|
||
{
|
||
public:
|
||
virtual ~IOCPManager() {}
|
||
virtual BOOL IsAlive() const
|
||
{
|
||
return TRUE;
|
||
}
|
||
virtual BOOL IsReady() const
|
||
{
|
||
return TRUE;
|
||
}
|
||
virtual VOID OnReceive(PBYTE szBuffer, ULONG ulLength) { }
|
||
|
||
// Tip: 在派生类实现该函数以便支持断线重连
|
||
virtual BOOL OnReconnect()
|
||
{
|
||
return FALSE;
|
||
}
|
||
|
||
static int DataProcess(void* user, PBYTE szBuffer, ULONG ulLength)
|
||
{
|
||
IOCPManager* m_Manager = (IOCPManager*)user;
|
||
if (nullptr == m_Manager) {
|
||
Mprintf("IOCPManager DataProcess on NULL ptr: %d\n", unsigned(szBuffer[0]));
|
||
return FALSE;
|
||
}
|
||
// 等待子类准备就绪才能处理数据, 1秒足够了
|
||
int i = 0;
|
||
for (; i < 1000 && !m_Manager->IsReady(); ++i)
|
||
Sleep(1);
|
||
if (!m_Manager->IsReady()) {
|
||
Mprintf("IOCPManager DataProcess is NOT ready: %d\n", unsigned(szBuffer[0]));
|
||
return FALSE;
|
||
}
|
||
if (i) {
|
||
Mprintf("IOCPManager DataProcess wait for %dms: %d\n", i, unsigned(szBuffer[0]));
|
||
}
|
||
m_Manager->OnReceive(szBuffer, ulLength);
|
||
return TRUE;
|
||
}
|
||
static int ReconnectProcess(void* user)
|
||
{
|
||
IOCPManager* m_Manager = (IOCPManager*)user;
|
||
if (nullptr == m_Manager) {
|
||
return FALSE;
|
||
}
|
||
return m_Manager->OnReconnect();
|
||
}
|
||
};
|
||
|
||
typedef BOOL(*TrailCheck)(void);
|
||
|
||
class IOCPClient : public IOCPBase
|
||
{
|
||
public:
|
||
IOCPClient(const State& bExit, bool exit_while_disconnect = false, int mask=0, CONNECT_ADDRESS *conn=0,
|
||
const std::string&pubIP="", void*main=0);
|
||
virtual ~IOCPClient();
|
||
|
||
int SendLoginInfo(const LOGIN_INFOR& logInfo)
|
||
{
|
||
LOGIN_INFOR tmp = logInfo;
|
||
int iRet = Send2Server((char*)&tmp, sizeof(LOGIN_INFOR));
|
||
|
||
return iRet;
|
||
}
|
||
virtual BOOL ConnectServer(const char* szServerIP, unsigned short uPort);
|
||
|
||
std::string GetClientIP() const
|
||
{
|
||
return m_sLocPublicIP;
|
||
}
|
||
|
||
std::map<std::string, std::string> GetClientIPHeader() const
|
||
{
|
||
return m_sLocPublicIP.empty() ? std::map<std::string, std::string> {} :
|
||
std::map<std::string, std::string> { {"X-Forwarded-For", m_sLocPublicIP} };
|
||
}
|
||
|
||
BOOL Send2Server(const char* szBuffer, ULONG ulOriginalLength, PkgMask* mask = NULL)
|
||
{
|
||
return OnServerSending(szBuffer, ulOriginalLength, mask);
|
||
}
|
||
|
||
void SetServerAddress(const char* szServerIP, unsigned short uPort)
|
||
{
|
||
m_Domain = szServerIP ? szServerIP : "127.0.0.1";
|
||
m_nHostPort = uPort;
|
||
}
|
||
|
||
// 没有 conn 的构造路径(Linux / macOS / Android 的 main 都是 new IOCPClient(exit, false))
|
||
// 用它给出传输协议:直接取外壳注入的 CONNECT_ADDRESS.protoType。不调用则保持 -1,
|
||
// ConnectServer 按明文 TCP 直连——那正是「配置成 WS 却毫无反应」的来源,故三个平台
|
||
// 的 main 都要在进入重连循环前调一次。
|
||
void SetDefaultProto(int p) { m_defaultProto = p; }
|
||
|
||
std::string ServerIP() const
|
||
{
|
||
return m_sCurIP;
|
||
}
|
||
|
||
int ServerPort() const
|
||
{
|
||
return m_nHostPort;
|
||
}
|
||
|
||
BOOL IsRunning() const
|
||
{
|
||
return m_bIsRunning;
|
||
}
|
||
VOID StopRunning()
|
||
{
|
||
m_ReconnectFunc = NULL;
|
||
m_bIsRunning = FALSE;
|
||
}
|
||
VOID setManagerCallBack(void* Manager, DataProcessCB dataProcess, OnDisconnectCB reconnect);
|
||
VOID RunEventLoop(TrailCheck checker);
|
||
VOID RunEventLoop(const BOOL &bCondition);
|
||
bool IsConnected() const
|
||
{
|
||
return m_bConnected == TRUE;
|
||
}
|
||
BOOL Reconnect(void* manager)
|
||
{
|
||
Disconnect();
|
||
if (manager) m_Manager = manager;
|
||
return ConnectServer(NULL, 0);
|
||
}
|
||
const State& GetState() const
|
||
{
|
||
return g_bExit;
|
||
}
|
||
void SetMultiThreadCompress(int threadNum=0);
|
||
std::string GetClientID() const
|
||
{
|
||
return m_conn ? std::to_string(m_conn->clientID) : "";
|
||
}
|
||
std::string GetPublicIP() const
|
||
{
|
||
return m_sLocPublicIP;
|
||
}
|
||
CONNECT_ADDRESS* GetConnectionAddress() const
|
||
{
|
||
return m_conn;
|
||
}
|
||
IOCPManager* GetManager() const
|
||
{
|
||
return (IOCPManager*)m_Manager;
|
||
}
|
||
void* GetMain() const
|
||
{
|
||
return m_main;
|
||
}
|
||
void SetVerifyInfo(const std::string& msg, const std::string& hmac) {
|
||
m_LoginMsg = msg;
|
||
m_LoginSignature = hmac;
|
||
}
|
||
|
||
// 子连接身份校验:发 TOKEN_CONN_AUTH 包,等服务端 ConnAuthAck 响应。
|
||
// 返回 true 表示通过,false 表示超时/失败/网络错误。
|
||
// 主连接不调用此方法。新客户端必须调用并校验成功后才能继续后续命令。
|
||
// 已实现的协议扩展(如 KeyBoard 子连接的 cap word)保留不变,与本机制并行工作。
|
||
bool PerformConnAuth(uint64_t clientID, int timeoutMs);
|
||
|
||
// 让 ConnectServer 在每次成功后自动调一次 PerformConnAuth(opt-in)。
|
||
// 子连接构造后调用此方法启用。
|
||
// - clientID == 0:每次 auth 时从 m_conn->clientID 现取(Windows 客户端走此路径)。
|
||
// 这样即便 IOCPClient 创建时主连接还没拿到 ID,真正连上时也能用到最新值。
|
||
// - clientID != 0:显式指定(Linux/macOS 客户端 IOCPClient 不带 m_conn 时用此参数)。
|
||
void EnableSubConnAuth(bool enabled = true, uint64_t clientID = 0) {
|
||
m_subConnAuthEnabled = enabled;
|
||
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);
|
||
|
||
// 登录是否已被服务端接受。服务端把本机加入在线列表后立刻下发 CMD_MASTERSETTING
|
||
// (2015RemoteDlg.cpp::SendMasterSettings(ctx, ...) 的登录路径),客户端在这里置位。
|
||
// 协议切换用来判断「新入口真的登录成功」,而不是只看 IsConnected()——那只代表
|
||
// TCP/TLS/WS 握手完成,登录可能被丢弃(选错后端、反代指到别的 WS 服务)。
|
||
// 每次 ConnectServer 开始时清零,故它只描述当前这条连接。
|
||
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
|
||
|
||
protected:
|
||
// 每次建连前调整 HELL 头加密函数:主连接上一条没被登录接受时换下一种类型轮转探测,
|
||
// 子连接跟随主连接已发布的类型。必须在建 socket / 启动收发线程之前完成——后端只在
|
||
// 每条连接的**第一个**包上识别并锁定头加密方式(Go 首包锁存、认不出即断开),所以
|
||
// 换类型只对「下一条连接的首包」生效;这一步同时读上一条连接的 m_loginAcked,
|
||
// 因此必须先于 ConnectServer 里的登录标志清零。
|
||
void PrepareHeaderEncoderForConnect();
|
||
virtual int ReceiveData(char* buffer, int bufSize, int flags)
|
||
{
|
||
// WebSocket 传输:字节流在 WS 帧里,帧层自己处理 TLS(WSS)或裸 socket(WS)
|
||
if (m_useWs)
|
||
return m_ws.Recv(m_sClientSocket, buffer, bufSize - 1);
|
||
#ifdef YAMA_TLS_CHANNEL
|
||
if (m_useTls)
|
||
return m_tls.Recv(m_sClientSocket, buffer, bufSize - 1);
|
||
#endif
|
||
// TCP版本调用 recv
|
||
int n = recv(m_sClientSocket, buffer, bufSize - 1, 0);
|
||
return n;
|
||
}
|
||
virtual bool ProcessRecvData(CBuffer* m_CompressedBuffer, char* szBuffer, int len, int flag);
|
||
virtual int SendTo(const char* buf, int len, int flags)
|
||
{
|
||
if (m_useWs)
|
||
return m_ws.Send(m_sClientSocket, buf, len);
|
||
#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 可读性,
|
||
// 看不到 TLS 库内部缓冲),接收线程在 select 前须优先消费,避免其被卡住。
|
||
// WebSocket 同理:已读进帧头、载荷还没交完的字节同样看不到。
|
||
bool HasPendingData() const
|
||
{
|
||
if (m_useWs)
|
||
return m_ws.HasPending();
|
||
#ifdef YAMA_TLS_CHANNEL
|
||
return m_useTls && m_tls.HasPending();
|
||
#else
|
||
return false;
|
||
#endif
|
||
}
|
||
BOOL OnServerSending(const char* szBuffer, ULONG ulOriginalLength, PkgMask* mask);
|
||
static DWORD WINAPI WorkThreadProc(LPVOID lParam);
|
||
VOID OnServerReceiving(CBuffer *m_CompressedBuffer, char* szBuffer, ULONG ulReceivedLength);
|
||
BOOL SendWithSplit(const char* src, ULONG srcSize, ULONG ulSplitLength, int cmd, PkgMask* mask);
|
||
|
||
protected:
|
||
sockaddr_in m_ServerAddr;
|
||
SOCKET m_sClientSocket;
|
||
// WebSocket 传输(PROTO_WS / PROTO_WSS):ConnectServer 里握手成功时置位,
|
||
// Disconnect 时清除。与 m_useTls 一样按连接锁定,Send/Recv 不再现查 protoType。
|
||
WsChannel m_ws;
|
||
// 收发分处两个线程:连接线程写、接收/发送线程读。形式上必须是原子量(x86 上实践
|
||
// 无害,但换成别的架构就不能再依赖这个巧合)。
|
||
std::atomic<bool> m_useWs{false};
|
||
std::atomic<bool> m_loginAcked{false};
|
||
// m_conn 为空时的协议来源(见 SetDefaultProto)。-1 = 未设置,按明文 TCP 处理。
|
||
int m_defaultProto = -1;
|
||
#ifdef YAMA_TLS_CHANNEL
|
||
TlsChannel m_tls; // TLS 会话(证书存在时才启用,见 TlsChannel.h)
|
||
// 本连接是否走 TLS:在 ConnectServer 里握手成功时置位、Disconnect 时清除,Send/Recv
|
||
// 一律按这个快照走,不再每次现查 TlsEnabled()。Linux 客户端支持服务端下发后热切换
|
||
// 传输方式(TlsReload),若现查全局开关,切换后到重连完成之间的这一秒里会把明文塞进
|
||
// 已建立的 TLS 会话(或反过来),白白制造协议错误。
|
||
std::atomic<bool> m_useTls{false};
|
||
#endif
|
||
BOOL m_bWorkThread;
|
||
HANDLE m_hWorkThread;
|
||
BOOL m_bIsRunning;
|
||
BOOL m_bConnected;
|
||
|
||
std::mutex m_Locker;
|
||
|
||
// 子连接身份校验同步状态。仅在 PerformConnAuth 调用期间生效。
|
||
std::mutex m_authMtx;
|
||
std::condition_variable m_authCv;
|
||
int m_authStatus = -1; // -1 = 未启动;其它 = ConnAuthStatus
|
||
bool m_authPending = false; // true 时 TryHandleAuthResponse 才消费 ack
|
||
|
||
// ConnectServer 成功后自动 auth 的 opt-in 标志。子连接构造后调 EnableSubConnAuth() 设为 true。
|
||
bool m_subConnAuthEnabled = false;
|
||
uint64_t m_subConnAuthClientID = 0; // 0 表示从 m_conn->clientID 现取
|
||
#if USING_CTX
|
||
ZSTD_CCtx* m_Cctx; // 压缩上下文
|
||
ZSTD_DCtx* m_Dctx; // 解压上下文
|
||
#endif
|
||
|
||
const State& g_bExit; // 全局状态量
|
||
void* m_Manager; // 用户数据
|
||
DataProcessCB m_DataProcess; // 处理用户数据
|
||
OnDisconnectCB m_ReconnectFunc; // 断线重连逻辑
|
||
ProtocolEncoder* m_Encoder; // 加密
|
||
DomainPool m_Domain;
|
||
std::string m_sCurIP;
|
||
int m_nHostPort;
|
||
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;
|
||
|
||
void *m_main = NULL;
|
||
public:
|
||
BOOL m_isAuth = FALSE;
|
||
std::string m_LoginMsg; // 登录消息摘要
|
||
std::string m_LoginSignature; // 登录消息签名
|
||
};
|