Files
SimpleRemoter/server/2015Remote/ServerWsSession.cpp
T

482 lines
17 KiB
C++
Raw Permalink Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
// 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;
}
}