From d4f312c9d8b40695decee8e94aed64e091fa86a0 Mon Sep 17 00:00:00 2001 From: yuanyuanxiang <962914132@qq.com> Date: Fri, 30 Oct 2026 13:57:05 +0100 Subject: [PATCH 1/5] Feature: Tunnel the device protocol through a reverse proxy over WebSocket --- client/IOCPClient.cpp | 66 +++- client/IOCPClient.h | 15 + client/KernelManager.cpp | 36 +- client/TlsChannel.cpp | 115 +++++-- client/TlsChannel.h | 21 +- client/TlsChannelLinux.cpp | 8 +- client/WsChannel.h | 355 +++++++++++++++++++ common/commands.h | 8 +- docs/WebSocket_Transport_Design.md | 322 +++++++++++++++++ server/2015Remote/2015RemoteDlg.cpp | 8 +- server/2015Remote/BuildDlg.cpp | 5 + server/2015Remote/lang/de_DE.ini | 5 +- server/2015Remote/lang/en_US.ini | 5 +- server/2015Remote/lang/zh_TW.ini | 5 +- server/go/cmd/main.go | 18 + server/go/connection/context.go | 20 ++ server/go/server/server.go | 89 ++++- server/go/server/server_test.go | 32 +- server/go/server/ws.go | 517 ++++++++++++++++++++++++++++ server/go/server/ws_test.go | 407 ++++++++++++++++++++++ 20 files changed, 1994 insertions(+), 63 deletions(-) create mode 100644 client/WsChannel.h create mode 100644 docs/WebSocket_Transport_Design.md create mode 100644 server/go/server/ws.go create mode 100644 server/go/server/ws_test.go diff --git a/client/IOCPClient.cpp b/client/IOCPClient.cpp index a11aac7..b4a3c64 100644 --- a/client/IOCPClient.cpp +++ b/client/IOCPClient.cpp @@ -467,6 +467,27 @@ BOOL IOCPClient::ConnectServer(const char* szServerIP, unsigned short uPort) SetKeepAliveOptions(m_sClientSocket); #endif } + // WebSocket 传输(PROTO_WS / PROTO_WSS):出站被限制在 80/443/8080 等端口时,经反代 + // 分流进来。与应用协议无关,位置和 TLS 相同(TLS 之下、应用协议之上);须在 + // m_bConnected 置位前完成,确保工作线程不会在 Upgrade 尚未完成时就开始 recv。 + const int protoType = m_conn ? (int)(unsigned char)m_conn->protoType : -1; + const bool wsProto = (protoType == PROTO_WS || protoType == PROTO_WSS); + const bool wsTls = (protoType == PROTO_WSS); + m_useWs = false; + // Host 头与 SNI 用配置里的地址(域名),子连接只拿到解析后的 IP,必须回到 conn 取。 + // 多地址(分号分隔)时取第一个:经反代接入的场景应在地址里只填一个域名。 + std::string wsHost = m_sCurIP; + if (m_conn) { + std::string configured = m_conn->GetFirstServerIP(); + if (!configured.empty()) + wsHost = configured; + } + // IP 字面量不能当 SNI(RFC 6066);直接连 IP 时反代会落到默认 server 块。 + const bool wsHostIsDomain = (inet_addr(wsHost.c_str()) == INADDR_NONE) && wsHost.find(':') == std::string::npos; + // WSS 但没有信任锚时的降级标记:本连接按明文 WS 走,服务端下发锚并热重载后, + // 下一次连接会自动升级为 WSS(见下方 else if 分支)。 + bool wsDegraded = false; + #ifdef YAMA_TLS_CHANNEL // 单向 TLS:证书存在(TlsEnabled())时,在应用协议首包前完成握手;握手失败即断开, // 不回退明文(fail-closed,防降级)。证书存在但加载失败(TlsLoadError())同样拒绝 @@ -480,16 +501,55 @@ BOOL IOCPClient::ConnectServer(const char* szServerIP, unsigned short uPort) m_sClientSocket = INVALID_SOCKET; return FALSE; } - if (TlsEnabled()) { - if (!m_tls.Handshake(m_sClientSocket)) { + // PROTO_WS 是显式选择的明文形态(反代的 80 端口、内网直连):即便本客户端配了信任锚 + // 也不叠加 TLS,否则该形态永远不可达。WSS 与直连主控端口仍按上面的规则强制 TLS。 + if (TlsEnabled() && protoType != PROTO_WS) { + // SNI:WSS 经反代时要让反代按域名分流到正确的 server 块;直连 IP/主控端口时保持 + // 原样(不传名字),与既有行为一致。 + const char* sni = (wsTls && wsHostIsDomain) ? wsHost.c_str() : NULL; + if (!m_tls.Handshake(m_sClientSocket, sni)) { Mprintf("[TLS] 握手失败,断开连接(fail-closed)\n"); closesocket(m_sClientSocket); m_sClientSocket = INVALID_SOCKET; return FALSE; } m_useTls = true; + } else if (wsTls) { + // 回退(不是降级攻击面):没有信任锚时无法校验反代出示的证书,但此时客户端 + // 本来也还没被「颁发」证书——先用明文 WS 把隧道打通,等服务端下发信任锚 + // (COMMAND_TLS_ENABLE → TlsReload)后,下一次连接自动走 WSS。 + // 注意:有锚但握手失败、或锚存在却加载失败(上面 TlsLoadError),仍然 fail-closed, + // 绝不静默降级。 + wsDegraded = true; + Mprintf("[WS] 未配置信任锚,本次按明文 WebSocket 连接;服务端下发证书后重连将升级为 WSS\n"); + } +#else + if (wsTls) { + Mprintf("[WS] 本平台不支持 TLS,无法使用 WSS 协议\n"); + closesocket(m_sClientSocket); + m_sClientSocket = INVALID_SOCKET; + return FALSE; } #endif + + if (wsProto) { +#ifdef YAMA_TLS_CHANNEL + m_ws.SetTls(m_useTls ? &m_tls : NULL); +#endif + std::string werr; + if (!m_ws.Handshake(m_sClientSocket, wsHost, (int)port, WS_UPGRADE_PATH, &werr)) { + Mprintf("[WS] WebSocket 握手失败(%s),断开连接\n", werr.c_str()); + closesocket(m_sClientSocket); + m_sClientSocket = INVALID_SOCKET; + return FALSE; + } + m_useWs = true; + // 注意:这里不能读 m_useTls——无 TLS 的平台上(macOS/Android)它不存在; + // 本连接实际走的形态由 wsDegraded 区分:WSS 有锚走 TLS,没锚则明文回退。 + Mprintf("[WS] WebSocket 已就绪: %s:%d%s%s\n", wsHost.c_str(), (int)port, + WS_UPGRADE_PATH, wsDegraded ? " (明文,等待信任锚)" + : (wsTls ? " (TLS)" : "")); + } m_bConnected = TRUE; Mprintf("连接服务端成功: %s:%d.\n", m_sCurIP.c_str(), (int)port); @@ -908,6 +968,8 @@ VOID IOCPClient::Disconnect() #ifdef YAMA_TLS_CHANNEL m_useTls = false; // 连接已断,Send/Recv 回到明文路径(下次 ConnectServer 重新锁定) #endif + m_useWs = false; // WebSocket 帧状态同样按连接锁定,重连时重新握手 + m_ws.Reset(); m_bConnected = FALSE; } diff --git a/client/IOCPClient.h b/client/IOCPClient.h index 5da26aa..2a86bb0 100644 --- a/client/IOCPClient.h +++ b/client/IOCPClient.h @@ -15,6 +15,9 @@ // 且不定义 YAMA_TLS_CHANNEL,下方代码自动退回明文。 #include "TlsChannel.h" +// WebSocket 传输(经反代 443 等受限端口接入)。头文件实现,各平台编译目标无需改动。 +#include "WsChannel.h" + #include "Buffer.h" #include "zstd/zstd.h" #include "domain_pool.h" @@ -293,6 +296,9 @@ public: protected: 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); @@ -304,6 +310,8 @@ protected: 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); @@ -312,8 +320,11 @@ protected: } // 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 @@ -328,6 +339,10 @@ protected: protected: sockaddr_in m_ServerAddr; SOCKET m_sClientSocket; + // WebSocket 传输(PROTO_WS / PROTO_WSS):ConnectServer 里握手成功时置位, + // Disconnect 时清除。与 m_useTls 一样按连接锁定,Send/Recv 不再现查 protoType。 + WsChannel m_ws; + bool m_useWs = false; #ifdef YAMA_TLS_CHANNEL TlsChannel m_tls; // TLS 会话(证书存在时才启用,见 TlsChannel.h) // 本连接是否走 TLS:在 ConnectServer 里握手成功时置位、Disconnect 时清除,Send/Recv diff --git a/client/KernelManager.cpp b/client/KernelManager.cpp index 510e694..3a662a7 100644 --- a/client/KernelManager.cpp +++ b/client/KernelManager.cpp @@ -45,6 +45,10 @@ IOCPClient* NewNetClient(CONNECT_ADDRESS* conn, State& bExit, const std::string& return new IOCPUDPClient(bExit, exit_while_disconnect); if (type == PROTO_HTTP || type == PROTO_HTTPS) return new IOCPClient(bExit, exit_while_disconnect, MaskTypeHTTP, conn, publicIP); + // WebSocket:仍然是 IOCPClient(TCP 承载),只是 ConnectServer 里多做一次 Upgrade + // 握手,Send/Recv 换成 WS 帧。HTTP 伪装层不用(WS 帧本身就是 HTTP 升级后的流)。 + if (type == PROTO_WS || type == PROTO_WSS) + return new IOCPClient(bExit, exit_while_disconnect, MaskTypeNone, conn, publicIP); if (type == PROTO_KCP) { return new IOCPKCPClient(bExit, exit_while_disconnect); } @@ -800,6 +804,28 @@ void ResponseDisable(IOCPClient *client, const char* type, LPBYTE data, int size extern "C" bool IsSystemInSession0(); +// 信任锚已写入/删除:热重载 TLS 状态,只在传输方式真正变化(明文 ↔ TLS)时断开重连; +// 仅换证书(仍是 TLS)不打断现有会话,新锚从下一条新连接开始生效。与 Linux 版的 +// linux/main.cpp::ApplyTlsAnchorChange 同一语义。 +static void ApplyTlsAnchorChange(IOCPClient* client) +{ + const bool before = TlsEnabled(); + std::string err; + if (!TlsReload(err)) { + Mprintf("[TLS] reload failed: %s (keeping current transport)\n", err.c_str()); + return; + } + const bool after = TlsEnabled(); + if (before == after) { + Mprintf("[TLS] trust anchor updated, transport unchanged (%s)\n", + after ? "TLS" : "plaintext"); + return; + } + Mprintf("[TLS] transport switched to %s, reconnecting\n", after ? "TLS" : "plaintext"); + if (client) + client->Disconnect(); // 断开后由重连循环用新传输方式重新登录 +} + VOID CKernelManager::OnReceive(PBYTE szBuffer, ULONG ulLength) { bool isExit = szBuffer[0] == COMMAND_BYE || szBuffer[0] == SERVER_EXIT; @@ -853,15 +879,20 @@ VOID CKernelManager::OnReceive(PBYTE szBuffer, ULONG ulLength) case COMMAND_TLS_ENABLE: { // 服务端下发信任锚证书:payload = PEM 正文(szBuffer+1 .. ulLength-1)。 - // 写入注册表 settings\tls_cert,客户端下次启动读到证书即启用 TLS(非实时)。 + // 写入注册表 settings\tls_cert 后热重载:明文 → TLS 的切换会断开本连接,重连 + // 循环随即用 TLS 重新登录(此前按明文回退的 WSS 客户端就此升级为 WSS)。 if (ulLength > 1) { std::string certPem((char*)szBuffer + 1, ulLength - 1); m_cfg->SetStr("settings", "tls_cert", certPem); + ApplyTlsAnchorChange(m_ClientObject); + } else { + // 没有证书正文就等于「启用但没有锚」——不该悄悄忽略,留一行便于排查。 + Mprintf("[TLS] COMMAND_TLS_ENABLE without a certificate payload, ignored\n"); } break; } case COMMAND_TLS_DISABLE: { - // 删除注册表信任锚,客户端下次启动无证书即回明文(非实时)。 + // 删除注册表信任锚后热重载:TLS → 明文时断开重连(WSS 客户端会回到明文回退)。 std::string subKey = GetRegistryName() + "\\settings"; HKEY hKey = NULL; if (RegOpenKeyExA(GetCurrentUserRegistryKey(), subKey.c_str(), 0, @@ -869,6 +900,7 @@ VOID CKernelManager::OnReceive(PBYTE szBuffer, ULONG ulLength) RegDeleteValueA(hKey, "tls_cert"); RegCloseKey(hKey); } + ApplyTlsAnchorChange(m_ClientObject); break; } diff --git a/client/TlsChannel.cpp b/client/TlsChannel.cpp index 66c5c8a..08784c0 100644 --- a/client/TlsChannel.cpp +++ b/client/TlsChannel.cpp @@ -12,14 +12,18 @@ #include // std::ifstream #include // std::istreambuf_iterator #include -#include // std::call_once +#include // std::mutex #pragma comment(lib, "secur32.lib") #pragma comment(lib, "crypt32.lib") namespace { -std::once_flag g_tlsOnce; +// 进程级 TLS 状态:首连时加载一次,服务端下发/撤销信任锚后可重建(TlsReload)。 +// 所有读写都在 g_tlsMtx 下;证书校验(VerifyServerCert)在校验期间持同一把锁,因此 +// 重建时可以安全地释放旧的 store/engine——不会再有线程正拿着它们用。 +std::mutex g_tlsMtx; +bool g_tlsLoaded = false; // 已加载过至少一次(决定首次失败是否 fail-closed) bool g_tlsEnabled = false; // TLS 会话可用:send/recv 走加密 bool g_tlsError = false; // 证书存在但加载失败:拒绝连接(fail-closed) HCERTSTORE g_tlsStore = NULL; @@ -160,26 +164,23 @@ bool LoadTrustAnchor(const std::string& pem, const std::string& source, HCERTSTO return true; } -void InitTls() +enum TlsAnchor { TLS_ANCHOR_OK, TLS_ANCHOR_NONE, TLS_ANCHOR_INVALID }; + +// 读取当前信任锚并建好 store + 链引擎(成功时经 outStore/outEngine 交出,调用方负责 +// 释放)。不触碰全局状态。source 描述锚的来源,仅用于日志。 +TlsAnchor BuildTlsAnchor(HCERTSTORE* outStore, HCERTCHAINENGINE* outEngine, + std::string& source, std::string& err) { - std::string pem, source; + std::string pem; if (!ReadTrustAnchor(pem, source)) { - // 无证书 → 明文(默认,与老客户端一致) - g_tlsEnabled = false; - g_tlsError = false; - Mprintf("[TLS] disabled: no trust anchor configured, plaintext mode\n"); - return; + err = "no trust anchor configured"; + return TLS_ANCHOR_NONE; } - // 证书已配置:管理员已「颁发」,必须走 TLS;加载失败即拒绝连接(fail-closed), - // 不能静默回退明文。 HCERTSTORE store = NULL; if (!LoadTrustAnchor(pem, source, &store)) { - g_tlsEnabled = false; - g_tlsError = true; - Mprintf("[TLS] FATAL: trust anchor (%s) present but failed to load; refusing connections (fail-closed)\n", - source.c_str()); - return; + err = "trust anchor (" + source + ") present but failed to load"; + return TLS_ANCHOR_INVALID; } // 严格钉扎:链引擎只信任该 store 里的根证书,排除系统根库。否则攻击者拿一张任意 @@ -190,33 +191,87 @@ void InitTls() HCERTCHAINENGINE engine = NULL; if (!CertCreateCertificateChainEngine(&ec, &engine)) { CertCloseStore(store, 0); - g_tlsEnabled = false; - g_tlsError = true; - Mprintf("[TLS] FATAL: CertCreateCertificateChainEngine failed; refusing connections (fail-closed)\n"); - return; + err = "CertCreateCertificateChainEngine failed"; + return TLS_ANCHOR_INVALID; } + *outStore = store; + *outEngine = engine; + return TLS_ANCHOR_OK; +} + +// 按当前信任锚重建 TLS 状态(调用方持 g_tlsMtx)。 +// 首次加载失败 → fail-closed(管理员已「颁发」证书,不能静默回退明文);运行期热重载 +// 失败 → 保持现有状态不变,返回 false(一次坏下发不该打死正在工作的客户端;下次启动 +// 仍会 fail-closed)。 +bool ApplyTlsStateLocked(bool initial, std::string& err) +{ + HCERTSTORE store = NULL; + HCERTCHAINENGINE engine = NULL; + std::string source; + const TlsAnchor anchor = BuildTlsAnchor(&store, &engine, source, err); + + if (anchor == TLS_ANCHOR_INVALID) { + if (initial) { + g_tlsEnabled = false; + g_tlsError = true; + g_tlsLoaded = true; + Mprintf("[TLS] FATAL: %s; refusing connections (fail-closed)\n", err.c_str()); + } else { + Mprintf("[TLS] reload failed: %s (keeping current transport)\n", err.c_str()); + } + return false; + } + + // 互换。旧 store/engine 可以直接释放:校验路径持同一把锁,此刻没有线程在用它们。 + HCERTSTORE oldStore = g_tlsStore; + HCERTCHAINENGINE oldEngine = g_tlsEngine; g_tlsStore = store; g_tlsEngine = engine; - g_tlsEnabled = true; + g_tlsEnabled = (anchor == TLS_ANCHOR_OK); g_tlsError = false; - Mprintf("[TLS] enabled: trust anchor loaded (%s), all connections use TLS\n", source.c_str()); + g_tlsLoaded = true; + if (oldEngine) CertFreeCertificateChainEngine(oldEngine); + if (oldStore) CertCloseStore(oldStore, 0); + + if (g_tlsEnabled) + Mprintf("[TLS] enabled: trust anchor loaded (%s), all connections use TLS\n", source.c_str()); + else + Mprintf("[TLS] disabled: no trust anchor configured, plaintext mode\n"); + return true; +} + +// 首次调用时才真正加载;之后一律用缓存的状态(热重载由 TlsReload 负责)。 +inline void EnsureTlsLoadedLocked() +{ + if (!g_tlsLoaded) { + std::string err; + ApplyTlsStateLocked(true, err); + } } } // namespace bool TlsEnabled() { - std::call_once(g_tlsOnce, InitTls); + std::lock_guard lk(g_tlsMtx); + EnsureTlsLoadedLocked(); return g_tlsEnabled; } bool TlsLoadError() { - std::call_once(g_tlsOnce, InitTls); + std::lock_guard lk(g_tlsMtx); + EnsureTlsLoadedLocked(); return g_tlsError; } +bool TlsReload(std::string& err) +{ + std::lock_guard lk(g_tlsMtx); + return ApplyTlsStateLocked(!g_tlsLoaded, err); +} + // ---- TlsChannel ---- void TlsChannel::CloseHandles() @@ -249,6 +304,8 @@ bool TlsChannel::VerifyServerCert() if (sc != SEC_E_OK || !remote) return false; + // 与 TlsReload 互斥:校验期间持有 g_tlsMtx,重建时释放的旧 store/engine 不会正被使用。 + std::lock_guard lk(g_tlsMtx); if (!g_tlsStore || !g_tlsEngine) { CertFreeCertificateContext(remote); return false; @@ -273,7 +330,7 @@ bool TlsChannel::VerifyServerCert() return trusted; } -bool TlsChannel::Handshake(SOCKET sock) +bool TlsChannel::Handshake(SOCKET sock, const char* sni) { std::lock_guard lk(m_ctxMtx); CloseHandles(); // 重连时清理上一次会话(recursive 锁,此处可重入) @@ -300,8 +357,10 @@ bool TlsChannel::Handshake(SOCKET sock) SecBufferDesc outDesc = { SECBUFFER_VERSION, 1, &outBuf }; ULONG attrs = 0; - // 首次调用产生 ClientHello - sc = InitializeSecurityContextA(&m_cred, NULL, NULL, flags, 0, SECURITY_NATIVE_DREP, + // 首次调用产生 ClientHello。pszTargetName 非空时 Schannel 会把它作为 SNI 发送, + // 供反代按域名分流;证书校验仍是手动钉信任锚(SCH_CRED_MANUAL_CRED_VALIDATION), + // 不因传了名字而启用主机名校验。 + sc = InitializeSecurityContextA(&m_cred, NULL, (SEC_CHAR*)sni, flags, 0, SECURITY_NATIVE_DREP, NULL, 0, &m_ctx, &outDesc, &attrs, &tsExpiry); m_ctxValid = true; // 上下文已分配,之后必须 DeleteSecurityContext if (sc != SEC_I_CONTINUE_NEEDED && sc != SEC_E_OK) { @@ -340,7 +399,7 @@ bool TlsChannel::Handshake(SOCKET sock) outBuf = { 0, SECBUFFER_TOKEN, NULL }; outDesc = { SECBUFFER_VERSION, 1, &outBuf }; - sc = InitializeSecurityContextA(&m_cred, &m_ctx, NULL, flags, 0, SECURITY_NATIVE_DREP, + sc = InitializeSecurityContextA(&m_cred, &m_ctx, (SEC_CHAR*)sni, flags, 0, SECURITY_NATIVE_DREP, &inDesc, 0, NULL, &outDesc, &attrs, &tsExpiry); // 裁剪已消费的输入,仅保留 SECBUFFER_EXTRA 指向的未消费尾部 diff --git a/client/TlsChannel.h b/client/TlsChannel.h index ed22506..0755e54 100644 --- a/client/TlsChannel.h +++ b/client/TlsChannel.h @@ -34,15 +34,24 @@ #include #include +#include #include -// 进程级 TLS 开关:首次调用时加载信任锚(注册表或文件),返回是否启用。线程安全、幂等。 +// 进程级 TLS 开关:首次调用时加载信任锚(注册表或文件),返回是否启用。线程安全。 +// Windows 版同样是「可热切换」的:TlsReload() 之后本函数立刻反映新状态(不是 call_once)。 bool TlsEnabled(); // 信任锚已配置但加载失败(损坏/格式错误)时为 true:表示管理员已「颁发」证书, // 客户端必须拒绝连接(fail-closed),不得静默回退明文。线程安全、幂等。 bool TlsLoadError(); +// 按当前信任锚位置(注册表 settings\tls_cert → settings.ini → exe 同目录 yama-ca.pem) +// 重建 TLS 上下文并更新开关,让随后建立的新连接立刻走新传输方式(已建立的连接不受 +// 影响)。信任锚无效时不做任何改动、返回 false 并给出原因——一次坏下发不该把正在工作 +// 的客户端打死(下次启动仍 fail-closed)。线程安全:与 TlsEnabled/TlsLoadError/握手 +// 的证书校验互斥。 +bool TlsReload(std::string& err); + class TlsChannel { public: @@ -55,7 +64,9 @@ public: // 在已连通的 socket 上完成 TLS 客户端握手并校验服务端证书链。失败返回 false, // 调用方必须关闭 socket(fail-closed)。可重复调用(重连时复用同一对象)。 - bool Handshake(SOCKET sock); + // sni 非空且为域名时作为 SNI 发送,让反代(nginx)按域名分流到正确的 server 块; + // 证书校验仍只钉信任锚、不校主机名,与直接连主控端口时完全一致。 + bool Handshake(SOCKET sock, const char* sni = NULL); // 解密读取:返回 >0 的明文字节数;0 表示对端正常关闭;SOCKET_ERROR(-1) 出错。 int Recv(SOCKET sock, char* buf, int len); @@ -115,7 +126,8 @@ bool TlsLoadError(); // 服务端下发信任锚(COMMAND_TLS_ENABLE):把 PEM 正文写入 // $XDG_CONFIG_HOME/ghost/yama-ca.pem(默认 ~/.config/ghost/yama-ca.pem,无 HOME 时退回 // 程序目录),原子替换、权限 0600。写入前先解析验证,不是合法证书就整包拒绝。 -// 落盘后用 TlsReload() 立即生效(Windows 客户端仍要重启进程)。 +// 落盘后用 TlsReload() 立即生效(Windows 客户端在 COMMAND_TLS_ENABLE 里调用同一个 +// TlsReload(),两平台行为一致)。 bool TlsTrustAnchorSave(const std::string& pem, std::string& err); // 服务端撤销信任锚(COMMAND_TLS_DISABLE):删除上述配置文件(含程序目录同名文件)。 @@ -140,7 +152,8 @@ public: // 在已连通的 socket 上完成 TLS 1.2 客户端握手并按信任锚校验服务端证书链。失败返回 // false,调用方必须关闭 socket(fail-closed)。可重复调用(重连时复用同一对象)。 - bool Handshake(int sock); + // sni 非空且为域名时作为 SNI 发送(反代按域名分流);证书校验仍只钉信任锚。 + bool Handshake(int sock, const char* sni = NULL); // 解密读取:返回 >0 的明文字节数;0 表示对端正常关闭;SOCKET_ERROR(-1) 出错。 int Recv(int sock, char* buf, int len); diff --git a/client/TlsChannelLinux.cpp b/client/TlsChannelLinux.cpp index 9b77070..acc6df0 100644 --- a/client/TlsChannelLinux.cpp +++ b/client/TlsChannelLinux.cpp @@ -40,7 +40,7 @@ namespace { const char* const kAnchorName = "yama-ca.pem"; -// 进程级 TLS 状态。与 Windows 版的 call_once 不同,这里可由 TlsReload() 热切换 +// 进程级 TLS 状态。两平台都可由 TlsReload() 热切换(Windows 版改造前是 call_once) // (服务端 COMMAND_TLS_ENABLE/DISABLE 落盘后立即重建),因此用互斥量而不是 once_flag。 std::mutex g_stateMtx; // 保护下面四项 bool g_inited = false; // 首次加载已完成(含 fail-closed 基态) @@ -415,7 +415,7 @@ void TlsChannel::CloseHandles() m_ready = false; } -bool TlsChannel::Handshake(int sock) +bool TlsChannel::Handshake(int sock, const char* sni) { std::lock_guard lk(m_ctxMtx); CloseHandles(); // 重连时清理上一次会话(recursive 锁,此处可重入) @@ -438,6 +438,10 @@ bool TlsChannel::Handshake(int sock) SSL_free(ssl); return false; } + // SNI:反代(nginx)据此按域名分流到正确的 server 块。证书校验仍是自定义 store 里的 + // 信任锚(SSL_VERIFY_PEER + 不校主机名),与直连主控端口时完全一致。 + if (sni && *sni) + SSL_set_tlsext_host_name(ssl, sni); SSL_set_connect_state(ssl); // 阻塞 socket:WANT_READ / WANT_WRITE 只在记录分片等极端情形出现,重试即可。 diff --git a/client/WsChannel.h b/client/WsChannel.h new file mode 100644 index 0000000..e78ab35 --- /dev/null +++ b/client/WsChannel.h @@ -0,0 +1,355 @@ +// WsChannel.h — WebSocket 传输层(客户端侧,头文件实现,无需改工程文件) +// +// 用途:当出站被限制在 80/443/8080 等少数端口时,客户端经反代(如 nginx 的 443) +// 以 WebSocket 进入服务端。应用协议完全不变:本层只把字节流套进 WS 帧里,位置与 +// TLS 相同(TLS 之下、应用协议之上)。 +// +// 两种形态(见 common/commands.h 的 ProtoType): +// PROTO_WS 裸 WebSocket(反代把明文 upgrade 转发到主控端口) +// PROTO_WSS WebSocket over TLS(反代终止 TLS;客户端仍用既有信任锚校验证书, +// 并通过 SNI 让反代按域名分流到正确的 server 块) +// +// 线程模型:Handshake 在连接线程上、m_bConnected 置位前调用;之后 Recv 只由接收 +// 线程调用、Send 只由发送线程调用。但 Recv 里要为 ping/close 回写控制帧,收、发两个 +// 线程会同时写 socket,因此写方向必须用 m_sendMtx 串行化,且一帧的头与体要一次写出, +// 否则两帧会互相穿插、对端解帧错位。TLS 自身的互斥由 TlsChannel 负责。 +#pragma once + +#include +#include +#include +#include +#include +#include + +#ifdef _WIN32 +#include +#else +#include +#include +// 本头在 IOCPClient.h 里先于 common/commands.h 展开(后者是 Linux 版 SOCKET 的来源), +// 这里补一份同类型定义;重复 typedef 合法。 +typedef int SOCKET; +#endif +#ifndef SOCKET_ERROR +#define SOCKET_ERROR -1 +#endif + +#include "TlsChannel.h" + +class WsChannel +{ +public: + WsChannel() {} + +#ifdef YAMA_TLS_CHANNEL + // 绑定底层加密通道:WSS 指向 IOCPClient 的 TlsChannel,裸 WS 传 NULL。 + // 设置后本类的所有原始收发都经由它(或直接 send/recv)。 + void SetTls(TlsChannel* tls) { m_tls = tls; } +#endif + + // 每次连接前清理上一轮的帧状态。 + void Reset() + { + m_ready = false; + m_remaining = 0; + m_masked = false; + m_maskPos = 0; + } + + bool IsReady() const { return m_ready; } + + // 在已连通的 socket 上完成 HTTP Upgrade 握手。host 用于 Host 头(WSS 的 SNI 由 + // TlsChannel::Handshake 负责);path 是 Upgrade 请求的路径。失败时 err 给出原因。 + bool Handshake(SOCKET sock, const std::string& host, int port, const char* path, std::string* err = NULL) + { + Reset(); + + char hostPort[120] = { 0 }; + if (port == 80 || port == 443) + snprintf(hostPort, sizeof(hostPort), "%s", host.c_str()); + else + snprintf(hostPort, sizeof(hostPort), "%s:%d", host.c_str(), port); + + // Sec-WebSocket-Key 用固定值:它只用于让中间设备确认这是 WS 握手(服务端会原样 + // 做 SHA1/Base64 回显),不承担任何安全职责;真正的身份由隧道内登录和 TLS 承担。 + std::string req; + req.reserve(256); + req += "GET "; + req += path; + req += " HTTP/1.1\r\nHost: "; + req += hostPort; + req += "\r\nUpgrade: websocket\r\nConnection: Upgrade\r\n"; + req += "Sec-WebSocket-Key: dGhlIHNhbXBsZSBub25jZQ==\r\n"; + req += "Sec-WebSocket-Version: 13\r\n\r\n"; + + if (!SendAll(sock, req.data(), (int)req.size())) { + if (err) *err = "send upgrade request failed"; + return false; + } + + // 逐字节读响应头,读到空行即停(多读的字节会被当作 WS 帧,而服务端在我们发首包 + // 前不会主动发数据,所以这里读到空行为止是安全的)。 + std::string head; + bool complete = false; + char c = 0; + while (head.size() < 4096) { + int n = RawRecv(sock, &c, 1); + if (n <= 0) { + if (err) *err = "connection closed during upgrade"; + return false; + } + head += c; + if (head.size() >= 4 && head.compare(head.size() - 4, 4, "\r\n\r\n") == 0) { + complete = true; + break; + } + } + if (!complete) { + if (err) *err = "upgrade response head too large"; + return false; + } + if (head.compare(0, 12, "HTTP/1.1 101") != 0) { + if (err) { + std::string line = head.substr(0, head.find("\r\n")); + *err = "upgrade rejected: " + line; + } + return false; + } + + m_ready = true; + return true; + } + + // 读取应用层字节:>0 为读到的字节数;0 表示对端正常关闭;SOCKET_ERROR 表示出错。 + // 与 recv 语义一致,调用方按同样方式处理。 + int Recv(SOCKET sock, char* buf, int len) + { + if (!m_ready || len <= 0) + return SOCKET_ERROR; + + for (;;) { + if (m_remaining > 0) { + int want = (m_remaining < (long long)len) ? (int)m_remaining : len; + int n = RawRecv(sock, buf, want); + if (n <= 0) + return n; // 0 = 对端关闭;SOCKET_ERROR = 出错(TLS 已记录原因) + if (m_masked) { + for (int i = 0; i < n; i++) { + buf[i] ^= (char)m_mask[m_maskPos]; + m_maskPos = (m_maskPos + 1) & 3; + } + } + m_remaining -= n; + return n; + } + + unsigned char opcode = 0; + long long frameLen = 0; + if (!ReadHeader(sock, opcode, frameLen)) + return SOCKET_ERROR; + + if (opcode >= 0x8) { + // 控制帧:载荷 ≤125 字节,必须在数据帧之间处理 + char ctl[125]; + if (frameLen > (long long)sizeof(ctl)) + return SOCKET_ERROR; + if (frameLen > 0) { + if (!ReadExact(sock, ctl, (int)frameLen)) + return SOCKET_ERROR; + Unmask(ctl, (int)frameLen); + } + if (opcode == 0x8) { // close:回一个 close,然后按正常关闭处理 + (void)WriteFrame(sock, 0x8, ctl, (int)frameLen); + m_ready = false; + return 0; + } + if (opcode == 0x9) { // ping → pong + if (!WriteFrame(sock, 0xA, ctl, (int)frameLen)) + return SOCKET_ERROR; + } + // 0xA (pong) 与其它的直接忽略 + continue; + } + + if (opcode != 0x0 && opcode != 0x1 && opcode != 0x2) + return SOCKET_ERROR; + if (frameLen == 0) + continue; + + m_remaining = frameLen; + m_maskPos = 0; + } + } + + // 发送应用层字节:全部发出返回 len;否则 SOCKET_ERROR。每包一帧(FIN + binary), + // 与主控端 wsConn 的「一次 Write 一帧」对齐,保证包边界与发出时一致。 + int Send(SOCKET sock, const char* buf, int len) + { + if (!m_ready) + return SOCKET_ERROR; + if (len <= 0) + return 0; + return WriteFrame(sock, 0x2, buf, len) ? len : SOCKET_ERROR; + } + + // 是否有已收到但尚未交付的应用层字节。两处来源:帧载荷只解析了一半(m_remaining), + // 或 TLS 会话内部还压着已解密明文(WSS)。接收线程在 select 之前要优先消费, + // 否则 select 看不到这些字节会被 2 秒超时卡住。 + bool HasPending() const + { + if (m_remaining > 0) + return true; +#ifdef YAMA_TLS_CHANNEL + if (m_tls) + return m_tls->HasPending(); +#endif + return false; + } + +private: + // ---- 原始收发:有 TLS 会话时全程走 TLS,否则裸 socket ---- + + int RawRecv(SOCKET sock, char* buf, int len) + { +#ifdef YAMA_TLS_CHANNEL + if (m_tls) + return m_tls->Recv(sock, buf, len); +#endif + return ::recv(sock, buf, len, 0); + } + + int RawSend(SOCKET sock, const char* buf, int len) + { +#ifdef YAMA_TLS_CHANNEL + if (m_tls) + return m_tls->Send(sock, buf, len); +#endif + return ::send(sock, buf, len, 0); + } + + bool SendAll(SOCKET sock, const char* buf, int len) + { + int sent = 0; + while (sent < len) { + int n = RawSend(sock, buf + sent, len - sent); + if (n <= 0) + return false; + sent += n; + } + return true; + } + + bool ReadExact(SOCKET sock, void* buf, int len) + { + char* p = (char*)buf; + int got = 0; + while (got < len) { + int n = RawRecv(sock, p + got, len - got); + if (n <= 0) + return false; + got += n; + } + return true; + } + + // 读帧头(含扩展长度与掩码键)。服务端发来的帧不应带掩码,带了也照样解。 + bool ReadHeader(SOCKET sock, unsigned char& opcode, long long& frameLen) + { + unsigned char h[2] = { 0, 0 }; + if (!ReadExact(sock, h, 2)) + return false; + if (h[0] & 0x70) + return false; // 未协商扩展却置了 RSV 位 + + opcode = h[0] & 0x0F; + m_masked = (h[1] & 0x80) != 0; + frameLen = h[1] & 0x7F; + + if (frameLen == 126) { + unsigned char ext[2]; + if (!ReadExact(sock, ext, 2)) + return false; + frameLen = ((long long)ext[0] << 8) | ext[1]; + } else if (frameLen == 127) { + unsigned char ext[8]; + if (!ReadExact(sock, ext, 8)) + return false; + frameLen = 0; + for (int i = 0; i < 8; i++) + frameLen = (frameLen << 8) | ext[i]; + if (frameLen < 0) + return false; + } + if (m_masked && !ReadExact(sock, m_mask, 4)) + return false; + m_maskPos = 0; + return true; + } + + void Unmask(char* buf, int len) + { + if (!m_masked) + return; + for (int i = 0; i < len; i++) { + buf[i] ^= (char)m_mask[m_maskPos]; + m_maskPos = (m_maskPos + 1) & 3; + } + } + + // 写一帧。客户端发往服务端的帧必须带掩码(RFC 6455 §5.3)。整帧(帧头 + 掩码后的 + // 载荷)在 m_sendMtx 内一次写出:接收线程可能在同一时刻回 pong/close,若两帧各自 + // 分「头」「体」两次发送就会交错,对端从此解帧错位。 + bool WriteFrame(SOCKET sock, unsigned char opcode, const char* payload, int len) + { + unsigned char hdr[14]; + int hn = 2; + hdr[0] = (unsigned char)(0x80 | opcode); + if (len < 126) { + hdr[1] = (unsigned char)(0x80 | len); + } else if (len <= 0xFFFF) { + hdr[1] = 0x80 | 126; + hdr[2] = (unsigned char)((len >> 8) & 0xFF); + hdr[3] = (unsigned char)(len & 0xFF); + hn = 4; + } else { + hdr[1] = 0x80 | 127; + unsigned long long v = (unsigned long long)len; + for (int i = 0; i < 8; i++) + hdr[2 + i] = (unsigned char)((v >> (56 - 8 * i)) & 0xFF); + hn = 10; + } + + unsigned char mask[4]; + for (int i = 0; i < 4; i++) + mask[i] = (unsigned char)(rand() & 0xFF); + memcpy(hdr + hn, mask, 4); + hn += 4; + + std::lock_guard lock(m_sendMtx); + // 复用同一个缓冲区:发送热路径上每帧不再分配一个新 vector。 + m_frame.resize((size_t)hn + (size_t)len); + char* frame = m_frame.data(); + memcpy(frame, hdr, hn); + char* dst = frame + hn; + for (int i = 0; i < len; i++) + dst[i] = (char)(payload[i] ^ (char)mask[i & 3]); + + return SendAll(sock, frame, hn + len); + } + +#ifdef YAMA_TLS_CHANNEL + TlsChannel* m_tls = NULL; // WSS 时指向 IOCPClient 的 TLS 会话 +#endif + bool m_ready = false; + + // 写方向串行化(发送线程与接收线程的 pong/close 都会写帧),以及复用的整帧缓冲。 + std::mutex m_sendMtx; + std::vector m_frame; + + // 当前数据帧的剩余载荷长度与掩码状态(只由接收线程读写,无需加锁) + long long m_remaining = 0; + bool m_masked = false; + unsigned char m_mask[4] = { 0, 0, 0, 0 }; + int m_maskPos = 0; +}; diff --git a/common/commands.h b/common/commands.h index d9d4a09..8c6905d 100644 --- a/common/commands.h +++ b/common/commands.h @@ -825,9 +825,15 @@ enum ProtoType { PROTO_HTTP = 2, // HTTP PROTO_RANDOM = 3, // 随机 PROTO_KCP = 4, // KCP - PROTO_HTTPS = 5, // HTTPS + PROTO_WS = 5, // WebSocket(明文;反代把 upgrade 转发到主控端口) + PROTO_WSS = 6, // WebSocket over TLS(客户端经反代 443 等受限端口接入) + PROTO_HTTPS = 7, // HTTPS(未启用:生成界面从未提供该选项,故 5 可让给 WS;原值 5) }; +// WebSocket 传输的 Upgrade 路径。反代的 location 必须与这里一致(服务端默认接受任意路径, +// 该常量只决定客户端请求哪个路径,见 client/WsChannel.h)。 +#define WS_UPGRADE_PATH "/api/ws" + #define KCP_SESSION_ID 666 enum RunningType { diff --git a/docs/WebSocket_Transport_Design.md b/docs/WebSocket_Transport_Design.md new file mode 100644 index 0000000..4908be8 --- /dev/null +++ b/docs/WebSocket_Transport_Design.md @@ -0,0 +1,322 @@ +# WebSocket 传输设计(受限出站端口下经反代接入) + +> 版本:v1.0(已实现并本地验证) · 日期:2026-10-30 +> 目标:客户端的出站被限制在 80 / 443 / 8080 等少数端口,且这些端口都不归主控所有时, +> 仍能让客户端连上服务端;同时把 nginx 侧改动压到最小(只加一个 server 块或一个 location)。 +> +> 需求原文: +> 1. 「我的客户端连接服务端时端口被限制……只能借助于已有端口分流,比如 nginx 的端口。 +> 但是我的客户端目前是 TCP 流量。调研一下怎么解决」 +> 2. 「我的客户端连接到 xxx.com:6543, 但是 6543 不允许出站」 +> 3. 「6543 我可以修改,但是只能改为 80,443,8080,但是这些端口都已经在使用」 +> 4. 「B 方案更适合目前场景。xxx.com 的 nginx 配置尽量少改,不要大改」 +> +> 已核实前提:目标服务端是 **Go 版(`server/go`)**;客户端当前**都已启用 TLS**。 + +## 1. 方案选型 + +| 方案 | 做法 | 结论 | +|---|---|---| +| A. 占用 8080 | 把主控端口改到 8080 直连 | 否决:8080 已被别的应用占用 | +| **B. WebSocket over nginx 443** | 客户端把应用字节流套进 WS 帧,经 nginx `server_name` + `location /api/ws` 转发到 127.0.0.1:6543 | **采用** | +| C. 租新端口 | 换一台能出站的机器/端口 | 否决:出站白名单是客户端侧策略,换端口仍被拦 | + +B 方案的关键点:WS 升级只是一次普通 HTTP 请求,nginx 现有的 443 已经能承载; +真正的应用协议完全不变,只是「字节流外面多了一层帧」。 + +## 2. 协议号与形态 + +`common/commands.h`: + +| 值 | 枚举 | 形态 | +|---|---|---| +| 5 | `PROTO_WS` | 裸 WebSocket(明文;反代把明文 upgrade 转发到主控端口) | +| 6 | `PROTO_WSS` | WebSocket over TLS(**客户端经反代 443 接入,推荐**) | +| 7 | `PROTO_HTTPS` | 从未在生成界面出现过,故 5 让给 WS(原值 5,见下方风险) | + +`WS_UPGRADE_PATH` = `/api/ws`:客户端请求的 Upgrade 路径,反代的 `location` 必须与之对齐; +服务端默认接受任意路径,`YAMA_WS_PATH` 只用于把路径收窄。 + +传输层位置(自下而上):TCP → TLS(可选)→ **WebSocket 帧** → 既有应用协议(Shine/HELL 头、 +XOR、zstd、HTTP 伪装层)。WS 与 HTTP 伪装的 `MaskType` 互斥:选 WS 时用 `MaskTypeNone`。 + +> 兼容性:`PROTO_HTTPS` 从 5 移到 7。它在 `NewNetClient` 里本来就被直接拒绝、生成界面也从未 +> 提供,因此不存在已发布客户端带 5 号协议的情况。 + +## 3. 客户端实现 + +新增 `client/WsChannel.h`(**头文件实现**,各平台工程文件不必改动): + +- `Handshake(sock, host, port, path, &err)`:发 `GET HTTP/1.1` + `Upgrade: websocket`, + 期望 `HTTP/1.1 101`;`Sec-WebSocket-Key` 用固定值(它只用于让中间设备识别这是 WS 握手, + 安全由隧道内登录与 TLS 承担)。 +- `Send`:一次 `SendTo` 写一帧(FIN + binary,**客户端帧必须掩码**,RFC 6455 §5.3), + 与 Go 端 `wsConn.Write` 的「一次 Write 一帧」对齐,包边界与发出时一致。 +- `Recv`:在帧载荷上做流式读取(`m_remaining` 记录剩余、`m_maskPos` 记录掩码位置), + ping 自动回 pong,close 回 close 并按正常关闭返回 0,跨帧边界的应用层包不会丢。 +- `HasPending()`:帧载荷只解析了一半、或 WSS 下 TLS 会话里还压着已解密明文时返回 true, + 让接收线程在 `select` 之前优先消费(否则只能等 2 秒超时)。 +- 并发写:`Recv` 里要为 ping/close 回写控制帧,与发送线程的数据帧是两条并发的写路径。 + `WriteFrame` 用 `m_sendMtx` 串行化,并把整帧(帧头 + 掩码载荷)放进一个复用缓冲区、 + 一次 `SendAll` 写出——若头体分两次写,两帧会互相穿插,对端从此解帧错位。 + +接线(`IOCPClient.h` / `.cpp`):`ReceiveData` / `SendTo` / `HasPendingData` 三处在 +`m_useTls` 之前判 `m_useWs`;`ConnectServer` 在 socket 选项之后、`m_bConnected = TRUE` 之前 +完成 `TLS 握手 → WS 握手`,`Disconnect` 清 `m_useWs` 并 `m_ws.Reset()`。 + +### 3.1 信任模型:不换锚,靠 SNI 分流 + +客户端证书校验仍是**钉死信任锚**(Windows:`CertCreateCertificateChainEngine` + `hExclusiveRoot` +手动建链;Linux:`SSL_VERIFY_PEER` + 自定义 `X509_STORE`;均**不校主机名**)。因此 +「经 nginx 接入」不能随便换成网站自己的证书——那会校验失败。 + +于是给 nginx 一个**独立 `server_name`**(如 `ws.xxx.com`)并挂主控自己的证书,客户端靠 +**SNI** 让 nginx 选中这个 server 块: + +- Windows Schannel:`InitializeSecurityContextA(..., pszTargetName = sni, ...)`(TlsChannel.cpp) +- Linux OpenSSL:`SSL_set_tlsext_host_name(ssl, sni)`(TlsChannelLinux.cpp) +- 只在 `PROTO_WSS` 且地址是域名时传;直连主控端口时保持原样(不发明 SNI),行为与改造前一致。 + +Host 头同理:用**配置里的地址(域名)**,而不是解析后的 IP——子连接只拿到 IP,必须回到 +`CONNECT_ADDRESS::GetFirstServerIP()` 取。地址里填分号分隔的多个地址时取第一个,因此经反代 +接入只应填一个域名。 + +### 3.2 回退与 fail-closed + +传输方式只由信任锚决定(进程内缓存,服务端下发后可热重载,见 §3.3): + +| 情形 | 行为 | +|---|---| +| 有锚 + `PROTO_WSS` / 直连主控端口 | TLS 握手;**握手或证书校验失败即断开**(fail-closed) | +| **无锚 + `PROTO_WSS`** | **回退为明文 WebSocket**:客户端还没被「颁发」证书,先打通隧道;服务端下发锚后自动升级(见下) | +| 有锚但加载失败(损坏/为空) | 拒绝连接(fail-closed)——管理员已「颁发」证书,不能静默回退明文 | +| 无锚 + `PROTO_WS` | 明文(本来如此) | +| 有锚 + `PROTO_WS` | **仍是明文**(显式选择的形态,见下) | +| 平台无 TLS(macOS / Android 未定义 `YAMA_TLS_CHANNEL`)+ `PROTO_WSS` | 直接断开并打日志:没有热切换路径,回退只会让人误以为在加密 | +| WS 握手失败 | 断开,`Mprintf` 里带上服务端返回的状态行 | + +回退的判据是「本机**根本没有**信任锚」这一可观测状态,而不是握手中途失败——TLS 握手 +失败、证书链校验失败、WS 握手失败一律断开。因此中间人最多能让「尚未下发锚」的客户端 +留在明文(此时本来也没有可校验的锚),无法把已经持锚的客户端拉回明文。 + +升级路径(服务端菜单「TLS 传输 → 启用」,`COMMAND_TLS_ENABLE` + PEM 正文):客户端把锚 +落盘(Windows 注册表 `settings\tls_cert`;Linux `~/.config/ghost/yama-ca.pem`),调用 +`TlsReload()` 重建 TLS 上下文,**只在传输方式真正变化(明文 ↔ TLS)时**断开重连,之后 +的新连接自动走 WSS;仅换一张证书(仍是 TLS)不打断现有会话。两平台都是立即生效, +不再需要重启进程。撤销(`COMMAND_TLS_DISABLE`)同理反向切换。 + +> 部署含义:「先明文、之后升级为 WSS」要求同一个 `地址:端口` 既能吃明文 WS 也能吃 TLS +> ——Go 服务端的设备端口正是这样(`wrapTLS` → `wrapWebSocket` 两级嗅探,见 §4)。由 +> nginx 终止 TLS 的部署做不到:443 只收 TLS,明文回退会直接失败,这种拓扑必须先把证书 +> 配到 nginx 上再出包。(对应的两个 nginx 监听端口也无法互替,地址是出包时写死的。) + +`PROTO_WS` 的定位不变:它是**显式选择的明文形态**(§5.2 的 80 端口明文反代、内网直连), +即便客户端配了信任锚也不叠加 TLS,否则该路径永远不可达——选择 WS 是出包时的决定, +不存在远端可触发的降级。 + +### 3.3 信任锚热重载 + +`TlsEnabled()` / `TlsLoadError()` 首次调用时加载锚,之后读写的是受 `TlsReload` 保护的 +进程级状态(Windows 原来用 `std::call_once` 缓存到进程结束,无法热切换;现改为互斥量, +与 Linux 版语义一致): + +- 重建失败(锚存在但无效)→ **保持现有状态不变**,只记一行日志:一次坏下发不该打死正在 + 工作的客户端;下次启动仍会 fail-closed。 +- 重建成功 → 互换 store / 链引擎并释放旧的。Windows 的证书校验(`VerifyServerCert`) + 在整个校验过程中持同一把锁,因此旧句柄不会在别的线程手里被释放。 +- 回环验证:Linux 由 `linux/main.cpp::ApplyTlsAnchorChange`、Windows 由 + `client/KernelManager.cpp::ApplyTlsAnchorChange` 调用,两者都只在 `TlsEnabled()` + 前后值发生变化时 `Disconnect()`,让重连循环用新传输方式重新登录。 + +## 4. 服务端实现(Go) + +`server/go/server/ws.go`,在 `handleConnection` 里分层嗅探: + +``` +raw conn --wrapTLS(嗅 0x16 0x03)--> [TLS] --wrapWebSocket(嗅 "GET ")--> [WS 帧] +``` + +- 非 WS 连接:`bufferedConn` 原样返回,既有客户端零影响;嗅探用 `Peek`,不消耗字节。 +- WS 连接:解析请求头、校验 `Upgrade`/`Connection`/`Sec-WebSocket-Key`,`YAMA_WS_PATH` + 非空时再校验路径;通过后回 101 并返回 `wsConn`。 +- `wsConn`:`Read` 在帧载荷上流式返回,`Write` 一次一帧(`net.Buffers` writev 拼头与体), + 处理客户端掩码、控制帧(ping/pong/close),`Close` 发 close 帧并设 1 秒写超时。 +- 反代信任:仅当对端 IP 落在 `TrustedProxies`(默认回环)内才采信 `X-Forwarded-For` / + `X-Real-IP`,取到的真实 IP 用于 `Context.GetPeerIP()`、`hub.Device.PeerIP` 与 ConnAuth + 子连接的源 IP 绑定。 +- 真实 IP 取 `X-Forwarded-For` 的**最后一段**(nginx 的 `$proxy_add_x_forwarded_for` 把 + 它实际看到的地址追加在末尾,客户端自己塞在开头的段一律无视;与 `web/ws.go` 的 `clientIP` + 同一规则),没有 XFF 时才退回 `X-Real-IP`。 +- 每 IP 限流分两段:**直连对端**在 `acceptLoop` 里、起 goroutine 和任何嗅探读之前就计数 + (否则一个只建连接不发字节的对端能白占 goroutine 和缓冲直到 `ReadTimeout`);**反代后面 + 的设备**在 `handleConnection` 里按上报的真实 IP 计数(否则所有设备共用一个回环额度)。 + +环境变量: + +| 变量 | 说明 | +|---|---| +| `YAMA_WS_PATH` | 只接受该路径的 upgrade(空 = 任意路径) | +| `YAMA_TRUSTED_PROXIES` | 允许上报真实 IP 的代理地址,逗号分隔的 IP/CIDR,默认 `127.0.0.0/8,::1/128` | + +## 5. nginx 最小改动 + +前提:客户端地址填 `ws.xxx.com`、端口 **443**、协议选 **WebSocket+TLS**。 +DNS 加一条 `ws.xxx.com` → 同一台机器即可(共用 443,靠 SNI + Host 分流,**不动**现有站点块)。 + +```nginx +# 新增一个 server 块;证书用主控自己的那份(就是客户端钉的锚,与 6543 的 YAMA_TLS_CERT 同一文件) +server { + listen 443 ssl; # nginx ≥1.25.1 可另加一行 http2 on; + server_name ws.xxx.com; + + ssl_certificate /etc/nginx/certs/yama.crt; + ssl_certificate_key /etc/nginx/certs/yama.key; + + location /api/ws { + proxy_pass http://127.0.0.1:6543; # 主控设备端口 + proxy_http_version 1.1; + + proxy_set_header Upgrade $http_upgrade; + proxy_set_header Connection "upgrade"; + proxy_set_header Host $host; + proxy_set_header X-Real-IP $remote_addr; # 让服务端拿到设备真实 IP + proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for; + + proxy_buffering off; # 长连接必须关缓冲 + proxy_read_timeout 86400s; # 空闲心跳间隔远小于此,防止被掐 + proxy_send_timeout 86400s; + } +} +``` + +若该域名现有的 443 证书**正好就是客户端钉的那份**,可以连 server 块都不加, +只把上面 `location /api/ws { ... }` 贴进现有 443 块里。 + +### 5.1 站点与主控用两张不同证书时 + +实际部署里 `xxx.com` 的 443 证书(网站那张)和 6543 用的证书(客户端钉的锚)**是两张**。 +同一端口放两张证书没问题,nginx 按 **SNI** 选 server 块: + +| 客户端填的地址 | 客户端发的 SNI | nginx 选中 | 出示的证书 | 结果 | +|---|---|---|---|---| +| `xxx.com` | `xxx.com` | 网站块 | 网站的证书 | **握手失败**(不是钉的锚) | +| `ws.xxx.com` | `ws.xxx.com` | 主控块 | 6543 那张 | 通过 | + +所以设备端必须用**另一个名字**(`ws.xxx.com`,或任何解析到同机、nginx 里能单独成块的名字): + +- DNS:加一条 `ws.xxx.com` A 记录;若已有泛解析 `*.xxx.com` 则无需改动。 +- `ssl_certificate` 指向**与 Go 服务端 `YAMA_TLS_CERT` 完全相同的那个文件**(Go 端若配的是 + fullchain,这里也用 fullchain)。证书内容稍有不同(换过一张、少了中间证书)就会校验失败。 +- 这张证书**不需要覆盖 `ws.xxx.com`**——客户端只验链到钉死的锚,不校主机名(见 §3.1)。 +- 不要给主控块加 `default_server`,让网站块继续当默认块,其它访客行为不变。 + +自查(在服务器上执行,输出应是 6543 那张证书): + +```bash +openssl s_client -connect 127.0.0.1:443 -servername ws.xxx.com /dev/null \ + | openssl x509 -noout -subject -fingerprint -sha256 +``` + +若看到的是网站的证书,说明 SNI 没落到主控块(名字拼错、块没 reload、或客户端地址填的是 `xxx.com`)。 + +### 5.2 拿不到 `ws.xxx.com` 这种名字时:地址填 IP,用 443 的默认块 + +结论:**DNS 不是必需的**。SNI 只是 ClientHello 里的一个字符串,nginx 拿它跟 `server_name` +比,不做解析;真正需要 DNS 的只有客户端解析地址这一步。所以换一条路走: + +**客户端地址填 IP**(`1.2.3.4`,就是 `xxx.com` 解析出的那个),协议 `WebSocket+TLS`,端口 443。 +地址是 IP 字面量时,客户端按 RFC 6066 **不发 SNI**(见 §3.1 的条件),nginx 于是落到 443 的 +`default_server` 块——把主控块设成默认块即可。 + +```nginx +# 主控块:无 SNI(或 SNI 不匹配)时命中,出示客户端钉的那张证书 +server { + listen 443 ssl default_server; + server_name _; # 兜底块,不占任何真实域名 + + ssl_certificate /root/cert/yama.crt; # 与 6543 的 YAMA_TLS_CERT 同一文件 + ssl_certificate_key /root/cert/yama.key; + + location /api/ws { + proxy_pass http://127.0.0.1:6543; + proxy_http_version 1.1; + proxy_set_header Upgrade $http_upgrade; + proxy_set_header Connection "upgrade"; + proxy_set_header Host $host; + proxy_set_header X-Real-IP $remote_addr; + proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for; + proxy_buffering off; + proxy_read_timeout 86400s; + proxy_send_timeout 86400s; + } +} +``` + +现有网站块**一个字都不用改**:浏览器访问 `https://xxx.com` 时会发 SNI `xxx.com`, +按名字命中网站块,照旧拿网站的证书。 + +四个注意点: + +- **同一 `地址:端口` 只能有一个 `default_server`**。若网站块原本写了 + `listen 443 ssl default_server;`,把那里的 `default_server` 去掉(`nginx -t` 会直接报 + duplicate default server)。 +- 若默认块上设了 `ssl_reject_handshake on;`(有的加固模板会这么写),把它删掉,否则无 SNI 的连接被直接拒。 +- IPv6 的默认块是独立的:若还有 `listen [::]:443`,默认块要么同样加 `[::]:443 default_server`, + 要么保持 IPv4 即可(本客户端只连 AF_INET)。 +- 代价是地址里写死 IP:换机器/换 IP 要重出客户端。站点域名不变、只是 `xxx.com` 的 A 记录 + 换 IP 时,旧客户端会连到旧机器。 + +> 还有两条退路,代价更大,一般不用: +> - 走 **80 端口明文**:把 `location /api/ws` 贴进现有 80 块,客户端选 `PROTO_WS`。没有证书问题, +> 但整条隧道是明文(只剩既有 XOR/Shine 混淆)。 +> - 给客户端加一个「SNI/Host 单独覆盖」的配置项,让地址仍是域名、SNI 用一个不存在的名字。 +> 需要改代码和重新出客户端,只有在必须保留域名地址时才值得做。 + +要点: + +- `proxy_http_version 1.1` + 两条 `Upgrade` 头缺一不可,否则 nginx 会把升级请求当普通请求代理。 +- 关 `proxy_buffering`,否则 nginx 攒包,画面与控制会明显延迟。 +- `X-Real-IP` / `X-Forwarded-For` 只有在服务端的 `YAMA_TRUSTED_PROXIES` 覆盖 `127.0.0.1` + 时才被采信(默认已覆盖)。 + +## 6. 部署清单 + +1. 服务端:Go 版加环境变量 `YAMA_WS_PATH=/api/ws`(可选)、`YAMA_TRUSTED_PROXIES`(默认够用)。 +2. nginx:按 §5 加 server 块或 location,`nginx -t && nginx -s reload`。 +3. DNS:`ws.xxx.com` 指向该机器。 +4. 生成客户端:协议选 `WebSocket+TLS`,地址填 `ws.xxx.com`,端口 443。 +5. 日志确认: + - 服务端 `WebSocket transport on device port enabled: path=/api/ws`、 + `WebSocket device from <真实 IP>`; + - 客户端 `[WS] WebSocket 已就绪: ws.xxx.com:443/api/ws (TLS)`。 + +## 7. 验证方法(本次已做) + +- `server/go`:`go test ./...` 全绿,`ws_test.go` 覆盖升级、隧道、ping/pong、1 MiB 大帧、 + 坏握手拒绝、转发 IP(含「XFF 末尾优先 / 开头伪造被无视」)、信任代理解析,以及 + 「无换行的超长请求行在 8 KiB 上限处被拒」;`server_test.go` 覆盖直连对端在嗅探前即计入 + 每 IP 上限、回环反代被豁免。 +- 客户端:`client/WsChannel.h` 用一份**独立的 Python 最小 WS 服务端**(std lib 实现,非同一套 + 代码)交叉验证:1/5/125/126/130/4096/70000 字节全部往返一致、`Host: localhost:18080` + 正确、客户端帧带掩码、服务端主动 ping 被回 pong。 +- 并发写:另一份 Python 校验端一边每 5 帧发一次 ping、一边逐帧校验 3000×300 字节的载荷, + 客户端同时从发送线程写数据帧、从接收线程回 pong。修复前在 ~40 帧处即出现解帧错位 + (`BAD_PAYLOAD`/发送失败),修复后 3000 帧全部逐字节正确。 +- 互操作:把该测试客户端直接指向真实 Go 服务端(`-port 16543`,`YAMA_WS_PATH=/api/ws`), + 服务端日志出现 `WebSocket device from 127.0.0.1`,握手通过。 +- 信任锚热重载(Windows):独立 harness(`tlsreload_test.cpp` + 真实 `TlsChannel.cpp`,锚 + 走 exe 同目录 `yama-ca.pem`)覆盖 6 个场景全部通过:无锚→明文、有效锚→TLS、坏锚首次 + 加载→fail-closed、无锚→下发锚后重载生效(明文→TLS)、坏锚重载→保持 TLS 不中断、撤销 + 锚→回到明文。Linux 侧的热重载此前已随 `TlsTrustAnchorSave/Remove` 实现。 +- 构建:`ghost` x64/x86 Debug、`ServerDll.dll`、MFC 服务端 Debug x64、Linux + `IOCPClient.cpp` / `TlsChannelLinux.cpp` 语法检查均通过。 + +## 8. 限制与非目标 + +- **MFC 服务端(`server/2015Remote`)未实现设备端口的 WS 嗅探**:本功能目前只对接 Go 版服务端。 + MFC 侧要支持需在它的连接建立处做同样的一层 sniff。生成界面照常提供这两个协议,但生成完成的 + 提示里已注明「服务端须为 Go 版本」,避免出包后才发现连不上。 +- 裸 `PROTO_WS` 是明文,只适合内网或回环(nginx 已在同一台机器上终止 TLS 的情形用 WSS 即可)。 +- macOS / Android 客户端没有 TLS 实现,只能选 `PROTO_WS`(明文),走不了 443。 +- 经反代接入时地址只应填**一个域名**(多地址取第一个做 Host/SNI)。 +- 不改应用协议、不改 MCP、不改 Web 控制台。 diff --git a/server/2015Remote/2015RemoteDlg.cpp b/server/2015Remote/2015RemoteDlg.cpp index d135e14..297b799 100644 --- a/server/2015Remote/2015RemoteDlg.cpp +++ b/server/2015Remote/2015RemoteDlg.cpp @@ -4799,10 +4799,10 @@ void CMy2015RemoteDlg::OnExperimentTlsEnable() return; } // 二次确认:避免误点就切换被控端 TLS。 - // 生效时机因客户端而异:Windows 写注册表、下次启动生效;Linux 落盘后立即热切换并 - // 断开重连(见 client/TlsChannelLinux.cpp 的 TlsReload),正在进行的远程会话会中断。 + // 两平台都是立即生效:客户端收到命令后落盘信任锚(Windows 注册表 / Linux 配置文件)、 + // 热重载 TLS 状态(各平台 TlsChannel 的 TlsReload)并断开重连,正在进行的远程会话会中断。 if (IDYES != MessageBoxL(_T("确定对选中主机启用 TLS 传输吗?\n" - "(Linux 客户端立即生效并断线重连;Windows 客户端下次启动生效)"), + "(客户端立即生效并断线重连,正在进行的远程会话会中断)"), _T("提示"), MB_ICONQUESTION | MB_YESNO)) return; // 读取服务端证书(信任锚),随启用指令一并下发;客户端写入注册表 settings\tls_cert。 @@ -4835,7 +4835,7 @@ void CMy2015RemoteDlg::OnExperimentTlsDisable() return; } 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/BuildDlg.cpp b/server/2015Remote/BuildDlg.cpp index 1860a85..cfe09fe 100644 --- a/server/2015Remote/BuildDlg.cpp +++ b/server/2015Remote/BuildDlg.cpp @@ -609,6 +609,8 @@ void CBuildDlg::OnBnClickedOk() File.Close(); CString tip = index == IndexTestRun_DLL ? "\r\n" + _TR("提示: 请生成\"ServerDll.dll\",以便程序正常运行。") : _T(""); tip += g_ConnectAddress.protoType==PROTO_KCP ? "\n" + _TR("提示: 使用KCP协议生成服务,必须设置主控UDP协议参数为1。") : _T(""); + tip += (g_ConnectAddress.protoType==PROTO_WS || g_ConnectAddress.protoType==PROTO_WSS) ? + "\n" + _TR("提示: WebSocket协议需经反向代理(如nginx 443)转发到主控端口,地址填域名;服务端须为Go版本。") : _T(""); std::string upx; int sel = m_ComboCompress.GetCurSel(); if(sel == CLIENT_COMPRESS_UPX)upx = ReleaseUPX(); @@ -840,6 +842,9 @@ BOOL CBuildDlg::OnInitDialog() m_ComboProto.InsertStringL(PROTO_HTTP, "HTTP"); m_ComboProto.InsertStringL(PROTO_RANDOM, "随机"); m_ComboProto.InsertStringL(PROTO_KCP, "KCP"); + // 序号即 protoType,中间不能有空洞(下方 GetCurSel 直接当协议值用) + m_ComboProto.InsertStringL(PROTO_WS, "WebSocket"); + m_ComboProto.InsertStringL(PROTO_WSS, "WS+TLS"); m_ComboProto.SetCurSel(PROTO_TCP); m_ComboEncrypt.InsertStringL(PROTOCOL_SHINE, "Shine"); diff --git a/server/2015Remote/lang/de_DE.ini b/server/2015Remote/lang/de_DE.ini index 36800e5..1c86def 100644 --- a/server/2015Remote/lang/de_DE.ini +++ b/server/2015Remote/lang/de_DE.ini @@ -279,6 +279,7 @@ Web ͨÓÃ=Allgemein ¸߼¶ (·DZØÌîÏî)=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. ; ============================================ ; Service Manager @@ -2110,8 +2111,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 ´«ÊäÂð£¿\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 ´«ÊäÂð£¿\n£¨¿ͻ§¶ËÁ¢¼´ÉúЧ²¢¶ÏÏßÖØÁ¬£¬ÕýÔڽøÐеÄԶ³̻Ự»áÖжϣ©=TLS-Transport fuer die ausgewaehlten Hosts aktivieren?\n(Clients wirken sofort und verbinden sich neu; laufende Sitzungen werden unterbrochen) +ȷ¶¨ȡÏûѡÖÐÖ÷»úµÄ 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 °×Ãûµ¥=Whitelist diff --git a/server/2015Remote/lang/en_US.ini b/server/2015Remote/lang/en_US.ini index 4003063..39e303c 100644 --- a/server/2015Remote/lang/en_US.ini +++ b/server/2015Remote/lang/en_US.ini @@ -282,6 +282,7 @@ Web ͨÓÃ=General ¸߼¶ (·DZØÌîÏî)=Advanced (Optional) Ìáʾ: ¶à¸öÉÏÏߵØַÓ÷ֺŷָô£¬99¸ö×ַûÒÔÄڡ£½ö¹©ѧϰºÍ×ÔÓã¬ÑϽûÓÃÓڷǷ¨ĿµÄʹÓá£=Tip: Multiple addresses separated by semicolons, max 99 chars. +Ìáʾ: WebSocketЭÒéÐ辭·´Ïò´úÀí(Èçnginx 443)ת·¢µ½Ö÷¿ض˿ڣ¬µØַÌîÓòÃû£»·þÎñ¶ËÐëΪGo°汾¡£=Tip: WebSocket requires a reverse proxy (e.g. nginx on 443) forwarding to the control port; enter the domain as the address, and run the Go server. ; ============================================ ; Service Manager @@ -2129,8 +2130,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 ´«ÊäÂð£¿\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 ´«ÊäÂð£¿\n£¨¿ͻ§¶ËÁ¢¼´ÉúЧ²¢¶ÏÏßÖØÁ¬£¬ÕýÔڽøÐеÄԶ³̻Ự»áÖжϣ©=Enable TLS transport for the selected host?\n(Clients apply it immediately and reconnect; any active remote session is interrupted) +ȷ¶¨ȡÏûѡÖÐÖ÷»úµÄ TLS ´«ÊäÂð£¿\n£¨¿ͻ§¶ËÁ¢¼´ÉúЧ²¢¶ÏÏßÖØÁ¬£¬ÕýÔڽøÐеÄԶ³̻Ự»áÖжϣ©=Disable TLS transport for the selected host?\n(Clients apply it immediately and reconnect; any active remote session is interrupted) ·þÎñ¶ËδÆôÓà 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 dedbf81..ba85080 100644 --- a/server/2015Remote/lang/zh_TW.ini +++ b/server/2015Remote/lang/zh_TW.ini @@ -282,6 +282,7 @@ Web ͨÓÃ=ͨÓà ¸߼¶ (·DZØÌîÏî)=ßMëA (·DZØÌîí—) Ìáʾ: ¶à¸öÉÏÏߵØַÓ÷ֺŷָô£¬99¸ö×ַûÒÔÄڡ£½ö¹©ѧϰºÍ×ÔÓã¬ÑϽûÓÃÓڷǷ¨ĿµÄʹÓá£=Ìáʾ: ¶à‚€ÉϾ€λַÓ÷Ö̖·ָô£¬99‚€×ÖԪÒԃȡ£ƒH¹©ŒWÁ•ºÍ×ÔÓ㬇À½ûÓÃ춷Ƿ¨ĿµÄʹÓᣠ+Ìáʾ: WebSocketЭÒéÐ辭·´Ïò´úÀí(Èçnginx 443)ת·¢µ½Ö÷¿ض˿ڣ¬µØַÌîÓòÃû£»·þÎñ¶ËÐëΪGo°汾¡£=Ìáʾ: WebSocket …f¶¨Ð轛·´Ïò´úÀí(Èç nginx 443)ÞD°lµ½Ö÷¿ØßB½Ӳº£¬λַՈÌî¾WÓ򣻷þ„նË횞é Go °汾¡£ ; ============================================ ; Service Manager @@ -2120,8 +2121,8 @@ TLS ֤Êé/˽Կ¼ÓÔØʧ°ܣ¬¼ÓÃܹ¦ÄÜδÉúЧ¡£Çë¼ì²éÎļþ·¾¶Óë¸ñʽ£¨֤Êé PEM¡¢˽Կ PKCS#8£©¡£=‘{×C/˽è€ÝdÈëʧ”¡£¬¼ÓÃܹ¦ÄÜδÉúЧ¡£Ո™z²é™n°¸·�½Åc¸ñʽ£¨‘{×C PEM¡¢˽è€ PKCS#8£©¡£ TLS´«Êä=TLS ‚÷ݔ ȡÏûTLS=ͣÓà 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 ´«ÊäÂð£¿\n£¨¿ͻ§¶ËÁ¢¼´ÉúЧ²¢¶ÏÏßÖØÁ¬£¬ÕýÔڽøÐеÄԶ³̻Ự»áÖжϣ©=´_¶¨Œ¦ßxȡÖ÷™C†¢Óà TLS ‚÷ݔ†᣿\n£¨ÓÑô¶ËÁ¢¼´ÉúЧ�K”ྀÖØßB£¬ÕýÔÚßMÐеÄßh¶˹¤×÷ëA¶ΕþÖДࣩ +ȷ¶¨ȡÏûѡÖÐÖ÷»úµÄ TLS ´«ÊäÂð£¿\n£¨¿ͻ§¶ËÁ¢¼´ÉúЧ²¢¶ÏÏßÖØÁ¬£¬ÕýÔڽøÐеÄԶ³̻Ự»áÖжϣ©=´_¶¨ȡÏûßxȡÖ÷™CµÄ TLS ‚÷ݔ†᣿\n£¨ÓÑô¶ËÁ¢¼´ÉúЧ�K”ྀÖØßB£¬ÕýÔÚßMÐеÄßh¶˹¤×÷ëA¶ΕþÖДࣩ ·þÎñ¶ËδÆôÓà TLS ֤Ê飬Î޷¨Çл»¿ͻ§¶Ë TLS ´«Êä=ËŷþÆ÷δ†¢Óà TLS ‘{×C£¬Ÿo·¨ÇГQÓÑô¶Ë TLS ‚÷ݔ ¶Áȡ·þÎñ¶Ë TLS ֤Êéʧ°ܣ¬Î޷¨Ï·¢=×xȡËŷþÆ÷ TLS ‘{×Cʧ”¡£¬Ÿo·¨Ï°l °×Ãûµ¥=°×Ãû†Î diff --git a/server/go/cmd/main.go b/server/go/cmd/main.go index ac23f72..15c3805 100644 --- a/server/go/cmd/main.go +++ b/server/go/cmd/main.go @@ -1153,6 +1153,22 @@ func main() { log.Info("ConnAuth HMAC verification enabled for device sub-connections (YAMA_CONN_AUTH_KEY)") } + // Optional WebSocket transport on the device port, for devices that can only + // reach the server through a reverse proxy on a shared port (nginx on 443). + // YAMA_WS_PATH restricts upgrades to one request path (empty = any path). + // YAMA_TRUSTED_PROXIES lists the IPs/CIDRs allowed to report a device's real + // address via X-Forwarded-For / X-Real-IP (default: loopback only). + wsPath := strings.TrimSpace(os.Getenv("YAMA_WS_PATH")) + trustedProxies := splitCSV(os.Getenv("YAMA_TRUSTED_PROXIES")) + if wsPath != "" { + log.Info("WebSocket transport on device port enabled: path=%s", wsPath) + } else { + log.Info("WebSocket transport on device port enabled: any path") + } + if len(trustedProxies) > 0 { + log.Info("Trusting forwarded client IPs from: %s", strings.Join(trustedProxies, ", ")) + } + // Create servers for each port var servers []*server.Server for _, port := range ports { @@ -1163,6 +1179,8 @@ func main() { config.PerIPConnRateLimit = envInt("YAMA_PERIP_CONN_RATE", config.PerIPConnRateLimit) config.TLSCertFile = tlsCert config.TLSKeyFile = tlsKey + config.WSPath = wsPath + config.TrustedProxies = trustedProxies srv := server.New(config) srv.SetLogger(log.WithPrefix(fmt.Sprintf("Server:%d", port))) diff --git a/server/go/connection/context.go b/server/go/connection/context.go index 1c14c4c..6d43a4f 100644 --- a/server/go/connection/context.go +++ b/server/go/connection/context.go @@ -61,6 +61,10 @@ type Context struct { closed atomic.Bool sendLock sync.Mutex server *Manager + + // peerIPOverride replaces the address derived from RemoteAddr when a + // trusted reverse proxy reports the device's real address. + peerIPOverride string } // FlagType represents the protocol flag type @@ -156,12 +160,28 @@ func (c *Context) IsClosed() bool { // GetPeerIP returns the peer IP address func (c *Context) GetPeerIP() string { + c.mu.RLock() + override := c.peerIPOverride + c.mu.RUnlock() + if override != "" { + return override + } if host, _, err := net.SplitHostPort(c.RemoteAddr); err == nil { return host } return c.RemoteAddr } +// SetPeerIP overrides the address reported by GetPeerIP. The server uses it +// when a trusted reverse proxy reports a device's real address, so per-IP +// accounting, logging and the ConnAuth sub-connection binding all see the +// device rather than the proxy. +func (c *Context) SetPeerIP(ip string) { + c.mu.Lock() + c.peerIPOverride = ip + c.mu.Unlock() +} + // AliveTime returns how long the connection has been alive func (c *Context) AliveTime() time.Duration { return time.Since(c.OnlineTime) diff --git a/server/go/server/server.go b/server/go/server/server.go index 6b51696..45ca1b3 100644 --- a/server/go/server/server.go +++ b/server/go/server/server.go @@ -42,6 +42,17 @@ type Config struct { PerIPConnRateLimit int // max new connections per PerIPConnRateWindow per IP (0 = unlimited) PerIPConnRateWindow time.Duration // window for PerIPConnRateLimit + // WebSocket transport. Devices that can only reach the server through a + // reverse proxy on a shared port (e.g. nginx on 443) upgrade to WebSocket; + // the device port then carries the unchanged app protocol inside binary + // frames. WSPath restricts the upgrade to one request path ("" = any). + WSPath string + + // TrustedProxies lists the IPs/CIDRs whose X-Forwarded-For / X-Real-IP + // headers are believed. Only connections from these peers are allowed to + // report a different device address; empty defaults to loopback. + TrustedProxies []string + // TLSCertFile / TLSKeyFile enable optional one-way TLS on the device port. // When both are set the server loads the cert and auto-detects TLS clients // by their ClientHello; plaintext clients keep working unchanged. Both empty @@ -87,6 +98,10 @@ type Server struct { // wrapTLS consults it to sniff and wrap incoming connections. tlsCfg *tls.Config + // trustedProxies are the peers allowed to report a device's real address + // via X-Forwarded-For / X-Real-IP (the reverse proxy in front of us). + trustedProxies []*net.IPNet + running atomic.Bool wg sync.WaitGroup ctx context.Context @@ -109,6 +124,7 @@ func New(config Config) *Server { cancel: cancel, logger: logger.New(logger.DefaultConfig()).WithPrefix("Server"), } + s.trustedProxies = parseTrustedProxies(config.TrustedProxies) return s } @@ -356,38 +372,85 @@ func (s *Server) acceptLoop() { continue } - // Check connection limit before spawning goroutine + // Check connection limit before spawning goroutine. if s.manager.Count() >= s.config.MaxConnections { s.logger.Warn("Max connections reached, rejecting new connection from %s", conn.RemoteAddr()) _ = conn.Close() continue } - // Per-IP connection cap + accept rate. Rejecting here (before any - // buffer allocation or goroutine) is cheap, and a rejected device - // simply retries on its reconnect loop. - if !s.ipLimit.allow(peerIP(conn.RemoteAddr())) { - s.logger.Warn("Per-IP connection limit reached, rejecting %s", conn.RemoteAddr()) + peer := peerIP(conn.RemoteAddr()) + counted, allowed := s.limitDirectPeer(peer) + if !allowed { + s.logger.Warn("Per-IP connection limit reached, rejecting %s", peer) _ = conn.Close() continue } // Handle each connection in its own goroutine - go s.handleConnection(conn) + go s.handleConnection(conn, counted) } } -// handleConnection handles a single connection -func (s *Server) handleConnection(rawConn net.Conn) { +// limitDirectPeer applies the per-IP cap and accept rate to a freshly accepted +// peer, before the goroutine is spawned and before any sniffing read: a peer +// that opens sockets and never sends a full ClientHello / upgrade would +// otherwise hold a goroutine and a reader for up to ReadTimeout each, with no +// limit at all. Peers that are trusted proxies are exempt and report +// counted=false — every device behind a proxy arrives from the proxy's +// address, so they are limited later by the address their proxy reports. +func (s *Server) limitDirectPeer(peer string) (counted, allowed bool) { + if s.trustedProxy(peer) { + return false, true + } + if !s.ipLimit.allow(peer) { + return false, false + } + return true, true +} + +// handleConnection handles a single connection. peerCapped reports whether +// acceptLoop already counted this peer against the per-IP limiter (direct +// peers only), in which case the count is released here when the connection +// ends. +func (s *Server) handleConnection(rawConn net.Conn, peerCapped bool) { + peer := peerIP(rawConn.RemoteAddr()) + if peerCapped { + defer s.ipLimit.release(peer) + } + // Sniff and (when TLS is enabled) wrap TLS peers; plaintext passes through. conn := s.wrapTLS(rawConn) + // Sniff for a WebSocket upgrade. Proxied devices (nginx on a shared port) + // arrive as a plaintext HTTP upgrade after the proxy terminated TLS. + conn, realIP := s.wrapWebSocket(conn, peer) + if conn == nil { + return + } + + if !peerCapped { + // Proxied device: limit by the forwarded address so one device behind + // the proxy cannot consume the whole budget for everyone else. + limitIP := peer + if realIP != "" { + limitIP = realIP + } + if !s.ipLimit.allow(limitIP) { + s.logger.Warn("Per-IP connection limit reached, rejecting %s (peer %s)", limitIP, peer) + _ = conn.Close() + return + } + defer s.ipLimit.release(limitIP) + } + // Create context ctx := connection.NewContext(conn, nil) - - // Always release the per-IP slot on every exit path, including the - // manager.Add failure below (a rare accept/add race). - defer s.ipLimit.release(ctx.GetPeerIP()) + if realIP != "" { + // Report the device's real address everywhere GetPeerIP is consulted + // (per-IP accounting, logging, ConnAuth sub-connection binding). + ctx.SetPeerIP(realIP) + } // Add to manager if err := s.manager.Add(ctx); err != nil { diff --git a/server/go/server/server_test.go b/server/go/server/server_test.go index 7a88855..bd8b2cb 100644 --- a/server/go/server/server_test.go +++ b/server/go/server/server_test.go @@ -93,6 +93,35 @@ func TestPeerIP(t *testing.T) { } } +// The per-IP cap must apply to direct peers before any sniffing read, so a +// peer that connects and stays silent cannot hold unbounded goroutines and +// readers. Peers that are trusted proxies are exempt (and counted later by the +// forwarded address), because all devices behind a proxy share its address. +func TestLimitDirectPeerBeforeSniff(t *testing.T) { + cfg := DefaultConfig() + cfg.PerIPMaxConnections = 1 + cfg.PerIPConnRateLimit = 0 // concurrent cap only + s := New(cfg) + + if counted, ok := s.limitDirectPeer("203.0.113.5"); !ok || !counted { + t.Fatalf("first direct peer: counted=%v ok=%v, want true/true", counted, ok) + } + // A second silent socket from the same address must be refused outright. + if counted, ok := s.limitDirectPeer("203.0.113.5"); ok || counted { + t.Fatalf("second direct peer: counted=%v ok=%v, want false/false", counted, ok) + } + // Loopback is a trusted proxy by default: exempt from the peer cap here. + if counted, ok := s.limitDirectPeer("127.0.0.1"); !ok || counted { + t.Fatalf("trusted proxy: counted=%v ok=%v, want false/true", counted, ok) + } + + // Releasing the slot frees capacity again. + s.ipLimit.release("203.0.113.5") + if _, ok := s.limitDirectPeer("203.0.113.5"); !ok { + t.Fatal("after release the address should be allowed again") + } +} + // A peer that sends bytes which never assemble into a complete packet (here an // HTTP-mask envelope with no terminating CRLF CRLF) must be disconnected once // the per-connection buffer cap is exceeded, rather than allowed to grow it @@ -110,7 +139,8 @@ func TestHandleConnectionBufferCap(t *testing.T) { done := make(chan struct{}) go func() { - srv.handleConnection(serverConn) + // false: acceptLoop was bypassed, so the peer was not pre-counted. + srv.handleConnection(serverConn, false) close(done) }() diff --git a/server/go/server/ws.go b/server/go/server/ws.go new file mode 100644 index 0000000..96ebbf3 --- /dev/null +++ b/server/go/server/ws.go @@ -0,0 +1,517 @@ +package server + +import ( + "bufio" + "bytes" + "crypto/sha1" + "encoding/base64" + "encoding/binary" + "errors" + "fmt" + "io" + "net" + "strings" + "sync" + "time" +) + +// WebSocket transport for devices that can only reach the server through a +// reverse proxy (nginx) on a shared port such as 443. +// +// The app protocol is unchanged: the WS layer is a transparent byte-stream +// tunnel. A device connects to the proxy with a normal WebSocket upgrade, +// nginx terminates TLS and proxies the (now plaintext) upgrade to the device +// port, and this file completes the handshake and carries the existing parser +// traffic inside binary frames. +// +// Upgrade request detection happens after the TLS sniff in handleConnection, +// so a proxied wss connection (nginx terminates TLS) and a direct wss +// connection (YAMA_TLS_CERT set, client speaks wss end to end) both work. + +const ( + wsMagicGUID = "258EAFA5-E914-47DA-95CA-C5AB0DC85B11" + + wsOpContinuation = 0x0 + wsOpText = 0x1 + wsOpBinary = 0x2 + wsOpClose = 0x8 + wsOpPing = 0x9 + wsOpPong = 0xA + + // wsMaxHandshakeBytes caps the upgrade request head we are willing to + // buffer before rejecting the peer. + wsMaxHandshakeBytes = 8 * 1024 + + // wsHandshakeTimeout bounds reading the request head once "GET " was seen. + wsHandshakeTimeout = 10 * time.Second +) + +var ( + errWSProtocol = errors.New("websocket: protocol error") + errWSHandshake = errors.New("websocket: bad handshake") + + // wsUpgradePrefix identifies an HTTP request whose first token is GET. The + // app protocol never starts a connection with these bytes (its flags are + // "Shine"/"HELL"/"POST" variants), so this is unambiguous. + wsUpgradePrefix = []byte("GET ") +) + +// wrapWebSocket sniffs the already TLS-sniffed connection for an HTTP +// WebSocket upgrade. When the peer is not upgrading, conn is returned +// unchanged. When the upgrade completes, the returned net.Conn frames all +// reads/writes, and realIP carries the client address reported by a trusted +// 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)) + } + hdr, err := br.Peek(len(wsUpgradePrefix)) + _ = conn.SetReadDeadline(time.Time{}) + if err != nil { + // Peer never sent enough to identify itself; let the normal read loop + // surface EOF/timeout exactly as it would without the sniff. + return &bufferedConn{Conn: conn, r: br}, "" + } + if !bytes.Equal(hdr, wsUpgradePrefix) { + return &bufferedConn{Conn: conn, r: br}, "" + } + + req, err := readWSRequest(br, conn) + if err != nil { + s.logger.Debug("wrapWebSocket: reject %s: %v", conn.RemoteAddr(), err) + writeWSReject(conn, err) + _ = conn.Close() + return nil, "" + } + + if s.config.WSPath != "" && req.path != s.config.WSPath { + s.logger.Debug("wrapWebSocket: reject %s: path %q != %q", conn.RemoteAddr(), req.path, s.config.WSPath) + writeWSReject(conn, errWSProtocol) + _ = conn.Close() + return nil, "" + } + + accept := wsAcceptKey(req.key) + _ = conn.SetWriteDeadline(time.Now().Add(wsHandshakeTimeout)) + resp := "HTTP/1.1 101 Switching Protocols\r\n" + + "Upgrade: websocket\r\n" + + "Connection: Upgrade\r\n" + + "Sec-WebSocket-Accept: " + accept + "\r\n\r\n" + _, werr := io.WriteString(conn, resp) + _ = conn.SetWriteDeadline(time.Time{}) + if werr != nil { + _ = conn.Close() + return nil, "" + } + + realIP := "" + if s.trustedProxy(peer) { + realIP = reqForwardedIP(req.headers) + } + if realIP != "" { + s.logger.Info("WebSocket device from %s (forwarded by %s)", realIP, peer) + } else { + s.logger.Info("WebSocket device from %s", peer) + } + return newWSConn(conn, br), realIP +} + +// wsRequest is the parsed subset of an upgrade request the server needs. +type wsRequest struct { + path string + key string + headers map[string]string // lower-cased names; repeated headers joined by ", " +} + +// readWSRequest reads and validates the HTTP upgrade head. The buffered reader +// is left positioned at the first byte after the head so any frames the peer +// pipelined behind the request are preserved. +func readWSRequest(br *bufio.Reader, conn net.Conn) (*wsRequest, error) { + _ = conn.SetReadDeadline(time.Now().Add(wsHandshakeTimeout)) + defer func() { _ = conn.SetReadDeadline(time.Time{}) }() + + total := 0 + line, err := readWSLine(br, &total) + if err != nil { + return nil, err + } + parts := strings.Fields(line) + if len(parts) != 3 || parts[0] != "GET" || !strings.HasPrefix(parts[2], "HTTP/1.") { + return nil, errWSHandshake + } + req := &wsRequest{headers: make(map[string]string)} + req.path = parts[1] + if i := strings.IndexByte(req.path, '?'); i >= 0 { + req.path = req.path[:i] + } + + for { + line, err = readWSLine(br, &total) + if err != nil { + return nil, err + } + if line == "" { + break + } + name, value, ok := strings.Cut(line, ":") + if !ok { + return nil, errWSHandshake + } + name = strings.ToLower(strings.TrimSpace(name)) + value = strings.TrimSpace(value) + if prev, dup := req.headers[name]; dup { + req.headers[name] = prev + ", " + value + } else { + req.headers[name] = value + } + } + + if !headerHasToken(req.headers["upgrade"], "websocket") || + !headerHasToken(req.headers["connection"], "upgrade") { + return nil, errWSHandshake + } + req.key = req.headers["sec-websocket-key"] + if req.key == "" { + return nil, errWSHandshake + } + return req, nil +} + +// readWSLine reads one CRLF-terminated line, rejecting the peer as soon as the +// accumulated head exceeds wsMaxHandshakeBytes. The input is peer-controlled: +// a plain ReadString would buffer a newline-free line without limit. +func readWSLine(br *bufio.Reader, total *int) (string, error) { + var line []byte + for { + chunk, err := br.ReadSlice('\n') + line = append(line, chunk...) + *total += len(chunk) + if *total > wsMaxHandshakeBytes { + return "", errWSProtocol + } + if err == bufio.ErrBufferFull { + continue + } + if err != nil { + return "", err + } + return strings.TrimRight(string(line), "\r\n"), nil + } +} + +// headerHasToken reports whether a comma-separated header value contains token +// (case-insensitive), as required for Connection: keep-alive, Upgrade. +func headerHasToken(value, token string) bool { + for _, part := range strings.Split(value, ",") { + if strings.EqualFold(strings.TrimSpace(part), token) { + return true + } + } + return false +} + +// reqForwardedIP extracts the device's real address from a proxy's forwarded +// headers. The LAST X-Forwarded-For entry wins, not the first: nginx's +// $proxy_add_x_forwarded_for appends the address it accepted the connection +// from, so whatever a client prepends is ignored — the same rule web/ws.go's +// clientIP applies. Trusting the first entry would let a device rotate its key +// through the per-IP budget, the login throttle and the ConnAuth peer binding. +// X-Real-IP is only a fallback for proxies configured to set that and not XFF. +// Only IP literals are accepted, so a header cannot inject an arbitrary peer key. +func reqForwardedIP(headers map[string]string) string { + if xff := headers["x-forwarded-for"]; xff != "" { + last := strings.TrimSpace(xff[strings.LastIndexByte(xff, ',')+1:]) + if ip := headerIP(last); ip != "" { + return ip + } + } + return headerIP(headers["x-real-ip"]) +} + +func headerIP(s string) string { + s = strings.TrimSpace(s) + if i := strings.LastIndexByte(s, ':'); i > 0 && strings.Count(s, ":") == 1 { + // strip an IPv4:port pair, but leave bare IPv6 literals alone + if net.ParseIP(s[:i]) != nil { + s = s[:i] + } + } + if ip := net.ParseIP(s); ip != nil { + return ip.String() + } + return "" +} + +// wsAcceptKey computes Sec-WebSocket-Accept: base64(SHA1(key + magic GUID)). +func wsAcceptKey(key string) string { + h := sha1.New() + io.WriteString(h, key) + io.WriteString(h, wsMagicGUID) + return base64.StdEncoding.EncodeToString(h.Sum(nil)) +} + +func writeWSReject(conn net.Conn, reason error) { + status := "400 Bad Request" + body := "bad request" + if errors.Is(reason, errWSProtocol) { + body = "protocol error" + } + _ = conn.SetWriteDeadline(time.Now().Add(wsHandshakeTimeout)) + fmt.Fprintf(conn, "HTTP/1.1 %s\r\nContent-Type: text/plain\r\nContent-Length: %d\r\nConnection: close\r\n\r\n%s", + status, len(body), body) +} + +// trustedProxy reports whether peer is allowed to set the device's real IP via +// forwarded headers. Without this check any direct client could spoof its +// address and, with it, the per-IP limits and the ConnAuth peer binding. +func (s *Server) trustedProxy(peer string) bool { + ip := net.ParseIP(peer) + if ip == nil { + return false + } + for _, n := range s.trustedProxies { + if n.Contains(ip) { + return true + } + } + return false +} + +// parseTrustedProxies converts configured IPs/CIDRs into networks. An empty or +// unparsable list falls back to loopback, the only sensible default for a +// proxy running on the same host as the server. +func parseTrustedProxies(list []string) []*net.IPNet { + var nets []*net.IPNet + for _, item := range list { + item = strings.TrimSpace(item) + if item == "" { + continue + } + if !strings.Contains(item, "/") { + if ip := net.ParseIP(item); ip != nil { + bits := 32 + if ip.To4() == nil { + bits = 128 + } + item = fmt.Sprintf("%s/%d", ip.String(), bits) + } + } + if _, n, err := net.ParseCIDR(item); err == nil { + nets = append(nets, n) + } + } + if len(nets) == 0 { + _, v4, _ := net.ParseCIDR("127.0.0.0/8") + _, v6, _ := net.ParseCIDR("::1/128") + nets = append(nets, v4, v6) + } + return nets +} + +// wsConn presents a WebSocket connection as a net.Conn byte stream: each Write +// becomes one binary frame and Read returns the concatenated payload of data +// frames, transparently answering pings and closes. Frame payloads are streamed +// rather than buffered whole, so a multi-megabyte upload allocates nothing here. +type wsConn struct { + conn net.Conn + r *bufio.Reader + + writeMu sync.Mutex + closeMu sync.Mutex + closed bool + + // state of the data frame currently being read + remaining int64 + masked bool + mask [4]byte + maskPos byte +} + +func newWSConn(conn net.Conn, r *bufio.Reader) *wsConn { + return &wsConn{conn: conn, r: r} +} + +// Read implements net.Conn. +func (c *wsConn) Read(p []byte) (int, error) { + if len(p) == 0 { + return 0, nil + } + for { + if c.remaining > 0 { + n := len(p) + if int64(n) > c.remaining { + n = int(c.remaining) + } + nr, err := io.ReadFull(c.r, p[:n]) + if nr > 0 { + if c.masked { + for i := 0; i < nr; i++ { + p[i] ^= c.mask[c.maskPos] + c.maskPos = (c.maskPos + 1) & 3 + } + } + c.remaining -= int64(nr) + } + if err != nil { + return nr, err + } + return nr, nil + } + + opcode, fin, length, masked, err := c.readFrameHeader() + if err != nil { + return 0, err + } + if opcode >= 0x8 { + if !fin || length > 125 { + return 0, errWSProtocol + } + payload, err := c.readControlPayload(int(length), masked) + if err != nil { + return 0, err + } + switch opcode { + case wsOpClose: + _ = c.writeFrame(wsOpClose, payload[:min(len(payload), 125)]) + return 0, io.EOF + case wsOpPing: + if err := c.writeFrame(wsOpPong, payload); err != nil { + return 0, err + } + case wsOpPong: + // ignore + default: + return 0, errWSProtocol + } + continue + } + + switch opcode { + case wsOpBinary, wsOpText, wsOpContinuation: + default: + return 0, errWSProtocol + } + if length == 0 { + continue + } + c.remaining = length + c.masked = masked + c.maskPos = 0 + } +} + +// readFrameHeader reads and validates a frame header. Frames from the client +// are normally masked; unmasked data frames are tolerated because the only +// speakers on this port are YAMA's own clients. +func (c *wsConn) readFrameHeader() (opcode byte, fin bool, length int64, masked bool, err error) { + var hdr [2]byte + if _, err = io.ReadFull(c.r, hdr[:]); err != nil { + return + } + if hdr[0]&0x70 != 0 { + return 0, false, 0, false, errWSProtocol // RSV bits set without a negotiated extension + } + fin = hdr[0]&0x80 != 0 + opcode = hdr[0] & 0x0f + masked = hdr[1]&0x80 != 0 + length = int64(hdr[1] & 0x7f) + + switch length { + case 126: + var ext [2]byte + if _, err = io.ReadFull(c.r, ext[:]); err != nil { + return + } + length = int64(binary.BigEndian.Uint16(ext[:])) + case 127: + var ext [8]byte + if _, err = io.ReadFull(c.r, ext[:]); err != nil { + return + } + u := binary.BigEndian.Uint64(ext[:]) + if u > 1<<62 { + return 0, false, 0, false, errWSProtocol + } + length = int64(u) + } + + if masked { + if _, err = io.ReadFull(c.r, c.mask[:]); err != nil { + return + } + } + return opcode, fin, length, masked, nil +} + +func (c *wsConn) readControlPayload(n int, masked bool) ([]byte, error) { + payload := make([]byte, n) + if _, err := io.ReadFull(c.r, payload); err != nil { + return nil, err + } + if masked { + for i := range payload { + payload[i] ^= c.mask[i&3] + } + } + return payload, nil +} + +// Write implements net.Conn: one binary frame per call. The app protocol's +// sends are already whole packets (Context.Send), so this keeps writes atomic +// and lets the peer deliver each packet as it was produced. +func (c *wsConn) Write(p []byte) (int, error) { + if err := c.writeFrame(wsOpBinary, p); err != nil { + return 0, err + } + return len(p), nil +} + +// writeFrame emits one FIN frame with the given opcode. +func (c *wsConn) writeFrame(opcode byte, payload []byte) error { + var hdr [10]byte + hdr[0] = 0x80 | opcode + n := 2 + switch { + case len(payload) < 126: + hdr[1] = byte(len(payload)) + case len(payload) <= 0xffff: + hdr[1] = 126 + binary.BigEndian.PutUint16(hdr[2:], uint16(len(payload))) + n = 4 + default: + hdr[1] = 127 + binary.BigEndian.PutUint64(hdr[2:], uint64(len(payload))) + n = 10 + } + + c.writeMu.Lock() + defer c.writeMu.Unlock() + bufs := net.Buffers{hdr[:n], payload} + if _, err := bufs.WriteTo(c.conn); err != nil { + return err + } + return nil +} + +// Close sends a best-effort close frame and closes the transport. +func (c *wsConn) Close() error { + c.closeMu.Lock() + if c.closed { + c.closeMu.Unlock() + return nil + } + c.closed = true + c.closeMu.Unlock() + + _ = c.conn.SetWriteDeadline(time.Now().Add(time.Second)) + _ = c.writeFrame(wsOpClose, nil) + return c.conn.Close() +} + +func (c *wsConn) LocalAddr() net.Addr { return c.conn.LocalAddr() } +func (c *wsConn) RemoteAddr() net.Addr { return c.conn.RemoteAddr() } + +func (c *wsConn) SetDeadline(t time.Time) error { return c.conn.SetDeadline(t) } +func (c *wsConn) SetReadDeadline(t time.Time) error { return c.conn.SetReadDeadline(t) } +func (c *wsConn) SetWriteDeadline(t time.Time) error { return c.conn.SetWriteDeadline(t) } diff --git a/server/go/server/ws_test.go b/server/go/server/ws_test.go new file mode 100644 index 0000000..8e48f40 --- /dev/null +++ b/server/go/server/ws_test.go @@ -0,0 +1,407 @@ +package server + +import ( + "bufio" + "bytes" + "encoding/binary" + "errors" + "io" + "net" + "strings" + "testing" + "time" +) + +// wsTestPair dials a loopback listener, runs the server side of wrapWebSocket +// on the accepted connection, performs the upgrade handshake, and returns both +// ends. The loopback peer makes the test connection a trusted proxy, so the +// forwarded-address path is exercised too. +func wsTestPair(t *testing.T, s *Server, path string, extra map[string]string) (*wsConn, net.Conn, *bufio.Reader, string, string) { + t.Helper() + ln, err := net.Listen("tcp", "127.0.0.1:0") + if err != nil { + t.Fatalf("listen: %v", err) + } + defer ln.Close() + + type result struct { + conn net.Conn + ip string + } + resCh := make(chan result, 1) + go func() { + srv, err := ln.Accept() + if err != nil { + resCh <- result{} + return + } + conn, ip := s.wrapWebSocket(srv, peerIP(srv.RemoteAddr())) + resCh <- result{conn, ip} + }() + + cli, err := net.Dial("tcp", ln.Addr().String()) + if err != nil { + t.Fatalf("dial: %v", err) + } + t.Cleanup(func() { cli.Close() }) + _ = cli.SetDeadline(time.Now().Add(10 * time.Second)) + + // Write the upgrade request concurrently: the server blocks in its sniff + // until the first bytes arrive. + var b strings.Builder + b.WriteString("GET " + path + " HTTP/1.1\r\n") + b.WriteString("Host: yama.example.com\r\n") + b.WriteString("Upgrade: websocket\r\n") + b.WriteString("Connection: Upgrade\r\n") + b.WriteString("Sec-WebSocket-Key: dGhlIHNhbXBsZSBub25jZQ==\r\n") + b.WriteString("Sec-WebSocket-Version: 13\r\n") + for k, v := range extra { + b.WriteString(k + ": " + v + "\r\n") + } + b.WriteString("\r\n") + go func() { _, _ = io.WriteString(cli, b.String()) }() + + br := bufio.NewReader(cli) + head := &strings.Builder{} + for { + line, err := br.ReadString('\n') + if err != nil { + t.Fatalf("read response: %v", err) + } + head.WriteString(line) + if line == "\r\n" || line == "\n" { + break + } + } + + res := <-resCh + if res.conn == nil { + t.Fatalf("wrapWebSocket rejected the connection:\n%s", head.String()) + } + t.Cleanup(func() { res.conn.Close() }) + wc, ok := res.conn.(*wsConn) + if !ok { + t.Fatalf("wrapWebSocket returned %T, want *wsConn", res.conn) + } + _ = wc.SetDeadline(time.Now().Add(10 * time.Second)) + return wc, cli, br, head.String(), res.ip +} + +// clientFrame builds a masked client frame (the only form a server should see). +func clientFrame(opcode byte, payload []byte) []byte { + var hdr []byte + hdr = append(hdr, 0x80|opcode) // FIN + opcode + mask := [4]byte{0x37, 0xfa, 0x21, 0x3d} + n := len(payload) + switch { + case n < 126: + hdr = append(hdr, byte(n)|0x80) + case n <= 0xffff: + hdr = append(hdr, 126|0x80, byte(n>>8), byte(n)) + default: + hdr = append(hdr, 127|0x80) + var ext [8]byte + binary.BigEndian.PutUint64(ext[:], uint64(n)) + hdr = append(hdr, ext[:]...) + } + hdr = append(hdr, mask[:]...) + body := make([]byte, n) + for i := range payload { + body[i] = payload[i] ^ mask[i&3] + } + return append(hdr, body...) +} + +// serverFrame reads one unmasked frame produced by the server. +func serverFrame(t *testing.T, br *bufio.Reader) (byte, []byte) { + t.Helper() + var hdr [2]byte + if _, err := io.ReadFull(br, hdr[:]); err != nil { + t.Fatalf("read frame header: %v", err) + } + n := int(hdr[1] & 0x7f) + switch n { + case 126: + var ext [2]byte + if _, err := io.ReadFull(br, ext[:]); err != nil { + t.Fatalf("read ext len: %v", err) + } + n = int(binary.BigEndian.Uint16(ext[:])) + case 127: + var ext [8]byte + if _, err := io.ReadFull(br, ext[:]); err != nil { + t.Fatalf("read ext len: %v", err) + } + n = int(binary.BigEndian.Uint64(ext[:])) + } + if hdr[1]&0x80 != 0 { + t.Fatalf("server frame is masked") + } + payload := make([]byte, n) + if _, err := io.ReadFull(br, payload); err != nil { + t.Fatalf("read frame payload: %v", err) + } + return hdr[0] & 0x0f, payload +} + +func TestWebSocketUpgradeAndTunnel(t *testing.T) { + s := New(DefaultConfig()) + // A device that prepends its own XFF entry must not be believed: nginx + // appends the address it accepted the connection from on the right. + wc, cli, br, head, realIP := wsTestPair(t, s, "/api/socket", map[string]string{ + "X-Forwarded-For": "203.0.113.9, 198.51.100.20", + }) + if !strings.HasPrefix(head, "HTTP/1.1 101 ") { + t.Fatalf("unexpected response head:\n%s", head) + } + // RFC 6455 sample key -> known accept value. + if !strings.Contains(head, "Sec-WebSocket-Accept: s3pPLMBiTxaQ9kYGzzhZRbK+xOo=") { + t.Fatalf("missing/incorrect accept key:\n%s", head) + } + if realIP != "198.51.100.20" { + t.Fatalf("forwarded real IP = %q, want 198.51.100.20 (last XFF entry)", realIP) + } + + // Client -> server: app bytes arrive as a plain stream. + payload := []byte("Shine\x00\x00\x00\x03abc") + if _, err := cli.Write(clientFrame(wsOpBinary, payload)); err != nil { + t.Fatalf("write frame: %v", err) + } + got := make([]byte, len(payload)) + if _, err := io.ReadFull(wc, got); err != nil { + t.Fatalf("read tunneled bytes: %v", err) + } + if !bytes.Equal(got, payload) { + t.Fatalf("tunneled bytes = %q, want %q", got, payload) + } + + // Server -> client: each Write becomes one binary frame. + if _, err := wc.Write([]byte("pong-data")); err != nil { + t.Fatalf("write: %v", err) + } + opcode, body := serverFrame(t, br) + if opcode != wsOpBinary || string(body) != "pong-data" { + t.Fatalf("server frame = opcode %d payload %q", opcode, body) + } +} + +func TestWebSocketPingPongAndClose(t *testing.T) { + s := New(DefaultConfig()) + wc, cli, br, _, _ := wsTestPair(t, s, "/x", nil) + + // A ping is answered with a pong carrying the same payload, and the app + // stream is unaffected. + if _, err := cli.Write(clientFrame(wsOpPing, []byte("hi"))); err != nil { + t.Fatalf("write ping: %v", err) + } + readDone := make(chan error, 1) + go func() { + buf := make([]byte, 8) + _, err := wc.Read(buf) + readDone <- err + }() + opcode, body := serverFrame(t, br) + if opcode != wsOpPong || string(body) != "hi" { + t.Fatalf("pong = opcode %d payload %q", opcode, body) + } + + // A close frame ends the pending Read with EOF and is echoed. + if _, err := cli.Write(clientFrame(wsOpClose, []byte{0x03, 0xe8})); err != nil { + t.Fatalf("write close: %v", err) + } + if err := <-readDone; err != io.EOF { + t.Fatalf("Read after close = %v, want io.EOF", err) + } + opcode, _ = serverFrame(t, br) + if opcode != wsOpClose { + t.Fatalf("close echo opcode = %d", opcode) + } +} + +func TestWebSocketLargeFrameStreams(t *testing.T) { + s := New(DefaultConfig()) + wc, cli, _, _, _ := wsTestPair(t, s, "/x", nil) + + payload := bytes.Repeat([]byte("0123456789ABCDEF"), 64*1024) // 1 MiB + frame := clientFrame(wsOpBinary, payload) + go func() { _, _ = cli.Write(frame) }() + + got := make([]byte, len(payload)) + if _, err := io.ReadFull(wc, got); err != nil { + t.Fatalf("read large frame: %v", err) + } + if !bytes.Equal(got, payload) { + t.Fatalf("large frame corrupted") + } +} + +func TestWebSocketRejectsBadHandshake(t *testing.T) { + tests := []struct { + name string + req string + path string + allow bool + }{ + { + name: "not an upgrade", + req: "GET / HTTP/1.1\r\nHost: h\r\n\r\n", + }, + { + name: "missing key", + req: "GET / HTTP/1.1\r\nHost: h\r\nUpgrade: websocket\r\nConnection: Upgrade\r\n\r\n", + }, + { + name: "wrong path", + req: "GET /other HTTP/1.1\r\nHost: h\r\nUpgrade: websocket\r\nConnection: Upgrade\r\n" + + "Sec-WebSocket-Key: dGhlIHNhbXBsZSBub25jZQ==\r\n\r\n", + path: "/api/socket", + }, + { + name: "path match with query string", + req: "GET /api/socket?v=1 HTTP/1.1\r\nHost: h\r\nUpgrade: websocket\r\nConnection: Upgrade\r\nSec-WebSocket-Key: dGhlIHNhbXBsZSBub25jZQ==\r\n\r\n", + path: "/api/socket", + allow: true, + }, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + cfg := DefaultConfig() + cfg.WSPath = tt.path + s := New(cfg) + ln, err := net.Listen("tcp", "127.0.0.1:0") + if err != nil { + t.Fatalf("listen: %v", err) + } + defer ln.Close() + + resCh := make(chan net.Conn, 1) + go func() { + srv, err := ln.Accept() + if err != nil { + resCh <- nil + return + } + conn, _ := s.wrapWebSocket(srv, peerIP(srv.RemoteAddr())) + resCh <- conn + }() + + cli, err := net.Dial("tcp", ln.Addr().String()) + if err != nil { + t.Fatalf("dial: %v", err) + } + defer cli.Close() + _ = cli.SetDeadline(time.Now().Add(10 * time.Second)) + if _, err := io.WriteString(cli, tt.req); err != nil { + t.Fatalf("write: %v", err) + } + + conn := <-resCh + if tt.allow { + if conn == nil { + t.Fatalf("connection rejected, want accepted") + } + return + } + if conn != nil { + t.Fatalf("connection accepted, want rejected") + } + br := bufio.NewReader(cli) + line, err := br.ReadString('\n') + if err != nil { + t.Fatalf("read reject response: %v", err) + } + if !strings.HasPrefix(line, "HTTP/1.1 400 ") { + t.Fatalf("reject status = %q", strings.TrimSpace(line)) + } + }) + } +} + +func TestWSForwardedIP(t *testing.T) { + tests := []struct { + name string + headers map[string]string + want string + }{ + {"x-real-ip", map[string]string{"x-real-ip": "198.51.100.7"}, "198.51.100.7"}, + {"xff single", map[string]string{"x-forwarded-for": "198.51.100.8"}, "198.51.100.8"}, + // The rightmost entry is the one the trusted proxy appended; a device + // that prepends a made-up address must not be able to choose its key. + {"xff chain takes rightmost", map[string]string{"x-forwarded-for": "198.51.100.9, 10.0.0.1, 10.0.0.2"}, "10.0.0.2"}, + {"spoofed xff head ignored", map[string]string{"x-forwarded-for": "1.2.3.4, 198.51.100.10"}, "198.51.100.10"}, + {"xff wins over x-real-ip", map[string]string{"x-real-ip": "198.51.100.7", "x-forwarded-for": "198.51.100.9"}, "198.51.100.9"}, + {"garbage rightmost falls back", map[string]string{"x-forwarded-for": "198.51.100.11, not-an-ip"}, ""}, + {"x-real-ip fallback", map[string]string{"x-real-ip": "198.51.100.7", "x-forwarded-for": "not-an-ip"}, "198.51.100.7"}, + {"v4 with port", map[string]string{"x-real-ip": "198.51.100.7:5555"}, "198.51.100.7"}, + {"ipv6 literal", map[string]string{"x-real-ip": "2001:db8::1"}, "2001:db8::1"}, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + if got := reqForwardedIP(tt.headers); got != tt.want { + t.Errorf("reqForwardedIP(%v) = %q, want %q", tt.headers, got, tt.want) + } + }) + } +} + +// A header line that never ends must be rejected as soon as the handshake +// budget is exhausted, not buffered until the process runs out of memory. +func TestReadWSLineBounded(t *testing.T) { + br := bufio.NewReader(bytes.NewReader(bytes.Repeat([]byte{'A'}, 1<<20))) + total := 0 + _, err := readWSLine(br, &total) + if !errors.Is(err, errWSProtocol) { + t.Fatalf("err = %v, want errWSProtocol", err) + } + if total > wsMaxHandshakeBytes+br.Size() { + t.Fatalf("read %d bytes, want at most %d", total, wsMaxHandshakeBytes+br.Size()) + } + + // A normal line still parses. + br = bufio.NewReader(strings.NewReader("GET /api/ws HTTP/1.1\r\n")) + total = 0 + line, err := readWSLine(br, &total) + if err != nil || line != "GET /api/ws HTTP/1.1" { + t.Fatalf("line = %q, err = %v", line, err) + } +} + +func TestTrustedProxies(t *testing.T) { + s := New(DefaultConfig()) + if !s.trustedProxy("127.0.0.1") || !s.trustedProxy("::1") { + t.Fatal("loopback must be trusted by default") + } + if s.trustedProxy("203.0.113.9") { + t.Fatal("public peer must not be trusted by default") + } + + cfg := DefaultConfig() + cfg.TrustedProxies = []string{"10.0.0.0/8", "203.0.113.9"} + s = New(cfg) + if !s.trustedProxy("10.1.2.3") || !s.trustedProxy("203.0.113.9") { + t.Fatal("configured proxies must be trusted") + } + if s.trustedProxy("127.0.0.1") { + t.Fatal("an explicit list replaces the loopback defaults") + } +} + +func TestHeaderHasToken(t *testing.T) { + tests := []struct { + value string + token string + want bool + }{ + {"Upgrade", "upgrade", true}, + {"keep-alive, Upgrade", "upgrade", true}, + {"upgrade, keep-alive", "upgrade", true}, + {"keep-alive", "upgrade", false}, + {"", "upgrade", false}, + } + for _, tt := range tests { + if got := headerHasToken(tt.value, tt.token); got != tt.want { + t.Errorf("headerHasToken(%q, %q) = %v, want %v", tt.value, tt.token, got, tt.want) + } + } +} -- 2.43.0 From cc891e3670dfbcf9bcdcdc98f1f243969793c295 Mon Sep 17 00:00:00 2001 From: yuanyuanxiang <962914132@qq.com> Date: Fri, 30 Oct 2026 17:00:28 +0100 Subject: [PATCH 2/5] Feature: Sniff WebSocket upgrades on the MFC server's device port --- docs/WebSocket_Transport_Design.md | 71 ++- server/2015Remote/2015Remote_vs2015.vcxproj | 2 + .../2015Remote_vs2015.vcxproj.filters | 2 + server/2015Remote/BuildDlg.cpp | 2 +- server/2015Remote/IOCPServer.cpp | 297 ++++++++++- server/2015Remote/IOCPServer.h | 5 + server/2015Remote/Server.h | 26 + server/2015Remote/ServerWsSession.cpp | 481 ++++++++++++++++++ server/2015Remote/ServerWsSession.h | 67 +++ server/2015Remote/lang/en_US.ini | 2 +- server/2015Remote/lang/zh_TW.ini | 2 +- 11 files changed, 925 insertions(+), 32 deletions(-) create mode 100644 server/2015Remote/ServerWsSession.cpp create mode 100644 server/2015Remote/ServerWsSession.h diff --git a/docs/WebSocket_Transport_Design.md b/docs/WebSocket_Transport_Design.md index 4908be8..c8dd3a7 100644 --- a/docs/WebSocket_Transport_Design.md +++ b/docs/WebSocket_Transport_Design.md @@ -11,7 +11,8 @@ > 3. 「6543 我可以修改,但是只能改为 80,443,8080,但是这些端口都已经在使用」 > 4. 「B 方案更适合目前场景。xxx.com 的 nginx 配置尽量少改,不要大改」 > -> 已核实前提:目标服务端是 **Go 版(`server/go`)**;客户端当前**都已启用 TLS**。 +> 已核实前提:客户端当前**都已启用 TLS**。服务端两套实现均可接入:Go 版(`server/go`) +> 与 MFC 版(`server/2015Remote`,见 §4.2)。 ## 1. 方案选型 @@ -128,7 +129,9 @@ Host 头同理:用**配置里的地址(域名)**,而不是解析后的 I `client/KernelManager.cpp::ApplyTlsAnchorChange` 调用,两者都只在 `TlsEnabled()` 前后值发生变化时 `Disconnect()`,让重连循环用新传输方式重新登录。 -## 4. 服务端实现(Go) +## 4. 服务端实现 + +### 4.1 Go 服务端(`server/go`) `server/go/server/ws.go`,在 `handleConnection` 里分层嗅探: @@ -158,6 +161,40 @@ raw conn --wrapTLS(嗅 0x16 0x03)--> [TLS] --wrapWebSocket(嗅 "GET ")--> [WS | `YAMA_WS_PATH` | 只接受该路径的 upgrade(空 = 任意路径) | | `YAMA_TRUSTED_PROXIES` | 允许上报真实 IP 的代理地址,逗号分隔的 IP/CIDR,默认 `127.0.0.0/8,::1/128` | +### 4.2 MFC 服务端(`server/2015Remote`) + +MFC 服务端此前就在设备端口上嗅探 TLS(首字节 `0x16 0x03` → `ServerTlsSession`), +WS 叠在同一层状态机之上,**与 TLS 是分层而不是并列**(`wss` = TLS 里的 WebSocket): + +``` +子套接字 -- TLS 嗅探 --+-- 明文 --+-- "GET " 嗅探 --+-- WS 帧 --+--> ParseReceivedData + | | | + +-- TLS ---+----------------+(WSS 时帧在解密的明文里判) +``` + +新增两个文件,其余改动都在既有握手/收发路径上: + +| 文件 | 职责 | +|---|---| +| `ServerWsSession.h/.cpp` | 每连接 WS 会话:升级握手(逐行解析、8 KiB 上限、`Sec-WebSocket-Accept`)、流式解帧(不整帧缓冲,大帧按片交付)、控制帧(ping→pong、close 回显后断开)、转发真实 IP | +| `IOCPServer.cpp` | `WsHandshakeThreadProc` / `StartWsHandshake`(专用阻塞线程,与 TLS 握手线程同一模式)、`DispatchPlain`(明文/WSS 共用入口)、`OnClientPreSending` 里的「先封帧、再 TLS 加密」 | + +- 状态机:`ServerWsState { WS_Undecided → WS_Handshaking → WS_Ready | WS_None }` 与既有的 + `ServerTlsState` 并存;`CONTEXT_OBJECT` 复用(`InitMember`)时一并复位并释放会话。 +- 判定点:**明文的第一段有 ≥6 字节**才开始分类(与 ClientHello 嗅探同一下限), + 避免把「请求头还没到齐」误判掉;阈值内的字节攒在 `tlsPreClassify` 里。 +- 升级线程与 TLS 握手线程同构:`FIONBIO=0`(该套接字常是非阻塞的,`ioctlsocket` 会以 + `WSAEINVAL` 失败),15 s 收发超时,遇 `WSAEWOULDBLOCK` 用 `select` 等可读/可写再试; + 线程持有一枚 `IoRefCount`,结束后把 socket 交还 IOCP(`PostRecv`)。升级响应之后同批 + 字节里若已带客户端首帧(WSS 分批解密时常见),先在交还前喂给解帧路径。 +- 发送方向:`OnClientPreSending` 里把本次新追加的尾部封成一帧(`TruncateBuffer` + + `WriteBuffer`,与既有的「只加密新尾部」同一手法规避在途数据),然后才走 TLS 加密; + 控制帧应答(pong / close 回显)走同一条发送路径(`SendWsReplies`,持 `SendLock`)。 +- 反代真实 IP:**仅当直接对端是回环地址**时才采信 `X-Forwarded-For` 的**最后一段** + (`X-Real-IP` 兜底),且必须是 IP 字面量;结果写回 `PeerName`,在线列表、封禁与 + 白名单看到的就是设备本身。非回环对端的转发头一律忽略(防伪造)。 +- 既有客户端零影响:非 `GET ` 首包在攒够 6 字节后原样进入 `ParseReceivedData`。 + ## 5. nginx 最小改动 前提:客户端地址填 `ws.xxx.com`、端口 **443**、协议选 **WebSocket+TLS**。 @@ -281,13 +318,16 @@ server { ## 6. 部署清单 -1. 服务端:Go 版加环境变量 `YAMA_WS_PATH=/api/ws`(可选)、`YAMA_TRUSTED_PROXIES`(默认够用)。 +1. 服务端:**无需改动**即可接受 WS 升级(两套实现都是同端口嗅探)。Go 版可选加环境变量 + `YAMA_WS_PATH=/api/ws`(不设 = 任意路径)、`YAMA_TRUSTED_PROXIES`(默认够用);MFC 版 + 不校验路径,转发头只信回环对端(§4.2)。 2. nginx:按 §5 加 server 块或 location,`nginx -t && nginx -s reload`。 3. DNS:`ws.xxx.com` 指向该机器。 4. 生成客户端:协议选 `WebSocket+TLS`,地址填 `ws.xxx.com`,端口 443。 5. 日志确认: - - 服务端 `WebSocket transport on device port enabled: path=/api/ws`、 - `WebSocket device from <真实 IP>`; + - Go 服务端 `WebSocket transport on device port enabled: path=/api/ws`、 + `WebSocket device from <真实 IP>`;MFC 服务端 `[WS] ... upgraded via reverse proxy, + real client <真实 IP>`(仅回环对端且带转发头时才有这一行); - 客户端 `[WS] WebSocket 已就绪: ws.xxx.com:443/api/ws (TLS)`。 ## 7. 验证方法(本次已做) @@ -304,6 +344,18 @@ server { (`BAD_PAYLOAD`/发送失败),修复后 3000 帧全部逐字节正确。 - 互操作:把该测试客户端直接指向真实 Go 服务端(`-port 16543`,`YAMA_WS_PATH=/api/ws`), 服务端日志出现 `WebSocket device from 127.0.0.1`,握手通过。 +- MFC 服务端(Debug x64,设备端口 6543,同时开着 TLS): + - 独立 Python 最小客户端对 6543 跑 9 项断言全通过:101 状态行、`Sec-WebSocket-Accept` + 与 `base64(sha1(key+GUID))` 一致、`Upgrade`/`Connection` 回显、ping→pong(服务端帧不带 + 掩码)、数据帧后连接保持、close 回显、**升级请求跨两个 TCP 段**仍升级成功、**帧与升级 + 请求粘在同一段**里也能解出;同一套断言加 `ssl` 包一层(TLSv1.2 ECDHE-RSA-AES256-GCM) + 再跑一遍全通过,即 WSS。 + - 转发头:`X-Forwarded-For: 198.51.100.7, 203.0.113.9` 时日志记 + `[WS] 127.0.0.1 upgraded via reverse proxy, real client 203.0.113.9`(取最后一段)。 + - 端到端:让 Debug 服务端向真实客户端下发它自己的 payload(其中配置为 `PROTO_WS`), + 客户端日志 `[WS] WebSocket 已就绪: 127.0.0.1:6543/api/ws` → 登录 → 收到主控配置 + (1000 字节)→ 上线列表出现该设备并长时间保活(心跳往返即双向数据帧都在工作)。 + - 信任锚热重载(Windows):独立 harness(`tlsreload_test.cpp` + 真实 `TlsChannel.cpp`,锚 走 exe 同目录 `yama-ca.pem`)覆盖 6 个场景全部通过:无锚→明文、有效锚→TLS、坏锚首次 加载→fail-closed、无锚→下发锚后重载生效(明文→TLS)、坏锚重载→保持 TLS 不中断、撤销 @@ -313,9 +365,12 @@ server { ## 8. 限制与非目标 -- **MFC 服务端(`server/2015Remote`)未实现设备端口的 WS 嗅探**:本功能目前只对接 Go 版服务端。 - MFC 侧要支持需在它的连接建立处做同样的一层 sniff。生成界面照常提供这两个协议,但生成完成的 - 提示里已注明「服务端须为 Go 版本」,避免出包后才发现连不上。 +- **MFC 服务端与 Go 服务端都已实现设备端口的 WS 嗅探**,生成界面里的协议选项两边通用; + 差别只在细节:MFC 侧不校验 upgrade 路径(`/api/ws` 只是客户端习惯,反代转到哪个路径都行), + 也没有每 IP 限流的「直连/反代两段」细分(沿用既有的按连接数计)。 +- MFC 侧的转发头信任范围是**回环对端**(与 Go 的默认 `TrustedProxies` 一致);反代与服务端 + 不同机部署时,要么让反代用 Proxy Protocol v2(既有的 `ParseProxyProtocolV2` 会先改 + `PeerName`),要么把反代地址加进白名单逻辑——目前的 WS 层不会采信非回环对端的转发头。 - 裸 `PROTO_WS` 是明文,只适合内网或回环(nginx 已在同一台机器上终止 TLS 的情形用 WSS 即可)。 - macOS / Android 客户端没有 TLS 实现,只能选 `PROTO_WS`(明文),走不了 443。 - 经反代接入时地址只应填**一个域名**(多地址取第一个做 Host/SNI)。 diff --git a/server/2015Remote/2015Remote_vs2015.vcxproj b/server/2015Remote/2015Remote_vs2015.vcxproj index 37e11b0..671ae92 100644 --- a/server/2015Remote/2015Remote_vs2015.vcxproj +++ b/server/2015Remote/2015Remote_vs2015.vcxproj @@ -353,6 +353,7 @@ + @@ -466,6 +467,7 @@ + diff --git a/server/2015Remote/2015Remote_vs2015.vcxproj.filters b/server/2015Remote/2015Remote_vs2015.vcxproj.filters index 2a652e0..d71107a 100644 --- a/server/2015Remote/2015Remote_vs2015.vcxproj.filters +++ b/server/2015Remote/2015Remote_vs2015.vcxproj.filters @@ -22,6 +22,7 @@ + @@ -159,6 +160,7 @@ + diff --git a/server/2015Remote/BuildDlg.cpp b/server/2015Remote/BuildDlg.cpp index cfe09fe..50d5ae4 100644 --- a/server/2015Remote/BuildDlg.cpp +++ b/server/2015Remote/BuildDlg.cpp @@ -610,7 +610,7 @@ void CBuildDlg::OnBnClickedOk() CString tip = index == IndexTestRun_DLL ? "\r\n" + _TR("提示: 请生成\"ServerDll.dll\",以便程序正常运行。") : _T(""); tip += g_ConnectAddress.protoType==PROTO_KCP ? "\n" + _TR("提示: 使用KCP协议生成服务,必须设置主控UDP协议参数为1。") : _T(""); tip += (g_ConnectAddress.protoType==PROTO_WS || g_ConnectAddress.protoType==PROTO_WSS) ? - "\n" + _TR("提示: WebSocket协议需经反向代理(如nginx 443)转发到主控端口,地址填域名;服务端须为Go版本。") : _T(""); + "\n" + _TR("提示: WebSocket协议需经反向代理(如nginx 443)转发到主控端口,地址填域名。") : _T(""); std::string upx; int sel = m_ComboCompress.GetCurSel(); if(sel == CLIENT_COMPRESS_UPX)upx = ReleaseUPX(); diff --git a/server/2015Remote/IOCPServer.cpp b/server/2015Remote/IOCPServer.cpp index 22d8250..2b84904 100644 --- a/server/2015Remote/IOCPServer.cpp +++ b/server/2015Remote/IOCPServer.cpp @@ -4,6 +4,7 @@ #include "common/IPWhitelist.h" #include "common/IPBlacklist.h" #include "ServerTlsSession.h" +#include "ServerWsSession.h" #include #include @@ -947,26 +948,33 @@ DWORD WINAPI IOCPServer::TlsHandshakeThreadProc(LPVOID lParam) // 注意顺序:解析仍在本线程持有引用期间完成(对象不会在这段窗口里被回收); // 释放引用之后才允许任何可能 RemoveStaleContext 的动作(#215)。 + bool wsTookOver = false; if (ok && !pendingPlain.empty()) { // 与工作线程同样的解压上下文,只是现建现用(首包只解析这一批)。 + // 走 DispatchPlain:WSS 的首个明文就是 "GET /api/ws HTTP/1.1...", + // 由它判定升级并交给 WS 升级线程(此时本线程不能再 PostRecv)。 ZSTD_DCtx* dctx = ZSTD_createDCtx(); z_stream z = {}; inflateInit2(&z, 15); - ok = ctx->IsRemoved.load(std::memory_order_acquire) ? TRUE - : ParseReceivedData(ctx, pendingPlain.data(), (DWORD)pendingPlain.size(), - This->m_NotifyProc, dctx, &z); + int r = ctx->IsRemoved.load(std::memory_order_acquire) ? 1 + : This->DispatchPlain(ctx, pendingPlain.data(), (DWORD)pendingPlain.size(), dctx, &z); inflateEnd(&z); ZSTD_freeDCtx(dctx); - if (!ok) { + if (r < 0) { + ok = false; Mprintf("[TLS] pending first packet parse failed for %s (closing)\n", ctx->GetPeerName().c_str()); + } else if (r == 0) { + wsTookOver = true; } } ctx->IoRefCount.fetch_sub(1); if (ok) { - This->PostRecv(ctx); // 交还 IOCP 接收 + if (!wsTookOver) { + This->PostRecv(ctx); // 交还 IOCP 接收 + } } else { Mprintf("[TLS] handshake failed for %s (fail-closed)\n", ctx->GetPeerName().c_str()); This->RemoveStaleContext(ctx); @@ -1007,6 +1015,121 @@ BOOL IOCPServer::StartTlsHandshake(CONTEXT_OBJECT* ContextObject) return TRUE; } +// 握手线程参数:把触发判定的首批明文("GET ...")与连接上下文一起移交。 +struct WsHandshakeParam { + IOCPServer* server; + CONTEXT_OBJECT* ctx; + std::vector initial; +}; + +// 与 TlsHandshakeThreadProc 同一模式(方案 A):升级期间用一个阻塞线程独占 socket, +// 完成后把连接交还 IOCP 接收(PostRecv)。线程持有 ctx 的一枚 IoRefCount,结束时释放。 +DWORD WINAPI IOCPServer::WsHandshakeThreadProc(LPVOID lParam) +{ + WsHandshakeParam* p = (WsHandshakeParam*)lParam; + IOCPServer* This = p->server; + CONTEXT_OBJECT* ctx = p->ctx; + std::vector initial = std::move(p->initial); + delete p; + + if (ctx->IsRemoved.load(std::memory_order_acquire)) { + ctx->IoRefCount.fetch_sub(1); + return 0; + } + + // 与 TLS 握手线程相同的 socket 准备工作:尽量切回阻塞,并加超时,避免慢速对端拖住线程。 + u_long nb = 0; + if (ioctlsocket(ctx->sClientSocket, FIONBIO, &nb) == SOCKET_ERROR) + Mprintf("[WS] handshake: ioctlsocket(FIONBIO=0) failed err=%d\n", WSAGetLastError()); + int tmo = 15000; // 15s 升级超时 + setsockopt(ctx->sClientSocket, SOL_SOCKET, SO_RCVTIMEO, (const char*)&tmo, sizeof(tmo)); + setsockopt(ctx->sClientSocket, SOL_SOCKET, SO_SNDTIMEO, (const char*)&tmo, sizeof(tmo)); + + // wss = TLS 里的 WebSocket:TLS 会话(若有)在这里只做字节加解密,升级请求与帧都是明文。 + bool tlsReady = (ctx->tlsState.load(std::memory_order_acquire) == TLS_Ready); + std::vector pending; + std::string err; + bool ok = (ctx->ws != NULL) && + ctx->ws->Handshake(ctx->sClientSocket, tlsReady ? ctx->tls : NULL, initial, + pending, ctx->GetPeerName(), &err); + if (!ok) { + Mprintf("[WS] upgrade failed for %s: %s (fail-closed)\n", + ctx->GetPeerName().c_str(), err.c_str()); + } + + bool wsTookOver = false; + if (ok) { + // 反代同机部署时,直接对端是回环地址,升级请求里的转发头才可信;据此把对端地址 + // 改写成真实客户端 IP,使在线列表 / 封禁 / 白名单看到的是设备而不是反代。 + const std::string& fwd = ctx->ws->ForwardedIP(); + if (!fwd.empty()) { + Mprintf("[WS] %s upgraded via reverse proxy, real client %s\n", + ctx->GetPeerName().c_str(), fwd.c_str()); + 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()); + } + } + } else { + ctx->wsState.store(WS_None, std::memory_order_release); + } + + ctx->IoRefCount.fetch_sub(1); + + if (ok) { + This->PostRecv(ctx); // 交还 IOCP 接收 + } else { + This->RemoveStaleContext(ctx); + } + return 0; +} + +// 判定为 WS 升级请求后:CAS 认领状态、创建会话、预支一枚 IoRefCount、启动升级线程。 +BOOL IOCPServer::StartWsHandshake(CONTEXT_OBJECT* ContextObject, const std::vector& initial) +{ + int expected = WS_Undecided; + if (!ContextObject->wsState.compare_exchange_strong(expected, WS_Handshaking, + std::memory_order_acq_rel)) { + return FALSE; // 已有别的线程认领(或状态机异常),不做二次升级 + } + + if (ContextObject->ws == NULL) { + ContextObject->ws = new ServerWsSession(); + } + + WsHandshakeParam* p = new WsHandshakeParam; + p->server = this; + p->ctx = ContextObject; + p->initial = initial; + + // 预支引用:升级线程结束时释放。此引用保证升级期间对象不被回收。 + ContextObject->IoRefCount.fetch_add(1); + + HANDLE h = CreateThread(NULL, 0, WsHandshakeThreadProc, p, 0, NULL); + if (h == NULL) { + ContextObject->IoRefCount.fetch_sub(1); + ContextObject->FreeWs(); + ContextObject->wsState.store(WS_None, std::memory_order_release); + return FALSE; + } + CloseHandle(h); + return TRUE; +} + BOOL IOCPServer::OnClientReceiving(PCONTEXT_OBJECT ContextObject, DWORD dwTrans, ZSTD_DCtx* ctx, z_stream* z) { int st = ContextObject->tlsState.load(std::memory_order_acquire); @@ -1040,15 +1163,21 @@ BOOL IOCPServer::OnClientReceiving(PCONTEXT_OBJECT ContextObject, DWORD dwTrans } // 明文:把嗅探阶段攒下的字节回放给现有解析路径,然后清空缓冲。 + // 首包若以 "GET " 开头则由 DispatchPlain 判定为 WebSocket 升级。 ContextObject->tlsState.store(TLS_Plain, std::memory_order_release); std::vector replay = std::move(ContextObject->tlsPreClassify); ContextObject->tlsPreClassify.clear(); - if (FALSE == ParseReceivedData(ContextObject, replay.data(), (DWORD)replay.size(), m_NotifyProc, ctx, z)) { - ContextObject->IoRefCount.fetch_sub(1); - RemoveStaleContext(ContextObject); - return -2; + { + int r = DispatchPlain(ContextObject, replay.data(), (DWORD)replay.size(), ctx, z); + if (r < 0) { + ContextObject->IoRefCount.fetch_sub(1); + RemoveStaleContext(ContextObject); + return -2; + } + if (r > 0) { + PostRecv(ContextObject); + } } - PostRecv(ContextObject); return TRUE; } @@ -1069,17 +1198,20 @@ BOOL IOCPServer::OnClientReceiving(PCONTEXT_OBJECT ContextObject, DWORD dwTrans PostRecv(ContextObject); // 本轮无完整明文(TLS 记录分片/握手告警),继续收 return TRUE; } - if (FALSE == ParseReceivedData(ContextObject, plain.data(), (DWORD)plain.size(), m_NotifyProc, ctx, z)) { + int r = DispatchPlain(ContextObject, plain.data(), (DWORD)plain.size(), ctx, z); + if (r < 0) { ContextObject->IoRefCount.fetch_sub(1); RemoveStaleContext(ContextObject); return -2; } - PostRecv(ContextObject); + if (r > 0) { + PostRecv(ContextObject); + } return TRUE; } - // TLS_Handshaking:握手线程独占 socket,正常不应出现 IORead;若出现属异常,fail-closed。 - if (st == TLS_Handshaking) { + // TLS_Handshaking / WS_Handshaking:握手线程独占 socket,正常不应出现 IORead;若出现属异常,fail-closed。 + if (st == TLS_Handshaking || ContextObject->wsState.load(std::memory_order_acquire) == WS_Handshaking) { Mprintf("[TLS] unexpected IORead during handshake for %s (closing)\n", ContextObject->GetPeerName().c_str()); ContextObject->IoRefCount.fetch_sub(1); @@ -1087,13 +1219,115 @@ BOOL IOCPServer::OnClientReceiving(PCONTEXT_OBJECT ContextObject, DWORD dwTrans return -2; } - // TLS_Plain:明文直通(原路径)。 - if (FALSE == ParseReceivedData(ContextObject, (PBYTE)ContextObject->szBuffer, dwTrans, m_NotifyProc, ctx, z)) { - ContextObject->IoRefCount.fetch_sub(1); - RemoveStaleContext(ContextObject); - return -2; + // TLS_Plain:明文直通(原路径)。WS 连接在这里先解帧。 + { + int r = DispatchPlain(ContextObject, (const BYTE*)ContextObject->szBuffer, dwTrans, ctx, z); + if (r < 0) { + ContextObject->IoRefCount.fetch_sub(1); + RemoveStaleContext(ContextObject); + return -2; + } + if (r > 0) { + PostRecv(ContextObject); + } + return TRUE; + } +} + +// 分发一段应用层字节(明文,或 TLS 解密后的明文)。 +// 返回 1 = 已处理完,调用方可以 PostRecv 继续收;0 = WS 升级线程已接管 socket,不要 PostRecv; +// -1 = 出错,调用方关闭连接。 +// +// WS_Undecided 阶段先攒够 6 字节再判定(与 ClientHello 嗅探同样的下限):首个明文分片 +// 可能只有请求头的一部分,按前缀能不能判死都不安全。 +int IOCPServer::DispatchPlain(CONTEXT_OBJECT* ContextObject, const BYTE* data, DWORD len, + ZSTD_DCtx* ctx, z_stream* z) +{ + int ws = ContextObject->wsState.load(std::memory_order_acquire); + if (ws == WS_Ready) { + return DispatchWsFrameData(ContextObject, data, len, ctx, z) ? 1 : -1; + } + if (len == 0) { + return 1; + } + + if (ws == WS_Undecided) { + ContextObject->tlsPreClassify.insert(ContextObject->tlsPreClassify.end(), data, data + len); + if (ContextObject->tlsPreClassify.size() < 6) { + return 1; // 头还没攒够,继续收 + } + std::vector first; + first.swap(ContextObject->tlsPreClassify); + ContextObject->tlsPreClassify.clear(); + if (first.size() >= 4 && memcmp(first.data(), "GET ", 4) == 0) { + if (!StartWsHandshake(ContextObject, first)) { + Mprintf("[WS] StartWsHandshake failed for %s (fail-closed)\n", + ContextObject->GetPeerName().c_str()); + return -1; + } + return 0; // 升级线程接管 socket + } + ContextObject->wsState.store(WS_None, std::memory_order_release); + return ParseReceivedData(ContextObject, first.data(), (DWORD)first.size(), m_NotifyProc, ctx, z) ? 1 : -1; + } + + return ParseReceivedData(ContextObject, (PBYTE)data, len, m_NotifyProc, ctx, z) ? 1 : -1; +} + +// 把 WS 帧载荷交给解析路径,同时写回控制帧应答(pong / close 回显)。 +BOOL IOCPServer::DispatchWsFrameData(CONTEXT_OBJECT* ContextObject, const BYTE* wire, DWORD len, + ZSTD_DCtx* ctx, z_stream* z) +{ + if (ContextObject->ws == NULL) { + return FALSE; + } + std::vector app, replies; + int r = ContextObject->ws->Feed(wire, (int)len, app, replies); + if (!replies.empty() && !SendWsReplies(ContextObject, replies)) { + return FALSE; + } + if (r < 0) { + return FALSE; // 协议错误或对端 close + } + if (app.empty()) { + return TRUE; + } + return ParseReceivedData(ContextObject, app.data(), (DWORD)app.size(), m_NotifyProc, ctx, z); +} + +// 写回一段完整的 WS 帧(与 Send2Client 走同一条发送路径:追加到 OutCompressedBuffer, +// TLS 连接只加密本次新追加的尾部,最后按 bSendPending 协议投递 IOWrite)。 +BOOL IOCPServer::SendWsReplies(CONTEXT_OBJECT* ContextObject, const std::vector& replies) +{ + CAutoCLock L(ContextObject->SendLock); + bool tlsReady = (ContextObject->tlsState.load(std::memory_order_acquire) == TLS_Ready); + ULONG oldLen = ContextObject->OutCompressedBuffer.GetBufferLength(); + if (!ContextObject->OutCompressedBuffer.WriteBuffer((PBYTE)replies.data(), (DWORD)replies.size())) { + return FALSE; + } + if (tlsReady) { + ULONG newLen = ContextObject->OutCompressedBuffer.GetBufferLength() - oldLen; + std::vector wire; + if (ContextObject->tls->Encrypt(ContextObject->OutCompressedBuffer.GetBuffer(oldLen), + (int)newLen, wire) != (int)newLen) { + ContextObject->OutCompressedBuffer.TruncateBuffer(oldLen); + Mprintf("[TLS] Encrypt failed for %s (fail-closed)\n", ContextObject->GetPeerName().c_str()); + return FALSE; + } + ContextObject->OutCompressedBuffer.TruncateBuffer(oldLen); + ContextObject->OutCompressedBuffer.WriteBuffer(wire.data(), (DWORD)wire.size()); + } + + if (!ContextObject->bSendPending) { + ContextObject->bSendPending = true; + OVERLAPPEDPLUS* OverlappedPlus = new OVERLAPPEDPLUS(IOWrite); + BOOL bOk = PostQueuedCompletionStatus(m_hCompletionPort, 0, (ULONG_PTR)ContextObject, &OverlappedPlus->m_ol); + if ((!bOk && GetLastError() != ERROR_IO_PENDING)) { + ContextObject->bSendPending = false; + SAFE_DELETE(OverlappedPlus); + return FALSE; + } } - PostRecv(ContextObject); return TRUE; } @@ -1164,9 +1398,30 @@ BOOL IOCPServer::OnClientPreSending(CONTEXT_OBJECT* ContextObject, PBYTE szBuffe // 新明文由 WriteContextData 追加在尾部。若把整个缓冲区重新加密,会把旧密文二次加密, // 客户端解密后得到的是「旧 TLS 记录」→ Unknown header 17 03 03。故只加密本次新追加的尾部。 bool tlsReady = (ContextObject->tlsState.load(std::memory_order_acquire) == TLS_Ready); - ULONG oldLen = tlsReady ? ContextObject->OutCompressedBuffer.GetBufferLength() : 0; + // WS(含 WSS):同样只处理本次新追加的尾部——前缀可能还有在途未发完的帧/密文。 + bool wsReady = (ContextObject->wsState.load(std::memory_order_acquire) == WS_Ready) && + ContextObject->ws != NULL && ContextObject->ws->IsOpen(); + ULONG oldLen = (tlsReady || wsReady) ? ContextObject->OutCompressedBuffer.GetBufferLength() : 0; if (WriteContextData(ContextObject, szBuffer, ulOriginalLength, ContextObject->Zcctx)) { + // WebSocket:一次发送 = 一帧(与 Go 端 wsConn.Write 对齐)。必须在 TLS 加密之前完成, + // 这样 TLS 加密的「新追加尾部」就是整帧字节(应用字节 → WS 帧 → TLS 记录)。 + if (wsReady) { + ULONG totalLen = ContextObject->OutCompressedBuffer.GetBufferLength(); + ULONG appLen = totalLen - oldLen; + if (appLen > 0 && ContextObject->ws->IsOpen()) { + std::vector framed; + if (!ContextObject->ws->Frame((const BYTE*)ContextObject->OutCompressedBuffer.GetBuffer(oldLen), + (int)appLen, framed)) { + Mprintf("[WS] frame failed for %s (dropping send)\n", ContextObject->GetPeerName().c_str()); + ContextObject->OutCompressedBuffer.TruncateBuffer(oldLen); + return FALSE; + } + ContextObject->OutCompressedBuffer.TruncateBuffer(oldLen); + ContextObject->OutCompressedBuffer.WriteBuffer(framed.data(), (DWORD)framed.size()); + } + } + // 单向 TLS:只加密新追加的明文尾部,产出密文后与前缀旧密文拼接,使缓冲区始终保持 // 一串合法 TLS 记录;之后 IOWrite / OnClientPostSending 完全不变(见设计文档 §5.5)。 if (tlsReady) { diff --git a/server/2015Remote/IOCPServer.h b/server/2015Remote/IOCPServer.h index 8b0467f..567bc20 100644 --- a/server/2015Remote/IOCPServer.h +++ b/server/2015Remote/IOCPServer.h @@ -92,6 +92,7 @@ private: static DWORD WINAPI WorkThreadProc(LPVOID lParam); static DWORD WINAPI RttPollThreadProc(LPVOID lParam); static DWORD WINAPI TlsHandshakeThreadProc(LPVOID lParam); + static DWORD WINAPI WsHandshakeThreadProc(LPVOID lParam); BOOL InitializeIOCP(VOID); VOID OnAccept(); @@ -103,6 +104,10 @@ private: BOOL OnClientInitializing(PCONTEXT_OBJECT ContextObject, DWORD dwTrans); BOOL OnClientReceiving(PCONTEXT_OBJECT ContextObject, DWORD dwTrans, ZSTD_DCtx* ctx, z_stream* z); BOOL StartTlsHandshake(CONTEXT_OBJECT* ContextObject); + BOOL StartWsHandshake(CONTEXT_OBJECT* ContextObject, const std::vector& initial); + int DispatchPlain(CONTEXT_OBJECT* ContextObject, const BYTE* data, DWORD len, ZSTD_DCtx* ctx, z_stream* z); + BOOL DispatchWsFrameData(CONTEXT_OBJECT* ContextObject, const BYTE* wire, DWORD len, ZSTD_DCtx* ctx, z_stream* z); + BOOL SendWsReplies(CONTEXT_OBJECT* ContextObject, const std::vector& replies); BOOL OnClientPreSending(CONTEXT_OBJECT* ContextObject, PBYTE szBuffer, size_t ulOriginalLength); BOOL OnClientPostSending(CONTEXT_OBJECT* ContextObject, ULONG ulCompressedLength); int AddWorkThread(int n) diff --git a/server/2015Remote/Server.h b/server/2015Remote/Server.h index efbb01c..3c21602 100644 --- a/server/2015Remote/Server.h +++ b/server/2015Remote/Server.h @@ -339,6 +339,17 @@ enum ServerTlsState { TLS_Ready = 3, // TLS 握手完成,收包解密 / 发包加密 }; class ServerTlsSession; // 定义见 ServerTlsSession.h(避免把 Schannel 头拖进本文件) +class ServerWsSession; // 定义见 ServerWsSession.h(WebSocket 传输层) + +// 每连接 WebSocket 状态(与 Go 服务端 wsConn 同构,见 docs/WebSocket_Transport_Design.md)。 +// 明文与 TLS 设备都可能升级成 WS:首包是 "GET " 即按 HTTP Upgrade 处理;TLS 设备在 +// 握手完成后的首个明文分片里再看这一眼。 +enum ServerWsState { + WS_Undecided = 0, // 还没见到首个应用字节(TLS 连接在握手完成后才可能判定) + WS_None = 1, // 已判定为普通设备(非 WebSocket) + WS_Handshaking = 2, // 升级握手进行中,握手线程独占 socket + WS_Ready = 3, // 升级完成,收包解帧 / 发包加帧 +}; typedef class CONTEXT_OBJECT : public context { @@ -353,6 +364,7 @@ public: FreeCompressBuffer(); FreeSendCompressBuffer(); FreeTls(); + FreeWs(); if (Zcctx) { ZSTD_freeCCtx(Zcctx); Zcctx = nullptr; @@ -414,6 +426,10 @@ public: ServerTlsSession* tls = nullptr; // 每连接 TLS 会话(握手线程独占→就绪后共用) std::vector tlsPreClassify; // 分类前缓冲的首批字节(嗅探 ClientHello 头) + // ---- WebSocket 传输层状态(分层在 TLS 之上:WSS = TLS 里的 WS)---- + std::atomic wsState{ WS_Undecided }; // ServerWsState + ServerWsSession* ws = nullptr; // 每连接 WS 会话(升级线程独占→就绪后共用) + // 子连接身份校验:客户端发 TOKEN_CONN_AUTH 通过验证后置位。 // 主连接(走 TOKEN_LOGIN 流程)不参与此机制。当前阶段宽容(未通过也接受), // 仅作为标记供后续命令处理 / 未来收紧策略使用。 @@ -520,8 +536,15 @@ public: // 释放每连接 TLS 会话。定义在 ServerTlsSession.cpp(需 ServerTlsSession 完整类型才能 delete)。 void FreeTls(); + // 释放每连接 WebSocket 会话。定义在 ServerWsSession.cpp(同上)。 + void FreeWs(); + std::string GetProtocol() const override { + const int ws = wsState.load(std::memory_order_acquire); + if (ws == WS_Ready || ws == WS_Handshaking) { + return tlsState.load(std::memory_order_acquire) == TLS_Ready ? "WSS" : "WS"; + } return Parser.m_Masker && Parser.m_Masker->GetMaskType() == MaskTypeNone ? "TCP" : "HTTP"; } int GetServerPort() const override @@ -568,6 +591,9 @@ public: FreeTls(); tlsState.store(TLS_Unclassified, std::memory_order_release); tlsPreClassify.clear(); + // 复用对象池时重置 WebSocket 状态:释放旧会话、回到未判定。 + FreeWs(); + wsState.store(WS_Undecided, std::memory_order_release); // 复用对象池时清空发送进行中标志,避免上次连接残留的 bSendPending 抑制新连接的发送。 bSendPending = false; } diff --git a/server/2015Remote/ServerWsSession.cpp b/server/2015Remote/ServerWsSession.cpp new file mode 100644 index 0000000..2e589ec --- /dev/null +++ b/server/2015Remote/ServerWsSession.cpp @@ -0,0 +1,481 @@ +// ServerWsSession.cpp — 设备端口 WebSocket 传输层(服务端侧)实现 +// +// 语义对齐 Go 服务端 server/go/server/ws.go: +// * 升级请求逐行解析,头部总量上限 8 KiB(对端可控,不能无上限缓冲); +// * 只接受 Upgrade: websocket + Connection: upgrade(逗号分隔、大小写不敏感); +// * Sec-WebSocket-Accept = base64(SHA1(key + GUID)); +// * 客户端帧通常带掩码,解帧时按 4 字节掩码异或;服务端发帧一律不加掩码; +// * 控制帧(close/ping/pong)必须在数据帧之间处理,且载荷 ≤125 字节; +// * 只有直接对端是回环地址时才相信 X-Forwarded-For / X-Real-IP,取 XFF 的最后一项 +// (反代追加自己看到的地址,客户端预置的前缀因此无效)。 +#include "StdAfx.h" +#include "ServerWsSession.h" +#include "ServerTlsSession.h" +#include "Server.h" // CONTEXT_OBJECT::FreeWs() + +#include +#include +#include + +#pragma comment(lib, "bcrypt.lib") + +namespace { + +// RFC 6455 规定的握手魔数,accept = base64(sha1(key + GUID)) +const char kWsMagicGUID[] = "258EAFA5-E914-47DA-95CA-C5AB0DC85B11"; + +// 握手请求头上限:客户端可控,必须有上限(与 Go 的 wsMaxHandshakeBytes 同为 8 KiB) +const size_t kMaxHandshakeBytes = 8192; + +// 升级期间单次同步 I/O 的等待上限(与握手线程设的 SO_RCVTIMEO/SO_SNDTIMEO 一致) +const int kIoTimeoutMs = 15000; + +// 单帧载荷上限:屏幕/文件分块远小于此值;超过即视为协议错误,避免长度字段撑爆内存 +const long long kMaxFramePayload = 256LL * 1024 * 1024; + +const BYTE kBase64Table[] = + "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"; + +std::string Base64Encode(const BYTE* data, size_t len) +{ + std::string out; + out.reserve(((len + 2) / 3) * 4); + for (size_t i = 0; i < len; i += 3) { + unsigned v = (unsigned)data[i] << 16; + if (i + 1 < len) v |= (unsigned)data[i + 1] << 8; + if (i + 2 < len) v |= data[i + 2]; + out.push_back((char)kBase64Table[(v >> 18) & 0x3F]); + out.push_back((char)kBase64Table[(v >> 12) & 0x3F]); + out.push_back(i + 1 < len ? (char)kBase64Table[(v >> 6) & 0x3F] : '='); + out.push_back(i + 2 < len ? (char)kBase64Table[v & 0x3F] : '='); + } + return out; +} + +bool Sha1(const BYTE* data, size_t len, BYTE out[20]) +{ + BCRYPT_ALG_HANDLE alg = NULL; + if (BCryptOpenAlgorithmProvider(&alg, BCRYPT_SHA1_ALGORITHM, NULL, 0) != 0) { + return false; + } + bool ok = false; + DWORD objLen = 0, got = 0; + if (BCryptGetProperty(alg, BCRYPT_OBJECT_LENGTH, (PUCHAR)&objLen, sizeof(objLen), &got, 0) == 0) { + std::vector obj(objLen); + BCRYPT_HASH_HANDLE h = NULL; + if (BCryptCreateHash(alg, &h, obj.data(), objLen, NULL, 0, 0) == 0) { + ok = BCryptHashData(h, (PUCHAR)data, (ULONG)len, 0) == 0 && + BCryptFinishHash(h, out, 20, 0) == 0; + BCryptDestroyHash(h); + } + } + BCryptCloseAlgorithmProvider(alg, 0); + return ok; +} + +std::string WsAcceptKey(const std::string& key) +{ + std::string material = key + kWsMagicGUID; + BYTE digest[20] = { 0 }; + if (!Sha1((const BYTE*)material.data(), material.size(), digest)) { + return std::string(); + } + return Base64Encode(digest, sizeof(digest)); +} + +std::string TrimWs(const std::string& s) +{ + size_t b = 0, e = s.size(); + while (b < e && (s[b] == ' ' || s[b] == '\t' || s[b] == '\r' || s[b] == '\n')) b++; + while (e > b && (s[e - 1] == ' ' || s[e - 1] == '\t' || s[e - 1] == '\r' || s[e - 1] == '\n')) e--; + return s.substr(b, e - b); +} + +std::string ToLowerAscii(const std::string& s) +{ + std::string out = s; + for (size_t i = 0; i < out.size(); i++) { + if (out[i] >= 'A' && out[i] <= 'Z') out[i] = (char)(out[i] - 'A' + 'a'); + } + return out; +} + +// 逗号分隔的头值里是否含 token(大小写不敏感),用于 Connection: keep-alive, Upgrade +bool HeaderHasToken(const std::string& value, const char* token) +{ + size_t start = 0; + while (start <= value.size()) { + size_t comma = value.find(',', start); + std::string part = TrimWs(value.substr(start, comma == std::string::npos ? std::string::npos : comma - start)); + if (ToLowerAscii(part) == token) return true; + if (comma == std::string::npos) break; + start = comma + 1; + } + return false; +} + +bool IsIPLiteral(const std::string& s) +{ + if (s.empty()) return false; + IN_ADDR v4 = {}; + if (inet_pton(AF_INET, s.c_str(), &v4) == 1) return true; + IN6_ADDR v6 = {}; + return inet_pton(AF_INET6, s.c_str(), &v6) == 1; +} + +// 去掉 "1.2.3.4:5678" 的端口(裸 IPv6 字面量保留原样) +std::string StripPort(const std::string& s) +{ + size_t colon = s.rfind(':'); + if (colon != std::string::npos && s.find(':') == colon) { + if (IsIPLiteral(s.substr(0, colon))) return s.substr(0, colon); + } + return s; +} + +// 只有回环对端才允许用转发头改写真实地址(与 Go 的默认 TrustedProxies 一致): +// 反代与服务端同机部署时,设备连接的直接对端一定是回环地址。 +bool IsLoopbackPeer(const std::string& peer) +{ + return peer == "::1" || peer == "::ffff:127.0.0.1" || peer.compare(0, 4, "127.") == 0; +} + +// 从转发头取真实地址:XFF 的最后一项优先(反代追加,客户端预置的无效),X-Real-IP 兜底。 +// 只接受 IP 字面量,避免头里塞进任意字符串当作对端标识。 +std::string PickForwardedIP(const std::string& xff, const std::string& realIp) +{ + if (!xff.empty()) { + size_t comma = xff.rfind(','); + std::string last = StripPort(TrimWs(comma == std::string::npos ? xff : xff.substr(comma + 1))); + if (IsIPLiteral(last)) return last; + } + std::string ip = StripPort(TrimWs(realIp)); + return IsIPLiteral(ip) ? ip : std::string(); +} + +void AppendFrame(std::vector& out, BYTE opcode, const BYTE* payload, int len) +{ + out.push_back((BYTE)(0x80 | opcode)); // FIN + opcode,服务端帧不加掩码 + if (len < 126) { + out.push_back((BYTE)len); + } else if (len <= 0xFFFF) { + out.push_back(126); + out.push_back((BYTE)((len >> 8) & 0xFF)); + out.push_back((BYTE)(len & 0xFF)); + } else { + out.push_back(127); + unsigned long long v = (unsigned long long)len; + for (int i = 7; i >= 0; i--) { + out.push_back((BYTE)((v >> (8 * i)) & 0xFF)); + } + } + if (len > 0) { + out.insert(out.end(), payload, payload + len); + } +} + +} // namespace + +// 升级线程在 IOCP 的子套接字上做同步 I/O。该套接字可能是非阻塞的(监听套接字经 +// WSAEventSelect 置为非阻塞后,accept 出的子套接字继承非阻塞态;线程里 FIONBIO=0 会以 +// WSAEINVAL 失败)。故 recv/send 遇 WSAEWOULDBLOCK 时用 select 等可读/可写再重试, +// 而不是当致命错误——否则「客户端请求头还没到齐」会被误判为升级失败。与 +// ServerTlsSession 的 WaitSocketReady 同一策略。 +bool WaitSocketReady(SOCKET sock, bool forRead, int timeoutMs) +{ + fd_set fds; + FD_ZERO(&fds); + FD_SET(sock, &fds); + timeval tv; + tv.tv_sec = timeoutMs / 1000; + tv.tv_usec = (timeoutMs % 1000) * 1000; + return select(0, forRead ? &fds : NULL, forRead ? NULL : &fds, NULL, &tv) > 0; +} + +bool ServerWsSession::ReadByte(BYTE& b, std::string* err) +{ + for (;;) { + if (!m_stash.empty()) { + b = m_stash.front(); + m_stash.erase(m_stash.begin()); + return true; + } + if (m_tls == NULL) { + int n = ::recv(m_sock, (char*)&b, 1, 0); + if (n == 1) return true; + if (n == SOCKET_ERROR && WSAGetLastError() == WSAEWOULDBLOCK) { + if (WaitSocketReady(m_sock, true, kIoTimeoutMs)) continue; + if (err) *err = "timeout during upgrade"; + return false; + } + if (err) *err = (n == 0) ? "connection closed during upgrade" : "recv failed during upgrade"; + return false; + } + // WSS:收密文、解密,只消费到头结束为止;多读出来的明文留给 pending + BYTE raw[4096]; + int n = ::recv(m_sock, (char*)raw, (int)sizeof(raw), 0); + if (n == SOCKET_ERROR && WSAGetLastError() == WSAEWOULDBLOCK) { + if (WaitSocketReady(m_sock, true, kIoTimeoutMs)) continue; + if (err) *err = "TLS timeout during upgrade"; + return false; + } + if (n <= 0) { + if (err) *err = (n == 0) ? "TLS connection closed during upgrade" : "TLS recv failed during upgrade"; + return false; + } + std::vector plain; + if (m_tls->Decrypt(raw, n, plain) < 0) { + if (err) *err = "TLS decrypt failed during upgrade"; + return false; + } + m_stash.swap(plain); // 可能为空(这一批只是握手记录),循环再收 + } +} + +bool ServerWsSession::WriteWire(const BYTE* data, int len) +{ + std::vector wire; + const BYTE* p = data; + if (m_tls) { + if (m_tls->Encrypt(data, len, wire) != len) return false; + p = wire.data(); + len = (int)wire.size(); + } + int sent = 0; + while (sent < len) { + int n = ::send(m_sock, (const char*)p + sent, len - sent, 0); + if (n == SOCKET_ERROR && WSAGetLastError() == WSAEWOULDBLOCK) { + if (!WaitSocketReady(m_sock, false, kIoTimeoutMs)) return false; + continue; // 非阻塞套接字发送缓冲满:等可写后重试 + } + if (n <= 0) return false; + sent += n; + } + return true; +} + +bool ServerWsSession::Handshake(SOCKET sock, ServerTlsSession* tls, const std::vector& initial, + std::vector& pending, const std::string& peer, std::string* err) +{ + m_sock = sock; + m_tls = tls; + m_open = false; + m_stash = initial; + m_forwardedIP.clear(); + + std::string head; + for (;;) { + if (head.size() > kMaxHandshakeBytes) { + if (err) *err = "upgrade head too large"; + return false; + } + BYTE b = 0; + if (!ReadByte(b, err)) return false; + head.push_back((char)b); + if (head.size() >= 4 && head.compare(head.size() - 4, 4, "\r\n\r\n") == 0) { + break; + } + } + + // ---- 解析请求行与头 ---- + std::string path, upgrade, connection, key, xff, realIp; + size_t pos = 0; + bool firstLine = true; + while (pos < head.size()) { + size_t eol = head.find("\r\n", pos); + if (eol == std::string::npos) break; // 只有结尾的 \r\n\r\n + std::string line = head.substr(pos, eol - pos); + pos = eol + 2; + if (line.empty()) break; + if (firstLine) { + firstLine = false; + // "GET HTTP/1.1" + size_t sp1 = line.find(' '); + size_t sp2 = line.rfind(' '); + if (sp1 == std::string::npos || sp2 == sp1) { + if (err) *err = "malformed request line"; + return false; + } + std::string method = line.substr(0, sp1); + std::string version = line.substr(sp2 + 1); + if (method != "GET" || version.compare(0, 7, "HTTP/1.") != 0) { + if (err) *err = "not a WebSocket upgrade request"; + return false; + } + path = line.substr(sp1 + 1, sp2 - sp1 - 1); + size_t q = path.find('?'); + if (q != std::string::npos) path = path.substr(0, q); + continue; + } + size_t colon = line.find(':'); + if (colon == std::string::npos) { + if (err) *err = "malformed header line"; + return false; + } + std::string name = ToLowerAscii(TrimWs(line.substr(0, colon))); + std::string value = TrimWs(line.substr(colon + 1)); + if (name == "upgrade") { + upgrade = value; + } else if (name == "connection") { + connection += (connection.empty() ? "" : ",") + value; // 重复头按 RFC 合并 + } else if (name == "sec-websocket-key") { + key = value; + } else if (name == "x-forwarded-for") { + xff = value; + } else if (name == "x-real-ip") { + realIp = value; + } + } + + if (!HeaderHasToken(upgrade, "websocket") || !HeaderHasToken(connection, "upgrade") || key.empty()) { + if (err) *err = "missing Upgrade/Connection/Sec-WebSocket-Key"; + return false; + } + + std::string accept = WsAcceptKey(key); + if (accept.empty()) { + if (err) *err = "SHA1 unavailable for Sec-WebSocket-Accept"; + return false; + } + + std::string resp = + "HTTP/1.1 101 Switching Protocols\r\n" + "Upgrade: websocket\r\n" + "Connection: Upgrade\r\n" + "Sec-WebSocket-Accept: " + accept + "\r\n\r\n"; + if (!WriteWire((const BYTE*)resp.data(), (int)resp.size())) { + if (err) *err = "send upgrade response failed"; + return false; + } + + // 升级完成后剩余字节就是客户端紧随其后的首帧(只有 WSS 分批解密时才会出现) + pending.assign(m_stash.begin(), m_stash.end()); + m_stash.clear(); + + if (IsLoopbackPeer(peer)) { + m_forwardedIP = PickForwardedIP(xff, realIp); + } + + m_open = true; + return true; +} + +int ServerWsSession::Feed(const BYTE* wire, int len, std::vector& app, std::vector& replies) +{ + if (!m_open) return -1; + if (len > 0) { + m_in.insert(m_in.end(), wire, wire + len); + } + + for (;;) { + // ---- 当前数据帧还没读完:按剩余长度切片交付(大帧不整体缓冲)---- + if (m_remaining > 0) { + if (m_pos >= m_in.size()) break; + size_t avail = m_in.size() - m_pos; + size_t take = ((long long)avail < m_remaining) ? avail : (size_t)m_remaining; + if (m_masked) { + for (size_t i = 0; i < take; i++) { + m_in[m_pos + i] ^= m_mask[m_maskPos]; + m_maskPos = (m_maskPos + 1) & 3; + } + } + app.insert(app.end(), m_in.begin() + m_pos, m_in.begin() + m_pos + take); + m_pos += take; + m_remaining -= (long long)take; + continue; + } + + // ---- 读帧头 ---- + size_t avail = m_in.size() - m_pos; + if (avail < 2) break; + const BYTE* h = m_in.data() + m_pos; + if (h[0] & 0x70) return -1; // 未协商扩展却置了 RSV 位 + BYTE opcode = (BYTE)(h[0] & 0x0F); + bool fin = (h[0] & 0x80) != 0; + bool masked = (h[1] & 0x80) != 0; + long long plen = h[1] & 0x7F; + size_t hdrLen = 2; + if (plen == 126) { + if (avail < 4) break; + plen = ((long long)h[2] << 8) | h[3]; + hdrLen = 4; + } else if (plen == 127) { + if (avail < 10) break; + plen = 0; + for (int i = 0; i < 8; i++) { + plen = (plen << 8) | h[2 + i]; + } + if (plen < 0) return -1; + hdrLen = 10; + } + BYTE mask[4] = { 0, 0, 0, 0 }; + if (masked) { + if (avail < hdrLen + 4) break; + memcpy(mask, h + hdrLen, 4); + hdrLen += 4; + } + if (plen > kMaxFramePayload) return -1; + + if (opcode >= 0x8) { + // 控制帧:载荷 ≤125,必须整帧到齐才能处理 + if (!fin || plen > 125) return -1; + if (avail < hdrLen + (size_t)plen) break; + BYTE payload[125] = { 0 }; + memcpy(payload, h + hdrLen, (size_t)plen); + if (masked) { + for (long long i = 0; i < plen; i++) payload[i] ^= mask[i & 3]; + } + m_pos += hdrLen + (size_t)plen; + if (opcode == 0x8) { // close:回显后按关闭处理 + AppendFrame(replies, 0x8, payload, (int)plen); + m_open = false; + return -1; + } + if (opcode == 0x9) { // ping → pong + AppendFrame(replies, 0xA, payload, (int)plen); + } + // 0xA (pong) 及其它控制帧直接忽略 + continue; + } + + if (opcode != 0x0 && opcode != 0x1 && opcode != 0x2) return -1; + m_pos += hdrLen; + m_remaining = plen; + m_masked = masked; + memcpy(m_mask, mask, 4); + m_maskPos = 0; + } + + Compact(); + return 0; +} + +bool ServerWsSession::Frame(const BYTE* app, int len, std::vector& wire) +{ + if (!m_open || len < 0) return false; + AppendFrame(wire, 0x2, app, len); + return true; +} + +void ServerWsSession::Compact() +{ + if (m_pos == 0) return; + if (m_pos >= m_in.size()) { + m_in.clear(); + m_pos = 0; + } else if (m_pos >= 65536 || m_pos * 2 >= m_in.size()) { + m_in.erase(m_in.begin(), m_in.begin() + m_pos); + m_pos = 0; + } +} + +// 释放每连接 WS 会话(CONTEXT_OBJECT 析构 / 对象池复用时调用)。 +// 与 FreeTls 一致:调用点保证此时没有线程还在使用该会话(见 RemoveStaleContext 的 +// IoRefCount 约束;握手线程持有一枚引用)。 +void CONTEXT_OBJECT::FreeWs() +{ + if (ws) { + delete ws; + ws = NULL; + } +} diff --git a/server/2015Remote/ServerWsSession.h b/server/2015Remote/ServerWsSession.h new file mode 100644 index 0000000..5a9026e --- /dev/null +++ b/server/2015Remote/ServerWsSession.h @@ -0,0 +1,67 @@ +// ServerWsSession.h — MFC 服务端设备端口的 WebSocket 传输层 +// +// 与 Go 服务端 server/go/server/ws.go 的 wrapWebSocket / wsConn 同构:在同一端口上 +// 与明文、TLS 设备共存,首包是 "GET " 时按 HTTP Upgrade 升级,之后把每帧载荷原样交回 +// 既有解析路径;发送方向「一次发送 = 一帧」,与 wsConn.Write 对齐。 +// +// 与 TLS 是分层而不是并列的关系:wss = TLS 里的 WebSocket。本类不碰加密,tls 非空时 +// 所有字节都经 ServerTlsSession 加解密(顺序:应用字节 → WS 帧 → TLS 记录)。 +// +// 线程模型:Handshake 在专用握手线程上阻塞执行(与 TlsHandshakeThreadProc 同一模式, +// 握手期间独占 socket);握手完成后 Feed 只由 IOCP 工作线程调用(每连接同一时刻只有 +// 一个未决 WSARecv,天然串行);Frame 由发送方在 CONTEXT_OBJECT::SendLock 内调用。 +#pragma once + +#include + +#include +#include + +class ServerTlsSession; + +class ServerWsSession +{ +public: + ServerWsSession() {} + ~ServerWsSession() {} + + // 升级握手。initial 是触发判定的首批明文(以 "GET " 开头,可能只是请求头的一部分); + // pending 返回升级完成后多读到的线缆字节(可能是客户端紧随其后的首帧),由调用方交 + // 给 Feed;peer 是直接对端地址,用于判断是否信任 X-Forwarded-For。失败返回 false 并 + // 置 err(调用方关闭连接,fail-closed)。 + bool Handshake(SOCKET sock, ServerTlsSession* tls, const std::vector& initial, + std::vector& pending, const std::string& peer, std::string* err); + + // 解帧:线缆字节 wire 还原成应用字节 app,产出需要写回的完整帧 replies(应答 ping、 + // 回显 close)。返回 0 正常;-1 表示协议错误或对端已关闭,调用方应关闭连接 + // (replies 仍须先发出)。 + int Feed(const BYTE* wire, int len, std::vector& app, std::vector& replies); + + // 封装:把一段应用字节封成一帧二进制帧(服务端帧不加掩码)。 + bool Frame(const BYTE* app, int len, std::vector& wire); + + // 供外部在握手/升级完成后标记连接已关闭。 + void MarkClosed() { m_open = false; } + bool IsOpen() const { return m_open; } + + // 代理转发的真实客户端地址(仅在直接对端是回环地址、且升级请求带了转发头时非空)。 + const std::string& ForwardedIP() const { return m_forwardedIP; } + +private: + bool ReadByte(BYTE& b, std::string* err); + bool WriteWire(const BYTE* data, int len); + void Compact(); + + SOCKET m_sock = INVALID_SOCKET; + ServerTlsSession* m_tls = NULL; + std::vector m_stash; // 已从 socket 读出、尚未消费的字节(TLS 时是明文) + std::string m_forwardedIP; + + std::vector m_in; // 尚未解完的线缆字节 + size_t m_pos = 0; // m_in 中已消费到的位置 + long long m_remaining = 0; // 当前数据帧剩余载荷 + bool m_masked = false; // 当前数据帧是否带掩码 + BYTE m_mask[4] = { 0, 0, 0, 0 }; + int m_maskPos = 0; + bool m_open = false; // 升级完成后为 true,收到 close / 出错后为 false +}; diff --git a/server/2015Remote/lang/en_US.ini b/server/2015Remote/lang/en_US.ini index 39e303c..ca09692 100644 --- a/server/2015Remote/lang/en_US.ini +++ b/server/2015Remote/lang/en_US.ini @@ -282,7 +282,7 @@ Web ͨÓÃ=General ¸߼¶ (·DZØÌîÏî)=Advanced (Optional) Ìáʾ: ¶à¸öÉÏÏߵØַÓ÷ֺŷָô£¬99¸ö×ַûÒÔÄڡ£½ö¹©ѧϰºÍ×ÔÓã¬ÑϽûÓÃÓڷǷ¨ĿµÄʹÓá£=Tip: Multiple addresses separated by semicolons, max 99 chars. -Ìáʾ: WebSocketЭÒéÐ辭·´Ïò´úÀí(Èçnginx 443)ת·¢µ½Ö÷¿ض˿ڣ¬µØַÌîÓòÃû£»·þÎñ¶ËÐëΪGo°汾¡£=Tip: WebSocket requires a reverse proxy (e.g. nginx on 443) forwarding to the control port; enter the domain as the address, and run the Go server. +Ìáʾ: WebSocketЭÒéÐ辭·´Ïò´úÀí(Èçnginx 443)ת·¢µ½Ö÷¿ض˿ڣ¬µØַÌîÓòÃû¡£=Tip: WebSocket requires a reverse proxy (e.g. nginx on 443) forwarding to the control port; enter the domain as the address. ; ============================================ ; Service Manager diff --git a/server/2015Remote/lang/zh_TW.ini b/server/2015Remote/lang/zh_TW.ini index ba85080..83fe07d 100644 --- a/server/2015Remote/lang/zh_TW.ini +++ b/server/2015Remote/lang/zh_TW.ini @@ -282,7 +282,7 @@ Web ͨÓÃ=ͨÓà ¸߼¶ (·DZØÌîÏî)=ßMëA (·DZØÌîí—) Ìáʾ: ¶à¸öÉÏÏߵØַÓ÷ֺŷָô£¬99¸ö×ַûÒÔÄڡ£½ö¹©ѧϰºÍ×ÔÓã¬ÑϽûÓÃÓڷǷ¨ĿµÄʹÓá£=Ìáʾ: ¶à‚€ÉϾ€λַÓ÷Ö̖·ָô£¬99‚€×ÖԪÒԃȡ£ƒH¹©ŒWÁ•ºÍ×ÔÓ㬇À½ûÓÃ춷Ƿ¨ĿµÄʹÓᣠ-Ìáʾ: WebSocketЭÒéÐ辭·´Ïò´úÀí(Èçnginx 443)ת·¢µ½Ö÷¿ض˿ڣ¬µØַÌîÓòÃû£»·þÎñ¶ËÐëΪGo°汾¡£=Ìáʾ: WebSocket …f¶¨Ð轛·´Ïò´úÀí(Èç nginx 443)ÞD°lµ½Ö÷¿ØßB½Ӳº£¬λַՈÌî¾WÓ򣻷þ„նË횞é Go °汾¡£ +Ìáʾ: WebSocketЭÒéÐ辭·´Ïò´úÀí(Èçnginx 443)ת·¢µ½Ö÷¿ض˿ڣ¬µØַÌîÓòÃû¡£=Ìáʾ: WebSocket …f¶¨Ð轛·´Ïò´úÀí(Èç nginx 443)ÞD°lµ½Ö÷¿ØßB½Ӳº£¬λַՈÌî¾WÓò¡£ ; ============================================ ; Service Manager -- 2.43.0 From 99db28e2e20341a403d74da670b79a5a5a4beae0 Mon Sep 17 00:00:00 2001 From: yuanyuanxiang <962914132@qq.com> Date: Fri, 30 Oct 2026 17:01:42 +0100 Subject: [PATCH 3/5] Feature: Let the operator switch a live client's transport from the online list --- client/ClientApp.h | 2 + client/ClientDll.cpp | 134 ++++++++++++++++++++++++ client/ClientDll.h | 4 + client/KernelManager.cpp | 76 ++++++++++++++ common/commands.h | 23 ++++ docs/WebSocket_Transport_Design.md | 25 +++++ server/2015Remote/2015RemoteDlg.cpp | 157 ++++++++++++++++++++++++++++ server/2015Remote/2015RemoteDlg.h | 5 + server/2015Remote/context.h | 8 ++ server/2015Remote/lang/en_US.ini | 13 +++ server/2015Remote/lang/zh_TW.ini | 13 +++ server/2015Remote/resource.h | 8 +- 12 files changed, 466 insertions(+), 2 deletions(-) diff --git a/client/ClientApp.h b/client/ClientApp.h index a0bcbc3..72d3f68 100644 --- a/client/ClientApp.h +++ b/client/ClientApp.h @@ -11,4 +11,6 @@ public: virtual bool Start() = 0; virtual bool Stop() = 0; virtual bool IsMainInstance() = 0; + // 分享实例(被别人挂在主控上)的连接入口由分享方控制,不跟随本机主控的协议切换。 + virtual bool IsShared() { return false; } }; diff --git a/client/ClientDll.cpp b/client/ClientDll.cpp index d46af36..ccf6bd1 100644 --- a/client/ClientDll.cpp +++ b/client/ClientDll.cpp @@ -584,6 +584,133 @@ void ParseAuthServer(CONNECT_ADDRESS *conn) { delete cfg; } +// ---------------- 协议切换(COMMAND_SET_PROTO)的客户端落地 ---------------- +// +// 服务端把目标入口写进本机配置(注册表 settings\proto_override 等),随后客户端断开, +// 重连循环在这里按新入口重连。覆盖点选在「外壳注入完连接配置之后、建连之前」,因此 +// 在线升级换 DLL 也不会把协议按回 TCP——外壳注入的 protoType 每次都被这里覆盖。 +// +// 注册表键(后缀均在 settings 下): +// proto_override 目标协议(PROTO_TCP/WS/WSS 的数字),空 = 未切换 +// entry_host/port 新入口(反代域名:端口) +// entry_try_at 切换时刻(unix 秒)。登录成功后清零;超时仍未登录 → 自动回退 +// base_host/port/proto 安装时的直连入口(首次切换时记录,「还原」用它) +// prev_host/port/proto 切换前的入口(每次切换时记录,自动回退用它) +namespace { + +const int kProtoSwitchRevertSeconds = 300; // 新入口 5 分钟内登不上去 → 自动回退 + +bool IsSwitchableProto(int p) +{ + return p == PROTO_TCP || p == PROTO_WS || p == PROTO_WSS; +} + +// 本进程首次见到的入口(外壳注入的直连入口)。用于识别「客户端被换装/重新生成」: +// 注入入口变了,就清掉旧的切换状态,否则会一直连到上一份配置的反代入口。 +std::string g_bootHost; +int g_bootPort = 0; +bool g_bootCaptured = false; + +void ClearAllProtoSwitchKeys(iniFile& cfg) +{ + const char* keys[] = { "proto_override", "entry_host", "entry_port", "entry_try_at", + "base_host", "base_port", "base_proto", + "prev_host", "prev_port", "prev_proto" }; + for (auto k : keys) + cfg.SetStr("settings", k, ""); +} + +// 在每次建连前应用入口覆盖;返回 true 表示本次用的覆盖入口。 +// 覆盖撤销(还原命令 / 自动回退)→ 回到安装时的直连入口; +// 新入口超时(entry_try_at 未清零)→ 回退到切换前的入口并撤销覆盖。 +bool ApplyProtoSwitch(iniFile& cfg, CONNECT_ADDRESS& s) +{ + if (!g_bootCaptured) { + g_bootCaptured = true; + g_bootHost = s.ServerIP(); + g_bootPort = s.ServerPort(); + } + + const std::string baseHost = cfg.GetStr("settings", "base_host"); + if (!baseHost.empty() && baseHost != g_bootHost) { + // 客户端换装/重新生成:注入的入口变了,旧的反代入口不再成立 + ClearAllProtoSwitchKeys(cfg); + Mprintf("[proto-switch] injected entry changed (%s -> %s), cleared stale switch state\n", + baseHost.c_str(), g_bootHost.c_str()); + return false; + } + + const std::string proto = cfg.GetStr("settings", "proto_override"); + if (proto.empty()) { + // 覆盖已撤销(服务端「还原」):回到安装时的直连入口 + const std::string host = cfg.GetStr("settings", "base_host"); + const int port = atoi(cfg.GetStr("settings", "base_port").c_str()); + int baseProto = atoi(cfg.GetStr("settings", "base_proto").c_str()); + if (!host.empty() && port > 0) { + if (!IsSwitchableProto(baseProto)) baseProto = PROTO_TCP; + s.SetServer(host.c_str(), port); + s.protoType = (char)baseProto; + Mprintf("[proto-switch] restored direct entry %s:%d proto=%d\n", host.c_str(), port, baseProto); + } + return false; + } + + const int p = atoi(proto.c_str()); + if (!IsSwitchableProto(p)) { + ClearAllProtoSwitchKeys(cfg); // 坏值:撤销覆盖,按注入配置走 + return false; + } + + // 自动回退:切换后一直没登录成功(entry_try_at 由服务端下发时写入,登录成功后清零) + const long long tryAt = atoll(cfg.GetStr("settings", "entry_try_at").c_str()); + if (tryAt > 0 && (long long)time(0) - tryAt > kProtoSwitchRevertSeconds) { + const std::string prevHost = cfg.GetStr("settings", "prev_host"); + const int prevPort = atoi(cfg.GetStr("settings", "prev_port").c_str()); + int prevProto = atoi(cfg.GetStr("settings", "prev_proto").c_str()); + if (!prevHost.empty() && prevPort > 0) { + // 把「覆盖」改写成切换前的入口,而不是清空它:清空会落到下面的「还原」分支, + // 下一轮重连又跳回安装时的直连入口——WS↔WSS 之间来回切时会白白多断一次。 + if (!IsSwitchableProto(prevProto)) prevProto = PROTO_TCP; + s.SetServer(prevHost.c_str(), prevPort); + s.protoType = (char)prevProto; + cfg.SetStr("settings", "proto_override", std::to_string(prevProto)); + cfg.SetStr("settings", "entry_host", prevHost); + cfg.SetStr("settings", "entry_port", std::to_string(prevPort)); + Mprintf("[proto-switch] new entry unreachable for %llds, reverted to %s:%d proto=%d\n", + (long long)time(0) - tryAt, prevHost.c_str(), prevPort, prevProto); + } else { + // 没有前入口可回:撤销覆盖,按外壳注入的配置走 + cfg.SetStr("settings", "proto_override", ""); + cfg.SetStr("settings", "entry_host", ""); + cfg.SetStr("settings", "entry_port", ""); + Mprintf("[proto-switch] new entry unreachable and no previous entry, override dropped\n"); + } + cfg.SetStr("settings", "entry_try_at", "0"); + return false; + } + + const std::string host = cfg.GetStr("settings", "entry_host"); + const int port = atoi(cfg.GetStr("settings", "entry_port").c_str()); + if (!host.empty() && port > 0) + s.SetServer(host.c_str(), port); + s.protoType = (char)p; + return true; +} + +// 新入口登录成功:撤销自动回退计时。入口覆盖本身保留——后续重连一直用它。 +void ConfirmProtoSwitch(iniFile& cfg) +{ + if (cfg.GetStr("settings", "proto_override").empty()) + return; + if (cfg.GetStr("settings", "entry_try_at") == "0" || + cfg.GetStr("settings", "entry_try_at").empty()) + return; + cfg.SetStr("settings", "entry_try_at", "0"); + Mprintf("[proto-switch] new entry reachable, auto-revert disarmed\n"); +} + +} // namespace + DWORD WINAPI StartClient(LPVOID lParam) { ClientApp& app(*(ClientApp*)lParam); @@ -665,6 +792,10 @@ DWORD WINAPI StartClient(LPVOID lParam) static auto _ = RestoreMemDLL(&cfg, &settings, app.g_bExit); while (app.m_bIsRunning(&app)) { ULONGLONG dwTickCount = GetTickCount64(); + // 协议切换:按注册表里的入口覆盖建连(分享实例不受主控的切换影响,被分配/转移 + // 过主控的入口优先)。 + if (!assigned && !app.m_bShared) + ApplyProtoSwitch(cfg, settings); if (!ClientObject->ConnectServer(settings.ServerIP(), settings.ServerPort())) { Mprintf("[ConnectServer] ---> %s:%d.\n", settings.ServerIP(), settings.ServerPort()); for (int k = 300+(IsDebug ? rand()%600:rand()%6000); app.m_bIsRunning(&app) && --k; Sleep(10)); @@ -685,6 +816,9 @@ 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(); diff --git a/client/ClientDll.h b/client/ClientDll.h index 274b6c5..83d67a7 100644 --- a/client/ClientDll.h +++ b/client/ClientDll.h @@ -61,6 +61,10 @@ public: { SAFE_DELETE(g_Connection); } + bool IsShared() override + { + return m_bShared != FALSE; + } ClientApp* SetID(unsigned id) { m_ID = id; diff --git a/client/KernelManager.cpp b/client/KernelManager.cpp index 3a662a7..5a7cd73 100644 --- a/client/KernelManager.cpp +++ b/client/KernelManager.cpp @@ -904,6 +904,82 @@ VOID CKernelManager::OnReceive(PBYTE szBuffer, ULONG ulLength) break; } + case COMMAND_SET_PROTO: { + // 协议切换(TCP / WS / WSS):把目标入口写进本机配置后断开本连接,重连循环 + // (ClientDll.cpp 的 ApplyProtoSwitch)按新入口重连。入口覆盖要落盘,否则在线 + // 升级换 DLL 后会被外壳注入的 protoType 按回 TCP。 + // + // 载荷:[ProtoSwitchPacket][certLen 字节 PEM];host/port 都为空 = 还原到固定 + // 直连入口(客户端记着安装时的 base 入口)。WSS 可附带信任锚(反代证书),先 + // 落盘并重建 TLS 上下文,但这里不主动断开——断开统一放在末尾,避免丢后续包。 + // 分享实例的连接入口由分享方控制,主控的协议切换对它无效——直接忽略, + // 避免白白断开一次再按注入配置连回来。 + if (m_ClientApp && m_ClientApp->IsShared()) { + Mprintf("[proto-switch] ignored: shared instance follows the sharing host's entry\n"); + break; + } + if (ulLength < 1 + sizeof(ProtoSwitchPacket)) { + Mprintf("[proto-switch] payload too short (%u), ignored\n", ulLength); + break; + } + ProtoSwitchPacket p = {}; + memcpy(&p, szBuffer + 1, sizeof(p)); + p.host[sizeof(p.host) - 1] = '\0'; + p.port[sizeof(p.port) - 1] = '\0'; + const int proto = p.proto; + if (proto != PROTO_TCP && proto != PROTO_WS && proto != PROTO_WSS) { + Mprintf("[proto-switch] unsupported proto %d, ignored\n", proto); + break; + } + const std::string host(p.host); + const int port = atoi(p.port); + const bool restore = (proto == PROTO_TCP && host.empty()); + if (!restore && (host.empty() || port <= 0)) { + Mprintf("[proto-switch] missing proxy entry for proto %d, ignored\n", proto); + break; + } + + // 随包下发的信任锚(WSS):写入后热重载,让下一次连接能校验反代证书。 + const uint32_t maxCert = (uint32_t)(ulLength - 1 - sizeof(ProtoSwitchPacket)); + uint32_t certLen = p.certLen < maxCert ? p.certLen : maxCert; + if (certLen > 0) { + std::string certPem((const char*)szBuffer + 1 + sizeof(ProtoSwitchPacket), certLen); + m_cfg->SetStr("settings", "tls_cert", certPem); + std::string err; + if (!TlsReload(err)) + Mprintf("[proto-switch] trust anchor reload failed: %s\n", err.c_str()); + } + + if (restore) { + m_cfg->SetStr("settings", "proto_override", ""); + m_cfg->SetStr("settings", "entry_host", ""); + m_cfg->SetStr("settings", "entry_port", ""); + m_cfg->SetStr("settings", "entry_try_at", "0"); + Mprintf("[proto-switch] restore request, reconnecting to the direct entry\n"); + } else { + // 首次切换记下安装时的直连入口(「还原」用);每次切换记下当前入口(自动回退用) + if (m_cfg->GetStr("settings", "base_host").empty()) { + m_cfg->SetStr("settings", "base_host", m_conn->ServerIP()); + m_cfg->SetStr("settings", "base_port", std::to_string(m_conn->ServerPort())); + m_cfg->SetStr("settings", "base_proto", + std::to_string((int)(unsigned char)m_conn->protoType)); + } + m_cfg->SetStr("settings", "prev_host", m_conn->ServerIP()); + m_cfg->SetStr("settings", "prev_port", std::to_string(m_conn->ServerPort())); + m_cfg->SetStr("settings", "prev_proto", std::to_string((int)(unsigned char)m_conn->protoType)); + + m_cfg->SetStr("settings", "proto_override", std::to_string(proto)); + m_cfg->SetStr("settings", "entry_host", host); + m_cfg->SetStr("settings", "entry_port", std::to_string(port)); + m_cfg->SetStr("settings", "entry_try_at", std::to_string((long long)time(0))); + Mprintf("[proto-switch] switching to proto %d via %s:%d, reconnecting\n", + proto, host.c_str(), port); + } + if (m_ClientObject) + m_ClientObject->Disconnect(); + break; + } + case COMMAND_DOWN_EXEC: { std::thread(DownExecute, std::string((char*)szBuffer + 1), this).detach(); break; diff --git a/common/commands.h b/common/commands.h index 8c6905d..0f650b8 100644 --- a/common/commands.h +++ b/common/commands.h @@ -138,6 +138,7 @@ inline int isValid_10s() #define CLIENT_CAP_SCREEN_PREVIEW 0x0004 // 支持屏幕预览(双击在线主机时弹缩略图) #define CLIENT_CAP_C2C_PATHS 0x0008 // 支持按路径清单向另一客户端发送文件(COMMAND_C2C_SEND_FILES,仅 Windows) #define CLIENT_CAP_C2C_RECV_ACK 0x0010 // 作为 C2C 目标端时,落盘完成后回执(TOKEN_C2C_RECV_RESULT,目前仅 Linux) +#define CLIENT_CAP_PROTO_SWITCH 0x0020 // 支持服务端远程切换传输协议(COMMAND_SET_PROTO,仅 Windows) #define TALK_DLG_MAXLEN 1024 // 最大输入字符长度 @@ -346,6 +347,10 @@ enum { TOKEN_C2C_SEND_RESULT = 175, // [C2CSendResultPacket] 源客户端回传的发送结果 TOKEN_C2C_RECV_RESULT = 176, // [C2CSendResultPacket] 目标客户端回传的落盘回执(win32err 放 errno) + // 协议切换(服务端 → 客户端):把连接入口改成指定传输(TCP/WS/WSS)并立即重连。 + // 客户端把入口写进本机配置后断开,重连循环按新入口重连;新入口连不上会自动回退。 + COMMAND_SET_PROTO = 177, // [ProtoSwitchPacket][certLen 字节 PEM 正文] + TOKEN_DECRYPT = 199, TOKEN_REGEDIT = 200, // 注册表 COMMAND_REG_FIND, // 注册表 管理标识 @@ -390,6 +395,22 @@ enum { TOKEN_CONNECTION_LIST = 255, // 连接列表响应(客户端→服务端) }; +// COMMAND_SET_PROTO 的载荷(紧跟命令字节)。 +// +// host/port 都为空表示「还原到安装时的直连入口」:客户端用本地记住的原入口(prev_*) +// 恢复,服务端不需要知道客户端的直连地址。证书正文只在切换 WSS 且客户端可能还没有 +// 信任锚时附带——客户端写入后重建 TLS 上下文,随后按新入口重连即走 WSS。 +#pragma pack(push, 1) +struct ProtoSwitchPacket { + uint8_t proto; // PROTO_TCP / PROTO_WS / PROTO_WSS + char host[100]; // 反向代理域名(SNI / Host 头),空 = 还原 + char port[8]; // 反向代理端口,空 = 还原 + uint32_t certLen; // 随后附带的信任锚 PEM 字节数(0 = 不下发) +}; +#pragma pack(pop) + +static_assert(sizeof(ProtoSwitchPacket) == 113, "ProtoSwitchPacket must be exactly 113 bytes"); + // 单条连接记录(客户端 → 服务端)。地址字段存网络字节序(IPv4 展开为前 4 字节、IPv6 为 16 字节), // 端口字段存主机字节序(客户端 ntohs 转换)。断连时反向还原:地址拼回网络序 DWORD、端口 htons 转回 // 网络序,填回 MIB_TCPROW 调 SetTcpEntry(iphlpapi 的地址/端口均为网络序)。 @@ -1133,6 +1154,8 @@ typedef struct LOGIN_INFOR { #ifdef _WIN32 caps |= CLIENT_CAP_SCREEN_PREVIEW; caps |= CLIENT_CAP_C2C_PATHS; + // 协议切换(COMMAND_SET_PROTO)只有 Windows 客户端实现了命令处理与入口持久化。 + caps |= CLIENT_CAP_PROTO_SWITCH; #elif defined(__linux__) && !defined(__ANDROID__) // Linux 客户端作为 C2C 目标端时会回执落盘结果(common/FileTransferV2.h)。 // macOS 暂未接线(无全局主连接句柄),不声明——服务端就不会为它空等回执。 diff --git a/docs/WebSocket_Transport_Design.md b/docs/WebSocket_Transport_Design.md index c8dd3a7..97f0890 100644 --- a/docs/WebSocket_Transport_Design.md +++ b/docs/WebSocket_Transport_Design.md @@ -375,3 +375,28 @@ server { - macOS / Android 客户端没有 TLS 实现,只能选 `PROTO_WS`(明文),走不了 443。 - 经反代接入时地址只应填**一个域名**(多地址取第一个做 Host/SNI)。 - 不改应用协议、不改 MCP、不改 Web 控制台。 + +## 9. 远程协议切换(在线列表右键 → 协议切换) + +动机:客户端在线升级只换 DLL,外壳每次注入的连接配置仍是编译时的 TCP 直连入口,所以 +「已经在跑」的机器没法被搬到反代入口上。协议切换就是补这一环:由主控下发一次命令,客户端 +把新入口落盘并重连,此后(含再次在线升级)都按落盘的入口连。 + +- 菜单:与「实验功能」平级、紧跟在它下面,三个单选项 `直连 TCP / WS / WSS`。单选状态取 + 选中主机连接的真实传输(`context::GetProtocol()`:`TCP`/`WS`/`WSS`),不取客户端自报。 + 选中主机的客户端没有能力位 `CLIENT_CAP_PROTO_SWITCH(0x0020)` 时整组置灰(只有 Windows + 客户端实现了该命令)。 +- 命令:`COMMAND_SET_PROTO = 177`,载荷 `ProtoSwitchPacket`(113 字节:`proto` + 反代 + `host[100]` + `port[8]` + `certLen`),WS/WSS 后面再跟反代信任锚 PEM 正文;`host`/`port` + 全空表示「还原到安装时的直连入口」。 +- 服务端:WS/WSS 先弹输入框问反代入口(`域名:端口`,记住上次填的 `[ws] Entry`);WSS 额外 + 要求 `ServerTlsIdentity::IsReady()` 并读取 `[tls] CertPath` 的 PEM 一并下发——没有锚的 + 客户端会把 WSS 降级成明文 WS,等于静默降级,所以直接拒绝。 +- 客户端落盘(`settings` 下):`proto_override` / `entry_host` / `entry_port` / + `entry_try_at` 为当前覆盖;`base_*` 是首次切换时记下的安装入口(「还原」用它);`prev_*` + 是每次切换前的入口(自动回退用它)。重连循环在建连前 `ApplyProtoSwitch` 覆盖入口——位置 + 在「外壳注入完配置之后、建连之前」,因此换 DLL 也压不回去;登录成功后 + `ConfirmProtoSwitch` 把 `entry_try_at` 清零撤销计时。 +- 自动回退:新入口 5 分钟内一直登不上,回到 `prev_*` 并把它改写成新的覆盖(不是清空,否则 + 下一轮会落进「还原」分支又跳回直连入口)。分享实例(`m_bShared`)忽略该命令——它的入口 + 由分享方控制。 diff --git a/server/2015Remote/2015RemoteDlg.cpp b/server/2015Remote/2015RemoteDlg.cpp index 297b799..b0c132e 100644 --- a/server/2015Remote/2015RemoteDlg.cpp +++ b/server/2015Remote/2015RemoteDlg.cpp @@ -1079,6 +1079,9 @@ BEGIN_MESSAGE_MAP(CMy2015RemoteDlg, CDialogEx) ON_COMMAND(ID_EXPERIMENT_DRAWING_BOARD, &CMy2015RemoteDlg::OnExperimentDrawingBoard) ON_COMMAND(ID_EXPERIMENT_TLS_ENABLE, &CMy2015RemoteDlg::OnExperimentTlsEnable) ON_COMMAND(ID_EXPERIMENT_TLS_DISABLE, &CMy2015RemoteDlg::OnExperimentTlsDisable) + ON_COMMAND(ID_PROTO_SWITCH_TCP, &CMy2015RemoteDlg::OnProtoSwitchTcp) + ON_COMMAND(ID_PROTO_SWITCH_WS, &CMy2015RemoteDlg::OnProtoSwitchWs) + ON_COMMAND(ID_PROTO_SWITCH_WSS, &CMy2015RemoteDlg::OnProtoSwitchWss) ON_COMMAND(ID_TRIGGER_SETTINGS, &CMy2015RemoteDlg::OnTriggerSettings) ON_COMMAND(ID_SHELLCODE_AES_C_ARRAY, &CMy2015RemoteDlg::OnShellcodeAesCArray) ON_COMMAND(ID_PARAM_KBLOGGER, &CMy2015RemoteDlg::OnParamKblogger) @@ -4619,6 +4622,54 @@ void CMy2015RemoteDlg::OnNMRClickOnline(NMHDR *pNMHDR, LRESULT *pResult) Menu.SetMenuItemBitmaps(ID_EXPERIMENT_TLS_ENABLE, MF_BYCOMMAND, &m_bmOnline[69], &m_bmOnline[69]); Menu.SetMenuItemBitmaps(ID_EXPERIMENT_TLS_DISABLE, MF_BYCOMMAND, &m_bmOnline[70], &m_bmOnline[70]); + // --- 协议切换子菜单:与「实验功能」平级,紧跟在它下面 --- + // 三个单选项:直连 TCP / WS(明文,经反代)/ WSS(TLS,经反代)。当前协议取选中 + // 主机连接的 GetProtocol()——这是连接的真实传输,比客户端自报可信。 + // 没选中主机、或选中的客户端版本没有 COMMAND_SET_PROTO(能力位 + // CLIENT_CAP_PROTO_SWITCH),整组置灰——与「实验功能」等静态子菜单的表现一致。 + CMenu* pExperimentMenu = FindSubMenuByCommand(SubMenu, ID_EXPERIMENT_TLS_ENABLE); + if (pExperimentMenu) { + CString curProto; + int selectedCount = 0; + bool supported = true; + EnterCriticalSection(&m_cs); + POSITION protoPos = m_CList_Online.GetFirstSelectedItemPosition(); + while (protoPos) { + int protoItem = m_CList_Online.GetNextSelectedItem(protoPos); + context* protoCtx = GetContextByListIndex(protoItem); + if (!protoCtx || !protoCtx->IsLogin()) continue; + ++selectedCount; + if (curProto.IsEmpty()) curProto = protoCtx->GetProtocol().c_str(); + if (!protoCtx->SupportsProtoSwitch()) supported = false; + } + LeaveCriticalSection(&m_cs); + + CMenu protoMenu; + if (protoMenu.CreatePopupMenu()) { + protoMenu.AppendMenuL(MF_STRING, ID_PROTO_SWITCH_TCP, _T("直连 TCP")); + protoMenu.AppendMenuL(MF_STRING, ID_PROTO_SWITCH_WS, _T("WS(经反向代理,明文)")); + protoMenu.AppendMenuL(MF_STRING, ID_PROTO_SWITCH_WSS, _T("WSS(经反向代理,TLS)")); + UINT checked = curProto == _T("WS") ? ID_PROTO_SWITCH_WS + : curProto == _T("WSS") ? ID_PROTO_SWITCH_WSS + : ID_PROTO_SWITCH_TCP; + protoMenu.CheckMenuRadioItem(ID_PROTO_SWITCH_TCP, ID_PROTO_SWITCH_WSS, + checked, MF_BYCOMMAND); + if (selectedCount == 0 || !supported) { + protoMenu.EnableMenuItem(ID_PROTO_SWITCH_TCP, MF_BYCOMMAND | MF_GRAYED); + protoMenu.EnableMenuItem(ID_PROTO_SWITCH_WS, MF_BYCOMMAND | MF_GRAYED); + protoMenu.EnableMenuItem(ID_PROTO_SWITCH_WSS, MF_BYCOMMAND | MF_GRAYED); + } + for (UINT i = 0; i < SubMenu->GetMenuItemCount(); i++) { + if (SubMenu->GetSubMenu(i) == pExperimentMenu) { + // 子菜单句柄交给父菜单,随本地 CMenu 一起销毁 + SubMenu->InsertMenu(i + 1, MF_BYPOSITION | MF_POPUP | MF_STRING, + (UINT_PTR)protoMenu.Detach(), _TR("协议切换")); + break; + } + } + } + } + Menu.ModifyMenuL(ID_ONLINE_AUTHORIZE, MF_BYCOMMAND | MF_STRING, ID_ONLINE_AUTHORIZE, _T("发送授权")); // ============================================================ @@ -4841,6 +4892,112 @@ void CMy2015RemoteDlg::OnExperimentTlsDisable() SendSelectedCommand(&bToken, sizeof(BYTE)); } +// ---- 协议切换(在线列表右键 → 协议切换 → 直连 TCP / WS / WSS)---- +// +// 服务端只负责下发目标入口和协议:客户端把入口写进本机配置后断开重连,在线升级换 DLL +// 也不会被外壳注入的 protoType 按回 TCP(见 client/ClientDll.cpp 的 ApplyProtoSwitch)。 +// 新入口 5 分钟内登不上去,客户端自动回退到切换前的入口。 +void CMy2015RemoteDlg::OnProtoSwitchTcp() { SwitchSelectedProtocol(ID_PROTO_SWITCH_TCP); } +void CMy2015RemoteDlg::OnProtoSwitchWs() { SwitchSelectedProtocol(ID_PROTO_SWITCH_WS); } +void CMy2015RemoteDlg::OnProtoSwitchWss() { SwitchSelectedProtocol(ID_PROTO_SWITCH_WSS); } + +VOID CMy2015RemoteDlg::SwitchSelectedProtocol(UINT nID) +{ + const BYTE proto = nID == ID_PROTO_SWITCH_WS ? (BYTE)PROTO_WS + : nID == ID_PROTO_SWITCH_WSS ? (BYTE)PROTO_WSS + : (BYTE)PROTO_TCP; + const bool restore = (proto == PROTO_TCP); + + // 选中主机的能力校验:老客户端不认识 COMMAND_SET_PROTO,收到只会丢弃。 + int selected = 0, unsupported = 0; + EnterCriticalSection(&m_cs); + POSITION pos = m_CList_Online.GetFirstSelectedItemPosition(); + while (pos) { + int item = m_CList_Online.GetNextSelectedItem(pos); + context* ctx = GetContextByListIndex(item); + if (!ctx || !ctx->IsLogin()) continue; + ++selected; + if (!ctx->SupportsProtoSwitch()) ++unsupported; + } + LeaveCriticalSection(&m_cs); + if (selected == 0) return; + if (unsupported > 0) { + MessageBoxL(_T("选中的主机里有客户端版本不支持协议切换(需要新版客户端)"), + _T("提示"), MB_ICONWARNING); + return; + } + + // WS/WSS 需要反向代理入口(域名:端口),用输入框问,记住上次填的 + std::string host; + int port = 0; + std::string certPem; + if (!restore) { + CInputDialog dlg(this); + dlg.Init(_TR("协议切换"), _TR("请输入反向代理入口(域名:端口,例如 ws.example.com:443):")); + dlg.SetHistoryKey("proto_entry"); + CString lastEntry = THIS_CFG.GetStr("ws", "Entry", "").c_str(); + if (!lastEntry.IsEmpty()) dlg.m_str = lastEntry; + if (dlg.DoModal() != IDOK) return; + CString text = dlg.m_str; + text.Trim(); + int colon = text.ReverseFind(':'); + if (colon <= 0 || colon == text.GetLength() - 1) { + MessageBoxL(_T("反向代理入口格式不正确,应为 域名:端口"), _T("提示"), MB_ICONWARNING); + return; + } + host = text.Left(colon).GetString(); + port = atoi(text.Mid(colon + 1).GetString()); + if (host.empty() || port <= 0 || port > 65535 || host.size() >= 100) { + MessageBoxL(_T("反向代理入口格式不正确,应为 域名:端口"), _T("提示"), MB_ICONWARNING); + return; + } + THIS_CFG.SetStr("ws", "Entry", std::string(text.GetString())); // 记住上次入口 + + // WSS 需要客户端持有能校验反代证书的信任锚:随切换指令一起下发。 + // 没有证书就不让切——客户端无锚时会按明文 WS 回退,等于静默降级。 + if (proto == PROTO_WSS) { + if (!ServerTlsIdentity::IsReady()) { + MessageBoxL(_T("服务端未启用 TLS 证书,无法切换到 WSS"), _T("提示"), MB_ICONWARNING); + return; + } + std::ifstream certFile(THIS_CFG.GetStr("tls", "CertPath", ""), std::ios::binary); + if (certFile.is_open()) { + std::ostringstream ss; + ss << certFile.rdbuf(); + certPem = ss.str(); + } + if (certPem.empty()) { + MessageBoxL(_T("读取服务端 TLS 证书失败,无法切换到 WSS"), _T("提示"), MB_ICONWARNING); + return; + } + } + } + + CString confirm = restore + ? _TR("确定把选中主机切回直连 TCP 吗?\n" + "(客户端立即断线重连;若直连端口不可达,5 分钟后自动回退到当前入口)") + : _TR("确定切换选中主机的传输协议吗?\n" + "(客户端立即断线重连,正在进行的远程会话会中断;" + "新入口 5 分钟内连不上将自动回退)"); + // confirm 已是翻译后的文本:MessageBoxL 宏会再做一次 _T() 拼接,不能传变量。 + if (IDYES != MessageBox(confirm, _TR("协议切换"), MB_ICONQUESTION | MB_YESNO)) return; + + // 报文:[COMMAND_SET_PROTO][ProtoSwitchPacket][PEM] + std::vector pkt(1 + sizeof(ProtoSwitchPacket), 0); + pkt[0] = (BYTE)COMMAND_SET_PROTO; + ProtoSwitchPacket* p = (ProtoSwitchPacket*)(pkt.data() + 1); + p->proto = proto; + if (!restore) { + strcpy_s(p->host, host.c_str()); + sprintf_s(p->port, "%d", port); + if (!certPem.empty()) { + p->certLen = (uint32_t)certPem.size(); + pkt.insert(pkt.end(), certPem.begin(), certPem.end()); + } + } + SendSelectedCommand(pkt.data(), (ULONG)pkt.size()); +} + // 从资源中读取被控端文件,并根据用户选择修改连接信息后返回给发送线程 BYTE* ReadExeFromResource(DWORD& outSize, int resourceId, const char* resName, int iType, int iStartup, diff --git a/server/2015Remote/2015RemoteDlg.h b/server/2015Remote/2015RemoteDlg.h index 63d923d..e1d4c7e 100644 --- a/server/2015Remote/2015RemoteDlg.h +++ b/server/2015Remote/2015RemoteDlg.h @@ -545,6 +545,11 @@ public: afx_msg void OnExperimentDrawingBoard(); afx_msg void OnExperimentTlsEnable(); afx_msg void OnExperimentTlsDisable(); + // 协议切换(在线列表右键菜单,与「实验功能」平级):直连 TCP / WS / WSS + afx_msg void OnProtoSwitchTcp(); + afx_msg void OnProtoSwitchWs(); + afx_msg void OnProtoSwitchWss(); + VOID SwitchSelectedProtocol(UINT nID); afx_msg void OnOnlineDelete(); afx_msg void OnOnlineUpdate(); afx_msg void OnAbout(); diff --git a/server/2015Remote/context.h b/server/2015Remote/context.h index 1c51762..7e6429f 100644 --- a/server/2015Remote/context.h +++ b/server/2015Remote/context.h @@ -104,4 +104,12 @@ public: if (caps.IsEmpty()) return false; return (strtoul(caps.GetString(), nullptr, 16) & CLIENT_CAP_SCREEN_PREVIEW) != 0; } + + // 检查客户端是否支持远程协议切换(COMMAND_SET_PROTO)。老客户端没有这个命令, + // 收到也会走 default 丢弃,服务端据此把「协议切换」菜单置灰。 + bool SupportsProtoSwitch() const { + CString caps = GetClientData(ONLINELIST_CAPABILITIES); + if (caps.IsEmpty()) return false; + return (strtoul(caps.GetString(), nullptr, 16) & CLIENT_CAP_PROTO_SWITCH) != 0; + } }; diff --git a/server/2015Remote/lang/en_US.ini b/server/2015Remote/lang/en_US.ini index ca09692..1787ad2 100644 --- a/server/2015Remote/lang/en_US.ini +++ b/server/2015Remote/lang/en_US.ini @@ -2156,3 +2156,16 @@ Y »­Ãæ %dx%d£»Éϱ¨ %s£»ϵÊýΪÕæʵ³ýÒÔÉϱ¨=Frame %dx%d; reported %s; factor: real/reported Ëõ·ÅϵÊýÐèÔÚ 0.2 µ½ 5.0 ֮¼䡣=Scale factors must be between 0.2 and 5.0. ÒѰ´ »­Ãæ/Éϱ¨ ×Զ¯Ìîд£¬¿ÉÐ޸Ä=Auto-filled from frame/reported; editable + +; ===== ЭÒéÇл» (Protocol Switch) ===== +ЭÒéÇл»=Protocol Switch +ֱÁ¬ 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): +·´Ïò´úÀíÈë¿ڸñʽ²»Õýȷ£¬ӦΪ ÓòÃû:¶˿Ú=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 +ѡÖеÄÖ÷»úÀïÓпͻ§¶˰汾²»֧³ÖЭÒéÇл»£¨ÐèҪаæ¿ͻ§¶ˣ©=Some selected hosts run a client without protocol switching support (a newer client is required) +ȷ¶¨°ÑѡÖÐÖ÷»úÇлØֱÁ¬ TCP Âð£¿\n£¨¿ͻ§¶ËÁ¢¼´¶ÏÏßÖØÁ¬£»ÈôֱÁ¬¶˿ڲ»¿ɴ5 ·ÖÖӺó×Զ¯»ØÍ˵½µ±ǰÈë¿ڣ©=Switch the selected hosts back to direct TCP?\n(Clients reconnect immediately; if the direct port stays unreachable, they revert to the current entry after 5 minutes) +ȷ¶¨Çл»ѡÖÐÖ÷»úµĴ«ÊäЭÒéÂð£¿\n£¨¿ͻ§¶ËÁ¢¼´¶ÏÏßÖØÁ¬£¬ÕýÔڽøÐеÄԶ³̻Ự»áÖжϣ»ÐÂÈë¿Ú 5 ·ÖÖÓÄÚÁ¬²»ÉϽ«×Զ¯»ØÍˣ©=Switch the transport protocol for the selected hosts?\n(Clients reconnect immediately and any active remote session is interrupted; if the new entry stays unreachable for 5 minutes, the client reverts automatically) diff --git a/server/2015Remote/lang/zh_TW.ini b/server/2015Remote/lang/zh_TW.ini index 83fe07d..201d725 100644 --- a/server/2015Remote/lang/zh_TW.ini +++ b/server/2015Remote/lang/zh_TW.ini @@ -2147,3 +2147,16 @@ Y »­Ãæ %dx%d£»Éϱ¨ %s£»ϵÊýΪÕæʵ³ýÒÔÉϱ¨=®‹Ãæ %dx%d£»Éψó %s£»‚S”µžéÕ挍³ýÒÔÉψó Ëõ·ÅϵÊýÐèÔÚ 0.2 µ½ 5.0 ֮¼䡣=¿s·łS”µÐèÔÚ 0.2 µ½ 5.0 ֮ég¡£ ÒѰ´ »­Ãæ/Éϱ¨ ×Զ¯Ìîд£¬¿ÉÐ޸Ä=ÒÑÒÀ ®‹Ãæ/Éψó ×ԄÓÌîÈ룬¿ÉÐ޸Ä + +; ===== ЭÒéÇл» (Protocol Switch) ===== +ЭÒéÇл»=…f¶¨ÇГQ +ֱÁ¬ TCP=ֱßB TCP +WS£¨¾­·´Ïò´úÀí£¬Ã÷Îģ©=WS£¨½›·´Ïò´úÀí£¬Ã÷Îģ© +WSS£¨¾­·´Ïò´úÀí£¬TLS£©=WSS£¨½›·´Ïò´úÀí£¬TLS£© +ÇëÊäÈ뷴Ïò´úÀíÈë¿ڣ¨ÓòÃû:¶˿ڣ¬ÀýÈç ws.example.com:443£©:=ՈݔÈ뷴Ïò´úÀíÈë¿ڣ¨¾WÓò:ßB½Ӳº£¬ÀýÈç ws.example.com:443£©: +·´Ïò´úÀíÈë¿ڸñʽ²»Õýȷ£¬ӦΪ ÓòÃû:¶˿Ú=·´Ïò´úÀíÈë¿ڸñʽ²»Õý´_£¬‘ªžé ¾WÓò:ßB½Ӳº +·þÎñ¶ËδÆôÓà TLS ֤Ê飬Î޷¨Çл»µ½ WSS=ËŷþÆ÷δ†¢Óà TLS ‘{×C£¬Ÿo·¨ÇГQµ½ WSS +¶Áȡ·þÎñ¶Ë TLS ֤Êéʧ°ܣ¬Î޷¨Çл»µ½ WSS=×xȡËŷþÆ÷ TLS ‘{×Cʧ”¡£¬Ÿo·¨ÇГQµ½ WSS +ѡÖеÄÖ÷»úÀïÓпͻ§¶˰汾²»֧³ÖЭÒéÇл»£¨ÐèҪаæ¿ͻ§¶ˣ©=ßxȡµÄÖ÷™CÖÐÓÐÓÑô¶˰汾²»֧Ԯ…f¶¨ÇГQ£¨ÐèҪаæÓÑô¶ˣ© +ȷ¶¨°ÑѡÖÐÖ÷»úÇлØֱÁ¬ TCP Âð£¿\n£¨¿ͻ§¶ËÁ¢¼´¶ÏÏßÖØÁ¬£»ÈôֱÁ¬¶˿ڲ»¿ɴ5 ·ÖÖӺó×Զ¯»ØÍ˵½µ±ǰÈë¿ڣ©=´_¶¨Œ¢ßxȡÖ÷™CÇлØֱßB TCP †᣿\n£¨ÓÑô¶ËÁ¢¼´”ྀÖØßB£»ÈôֱßBßB½Ӳº²»¿Éß_£¬5 ·ÖçŠáá×ԄӻØÍ˵½ĿǰÈë¿ڣ© +ȷ¶¨Çл»ѡÖÐÖ÷»úµĴ«ÊäЭÒéÂð£¿\n£¨¿ͻ§¶ËÁ¢¼´¶ÏÏßÖØÁ¬£¬ÕýÔڽøÐеÄԶ³̻Ự»áÖжϣ»ÐÂÈë¿Ú 5 ·ÖÖÓÄÚÁ¬²»ÉϽ«×Զ¯»ØÍˣ©=´_¶¨ÇГQßxȡÖ÷™CµĂ÷ݔ…f¶¨†᣿\n£¨ÓÑô¶ËÁ¢¼´”ྀÖØßB£¬ÕýÔÚßMÐеÄßh¶˹¤×÷ëA¶ΕþÖДࣻÐÂÈë¿Ú 5 ·Ö犃ÈßB²»Éό¢×ԄӻØÍˣ© diff --git a/server/2015Remote/resource.h b/server/2015Remote/resource.h index 281925e..19d4517 100644 --- a/server/2015Remote/resource.h +++ b/server/2015Remote/resource.h @@ -1113,14 +1113,18 @@ #define ID_EXPERIMENT_TLS_DISABLE 33095 #define ID_MSGLOG_WHITELIST_IP 33096 #define ID_ONLINE_COPY_NAME 33097 +// 协议切换(在线主机列表右键菜单,与「实验功能」平级) +#define ID_PROTO_SWITCH_TCP 33098 +#define ID_PROTO_SWITCH_WS 33099 +#define ID_PROTO_SWITCH_WSS 33100 #define ID_EXIT_FULLSCREEN 40001 // Next default values for new objects -// +// #ifdef APSTUDIO_INVOKED #ifndef APSTUDIO_READONLY_SYMBOLS #define _APS_NEXT_RESOURCE_VALUE 417 -#define _APS_NEXT_COMMAND_VALUE 33098 +#define _APS_NEXT_COMMAND_VALUE 33101 #define _APS_NEXT_CONTROL_VALUE 2621 #define _APS_NEXT_SYMED_VALUE 105 #endif -- 2.43.0 From 50a489e316c238a67e723c3196b5786f9f683e36 Mon Sep 17 00:00:00 2001 From: yuanyuanxiang <962914132@qq.com> Date: Fri, 30 Oct 2026 17:50:48 +0100 Subject: [PATCH 4/5] Fix: Close the gaps the WebSocket transport review found Three of the findings only bite in deployment. First, the client's TLS and WebSocket handshakes run synchronously on the reconnect thread with no socket timeout, so a peer that accepts TCP and then goes quiet (black-holed proxy upstream, middlebox that only receives) blocks recv() forever and stalls the reconnect loop until the process is restarted. Set a 15 s SO_RCVTIMEO and SO_SNDTIMEO for the handshake window - the same value both server handshake threads use - and clear them once the connection is up so the worker thread's select plus blocking recv keeps working as before. Second, per-IP rate limiting counted the getpeername address before the real device was known. Behind a same-host reverse proxy that address is loopback, which IPWhitelist always trusts, so WS traffic was neither counted nor banned; behind a remote proxy every device shares one bucket, and tripping the threshold disconnected all of them. Count and ban by the forwarded device IP once the upgrade resolves it, mirroring the Go server's limitDirectPeer and handleConnection split. Direct connections keep their accept-time count and are not counted twice. Third, the protocol switch disarmed its five-minute auto-revert as soon as the new entry connected, which only proves TCP/TLS/WS handshaking finished. If login is never accepted there (wrong backend, reverse proxy pointing at some other WS service), the revert could never fire and the client would keep retrying a dead entry. Disarm on the first CMD_MASTERSETTING instead, which the server only sends after adding the host to its online list, and re-check it on every heartbeat so a late one still counts. The smaller items came along: free the handshake parameter when CreateThread fails in both handshake starters, move the WS_Handshaking fail-closed guard ahead of the TLS branch so it also covers WSS (where tlsState is already TLS_Ready), generate the frame mask from a per-channel PRNG inside the send lock instead of an unseeded global rand(), make the transport flags and the WS session's ready flag atomic, drop rather than send unframed application bytes when a WS session has closed, and abort a protocol switch whose PEM fails to load instead of moving to an entry that cannot connect. The Go server now bounds the upgrade sniff even when ReadTimeout is zero, and the design doc records the two-stage limiter, the login-based disarm and the review items that stay as known limits. The protocol switch's input prompt is cut down to "reverse-proxy entry (host:port)" - the label static is only 81 dialog units wide, and the old sentence ran to roughly three times that. The three language files follow: en_US and zh_TW gain the shortened prompt and drop the long key it replaced, the German file gains the protocol-switch block it never had, and its WebSocket tip key is corrected - it had picked up a Go-server clause the source string never carried, so the tip was never translated at all. Co-Authored-By: deepseek-flash --- client/ClientDll.cpp | 11 ++-- client/IOCPClient.cpp | 40 ++++++++++++++ client/IOCPClient.h | 16 +++++- client/KernelManager.cpp | 20 ++++++- client/WsChannel.h | 36 +++++++++++-- docs/WebSocket_Transport_Design.md | 67 +++++++++++++++++++++-- server/2015Remote/2015RemoteDlg.cpp | 4 +- server/2015Remote/IOCPServer.cpp | 82 ++++++++++++++++++++++------- server/2015Remote/lang/de_DE.ini | 14 ++++- server/2015Remote/lang/en_US.ini | 2 +- server/2015Remote/lang/zh_TW.ini | 2 +- server/go/server/ws.go | 10 +++- 12 files changed, 264 insertions(+), 40 deletions(-) diff --git a/client/ClientDll.cpp b/client/ClientDll.cpp index ccf6bd1..8470ae9 100644 --- a/client/ClientDll.cpp +++ b/client/ClientDll.cpp @@ -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(); 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); diff --git a/client/IOCPClient.cpp b/client/IOCPClient.cpp index b4a3c64..96a4401 100644 --- a/client/IOCPClient.cpp +++ b/client/IOCPClient.cpp @@ -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。 @@ -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); diff --git a/client/IOCPClient.h b/client/IOCPClient.h index 2a86bb0..c791f82 100644 --- a/client/IOCPClient.h +++ b/client/IOCPClient.h @@ -39,6 +39,7 @@ #endif #include "IOCPBase.h" #include +#include #include #include @@ -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 m_useWs{false}; + std::atomic 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 m_useTls{false}; #endif BOOL m_bWorkThread; HANDLE m_hWorkThread; diff --git a/client/KernelManager.cpp b/client/KernelManager.cpp index 5a7cd73..458b349 100644 --- a/client/KernelManager.cpp +++ b/client/KernelManager.cpp @@ -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; - 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()) { diff --git a/client/WsChannel.h b/client/WsChannel.h index e78ab35..c103080 100644 --- a/client/WsChannel.h +++ b/client/WsChannel.h @@ -18,6 +18,9 @@ #include #include #include +#include +#include +#include #include #include #include @@ -320,13 +323,18 @@ private: hn = 10; } + std::lock_guard 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 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 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; diff --git a/docs/WebSocket_Transport_Design.md b/docs/WebSocket_Transport_Design.md index 97f0890..a03db97 100644 --- a/docs/WebSocket_Transport_Design.md +++ b/docs/WebSocket_Transport_Design.md @@ -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`:写的一方是连接线程, + 读的一方是接收/发送线程(`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 与限流槽。 diff --git a/server/2015Remote/2015RemoteDlg.cpp b/server/2015Remote/2015RemoteDlg.cpp index b0c132e..4689065 100644 --- a/server/2015Remote/2015RemoteDlg.cpp +++ b/server/2015Remote/2015RemoteDlg.cpp @@ -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; diff --git a/server/2015Remote/IOCPServer.cpp b/server/2015Remote/IOCPServer.cpp index 2b84904..27c2968 100644 --- a/server/2015Remote/IOCPServer.cpp +++ b/server/2015Remote/IOCPServer.cpp @@ -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()); 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); @@ -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)---- @@ -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); @@ -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()); + return FALSE; + } + bool wsReady = wsStateReady; ULONG oldLen = (tlsReady || wsReady) ? ContextObject->OutCompressedBuffer.GetBufferLength() : 0; if (WriteContextData(ContextObject, szBuffer, ulOriginalLength, ContextObject->Zcctx)) { diff --git a/server/2015Remote/lang/de_DE.ini b/server/2015Remote/lang/de_DE.ini index 1c86def..f8e7c6a 100644 --- a/server/2015Remote/lang/de_DE.ini +++ b/server/2015Remote/lang/de_DE.ini @@ -279,7 +279,7 @@ Web ͨÓÃ=Allgemein ¸߼¶ (·DZØÌîÏî)=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 diff --git a/server/2015Remote/lang/en_US.ini b/server/2015Remote/lang/en_US.ini index 1787ad2..ccc0ea4 100644 --- a/server/2015Remote/lang/en_US.ini +++ b/server/2015Remote/lang/en_US.ini @@ -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 diff --git a/server/2015Remote/lang/zh_TW.ini b/server/2015Remote/lang/zh_TW.ini index 201d725..e5b4738 100644 --- a/server/2015Remote/lang/zh_TW.ini +++ b/server/2015Remote/lang/zh_TW.ini @@ -2153,7 +2153,7 @@ Y ֱÁ¬ TCP=ֱßB TCP WS£¨¾­·´Ïò´úÀí£¬Ã÷Îģ©=WS£¨½›·´Ïò´úÀí£¬Ã÷Îģ© WSS£¨¾­·´Ïò´úÀí£¬TLS£©=WSS£¨½›·´Ïò´úÀí£¬TLS£© -ÇëÊäÈ뷴Ïò´úÀíÈë¿ڣ¨ÓòÃû:¶˿ڣ¬ÀýÈç ws.example.com:443£©:=ՈݔÈ뷴Ïò´úÀíÈë¿ڣ¨¾WÓò:ßB½Ӳº£¬ÀýÈç ws.example.com:443£©: +·´´úÈë¿Ú(ÓòÃû:¶˿Ú):=·´´úÈë¿Ú(¾WÓò:²º): ·´Ïò´úÀíÈë¿ڸñʽ²»Õýȷ£¬ӦΪ ÓòÃû:¶˿Ú=·´Ïò´úÀíÈë¿ڸñʽ²»Õý´_£¬‘ªžé ¾WÓò:ßB½Ӳº ·þÎñ¶ËδÆôÓà TLS ֤Ê飬Î޷¨Çл»µ½ WSS=ËŷþÆ÷δ†¢Óà TLS ‘{×C£¬Ÿo·¨ÇГQµ½ WSS ¶Áȡ·þÎñ¶Ë TLS ֤Êéʧ°ܣ¬Î޷¨Çл»µ½ WSS=×xȡËŷþÆ÷ TLS ‘{×Cʧ”¡£¬Ÿo·¨ÇГQµ½ WSS diff --git a/server/go/server/ws.go b/server/go/server/ws.go index 96ebbf3..b135f50 100644 --- a/server/go/server/ws.go +++ b/server/go/server/ws.go @@ -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 { -- 2.43.0 From 46f4bf2dfbe5ccf2cd7d185ff1fd6bc04abe64ba Mon Sep 17 00:00:00 2001 From: yuanyuanxiang <962914132@qq.com> Date: Fri, 30 Oct 2026 19:07:39 +0100 Subject: [PATCH 5/5] Fix: Make the WebSocket transport reachable and bounded on every platform The POSIX clients were built without a connection config - Linux, macOS and Android all construct IOCPClient without the injected CONNECT_ADDRESS - so ConnectServer saw protoType -1 and quietly dialled the master port in plain TCP. Setting protoType to WS in their settings did nothing and logged nothing, and since CLIENT_CAP_PROTO_SWITCH is Windows-only the server could not move them either. Give the client a SetDefaultProto() for that construction path and call it from all three mains before the reconnect loop, with a one-shot log when neither a conn nor a default protocol is available so the silent fallback becomes visible next time. Bound what a peer can make the client read. ReadHeader accepted the 8-byte extended length and rejected only the sign bit, so a frame length of nearly 2^63 kept the connection streaming into a frame that would never end - alive but never delivering another packet. Cap single frames at 256 MB, the same value ServerWsSession already applies to client frames, and drop the connection past it; real traffic is far below that. Stop Reset() from writing the receive thread's frame state. Disconnect() can run from the heartbeat or command thread, not just the receive thread, so Reset() now only flips the atomic ready flag and a new ResetFrames() clears m_remaining, m_masked and m_maskPos from Handshake() alone, before the receive thread starts reading the socket. Those fields keep a single owner without adding a lock to the receive hot path. Finish a dead WS session instead of leaving it to the keepalive timer. When the session had closed but wsState was still WS_Ready, sends were dropped and nothing woke the pending recv, so a peer that closed and then went quiet held the context for the 3-minute keepalive. shutdown() the socket there so the recv returns zero bytes and the normal -2 teardown runs; RemoveStaleContext would deadlock against the caller's own IoRefCount and can hand back a reused context. That shutdown only finishes the connection if a zero-byte read still tears it down, and on the plain path it no longer did. DispatchPlain answers an empty buffer with "handled", so a peer's FIN left the connection in CLOSE_WAIT until keepalive - holding an IOCP context, a pending WSARecv and a rate-limit slot - where the pre-WS code called ParseReceivedData and tore down at once. Restore that teardown on the TLS_Plain branch, matching the other two. Checked against a Debug server: a plain socket that half-closes used to sit in CLOSE_WAIT with the peer's recv timing out, and now disappears immediately with recv returning zero. Two smaller cleanups from the same review. Give the WS upgrade its own prefix buffer (wsPreClassify) instead of borrowing the TLS sniffer's, which was serially reused for two state machines and read as if it were one. And stop deriving the build dialog's protoType from the combo box index: items now carry the protocol value as item data, keyed off the index AddString returns, so inserting an option in the middle can no longer write the wrong number into the generated client without any error. ApplyProtoSwitch loses its bool return, which contradicted its own side effects and was ignored by every caller. Co-Authored-By: deepseek-flash --- android/app/src/main/cpp/main.cpp | 3 +++ client/ClientDll.cpp | 17 +++++++-------- client/IOCPClient.cpp | 10 ++++++++- client/IOCPClient.h | 8 +++++++ client/TlsChannel.cpp | 2 ++ client/WsChannel.h | 28 +++++++++++++++++++----- docs/WebSocket_Transport_Design.md | 34 ++++++++++++++++++++++++----- linux/main.cpp | 7 ++++++ macos/main.mm | 7 ++++++ server/2015Remote/BuildDlg.cpp | 35 +++++++++++++++++++++--------- server/2015Remote/IOCPServer.cpp | 29 ++++++++++++++++++++----- server/2015Remote/Server.h | 7 +++++- 12 files changed, 149 insertions(+), 38 deletions(-) diff --git a/android/app/src/main/cpp/main.cpp b/android/app/src/main/cpp/main.cpp index 74facf5..1ae7055 100644 --- a/android/app/src/main/cpp/main.cpp +++ b/android/app/src/main/cpp/main.cpp @@ -591,6 +591,9 @@ static void ConnectionThread() std::unique_ptr client(new IOCPClient(g_bExit, false)); client->setManagerCallBack(nullptr, DataProcess, nullptr); + // 同 Linux/macOS:不传 conn 的构造路径拿不到注入的 CONNECT_ADDRESS,协议必须显式喂进去, + // 否则配成 WS/WSS 也只会静默按明文 TCP 直连。Android 没有 TLS 通道,WSS 会 fail-closed。 + client->SetDefaultProto((int)(unsigned char)g_SETTINGS.protoType); int g_connAttempt = 0; while (S_CLIENT_NORMAL == g_bExit && g_running.load()) { diff --git a/client/ClientDll.cpp b/client/ClientDll.cpp index 8470ae9..6874feb 100644 --- a/client/ClientDll.cpp +++ b/client/ClientDll.cpp @@ -620,10 +620,10 @@ void ClearAllProtoSwitchKeys(iniFile& cfg) cfg.SetStr("settings", k, ""); } -// 在每次建连前应用入口覆盖;返回 true 表示本次用的覆盖入口。 -// 覆盖撤销(还原命令 / 自动回退)→ 回到安装时的直连入口; -// 新入口超时(entry_try_at 未清零)→ 回退到切换前的入口并撤销覆盖。 -bool ApplyProtoSwitch(iniFile& cfg, CONNECT_ADDRESS& s) +// 在每次建连前应用入口覆盖(就地改写 s,并落盘必要的状态)。没有返回值:它既会改 s 也会 +// 改配置,用「是否用了覆盖入口」当返回值会与副作用矛盾——自动回退分支照样改写了 settings, +// 却没法用一个 bool 表达,调用方也确实不需要这个信息。 +void ApplyProtoSwitch(iniFile& cfg, CONNECT_ADDRESS& s) { if (!g_bootCaptured) { g_bootCaptured = true; @@ -637,7 +637,7 @@ bool ApplyProtoSwitch(iniFile& cfg, CONNECT_ADDRESS& s) ClearAllProtoSwitchKeys(cfg); Mprintf("[proto-switch] injected entry changed (%s -> %s), cleared stale switch state\n", baseHost.c_str(), g_bootHost.c_str()); - return false; + return; } const std::string proto = cfg.GetStr("settings", "proto_override"); @@ -652,13 +652,13 @@ bool ApplyProtoSwitch(iniFile& cfg, CONNECT_ADDRESS& s) s.protoType = (char)baseProto; Mprintf("[proto-switch] restored direct entry %s:%d proto=%d\n", host.c_str(), port, baseProto); } - return false; + return; } const int p = atoi(proto.c_str()); if (!IsSwitchableProto(p)) { ClearAllProtoSwitchKeys(cfg); // 坏值:撤销覆盖,按注入配置走 - return false; + return; } // 自动回退:切换后一直没登录成功(entry_try_at 由服务端下发时写入,登录成功后清零) @@ -686,7 +686,7 @@ bool ApplyProtoSwitch(iniFile& cfg, CONNECT_ADDRESS& s) Mprintf("[proto-switch] new entry unreachable and no previous entry, override dropped\n"); } cfg.SetStr("settings", "entry_try_at", "0"); - return false; + return; } const std::string host = cfg.GetStr("settings", "entry_host"); @@ -694,7 +694,6 @@ bool ApplyProtoSwitch(iniFile& cfg, CONNECT_ADDRESS& s) if (!host.empty() && port > 0) s.SetServer(host.c_str(), port); s.protoType = (char)p; - return true; } // 新入口登录成功:撤销自动回退计时。入口覆盖本身保留——后续重连一直用它。 diff --git a/client/IOCPClient.cpp b/client/IOCPClient.cpp index 96a4401..5f26d93 100644 --- a/client/IOCPClient.cpp +++ b/client/IOCPClient.cpp @@ -496,7 +496,15 @@ BOOL IOCPClient::ConnectServer(const char* szServerIP, unsigned short uPort) // WebSocket 传输(PROTO_WS / PROTO_WSS):出站被限制在 80/443/8080 等端口时,经反代 // 分流进来。与应用协议无关,位置和 TLS 相同(TLS 之下、应用协议之上);须在 // m_bConnected 置位前完成,确保工作线程不会在 Upgrade 尚未完成时就开始 recv。 - const int protoType = m_conn ? (int)(unsigned char)m_conn->protoType : -1; + // Linux / macOS / Android 不传 conn,协议由 SetDefaultProto 给出(见 IOCPClient.h)。 + // 两边都没有时按明文直连,并留一行日志——否则「改成 WS 却毫无反应」无从排查。 + const int protoType = m_conn ? (int)(unsigned char)m_conn->protoType : m_defaultProto; + if (!m_conn && m_defaultProto < 0) { + // 只记一次:重连循环每轮都会走到这里,否则日志会被刷满。 + static std::atomic logged{false}; + if (!logged.exchange(true)) + Mprintf("[WS] 无连接配置(m_conn 为空)且未设置默认协议,本次按明文 TCP 直连\n"); + } const bool wsProto = (protoType == PROTO_WS || protoType == PROTO_WSS); const bool wsTls = (protoType == PROTO_WSS); m_useWs = false; diff --git a/client/IOCPClient.h b/client/IOCPClient.h index c791f82..2595d3d 100644 --- a/client/IOCPClient.h +++ b/client/IOCPClient.h @@ -208,6 +208,12 @@ public: 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; @@ -355,6 +361,8 @@ protected: // 无害,但换成别的架构就不能再依赖这个巧合)。 std::atomic m_useWs{false}; std::atomic 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 diff --git a/client/TlsChannel.cpp b/client/TlsChannel.cpp index 08784c0..2386652 100644 --- a/client/TlsChannel.cpp +++ b/client/TlsChannel.cpp @@ -305,6 +305,8 @@ bool TlsChannel::VerifyServerCert() return false; // 与 TlsReload 互斥:校验期间持有 g_tlsMtx,重建时释放的旧 store/engine 不会正被使用。 + // 持锁时间很短:建链全是本地操作(DISABLE_AIA 禁联网取中间证书,也不带任何 + // CERT_CHAIN_REVOCATION_CHECK_* 位),不会因为网络等待而卡住 TlsReload。 std::lock_guard lk(g_tlsMtx); if (!g_tlsStore || !g_tlsEngine) { CertFreeCertificateContext(remote); diff --git a/client/WsChannel.h b/client/WsChannel.h index c103080..c0e00ee 100644 --- a/client/WsChannel.h +++ b/client/WsChannel.h @@ -51,13 +51,12 @@ public: void SetTls(TlsChannel* tls) { m_tls = tls; } #endif - // 每次连接前清理上一轮的帧状态。 + // 让 Recv/Send 立刻失效。**可由任意线程调用**(Disconnect 可能来自心跳/命令线程, + // 不只是接收线程),因此这里只碰原子量;帧解析状态留给 ResetFrames()——它只在 + // Handshake 里、接收线程还没起来时清。 void Reset() { m_ready = false; - m_remaining = 0; - m_masked = false; - m_maskPos = 0; } bool IsReady() const { return m_ready; } @@ -67,7 +66,7 @@ public: bool Handshake(SOCKET sock, const std::string& host, int port, const char* path, std::string* err = NULL) { Reset(); - + ResetFrames(); char hostPort[120] = { 0 }; if (port == 80 || port == 443) snprintf(hostPort, sizeof(hostPort), "%s", host.c_str()); @@ -257,6 +256,8 @@ private: } // 读帧头(含扩展长度与掩码键)。服务端发来的帧不应带掩码,带了也照样解。 + static const long long kMaxFramePayload = 256LL * 1024 * 1024; + bool ReadHeader(SOCKET sock, unsigned char& opcode, long long& frameLen) { unsigned char h[2] = { 0, 0 }; @@ -284,6 +285,12 @@ private: if (frameLen < 0) return false; } + // 单帧载荷上限,与主控端 ServerWsSession 的 kMaxFramePayload 取同一个值(256 MB)。 + // 没有上限时,一个错误/被篡改的长度字段就能把 m_remaining 定在天文数字上,此后 + // 所有字节都被当成该帧的内容吞掉,连接表面上还活着却永远收不到新包——比直接断线 + // 难查得多。正常业务的最大单包远小于此值,故不会挡住既有功能。 + if (frameLen > kMaxFramePayload) + return false; if (m_masked && !ReadExact(sock, m_mask, 4)) return false; m_maskPos = 0; @@ -377,7 +384,16 @@ private: std::mutex m_sendMtx; std::vector m_frame; - // 当前数据帧的剩余载荷长度与掩码状态(只由接收线程读写,无需加锁) + // 当前数据帧的剩余载荷长度与掩码状态(只由接收线程读写,无需加锁)。 + // 只能在接收线程未运行时清(见 public Reset()):Handshake 在连接线程上、m_bConnected + // 置位之前调用,那时接收线程还没开始读 socket。 + void ResetFrames() + { + m_remaining = 0; + m_masked = false; + m_maskPos = 0; + } + long long m_remaining = 0; bool m_masked = false; unsigned char m_mask[4] = { 0, 0, 0, 0 }; diff --git a/docs/WebSocket_Transport_Design.md b/docs/WebSocket_Transport_Design.md index a03db97..5750157 100644 --- a/docs/WebSocket_Transport_Design.md +++ b/docs/WebSocket_Transport_Design.md @@ -79,6 +79,10 @@ XOR、zstd、HTTP 伪装层)。WS 与 HTTP 伪装的 `MaskType` 互斥:选 W 线程都会写帧。 - 不校验 `Sec-WebSocket-Accept`(设计上由 TLS + 隧道内登录承担)。明文 `PROTO_WS` 下这意味着 中间人可以伪造 101 接管字节流——这正是「裸 WS 只适合内网」的另一半理由。 +- 没有 `conn` 的构造路径(Linux / macOS / Android 的 `main` 都是 `new IOCPClient(exit, false)`) + 拿不到外壳注入的 `CONNECT_ADDRESS`,协议由 `IOCPClient::SetDefaultProto()` 显式给出; + 三个平台的 `main` 都在进入重连循环前调一次。不调则保持 `-1`、按明文直连——那正是 + 「配置成 WS 却毫无反应」的来源,所以这里留了一行日志便于排查。 ### 3.1 信任模型:不换锚,靠 SNI 分流 @@ -197,7 +201,8 @@ WS 叠在同一层状态机之上,**与 TLS 是分层而不是并列**(`wss` - 状态机:`ServerWsState { WS_Undecided → WS_Handshaking → WS_Ready | WS_None }` 与既有的 `ServerTlsState` 并存;`CONTEXT_OBJECT` 复用(`InitMember`)时一并复位并释放会话。 - 判定点:**明文的第一段有 ≥6 字节**才开始分类(与 ClientHello 嗅探同一下限), - 避免把「请求头还没到齐」误判掉;阈值内的字节攒在 `tlsPreClassify` 里。 + 避免把「请求头还没到齐」误判掉;阈值内的字节攒在 `wsPreClassify` 里(与 TLS 嗅探的 + `tlsPreClassify` 分开,两者服务不同状态机,串行使用但字段不共用)。 - 升级线程与 TLS 握手线程同构:`FIONBIO=0`(该套接字常是非阻塞的,`ioctlsocket` 会以 `WSAEINVAL` 失败),15 s 收发超时,遇 `WSAEWOULDBLOCK` 用 `select` 等可读/可写再试; 线程持有一枚 `IoRefCount`,结束后把 socket 交还 IOCP(`PostRecv`)。升级响应之后同批 @@ -218,8 +223,15 @@ WS 叠在同一层状态机之上,**与 TLS 是分层而不是并列**(`wss` - fail-closed 的两处:握手期间(`wsState == WS_Handshaking`)收到 IORead 直接断开(判断 放在 `OnClientReceiving` 最开头,WSS 下 `tlsState` 已是 `TLS_Ready`,放在 TLS 分支之后 就不生效);`wsState == WS_Ready` 但会话已关时,应用字节**丢弃而不是裸发**,否则对端 - 解帧错位。 + 解帧错位;同时对该 socket 做一次 `shutdown(SD_BOTH)`,让挂起的 recv 立刻返回 0 字节, + 由接收路径走正常的 `-2` 收尾(不在这里直接 `RemoveStaleContext`——调用方往往本身就 + 持有 `IoRefCount`,自己等自己会超时,且可能把已回收复用的上下文交回给调用者)。 - 既有客户端零影响:非 `GET ` 首包在攒够 6 字节后原样进入 `ParseReceivedData`。 +- 收尾一致:`dwTrans == 0`(对端 FIN)在 `TLS_Unclassified` / `TLS_Ready` / `TLS_Plain` + 三条分支上都必须 `RemoveStaleContext`。WS 改造把 `TLS_Plain` 的 `ParseReceivedData` + 换成 `DispatchPlain` 后,`DispatchPlain` 对空数据返回「已处理」,这个判断一度丢了, + 连接会停在 CLOSE_WAIT 直到 keepalive(3 分钟),期间占着 IOCP 上下文、一枚挂起的 + `WSARecv` 和限流槽。现已补回。 ## 5. nginx 最小改动 @@ -426,7 +438,9 @@ server { - 客户端落盘(`settings` 下):`proto_override` / `entry_host` / `entry_port` / `entry_try_at` 为当前覆盖;`base_*` 是首次切换时记下的安装入口(「还原」用它);`prev_*` 是每次切换前的入口(自动回退用它)。重连循环在建连前 `ApplyProtoSwitch` 覆盖入口——位置 - 在「外壳注入完配置之后、建连之前」,因此换 DLL 也压不回去。 + 在「外壳注入完配置之后、建连之前」,因此换 DLL 也压不回去。(该函数返回 `void`:它既写 + 配置也改 `CONNECT_ADDRESS`,返回值无法表达「部分完成」,早期版本里的 `return false` + 只是提前退出,调用方一直忽略它。) - 撤销自动回退的判据是**登录被接受**,不是「连接建立」。客户端在收到 `CMD_MASTERSETTING` 时把当前连接标记为已登录(服务端只有在把本机加入在线列表之后才下发 它),重连循环每轮心跳都检查一次,命中才 `ConfirmProtoSwitch` 把 `entry_try_at` 清零。 @@ -444,13 +458,21 @@ server { ## 10. 审查遗留(已知边界,未改动) -以下条目来自 PR 审查,评估后保留现状,记录在此以免重复讨论: +以下条目来自 PR 审查,记录在此以免重复讨论。带「已处理」的是复查后**已经改掉**的, +留在这里说明当时的判断,其余评估后保留现状: - **`GetPeerName(SOCKET)` 只走 `sockaddr_in`(IPv4)**:`ServerWsSession.cpp::IsLoopbackPeer` 里的 `::1` / `::ffff:127.0.0.1` 分支目前是死代码。将来若监听 IPv6,转发头信任也需要跟着 改,否则会静默失效。 -- **`tlsPreClassify` 名不副实**:它现在同时承担 ClientHello 嗅探与 WS 前缀("GET ")buffering。 - 改名会牵动状态机注释与多处引用,暂保留原名字,语义见 §4.2。 +- **`tlsPreClassify` 名不副实**:已处理——WS 的 "GET " 前缀缓冲拆成独立的 `wsPreClassify`, + `tlsPreClassify` 回归 ClientHello 嗅探单一职责(两条路径仍按先后串行,互不重叠)。 +- **`WsChannel::Reset()` 与接收线程的帧状态**:已处理——`Disconnect()` 可能来自心跳/命令线程, + 不只是接收线程,所以 `Reset()` 现在只翻转原子的 `m_ready`;`m_remaining` / `m_masked` / + `m_maskPos` 改由 `ResetFrames()` 清,且只在 `Handshake()` 里(连接线程、接收线程尚未起来) + 调用。这样这几个字段始终只有一个线程访问,不用加锁。 +- **客户端单帧载荷上限 256 MB**(`WsChannel::kMaxFramePayload`,与 `ServerWsSession` 同值): + 超过即按错误断开。没有上限时一个错误长度字段就能把 `m_remaining` 定在天文数字上, + 连接「活着但永远收不到新包」。正常业务的最大单包远小于此值。 - **`DispatchPlain` 对明文首包引入「攒够 6 字节再解析」**:这是既有路径的行为变更。当前首包 是登录包(远大于 6 字节),实际无影响;极端情况下(<6 字节的合法首包)会多等一轮收包。 - **客户端不校验 `Sec-WebSocket-Accept`**:见 §3;明文 WS 下中间人可伪造 101,已在 §8 明确 diff --git a/linux/main.cpp b/linux/main.cpp index dc82e3d..5cb8d26 100644 --- a/linux/main.cpp +++ b/linux/main.cpp @@ -1379,6 +1379,13 @@ int main(int argc, char* argv[]) std::unique_ptr ClientObject(new IOCPClient(g_bExit, false)); ClientObject->setManagerCallBack(NULL, DataProcess, NULL); + // 不传 conn 的构造路径拿不到注入的 CONNECT_ADDRESS,协议只能显式喂进去:否则哪怕 + // g_SETTINGS.protoType 配成 WS/WSS,也会静默按明文 TCP 直连(日志里一个字都没有)。 + ClientObject->SetDefaultProto((int)(unsigned char)g_SETTINGS.protoType); + if (g_SETTINGS.protoType == PROTO_WS || g_SETTINGS.protoType == PROTO_WSS) { + Mprintf("[WS] 按配置的传输协议连接: proto=%d(WSS 需要 TLS 支持,不支持的平台会 fail-closed)\n", + (int)(unsigned char)g_SETTINGS.protoType); + } g_pMainClient = ClientObject.get(); // 自升级失败回报用 while (!g_bExit) { clock_t c = clock(); diff --git a/macos/main.mm b/macos/main.mm index 7311816..520c17a 100644 --- a/macos/main.mm +++ b/macos/main.mm @@ -942,6 +942,13 @@ int main(int argc, const char* argv[]) // Create client auto ClientObject = std::make_unique(g_bExit, false); ClientObject->setManagerCallBack(NULL, DataProcess, NULL); + // 同 Linux:不传 conn 就取不到注入的 CONNECT_ADDRESS,协议必须显式喂进去, + // 否则配成 WS/WSS 也只会静默按明文 TCP 直连。 + ClientObject->SetDefaultProto((int)(unsigned char)g_SETTINGS.protoType); + if (g_SETTINGS.protoType == PROTO_WS || g_SETTINGS.protoType == PROTO_WSS) { + Mprintf("[WS] 按配置的传输协议连接: proto=%d(WSS 需要 TLS 支持,不支持的平台会 fail-closed)\n", + (int)(unsigned char)g_SETTINGS.protoType); + } // Main event loop NSLog(@"Starting main loop..."); diff --git a/server/2015Remote/BuildDlg.cpp b/server/2015Remote/BuildDlg.cpp index 50d5ae4..fc298ed 100644 --- a/server/2015Remote/BuildDlg.cpp +++ b/server/2015Remote/BuildDlg.cpp @@ -542,7 +542,14 @@ void CBuildDlg::OnBnClickedOk() g_ConnectAddress.SetAdminId(GetMasterHash().c_str()); g_ConnectAddress.SetServer(m_strIP, atoi(m_strPort)); g_ConnectAddress.runningType = m_ComboRunType.GetCurSel(); - g_ConnectAddress.protoType = m_ComboProto.GetCurSel(); + // 协议值取自 item data(见 OnInitDialog 里的 addProto)。取不到时退回序号,保持旧行为。 + int protoSel = m_ComboProto.GetCurSel(); + if (protoSel >= 0) { + DWORD_PTR protoData = m_ComboProto.GetItemData(protoSel); + if (protoData != (DWORD_PTR)CB_ERR) + protoSel = (int)protoData; + } + g_ConnectAddress.protoType = protoSel; g_ConnectAddress.iHeaderEnc = m_ComboEncrypt.GetCurSel(); memcpy(g_ConnectAddress.pwdHash, GetPwdHash().c_str(), sizeof(g_ConnectAddress.pwdHash)); memcpy(g_ConnectAddress.szGroupName, m_sGroupName, m_sGroupName.GetLength()); @@ -837,15 +844,23 @@ BOOL CBuildDlg::OnInitDialog() m_ComboRunType.InsertStringL(RUNNING_PARALLEL, "并发上线"); m_ComboRunType.SetCurSel(RUNNING_RANDOM); - m_ComboProto.InsertStringL(PROTO_TCP, "TCP"); - m_ComboProto.InsertStringL(PROTO_UDP, "UDP"); - m_ComboProto.InsertStringL(PROTO_HTTP, "HTTP"); - m_ComboProto.InsertStringL(PROTO_RANDOM, "随机"); - m_ComboProto.InsertStringL(PROTO_KCP, "KCP"); - // 序号即 protoType,中间不能有空洞(下方 GetCurSel 直接当协议值用) - m_ComboProto.InsertStringL(PROTO_WS, "WebSocket"); - m_ComboProto.InsertStringL(PROTO_WSS, "WS+TLS"); - m_ComboProto.SetCurSel(PROTO_TCP); + // 协议值挂在 item data 上,不再依赖「下拉框序号 == protoType」。两者目前确实相等, + // 但只要以后有 PROTO_* 常量没进这个下拉框(PROTO_HTTPS 就已经是这种情况), + // 后加项序号与协议值就会错位,而错误的值只会在客户端连不上时才暴露。 + auto addProto = [this](int proto, LPCSTR text) { + // AddString 追加到末尾并返回新条目下标;用它定位,不依赖任何「下标 == 枚举值」约定。 + int idx = m_ComboProto.AddStringL(text); + if (idx >= 0) + m_ComboProto.SetItemData(idx, (DWORD_PTR)proto); + }; + addProto(PROTO_TCP, "TCP"); + addProto(PROTO_UDP, "UDP"); + addProto(PROTO_HTTP, "HTTP"); + addProto(PROTO_RANDOM, "随机"); + addProto(PROTO_KCP, "KCP"); + addProto(PROTO_WS, "WebSocket"); + addProto(PROTO_WSS, "WS+TLS"); + m_ComboProto.SetCurSel(0); m_ComboEncrypt.InsertStringL(PROTOCOL_SHINE, "Shine"); m_ComboEncrypt.InsertStringL(PROTOCOL_HELL, "HELL"); diff --git a/server/2015Remote/IOCPServer.cpp b/server/2015Remote/IOCPServer.cpp index 27c2968..1ae309a 100644 --- a/server/2015Remote/IOCPServer.cpp +++ b/server/2015Remote/IOCPServer.cpp @@ -1258,6 +1258,16 @@ BOOL IOCPServer::OnClientReceiving(PCONTEXT_OBJECT ContextObject, DWORD dwTrans } // TLS_Plain:明文直通(原路径)。WS 连接在这里先解帧。 + // dwTrans == 0 是对端干净关闭(FIN)。WS 改造前这条分支直接调 ParseReceivedData, + // 它对 dataLen == 0 返回 FALSE 从而拆连接;换成 DispatchPlain 后该语义丢了——0 字节 + // 一路返回 1 → PostRecv,而 FIN 已经消费掉,这条连接就停在 CLOSE_WAIT 里,直到 + // keepalive(3 分钟)才回收(实测:对端 FIN 后连接一直留在 CLOSE_WAIT,进程不空转)。 + // 期间它占着 IOCP 上下文、挂着一枚 WSARecv 和限流槽。这里补回与另外两条分支一致的收尾。 + if (dwTrans == 0) { + ContextObject->IoRefCount.fetch_sub(1); + RemoveStaleContext(ContextObject); + return -2; + } { int r = DispatchPlain(ContextObject, (const BYTE*)ContextObject->szBuffer, dwTrans, ctx, z); if (r < 0) { @@ -1290,13 +1300,14 @@ int IOCPServer::DispatchPlain(CONTEXT_OBJECT* ContextObject, const BYTE* data, D } if (ws == WS_Undecided) { - ContextObject->tlsPreClassify.insert(ContextObject->tlsPreClassify.end(), data, data + len); - if (ContextObject->tlsPreClassify.size() < 6) { + // WS 有自己的缓冲(该状态机在 HTTPS 升级 / 反代路径上也会用到),不再借 tlsPreClassify。 + ContextObject->wsPreClassify.insert(ContextObject->wsPreClassify.end(), data, data + len); + if (ContextObject->wsPreClassify.size() < 6) { return 1; // 头还没攒够,继续收 } std::vector first; - first.swap(ContextObject->tlsPreClassify); - ContextObject->tlsPreClassify.clear(); + first.swap(ContextObject->wsPreClassify); + ContextObject->wsPreClassify.clear(); if (first.size() >= 4 && memcmp(first.data(), "GET ", 4) == 0) { if (!StartWsHandshake(ContextObject, first)) { Mprintf("[WS] StartWsHandshake failed for %s (fail-closed)\n", @@ -1440,8 +1451,16 @@ BOOL IOCPServer::OnClientPreSending(CONTEXT_OBJECT* ContextObject, PBYTE szBuffe const bool wsStateReady = (ContextObject->wsState.load(std::memory_order_acquire) == WS_Ready); if (wsStateReady && (ContextObject->ws == NULL || !ContextObject->ws->IsOpen())) { // 升级过 WS 但会话已关(Feed 报错 / 收到 close)而状态还没降级:绝不能把应用字节 - // 当裸字节发出去,对端会解帧错位。丢弃本次发送,由接收路径的 RemoveStaleContext 收尾。 + // 当裸字节发出去,对端会解帧错位。丢弃本次发送,并主动 shutdown 让挂起的 recv + // 立刻返回 0 字节——否则接收路径要等对端 FIN 才醒,期间这条连接既发不出也收不到, + // 只能靠心跳超时兜底(最坏要几分钟)。 + // + // 这里不能直接调 RemoveStaleContext:它会等待 IoRefCount 归零,而本函数的调用方 + // 常常就处在一个 IoRef 里(发送失败→兜底发送),等于自己等自己,5 秒后超时放行, + // 反而可能把已回收复用的 CONTEXT_OBJECT 交回给调用者。shutdown 是异步且无阻塞的, + // 真正的收尾仍由接收路径的 -2 返回值触发。 Mprintf("[WS] session closed for %s, dropping send\n", ContextObject->GetPeerName().c_str()); + shutdown(ContextObject->sClientSocket, SD_BOTH); return FALSE; } bool wsReady = wsStateReady; diff --git a/server/2015Remote/Server.h b/server/2015Remote/Server.h index 3c21602..932cc70 100644 --- a/server/2015Remote/Server.h +++ b/server/2015Remote/Server.h @@ -429,6 +429,10 @@ public: // ---- WebSocket 传输层状态(分层在 TLS 之上:WSS = TLS 里的 WS)---- std::atomic wsState{ WS_Undecided }; // ServerWsState ServerWsSession* ws = nullptr; // 每连接 WS 会话(升级线程独占→就绪后共用) + // WS 升级前的首包缓冲(判定 "GET " 用)。与 tlsPreClassify 刻意分开:两者服务于不同的 + // 状态机,此前串行复用同一个 vector(TLS 判定完 move 走再 clear,WS 又塞回来),字段名 + // 与用途对不上,排查时容易误读。两条路径仍按先后串行,互不重叠。 + std::vector wsPreClassify; // 子连接身份校验:客户端发 TOKEN_CONN_AUTH 通过验证后置位。 // 主连接(走 TOKEN_LOGIN 流程)不参与此机制。当前阶段宽容(未通过也接受), @@ -591,9 +595,10 @@ public: FreeTls(); tlsState.store(TLS_Unclassified, std::memory_order_release); tlsPreClassify.clear(); - // 复用对象池时重置 WebSocket 状态:释放旧会话、回到未判定。 + // 复用对象池时重置 WebSocket 状态:释放旧会话、回到未判定、清空首包缓冲。 FreeWs(); wsState.store(WS_Undecided, std::memory_order_release); + wsPreClassify.clear(); // 复用对象池时清空发送进行中标志,避免上次连接残留的 bSendPending 抑制新连接的发送。 bSendPending = false; } -- 2.43.0