Feature: WebSocket transport for clients behind restricted outbound ports #5

Merged
yuanyuanxiang merged 5 commits from ws_tls into main 2026-10-30 18:49:52 +00:00
12 changed files with 264 additions and 40 deletions
Showing only changes of commit 50a489e316 - Show all commits

No files matched your search

+8 -3
View File
1
@@ -816,13 +816,18 @@ DWORD WINAPI StartClient(LPVOID lParam)
while (ClientObject->IsRunning() && ClientObject->IsConnected() && !ClientObject->SendLoginInfo(login))
WAIT_n(app.m_bIsRunning(&app), 5 + time(0)%10, 200);
WAIT_n(app.m_bIsRunning(&app)&& ClientObject->IsRunning() && ClientObject->IsConnected(), 10, 200);
// 协议切换:新入口已经打通(登录包发出且连接仍在),撤销自动回退计时
if (ClientObject->IsConnected())
ConfirmProtoSwitch(cfg);
do {
Manager->SendHeartbeat();
Outdated
Review

必须修复 3:IsConnected() ≠ 登录成功。 这里只证明 TCP + TLS + WS 握手完成,服务端尚未处理登录包。若新入口能建连但登录始终不被接受(选错后端 / 反代指到别的 WS 服务 / 服务端登录阶段静默丢弃),entry_try_at 会被清零,5 分钟自动回退永久失效,客户端卡在错误入口反复重连。

§9 文档写的是「登录成功后 ConfirmProtoSwitch 清零」,与这里的实现不符。建议改为「收到服务端首个业务包」或「连接保持 N 秒且收到过数据」再撤销计时。

**必须修复 3:`IsConnected()` ≠ 登录成功。** 这里只证明 TCP + TLS + WS 握手完成,服务端尚未处理登录包。若新入口能建连但登录始终不被接受(选错后端 / 反代指到别的 WS 服务 / 服务端登录阶段静默丢弃),`entry_try_at` 会被清零,5 分钟自动回退**永久失效**,客户端卡在错误入口反复重连。 §9 文档写的是「登录成功后 `ConfirmProtoSwitch` 清零」,与这里的实现不符。建议改为「收到服务端首个业务包」或「连接保持 N 秒且收到过数据」再撤销计时。
SetThreadExecutionState(ES_CONTINUOUS | ES_SYSTEM_REQUIRED);
// 协议切换:新入口「登录被接受」后才撤销自动回退计时(ConfirmProtoSwitch 幂等)。
// IsConnected() 只代表 TCP/TLS/WS 握手完成;若新入口能建连但登录始终不被接受
// (选错后端、反代指到别的 WS 服务、服务端登录阶段丢弃),提前撤销会让 5 分钟
// 自动回退永久失效,客户端卡在错误入口反复重连。IsLoginAcked() 在收到
// CMD_MASTERSETTING 时置位——服务端只有在把本机加入在线列表后才发它。
// 不放在循环前一次判定:MasterSettings 可能比第一轮心跳晚到。
if (ClientObject->IsConnected() && ClientObject->IsLoginAcked())
ConfirmProtoSwitch(cfg);
if (assigned && time(0) > valid_to) {
app.SetProcessState(S_CLIENT_UPDATE);
settings.SetServer(ip.c_str(), port);
+40
View File
@@ -391,6 +391,9 @@ BOOL ConnectWithTimeout(SOCKET sock, SOCKADDR *addr, int timeout_sec=5)
BOOL IOCPClient::ConnectServer(const char* szServerIP, unsigned short uPort)
{
// 登录确认标志只描述「当前这条连接」:任何一次新建连都先清零,避免上一条连接的
// 确认结果替新连接背书(协议切换的自动回退靠它判断新入口是否真的登录成功)。
m_loginAcked.store(false, std::memory_order_release);
if (szServerIP != NULL && uPort != 0) {
SetServerAddress(szServerIP, uPort);
}
@@ -467,6 +470,29 @@ BOOL IOCPClient::ConnectServer(const char* szServerIP, unsigned short uPort)
SetKeepAliveOptions(m_sClientSocket);
#endif
}
// 握手超时:TLS / WebSocket 握手都是同步阻塞的(WsChannel::Handshake 逐字节 recv 等
// 101 响应),而 socket 默认没有收超时——对端接受 TCP 却迟迟不回数据时(反代上游黑洞、
// 中间设备只收不发),recv 会永久阻塞,StartClient 的重连循环整个停摆,只能重启进程。
// 这里给握手窗口设 15s 超时(与服务端两个握手线程同一个值),握手结束后立刻清零,
// 避免影响 WorkThread 之后依赖 select + 阻塞 recv 的常规收包。
bool hsTmoSet = false;
#ifdef _WIN32
{
DWORD hsTmo = 15000;
hsTmoSet = setsockopt(m_sClientSocket, SOL_SOCKET, SO_RCVTIMEO,
(const char*)&hsTmo, sizeof(hsTmo)) == 0;
setsockopt(m_sClientSocket, SOL_SOCKET, SO_SNDTIMEO, (const char*)&hsTmo, sizeof(hsTmo));
}
#else
{
struct timeval hsTmo;
hsTmo.tv_sec = 15;
hsTmo.tv_usec = 0;
hsTmoSet = setsockopt(m_sClientSocket, SOL_SOCKET, SO_RCVTIMEO, &hsTmo, sizeof(hsTmo)) == 0;
setsockopt(m_sClientSocket, SOL_SOCKET, SO_SNDTIMEO, &hsTmo, sizeof(hsTmo));
}
#endif
// WebSocket 传输(PROTO_WS / PROTO_WSS):出站被限制在 80/443/8080 等端口时,经反代
// 分流进来。与应用协议无关,位置和 TLS 相同(TLS 之下、应用协议之上);须在
// m_bConnected 置位前完成,确保工作线程不会在 Upgrade 尚未完成时就开始 recv。
2
@@ -550,6 +576,20 @@ BOOL IOCPClient::ConnectServer(const char* szServerIP, unsigned short uPort)
WS_UPGRADE_PATH, wsDegraded ? " (明文,等待信任锚)"
: (wsTls ? " (TLS)" : ""));
}
// 握手阶段结束(成功路径):清零握手超时,恢复普通阻塞收包。
if (hsTmoSet) {
#ifdef _WIN32
DWORD noTmo = 0;
setsockopt(m_sClientSocket, SOL_SOCKET, SO_RCVTIMEO, (const char*)&noTmo, sizeof(noTmo));
setsockopt(m_sClientSocket, SOL_SOCKET, SO_SNDTIMEO, (const char*)&noTmo, sizeof(noTmo));
#else
struct timeval noTmo;
noTmo.tv_sec = 0;
noTmo.tv_usec = 0;
setsockopt(m_sClientSocket, SOL_SOCKET, SO_RCVTIMEO, &noTmo, sizeof(noTmo));
setsockopt(m_sClientSocket, SOL_SOCKET, SO_SNDTIMEO, &noTmo, sizeof(noTmo));
#endif
}
m_bConnected = TRUE;
Mprintf("连接服务端成功: %s:%d.\n", m_sCurIP.c_str(), (int)port);
+14 -2
View File
@@ -39,6 +39,7 @@
#endif
#include "IOCPBase.h"
#include <mutex>
#include <atomic>
#include <condition_variable>
#include <chrono>
@@ -289,6 +290,14 @@ public:
// 仅在我们正在等待 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); }
// 主动断开当前连接,关闭 socket。提到 public 让外层(如 Linux/macOS main 的心跳
// 循环检测到服务端身份校验超时)能在重连前显式关闭旧 fd,避免泄漏。
virtual VOID Disconnect(); // 函数支持 TCP/UDP
@@ -342,14 +351,17 @@ protected:
// WebSocket 传输(PROTO_WS / PROTO_WSS):ConnectServer 里握手成功时置位,
// Disconnect 时清除。与 m_useTls 一样按连接锁定,Send/Recv 不再现查 protoType。
WsChannel m_ws;
bool m_useWs = false;
// 收发分处两个线程:连接线程写、接收/发送线程读。形式上必须是原子量(x86 上实践
// 无害,但换成别的架构就不能再依赖这个巧合)。
std::atomic<bool> m_useWs{false};
std::atomic<bool> m_loginAcked{false};
#ifdef YAMA_TLS_CHANNEL
TlsChannel m_tls; // TLS 会话(证书存在时才启用,见 TlsChannel.h)
// 本连接是否走 TLS:在 ConnectServer 里握手成功时置位、Disconnect 时清除,Send/Recv
// 一律按这个快照走,不再每次现查 TlsEnabled()。Linux 客户端支持服务端下发后热切换
// 传输方式(TlsReload),若现查全局开关,切换后到重连完成之间的这一秒里会把明文塞进
// 已建立的 TLS 会话(或反过来),白白制造协议错误。
bool m_useTls = false;
std::atomic<bool> m_useTls{false};
#endif
BOOL m_bWorkThread;
HANDLE m_hWorkThread;
+18 -2
View File
@@ -944,10 +944,21 @@ VOID CKernelManager::OnReceive(PBYTE szBuffer, ULONG ulLength)
uint32_t certLen = p.certLen < maxCert ? p.certLen : maxCert;
if (certLen > 0) {
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);
std::string err;
Review

这里 TlsReload 失败只打日志,随后仍然把入口切到 WSS 并断连。如果下发的 PEM 加载不了,客户端会进入 TlsLoadError() 的 fail-closed 状态——新入口连不上,只能等 5 分钟自动回退(而且受总评第 3 条影响,回退还可能被提前撤销)。

建议:TlsReload 失败时放弃本次切换(不写 proto_override/entry_*,不断连),直接把失败原因回报给操作端。这比「切过去再等回退」安全得多。

这里 `TlsReload` 失败只打日志,随后仍然把入口切到 WSS 并断连。如果下发的 PEM 加载不了,客户端会进入 `TlsLoadError()` 的 fail-closed 状态——新入口连不上,只能等 5 分钟自动回退(而且受总评第 3 条影响,回退还可能被提前撤销)。 建议:`TlsReload` 失败时**放弃本次切换**(不写 `proto_override`/`entry_*`,不断连),直接把失败原因回报给操作端。这比「切过去再等回退」安全得多。
if (!TlsReload(err))
Mprintf("[proto-switch] trust anchor reload failed: %s\n", err.c_str());
if (!TlsReload(err)) {
// 放弃本次切换(不写 proto_override/entry_*,不断连):PEM 加载不了时客户端
// 会进入 TlsLoadError() 的 fail-closed 状态,切过去只会「新入口连不上,等
// 5 分钟自动回退」——而且自动回退本身也可能被误撤销。回滚证书并回报操作端。
m_cfg->SetStr("settings", "tls_cert", prevCert);
const std::string loadErr = err;
TlsReload(err); // 让 TLS 上下文回到旧锚(失败也不影响:旧锚此前是好的)
Mprintf("[proto-switch] trust anchor reload failed: %s, switch aborted\n", loadErr.c_str());
ClientMsg msg("协议切换", ("证书加载失败,已取消切换: " + loadErr).c_str());
SendData((LPBYTE)&msg, sizeof(msg));
break;
}
}
if (restore) {
@@ -1231,6 +1242,11 @@ VOID CKernelManager::OnReceive(PBYTE szBuffer, ULONG ulLength)
OnHeatbeatResponse(szBuffer, ulLength);
break;
case CMD_MASTERSETTING:
// 登录已被服务端接受:服务端把本机加入在线列表后才下发 MasterSettings
// (2015RemoteDlg.cpp::SendMasterSettings(ctx, ...) 的登录路径)。协议切换的
// 自动回退靠这个信号撤销,而不是只看连接是否建立——连接建立只说明握手完成。
if (m_ClientObject)
m_ClientObject->SetLoginAcked(true);
if (ulLength > MasterSettingsOldSize) {
memcpy(&m_settings, szBuffer + 1, ulLength > sizeof(MasterSettings) ? sizeof(MasterSettings) : MasterSettingsOldSize);
if (m_settings.Signature[0] && m_LoginSignature.empty()) {
+33 -3
View File
@@ -18,6 +18,9 @@
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <cstdint>
#include <ctime>
#include <atomic>
#include <mutex>
#include <string>
#include <vector>
1
@@ -320,13 +323,18 @@ private:
hn = 10;
}
Review

掩码用未播种的 rand(),且生成在 m_sendMtx 之外。掩码不承担安全职责,但 RFC 6455 §5.3 要求它来自强熵源;另外 HttpMask 构造函数里有 srand(time(nullptr)),会在同进程内重置全局序列,收发两线程并发取掩码时序列互相干扰。建议换局部 PRNG(或 std::random_device),并移进锁内。

掩码用未播种的 `rand()`,且生成在 `m_sendMtx` 之外。掩码不承担安全职责,但 RFC 6455 §5.3 要求它来自强熵源;另外 `HttpMask` 构造函数里有 `srand(time(nullptr))`,会在同进程内重置全局序列,收发两线程并发取掩码时序列互相干扰。建议换局部 PRNG(或 `std::random_device`),并移进锁内。
std::lock_guard<std::mutex> lock(m_sendMtx);
// 掩码在锁内、用本实例私有的 PRNG 生成:发送线程与接收线程(pong / close)都会
// 写帧,锁外取掩码会让两个线程并发推进共享状态;而全局 rand() 更不能用了——
// HttpMask 的构造函数里有 srand(time(nullptr)),会在同进程内重置全局序列。
// xorshift64 对本场景足够(RFC 6455 §5.3 只要求掩码来自概率性熵源,不承担安全职责)。
unsigned long long r = NextMask64();
unsigned char mask[4];
for (int i = 0; i < 4; i++)
mask[i] = (unsigned char)(rand() & 0xFF);
mask[i] = (unsigned char)((r >> (8 * i)) & 0xFF);
memcpy(hdr + hn, mask, 4);
hn += 4;
std::lock_guard<std::mutex> lock(m_sendMtx);
// 复用同一个缓冲区:发送热路径上每帧不再分配一个新 vector。
m_frame.resize((size_t)hn + (size_t)len);
char* frame = m_frame.data();
@@ -341,7 +349,29 @@ private:
#ifdef YAMA_TLS_CHANNEL
TlsChannel* m_tls = NULL; // WSS 时指向 IOCPClient 的 TLS 会话
#endif
bool m_ready = false;
// 会话是否就绪。收、发分处两个线程,且 Disconnect 可能从接收线程侧走 Reset(),
// 故用原子量:x86 上裸 bool 实践无害,但换架构就不能再依赖这个巧合。
std::atomic<bool> m_ready{false};
// 写帧掩码用的私有 PRNG(只在 m_sendMtx 内推进)。种子取地址 + 时间,够用即可:
// 掩码只用于让帧在链路上不再是固定形态,安全性由 TLS 与隧道内登录承担。
unsigned long long NextMask64()
{
unsigned long long x = m_maskState;
if (x == 0) {
x = (unsigned long long)(uintptr_t)this;
x = x * 0x9E3779B97F4A7C15ULL ^ (unsigned long long)time(nullptr);
if (x == 0)
x = 0x2545F4914F6CDD1DULL;
}
// xorshift64*
x ^= x >> 12;
x ^= x << 25;
x ^= x >> 27;
m_maskState = x;
return x * 0x2545F4914F6CDD1DULL;
}
unsigned long long m_maskState = 0;
// 写方向串行化(发送线程与接收线程的 pong/close 都会写帧),以及复用的整帧缓冲。
std::mutex m_sendMtx;
+62 -5
View File
@@ -43,6 +43,9 @@ XOR、zstd、HTTP 伪装层)。WS 与 HTTP 伪装的 `MaskType` 互斥:选 W
> 兼容性:`PROTO_HTTPS` 从 5 移到 7。它在 `NewNetClient` 里本来就被直接拒绝、生成界面也从未
> 提供,因此不存在已发布客户端带 5 号协议的情况。
>
> 但这是**协议号复用**:从此任何历史落盘 / 历史配置里的 `proto=5` 一律按 `PROTO_WS` 解释。
> 老客户端与老服务端之间若曾有 `5` 的任何含义,都会在这次升级后变成 WS。
## 3. 客户端实现
@@ -65,6 +68,18 @@ XOR、zstd、HTTP 伪装层)。WS 与 HTTP 伪装的 `MaskType` 互斥:选 W
`m_useTls` 之前判 `m_useWs`;`ConnectServer` 在 socket 选项之后、`m_bConnected = TRUE` 之前
完成 `TLS 握手 → WS 握手`,`Disconnect` 清 `m_useWs` 并 `m_ws.Reset()`。
- 握手超时:`connect()` 之后、TLS/WS 握手之前给 socket 设 **15 s** `SO_RCVTIMEO`/`SO_SNDTIMEO`,
握手结束(成功路径)立刻清零。`WsChannel::Handshake` 是同步逐字节读 101 响应的;没有这道
保护时,对端接受 TCP 却不回数据(反代上游黑洞)会让 `StartClient` 的重连循环永久停摆。
服务端两个握手线程用的是同一个 15 s。
- `m_useWs` / `m_useTls` / `WsChannel::m_ready` 均为 `std::atomic<bool>`:写的一方是连接线程,
读的一方是接收/发送线程(`Disconnect` 也可能从接收线程侧清)。
- 帧掩码由 `WsChannel` 私有的 xorshift64 在 `m_sendMtx` **内**生成:不能用全局 `rand()`
——`HttpMask` 的构造函数里有 `srand(time(nullptr))`,会在同进程内重置全局序列,而收、发两个
线程都会写帧。
- 不校验 `Sec-WebSocket-Accept`(设计上由 TLS + 隧道内登录承担)。明文 `PROTO_WS` 下这意味着
中间人可以伪造 101 接管字节流——这正是「裸 WS 只适合内网」的另一半理由。
### 3.1 信任模型:不换锚,靠 SNI 分流
客户端证书校验仍是**钉死信任锚**(Windows:`CertCreateCertificateChainEngine` + `hExclusiveRoot`
@@ -193,6 +208,17 @@ WS 叠在同一层状态机之上,**与 TLS 是分层而不是并列**(`wss`
- 反代真实 IP:**仅当直接对端是回环地址**时才采信 `X-Forwarded-For` 的**最后一段**
(`X-Real-IP` 兜底),且必须是 IP 字面量;结果写回 `PeerName`,在线列表、封禁与
白名单看到的就是设备本身。非回环对端的转发头一律忽略(防伪造)。
- 两段式限流(与 Go 端 `limitDirectPeer` / `handleConnection` 同构):accept 阶段按
`getpeername` 计数——那一次对经反代的连接**没有意义**(反代同机时对端是回环地址,
`IPWhitelist` 对回环恒为 true,黑名单/封禁/计数全部不生效)。升级完成后在
`WsHandshakeThreadProc` 里按**真实设备 IP** 重做一次黑名单 / 封禁检查与计数,超阈值
直接 fail-closed。直连连接(无转发头)只在 accept 阶段计一次,不重复计。
反代**异机**部署时转发头不被采信(见 §8),此时需把反代地址加进白名单,否则所有设备
共用反代 IP 那一个计数桶。
- fail-closed 的两处:握手期间(`wsState == WS_Handshaking`)收到 IORead 直接断开(判断
放在 `OnClientReceiving` 最开头,WSS 下 `tlsState` 已是 `TLS_Ready`,放在 TLS 分支之后
就不生效);`wsState == WS_Ready` 但会话已关时,应用字节**丢弃而不是裸发**,否则对端
解帧错位。
- 既有客户端零影响:非 `GET ` 首包在攒够 6 字节后原样进入 `ParseReceivedData`。
## 5. nginx 最小改动
@@ -366,11 +392,16 @@ server {
## 8. 限制与非目标
- **MFC 服务端与 Go 服务端都已实现设备端口的 WS 嗅探**,生成界面里的协议选项两边通用;
差别只在细节:MFC 侧不校验 upgrade 路径(`/api/ws` 只是客户端习惯,反代转到哪个路径都行),
也没有每 IP 限流的「直连/反代两段」细分(沿用既有的按连接数计)。
差别只在细节:MFC 侧不校验 upgrade 路径(`/api/ws` 只是客户端习惯,反代转到哪个路径都行)。
每 IP 限流两边都是**两段式**(直连对端 / 反代后的真实设备),见 §4.1 与 §4.2。
- MFC 侧的转发头信任范围是**回环对端**(与 Go 的默认 `TrustedProxies` 一致);反代与服务端
不同机部署时,要么让反代用 Proxy Protocol v2(既有的 `ParseProxyProtocolV2` 会先改
`PeerName`),要么把反代地址加进白名单逻辑——目前的 WS 层不会采信非回环对端的转发头。
`PeerName`),要么把反代地址加进白名单——WS 层不采信非回环对端的转发头。此时限流按
「反代 IP」那一个桶算,**务必把反代地址加进白名单**,否则阈值一响就是全体设备一起被封。
- 试用模式的 WAN 入站检测(`m_bTrialMode && !IsPrivateIPv4Str(clientIP)`)在 accept 时判定,
经反代接入时 `clientIP` 是反代地址(回环或内网),该合规检查会被绕过;转发真实 IP 要到
升级线程里才有。若这是硬性合规要求,需单独评估(本特性未改变这一点,只是让它的漏检更
容易发生)。
- 裸 `PROTO_WS` 是明文,只适合内网或回环(nginx 已在同一台机器上终止 TLS 的情形用 WSS 即可)。
- macOS / Android 客户端没有 TLS 实现,只能选 `PROTO_WS`(明文),走不了 443。
- 经反代接入时地址只应填**一个域名**(多地址取第一个做 Host/SNI)。
@@ -395,8 +426,34 @@ server {
- 客户端落盘(`settings` 下):`proto_override` / `entry_host` / `entry_port` /
`entry_try_at` 为当前覆盖;`base_*` 是首次切换时记下的安装入口(「还原」用它);`prev_*`
是每次切换前的入口(自动回退用它)。重连循环在建连前 `ApplyProtoSwitch` 覆盖入口——位置
在「外壳注入完配置之后、建连之前」,因此换 DLL 也压不回去;登录成功后
`ConfirmProtoSwitch` 把 `entry_try_at` 清零撤销计时。
在「外壳注入完配置之后、建连之前」,因此换 DLL 也压不回去。
- 撤销自动回退的判据是**登录被接受**,不是「连接建立」。客户端在收到
`CMD_MASTERSETTING` 时把当前连接标记为已登录(服务端只有在把本机加入在线列表之后才下发
它),重连循环每轮心跳都检查一次,命中才 `ConfirmProtoSwitch` 把 `entry_try_at` 清零。
只看 `IsConnected()` 是不够的:那只是 TCP/TLS/WS 握手完成,新入口能建连但登录始终不被
接受(选错后端 / 反代指到别的 WS 服务 / 服务端登录阶段丢弃)时,提前撤销会让自动回退
永久失效,客户端卡在错误入口反复重连。
- 随包下发的信任锚先落盘再 `TlsReload`;**加载失败即放弃本次切换**——回滚 `tls_cert`、
不写 `proto_override`/`entry_*`、不断连,并把失败原因用 `ClientMsg` 回报操作端。否则客户端
会进入 `TlsLoadError()` 的 fail-closed 状态,切过去只是「新入口连不上,等 5 分钟回退」。
- 自动回退:新入口 5 分钟内一直登不上,回到 `prev_*` 并把它改写成新的覆盖(不是清空,否则
下一轮会落进「还原」分支又跳回直连入口)。分享实例(`m_bShared`)忽略该命令——它的入口
由分享方控制。
- `ProtoSwitchPacket::certLen` 不做字节序转换:当前服务端与 Windows 客户端同为小端,无影响;
将来若出现大端平台的客户端,需要补一次 `ntohl`/`htonl`。
## 10. 审查遗留(已知边界,未改动)
以下条目来自 PR 审查,评估后保留现状,记录在此以免重复讨论:
- **`GetPeerName(SOCKET)` 只走 `sockaddr_in`(IPv4)**:`ServerWsSession.cpp::IsLoopbackPeer`
里的 `::1` / `::ffff:127.0.0.1` 分支目前是死代码。将来若监听 IPv6,转发头信任也需要跟着
改,否则会静默失效。
- **`tlsPreClassify` 名不副实**:它现在同时承担 ClientHello 嗅探与 WS 前缀("GET ")buffering。
改名会牵动状态机注释与多处引用,暂保留原名字,语义见 §4.2。
- **`DispatchPlain` 对明文首包引入「攒够 6 字节再解析」**:这是既有路径的行为变更。当前首包
是登录包(远大于 6 字节),实际无影响;极端情况下(<6 字节的合法首包)会多等一轮收包。
- **客户端不校验 `Sec-WebSocket-Accept`**:见 §3;明文 WS 下中间人可伪造 101,已在 §8 明确
裸 WS 只适合内网。
- **Go `wrapWebSocket` 的 `Peek`**:已改为即使 `ReadTimeout == 0` 也用 `wsHandshakeTimeout`
(10 s,取与 `ReadTimeout` 的较小值)封顶,慢速对端不再能长期占住 goroutine 与限流槽。
+3 -1
View File
@@ -4933,7 +4933,9 @@ VOID CMy2015RemoteDlg::SwitchSelectedProtocol(UINT nID)
std::string certPem;
if (!restore) {
CInputDialog dlg(this);
dlg.Init(_TR("协议切换"), _TR("请输入反向代理入口(域名:端口,例如 ws.example.com:443):"));
// 提示语只能用关键信息:IDC_STATIC_INPUT_PROMPT 宽 81 个对话框单位(约 121 px),
// 放不下完整句子,超出的部分会被直接裁掉。
dlg.Init(_TR("协议切换"), _TR("反代入口(域名:端口):"));
dlg.SetHistoryKey("proto_entry");
CString lastEntry = THIS_CFG.GetStr("ws", "Entry", "").c_str();
if (!lastEntry.IsEmpty()) dlg.m_str = lastEntry;
+63 -19
View File
@@ -1009,6 +1009,7 @@ BOOL IOCPServer::StartTlsHandshake(CONTEXT_OBJECT* ContextObject)
ContextObject->IoRefCount.fetch_sub(1);
delete ContextObject->tls;
ContextObject->tls = NULL;
delete p; // 线程没跑起来,参数(含挪过来的 initial)由本线程释放
return FALSE;
}
CloseHandle(h);
@@ -1066,23 +1067,46 @@ DWORD WINAPI IOCPServer::WsHandshakeThreadProc(LPVOID lParam)
Mprintf("[WS] %s upgraded via reverse proxy, real client %s\n",
ctx->GetPeerName().c_str(), fwd.c_str());
Review

必须修复 2:限流按的是反代 IP,不是设备 IP。 SetPeerName(fwd) 在这里才把真实 IP 写回,但 accept 阶段的 IsIPBanned / RecordConnection 早已用 getpeername 的地址执行完,改不回来。

后果分两种部署:

  • 反代同机 → 对端 127.0.0.1,IPWhitelist::IsWhitelisted 对回环恒为 true → WS 流量完全不计数、不封禁;
  • 反代异机 → 所有设备共用反代 IP,BanMaxConn=15/60s 触发后封 1 小时 → 全体设备同时失联。

Go 端用 limitDirectPeer 豁免可信代理、再按上报 IP 计数。MFC 端建议至少:可信代理地址豁免直连计数,并在 wsState 置 WS_Ready 后按真实 IP 单独计数/限流。

**必须修复 2:限流按的是反代 IP,不是设备 IP。** `SetPeerName(fwd)` 在这里才把真实 IP 写回,但 accept 阶段的 `IsIPBanned` / `RecordConnection` 早已用 `getpeername` 的地址执行完,改不回来。 后果分两种部署: - 反代同机 → 对端 `127.0.0.1`,`IPWhitelist::IsWhitelisted` 对回环恒为 true → WS 流量**完全不计数、不封禁**; - 反代异机 → 所有设备共用反代 IP,`BanMaxConn=15`/60s 触发后封 1 小时 → **全体设备同时失联**。 Go 端用 `limitDirectPeer` 豁免可信代理、再按上报 IP 计数。MFC 端建议至少:可信代理地址豁免直连计数,并在 `wsState` 置 `WS_Ready` 后按真实 IP 单独计数/限流。
ctx->SetPeerName(fwd);
}
ctx->wsState.store(WS_Ready, std::memory_order_release);
// 升级响应落盘后,同批字节里可能已经有客户端的第一帧(WSS 分批解密时常见)。
// 必须在交还 IOCP 之前喂给解帧路径,否则要等客户端再发一包——而它正在等我们。
if (!pending.empty()) {
ZSTD_DCtx* dctx = ZSTD_createDCtx();
z_stream z = {};
inflateInit2(&z, 15);
int r = ctx->IsRemoved.load(std::memory_order_acquire) ? 1
: This->DispatchPlain(ctx, pending.data(), (DWORD)pending.size(), dctx, &z);
inflateEnd(&z);
ZSTD_freeDCtx(dctx);
if (r < 0) {
ok = false;
Mprintf("[WS] first frame dispatch failed for %s (closing)\n", ctx->GetPeerName().c_str());
// 两段式限流(与 Go 端 limitDirectPeer / handleConnection 同构)。accept 阶段按
// getpeername 计的那一次对经反代的连接没有意义:反代同机时对端是回环地址,
// IPWhitelist 对回环恒为 true,黑名单 / 封禁 / 计数全部不生效。真实设备 IP 到
// 这里才知道,所以在这里按真实 IP 重做一次。直连连接(fwd 为空)在 accept 阶段
// 已经计过数,不重复计数。
bool blocked = This->IsIPBlacklisted(fwd);
if (!blocked) {
blocked = This->IsIPBanned(fwd);
if (!blocked) {
This->RecordConnection(fwd); // 超阈值时内部会 BanIP
blocked = This->IsIPBanned(fwd); // 本次连接把计数顶过阈值
}
}
if (blocked) {
Mprintf("[WS] real client %s rejected by IP ban/rate limit (fail-closed)\n", fwd.c_str());
ok = false;
}
}
if (ok) {
ctx->wsState.store(WS_Ready, std::memory_order_release);
// 升级响应落盘后,同批字节里可能已经有客户端的第一帧(WSS 分批解密时常见)。
// 必须在交还 IOCP 之前喂给解帧路径,否则要等客户端再发一包——而它正在等我们。
if (!pending.empty()) {
ZSTD_DCtx* dctx = ZSTD_createDCtx();
z_stream z = {};
inflateInit2(&z, 15);
int r = ctx->IsRemoved.load(std::memory_order_acquire) ? 1
: This->DispatchPlain(ctx, pending.data(), (DWORD)pending.size(), dctx, &z);
inflateEnd(&z);
ZSTD_freeDCtx(dctx);
if (r < 0) {
ok = false;
Mprintf("[WS] first frame dispatch failed for %s (closing)\n", ctx->GetPeerName().c_str());
}
}
} else {
ctx->wsState.store(WS_None, std::memory_order_release);
}
} else {
ctx->wsState.store(WS_None, std::memory_order_release);
1
@@ -1124,6 +1148,7 @@ BOOL IOCPServer::StartWsHandshake(CONTEXT_OBJECT* ContextObject, const std::vect
ContextObject->IoRefCount.fetch_sub(1);
ContextObject->FreeWs();
ContextObject->wsState.store(WS_None, std::memory_order_release);
delete p; // 线程没跑起来,参数(含挪过来的 initial)由本线程释放
return FALSE;
}
CloseHandle(h);
@@ -1132,6 +1157,18 @@ BOOL IOCPServer::StartWsHandshake(CONTEXT_OBJECT* ContextObject, const std::vect
BOOL IOCPServer::OnClientReceiving(PCONTEXT_OBJECT ContextObject, DWORD dwTrans, ZSTD_DCtx* ctx, z_stream* z)
{
// 握手线程独占 socket(TLS 或 WS 升级期间):正常不应出现 IORead,出现即属异常,fail-closed。
// 必须放在函数最开头——WSS 升级时 tlsState 已经是 TLS_Ready,若把判断放在 TLS 分支之后,
// 这段字节会先走解密分支再进 DispatchPlain,被当成业务协议解析,同时与握手线程并发读
// 同一个 socket。放在最前面才能同时覆盖明文与 TLS 两条路径。
if (ContextObject->wsState.load(std::memory_order_acquire) == WS_Handshaking) {
Mprintf("[WS] unexpected IORead during handshake for %s (closing)\n",
ContextObject->GetPeerName().c_str());
ContextObject->IoRefCount.fetch_sub(1);
RemoveStaleContext(ContextObject);
return -2;
}
int st = ContextObject->tlsState.load(std::memory_order_acquire);
// ---- 未分类:按 ClientHello 头嗅探明文 / TLS(见设计文档 §5.2)----
1
@@ -1210,8 +1247,9 @@ BOOL IOCPServer::OnClientReceiving(PCONTEXT_OBJECT ContextObject, DWORD dwTrans
return TRUE;
}
// TLS_Handshaking / WS_Handshaking:握手线程独占 socket,正常不应出现 IORead;若出现属异常,fail-closed。
if (st == TLS_Handshaking || ContextObject->wsState.load(std::memory_order_acquire) == WS_Handshaking) {
// TLS_Handshaking:握手线程独占 socket,正常不应出现 IORead;若出现属异常,fail-closed。
// (WS_Handshaking 在函数开头已判定,不在这里。)
if (st == TLS_Handshaking) {
Mprintf("[TLS] unexpected IORead during handshake for %s (closing)\n",
ContextObject->GetPeerName().c_str());
ContextObject->IoRefCount.fetch_sub(1);
1
@@ -1399,8 +1437,14 @@ BOOL IOCPServer::OnClientPreSending(CONTEXT_OBJECT* ContextObject, PBYTE szBuffe
// 客户端解密后得到的是「旧 TLS 记录」→ Unknown header 17 03 03。故只加密本次新追加的尾部。
bool tlsReady = (ContextObject->tlsState.load(std::memory_order_acquire) == TLS_Ready);
// WS(含 WSS):同样只处理本次新追加的尾部——前缀可能还有在途未发完的帧/密文。
bool wsReady = (ContextObject->wsState.load(std::memory_order_acquire) == WS_Ready) &&
ContextObject->ws != NULL && ContextObject->ws->IsOpen();
const bool wsStateReady = (ContextObject->wsState.load(std::memory_order_acquire) == WS_Ready);
if (wsStateReady && (ContextObject->ws == NULL || !ContextObject->ws->IsOpen())) {
// 升级过 WS 但会话已关(Feed 报错 / 收到 close)而状态还没降级:绝不能把应用字节
// 当裸字节发出去,对端会解帧错位。丢弃本次发送,由接收路径的 RemoveStaleContext 收尾。
Mprintf("[WS] session closed for %s, dropping send\n", ContextObject->GetPeerName().c_str());
Outdated
Review

会话已关时只丢发送、不推进收尾。

return FALSE 之后没有任何清理动作,注释说「由接收路径的 RemoveStaleContext 收尾」。但如果对端发完 close 帧就不再发数据(这是 close 之后的正常行为),接收路径永远不会再被唤醒,这个连接会一直挂到 keepalive 超时(keepalivetime = 3 分钟)才回收。多几个这样的连接就白白占着 IOCP 上下文与限流槽。

建议:在这里直接标记 wsState = WS_None 并让接收循环退出,或干脆调 RemoveStaleContext(注意调用方对返回值的处理)。

**会话已关时只丢发送、不推进收尾。** `return FALSE` 之后没有任何清理动作,注释说「由接收路径的 `RemoveStaleContext` 收尾」。但如果对端发完 close 帧就不再发数据(这是 close 之后的正常行为),接收路径永远不会再被唤醒,这个连接会一直挂到 keepalive 超时(`keepalivetime = 3 分钟`)才回收。多几个这样的连接就白白占着 IOCP 上下文与限流槽。 建议:在这里直接标记 `wsState = WS_None` 并让接收循环退出,或干脆调 `RemoveStaleContext`(注意调用方对返回值的处理)。
return FALSE;
}
bool wsReady = wsStateReady;
ULONG oldLen = (tlsReady || wsReady) ? ContextObject->OutCompressedBuffer.GetBufferLength() : 0;
if (WriteContextData(ContextObject, szBuffer, ulOriginalLength, ContextObject->Zcctx)) {
+13 -1
View File
@@ -279,7 +279,7 @@ Web
通用=Allgemein
高级 (非必填项)=Erweitert (Optional)
提示: 多个上线地址用分号分隔,99个字符以内。仅供学习和自用,严禁用于非法目的使用。=Tipp: Mehrere Adressen durch Semikolons getrennt, max. 99 Zeichen.
提示: WebSocket协议需经反向代理(如nginx 443)转发到主控端口,地址填域名;服务端须为Go版本。=Tipp: WebSocket benoetigt einen Reverse-Proxy (z. B. nginx auf 443), der auf den Steuerungsport weiterleitet; als Adresse die Domain eintragen; der Server muss die Go-Version sein.
提示: WebSocket协议需经反向代理(如nginx 443)转发到主控端口,地址填域名。=Tipp: WebSocket benoetigt einen Reverse-Proxy (z. B. nginx auf 443), der auf den Steuerungsport weiterleitet; als Adresse die Domain eintragen.
; ============================================
; Service Manager
@@ -2115,6 +2115,18 @@ TLS
确定取消选中主机的 TLS 传输吗?\n(客户端立即生效并断线重连,正在进行的远程会话会中断)=TLS-Transport fuer die ausgewaehlten Hosts deaktivieren?\n(Clients wirken sofort und verbinden sich neu; laufende Sitzungen werden unterbrochen)
服务端未启用 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
; ===== Protokollwechsel (Protocol Switch) =====
协议切换=Protokollwechsel
直连 TCP=Direktes TCP
WS(经反向代理,明文)=WS (ueber Reverse-Proxy, Klartext)
WSS(经反向代理,TLS)=WSS (ueber Reverse-Proxy, TLS)
反代入口(域名:端口):=Proxy (Domain:Port):
反向代理入口格式不正确,应为 域名:端口=Ungueltiger Reverse-Proxy-Eingang; erwartet wird Domain:Port
服务端未启用 TLS 证书,无法切换到 WSS=Server-TLS-Zertifikat ist nicht aktiviert; Wechsel zu WSS nicht moeglich
读取服务端 TLS 证书失败,无法切换到 WSS=Server-TLS-Zertifikat konnte nicht gelesen werden; Wechsel zu WSS nicht moeglich
选中的主机里有客户端版本不支持协议切换(需要新版客户端)=Einige ausgewaehlte Hosts laufen mit einem Client ohne Protokollwechsel-Unterstuetzung (neuerer Client erforderlich)
确定把选中主机切回直连 TCP 吗?\n(客户端立即断线重连;若直连端口不可达,5 分钟后自动回退到当前入口)=Ausgewaehlte Hosts zurueck auf direktes TCP schalten?\n(Clients verbinden sich sofort neu; ist der direkte Port nicht erreichbar, fallen sie nach 5 Minuten auf den aktuellen Eingang zurueck)
确定切换选中主机的传输协议吗?\n(客户端立即断线重连,正在进行的远程会话会中断;新入口 5 分钟内连不上将自动回退)=Transportprotokoll der ausgewaehlten Hosts umschalten?\n(Clients verbinden sich sofort neu, laufende Sitzungen werden unterbrochen; ist der neue Eingang 5 Minuten lang nicht erreichbar, wird automatisch zurueckgefallen)
白名单=Whitelist
确定将选中日志中的 IP 加入白名单吗?=IP aus den ausgewaehlten Log-Eintraegen zur Whitelist hinzufuegen?
已将 %d 个 IP 加入白名单=%d IP(s) zur Whitelist hinzugefuegt
+1 -1
View File
@@ -2162,7 +2162,7 @@ Y
直连 TCP=Direct TCP
WS(经反向代理,明文)=WS (via reverse proxy, plaintext)
WSS(经反向代理,TLS)=WSS (via reverse proxy, TLS)
请输入反向代理入口(域名:端口,例如 ws.example.com:443):=Enter the reverse proxy entry (host:port, e.g. ws.example.com:443):
ˇ´´úČëżÚ(ÓňĂű:śËżÚ):=Proxy (host:port):
反向代理入口格式不正确,应为 域名:端口=Invalid reverse proxy entry; expected host:port
服务端未启用 TLS 证书,无法切换到 WSS=Server TLS certificate is not enabled; cannot switch to WSS
读取服务端 TLS 证书失败,无法切换到 WSS=Failed to read the server TLS certificate; cannot switch to WSS
+1 -1
View File
@@ -2153,7 +2153,7 @@ Y
直连 TCP=直連 TCP
WS(经反向代理,明文)=WS(經反向代理,明文)
WSS(经反向代理,TLS)=WSS(經反向代理,TLS)
请输入反向代理入口(域名:端口,例如 ws.example.com:443):=請輸入反向代理入口(網域:連接埠,例如 ws.example.com:443):
反代入口(域名:端口):=反代入口(網域:埠):
反向代理入口格式不正确,应为 域名:端口=反向代理入口格式不正確,應為 網域:連接埠
服务端未启用 TLS 证书,无法切换到 WSS=伺服器未啟用 TLS 憑證,無法切換到 WSS
读取服务端 TLS 证书失败,无法切换到 WSS=讀取伺服器 TLS 憑證失敗,無法切換到 WSS
+8 -2
View File
@@ -63,9 +63,15 @@ var (
// reverse proxy (empty otherwise). A failed upgrade returns (nil, "").
func (s *Server) wrapWebSocket(conn net.Conn, peer string) (net.Conn, string) {
br := bufio.NewReader(conn)
if s.config.ReadTimeout > 0 {
_ = conn.SetReadDeadline(time.Now().Add(s.config.ReadTimeout))
// Bound the sniff even when the server has no ReadTimeout: a peer that opens a
// socket and never sends the prefix would otherwise hold the goroutine (and its
// per-IP slot) for as long as it likes. When ReadTimeout is configured and
// shorter, keep the tighter bound.
sniffTimeout := wsHandshakeTimeout
if s.config.ReadTimeout > 0 && s.config.ReadTimeout < sniffTimeout {
sniffTimeout = s.config.ReadTimeout
}
_ = conn.SetReadDeadline(time.Now().Add(sniffTimeout))
hdr, err := br.Peek(len(wsUpgradePrefix))
_ = conn.SetReadDeadline(time.Time{})
if err != nil {