Feature: Sniff WebSocket upgrades on the MFC server's device port

This commit is contained in:
yuanyuanxiang committed 2026-10-30 17:22:17 +01:00
1 parent d4f312c9d8
commit cc891e3670
11 files changed
+925 -32

No files matched your search

+481
View File
@@ -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 <bcrypt.h>
#include <cstring>
#include <vector>
#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<BYTE> 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<BYTE>& 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<BYTE> 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<BYTE> 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<BYTE>& initial,
std::vector<BYTE>& 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 <path> 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<BYTE>& app, std::vector<BYTE>& 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<BYTE>& 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;
}
}