Feature: WebSocket transport for clients behind restricted outbound ports #5
No files matched your search
@@ -591,6 +591,9 @@ static void ConnectionThread()
|
||||
|
||||
std::unique_ptr<IOCPClient> 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()) {
|
||||
|
||||
@@ -11,4 +11,6 @@ public:
|
||||
virtual bool Start() = 0;
|
||||
virtual bool Stop() = 0;
|
||||
virtual bool IsMainInstance() = 0;
|
||||
// 分享实例(被别人挂在主控上)的连接入口由分享方控制,不跟随本机主控的协议切换。
|
||||
virtual bool IsShared() { return false; }
|
||||
};
|
||||
@@ -584,6 +584,132 @@ 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, "");
|
||||
}
|
||||
|
||||
// 在每次建连前应用入口覆盖(就地改写 s,并落盘必要的状态)。没有返回值:它既会改 s 也会
|
||||
// 改配置,用「是否用了覆盖入口」当返回值会与副作用矛盾——自动回退分支照样改写了 settings,
|
||||
// 却没法用一个 bool 表达,调用方也确实不需要这个信息。
|
||||
void 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;
|
||||
}
|
||||
|
||||
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;
|
||||
}
|
||||
|
||||
const int p = atoi(proto.c_str());
|
||||
if (!IsSwitchableProto(p)) {
|
||||
ClearAllProtoSwitchKeys(cfg); // 坏值:撤销覆盖,按注入配置走
|
||||
return;
|
||||
}
|
||||
|
||||
// 自动回退:切换后一直没登录成功(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;
|
||||
|
|
||||
}
|
||||
|
||||
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;
|
||||
}
|
||||
|
||||
// 新入口登录成功:撤销自动回退计时。入口覆盖本身保留——后续重连一直用它。
|
||||
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 +791,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));
|
||||
@@ -689,6 +819,14 @@ DWORD WINAPI StartClient(LPVOID lParam)
|
||||
do {
|
||||
Manager->SendHeartbeat();
|
||||
SetThreadExecutionState(ES_CONTINUOUS | ES_SYSTEM_REQUIRED);
|
||||
|
yuanyuanxiang
commented
必须修复 3: §9 文档写的是「登录成功后 **必须修复 3:`IsConnected()` ≠ 登录成功。** 这里只证明 TCP + TLS + WS 握手完成,服务端尚未处理登录包。若新入口能建连但登录始终不被接受(选错后端 / 反代指到别的 WS 服务 / 服务端登录阶段静默丢弃),`entry_try_at` 会被清零,5 分钟自动回退**永久失效**,客户端卡在错误入口反复重连。
§9 文档写的是「登录成功后 `ConfirmProtoSwitch` 清零」,与这里的实现不符。建议改为「收到服务端首个业务包」或「连接保持 N 秒且收到过数据」再撤销计时。
|
||||
// 协议切换:新入口「登录被接受」后才撤销自动回退计时(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);
|
||||
|
||||
@@ -61,6 +61,10 @@ public:
|
||||
{
|
||||
SAFE_DELETE(g_Connection);
|
||||
}
|
||||
bool IsShared() override
|
||||
{
|
||||
return m_bShared != FALSE;
|
||||
}
|
||||
ClientApp* SetID(unsigned id)
|
||||
{
|
||||
m_ID = id;
|
||||
|
||||
@@ -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,58 @@ 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。
|
||||
// Linux / macOS / Android 不传 conn,协议由 SetDefaultProto 给出(见 IOCPClient.h)。
|
||||
|
yuanyuanxiang
commented
protoType 为 -1 时静默退回明文。 Windows 的每条构造路径都传了 建议: **protoType 为 -1 时静默退回明文。** `m_conn` 为空就取 -1,`wsProto`/`wsTls` 均为 false,后面完全跳过 WS 分支,也不会打任何日志。
Windows 的每条构造路径都传了 `conn`(`ClientDll.cpp:104`、`Common.cpp:76`、`KernelManager.cpp` 全部 `new IOCPClient(..., conn, ...)`),所以主路径没问题。但 `linux/main.cpp:1380` 与 `macos/main.mm:943` 都是 `new IOCPClient(g_bExit, false)`——`m_conn` 恒为 NULL。那两个平台即使把 `g_SETTINGS.protoType` 改成 `PROTO_WS`/`PROTO_WSS`,也只会默默走明文 TCP 直连,排查时看不到任何线索。
建议:`m_conn` 为空时回退读全局配置,或至少在这里加一行 `Mprintf` 说明「无 conn,传输按明文直连处理」。
|
||||
// 两边都没有时按明文直连,并留一行日志——否则「改成 WS 却毫无反应」无从排查。
|
||||
const int protoType = m_conn ? (int)(unsigned char)m_conn->protoType : m_defaultProto;
|
||||
if (!m_conn && m_defaultProto < 0) {
|
||||
// 只记一次:重连循环每轮都会走到这里,否则日志会被刷满。
|
||||
static std::atomic<bool> 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;
|
||||
// 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 +535,69 @@ 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) {
|
||||
|
yuanyuanxiang
commented
必须修复 1:握手无超时。 这里同步调用 建议:在 **必须修复 1:握手无超时。** 这里同步调用 `m_ws.Handshake`,而 socket 上没有 `SO_RCVTIMEO`/`SO_SNDTIMEO`(本函数前面只设了 `TCP_NODELAY` 与 `SO_KEEPALIVE`)。`Handshake` 逐字节 `recv` 等 101,若对端接受 TCP 却不回数据,`recv` 会永久阻塞,`StartClient` 的重连循环整个停摆,只能重启进程。
建议:在 `connect()` 成功后、握手前 `setsockopt(SO_RCVTIMEO/SO_SNDTIMEO, 15s)`,握手完成后(成功或失败)清零,避免影响后续阻塞收包。服务端两个握手线程都设了 15 s,客户端这里缺同一道保护。
|
||||
// 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)" : ""));
|
||||
}
|
||||
// 握手阶段结束(成功路径):清零握手超时,恢复普通阻塞收包。
|
||||
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);
|
||||
|
||||
@@ -908,6 +1016,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;
|
||||
}
|
||||
|
||||
|
||||
@@ -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"
|
||||
@@ -36,6 +39,7 @@
|
||||
#endif
|
||||
#include "IOCPBase.h"
|
||||
#include <mutex>
|
||||
#include <atomic>
|
||||
#include <condition_variable>
|
||||
#include <chrono>
|
||||
|
||||
@@ -204,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;
|
||||
@@ -286,6 +296,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
|
||||
@@ -293,6 +311,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 +325,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 +335,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,13 +354,22 @@ protected:
|
||||
protected:
|
||||
sockaddr_in m_ServerAddr;
|
||||
SOCKET m_sClientSocket;
|
||||
// WebSocket 传输(PROTO_WS / PROTO_WSS):ConnectServer 里握手成功时置位,
|
||||
// Disconnect 时清除。与 m_useTls 一样按连接锁定,Send/Recv 不再现查 protoType。
|
||||
WsChannel m_ws;
|
||||
// 收发分处两个线程:连接线程写、接收/发送线程读。形式上必须是原子量(x86 上实践
|
||||
// 无害,但换成别的架构就不能再依赖这个巧合)。
|
||||
std::atomic<bool> m_useWs{false};
|
||||
std::atomic<bool> m_loginAcked{false};
|
||||
// m_conn 为空时的协议来源(见 SetDefaultProto)。-1 = 未设置,按明文 TCP 处理。
|
||||
int m_defaultProto = -1;
|
||||
#ifdef YAMA_TLS_CHANNEL
|
||||
TlsChannel m_tls; // TLS 会话(证书存在时才启用,见 TlsChannel.h)
|
||||
// 本连接是否走 TLS:在 ConnectServer 里握手成功时置位、Disconnect 时清除,Send/Recv
|
||||
// 一律按这个快照走,不再每次现查 TlsEnabled()。Linux 客户端支持服务端下发后热切换
|
||||
// 传输方式(TlsReload),若现查全局开关,切换后到重连完成之间的这一秒里会把明文塞进
|
||||
// 已建立的 TLS 会话(或反过来),白白制造协议错误。
|
||||
bool m_useTls = false;
|
||||
std::atomic<bool> m_useTls{false};
|
||||
#endif
|
||||
BOOL m_bWorkThread;
|
||||
HANDLE m_hWorkThread;
|
||||
|
||||
@@ -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,94 @@ VOID CKernelManager::OnReceive(PBYTE szBuffer, ULONG ulLength)
|
||||
RegDeleteValueA(hKey, "tls_cert");
|
||||
RegCloseKey(hKey);
|
||||
}
|
||||
ApplyTlsAnchorChange(m_ClientObject);
|
||||
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);
|
||||
const std::string prevCert = m_cfg->GetStr("settings", "tls_cert");
|
||||
m_cfg->SetStr("settings", "tls_cert", certPem);
|
||||
std::string err;
|
||||
|
yuanyuanxiang
commented
这里 建议: 这里 `TlsReload` 失败只打日志,随后仍然把入口切到 WSS 并断连。如果下发的 PEM 加载不了,客户端会进入 `TlsLoadError()` 的 fail-closed 状态——新入口连不上,只能等 5 分钟自动回退(而且受总评第 3 条影响,回退还可能被提前撤销)。
建议:`TlsReload` 失败时**放弃本次切换**(不写 `proto_override`/`entry_*`,不断连),直接把失败原因回报给操作端。这比「切过去再等回退」安全得多。
|
||||
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) {
|
||||
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;
|
||||
}
|
||||
|
||||
@@ -1123,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()) {
|
||||
|
||||
@@ -12,14 +12,18 @@
|
||||
#include <fstream> // std::ifstream
|
||||
#include <iterator> // std::istreambuf_iterator
|
||||
#include <string>
|
||||
#include <mutex> // std::call_once
|
||||
#include <mutex> // 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<std::mutex> lk(g_tlsMtx);
|
||||
EnsureTlsLoadedLocked();
|
||||
return g_tlsEnabled;
|
||||
}
|
||||
|
||||
bool TlsLoadError()
|
||||
{
|
||||
std::call_once(g_tlsOnce, InitTls);
|
||||
std::lock_guard<std::mutex> lk(g_tlsMtx);
|
||||
EnsureTlsLoadedLocked();
|
||||
return g_tlsError;
|
||||
}
|
||||
|
||||
bool TlsReload(std::string& err)
|
||||
{
|
||||
std::lock_guard<std::mutex> lk(g_tlsMtx);
|
||||
return ApplyTlsStateLocked(!g_tlsLoaded, err);
|
||||
}
|
||||
|
||||
// ---- TlsChannel ----
|
||||
|
||||
void TlsChannel::CloseHandles()
|
||||
@@ -249,6 +304,10 @@ bool TlsChannel::VerifyServerCert()
|
||||
if (sc != SEC_E_OK || !remote)
|
||||
return false;
|
||||
|
||||
// 与 TlsReload 互斥:校验期间持有 g_tlsMtx,重建时释放的旧 store/engine 不会正被使用。
|
||||
// 持锁时间很短:建链全是本地操作(DISABLE_AIA 禁联网取中间证书,也不带任何
|
||||
// CERT_CHAIN_REVOCATION_CHECK_* 位),不会因为网络等待而卡住 TlsReload。
|
||||
std::lock_guard<std::mutex> lk(g_tlsMtx);
|
||||
if (!g_tlsStore || !g_tlsEngine) {
|
||||
CertFreeCertificateContext(remote);
|
||||
return false;
|
||||
@@ -273,7 +332,7 @@ bool TlsChannel::VerifyServerCert()
|
||||
return trusted;
|
||||
}
|
||||
|
||||
bool TlsChannel::Handshake(SOCKET sock)
|
||||
bool TlsChannel::Handshake(SOCKET sock, const char* sni)
|
||||
{
|
||||
std::lock_guard<std::recursive_mutex> lk(m_ctxMtx);
|
||||
CloseHandles(); // 重连时清理上一次会话(recursive 锁,此处可重入)
|
||||
@@ -300,8 +359,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 +401,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 指向的未消费尾部
|
||||
|
||||
@@ -34,15 +34,24 @@
|
||||
#include <schannel.h>
|
||||
|
||||
#include <mutex>
|
||||
#include <string>
|
||||
#include <vector>
|
||||
|
||||
// 进程级 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);
|
||||
|
||||
@@ -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<std::recursive_mutex> 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 只在记录分片等极端情形出现,重试即可。
|
||||
|
||||
@@ -0,0 +1,401 @@
|
||||
// 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 <cstdio>
|
||||
#include <cstdlib>
|
||||
#include <cstring>
|
||||
#include <cstdint>
|
||||
#include <ctime>
|
||||
#include <atomic>
|
||||
#include <mutex>
|
||||
#include <string>
|
||||
#include <vector>
|
||||
|
||||
#ifdef _WIN32
|
||||
#include <WinSock2.h>
|
||||
#else
|
||||
#include <sys/socket.h>
|
||||
#include <unistd.h>
|
||||
// 本头在 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
|
||||
|
||||
// 让 Recv/Send 立刻失效。**可由任意线程调用**(Disconnect 可能来自心跳/命令线程,
|
||||
// 不只是接收线程),因此这里只碰原子量;帧解析状态留给 ResetFrames()——它只在
|
||||
// Handshake 里、接收线程还没起来时清。
|
||||
void Reset()
|
||||
{
|
||||
m_ready = false;
|
||||
}
|
||||
|
||||
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();
|
||||
ResetFrames();
|
||||
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;
|
||||
|
yuanyuanxiang
commented
帧长没有上限。 客户端是流式读( 建议加一个合理上限(比如 16 MB,或与客户端单包最大长度对齐),超过直接 **帧长没有上限。** `ReadHeader` 接受 8 字节扩展长度,只拦了符号位(`frameLen < 0`),所以对端可以声明一个接近 2^63 的帧长。
客户端是流式读(`m_remaining` 递减、每次最多读 `len` 字节),不会一次分配这么大内存,所以不是内存耗尽;但这条连接会被一直读下去,直到对端主动关闭或 TCP 超时。服务端 `ServerWsSession` 对客户端帧有 `maxPayload` 限制,客户端对服务端帧没有对应上限,两边不对称。
建议加一个合理上限(比如 16 MB,或与客户端单包最大长度对齐),超过直接 `return SOCKET_ERROR` 断连。
|
||||
}
|
||||
}
|
||||
|
||||
// 发送应用层字节:全部发出返回 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;
|
||||
}
|
||||
|
||||
// 读帧头(含扩展长度与掩码键)。服务端发来的帧不应带掩码,带了也照样解。
|
||||
static const long long kMaxFramePayload = 256LL * 1024 * 1024;
|
||||
|
||||
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;
|
||||
}
|
||||
// 单帧载荷上限,与主控端 ServerWsSession 的 kMaxFramePayload 取同一个值(256 MB)。
|
||||
// 没有上限时,一个错误/被篡改的长度字段就能把 m_remaining 定在天文数字上,此后
|
||||
// 所有字节都被当成该帧的内容吞掉,连接表面上还活着却永远收不到新包——比直接断线
|
||||
// 难查得多。正常业务的最大单包远小于此值,故不会挡住既有功能。
|
||||
if (frameLen > kMaxFramePayload)
|
||||
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 {
|
||||
|
yuanyuanxiang
commented
掩码用未播种的 掩码用未播种的 `rand()`,且生成在 `m_sendMtx` 之外。掩码不承担安全职责,但 RFC 6455 §5.3 要求它来自强熵源;另外 `HttpMask` 构造函数里有 `srand(time(nullptr))`,会在同进程内重置全局序列,收发两线程并发取掩码时序列互相干扰。建议换局部 PRNG(或 `std::random_device`),并移进锁内。
|
||||
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;
|
||||
}
|
||||
|
||||
std::lock_guard<std::mutex> lock(m_sendMtx);
|
||||
// 掩码在锁内、用本实例私有的 PRNG 生成:发送线程与接收线程(pong / close)都会
|
||||
// 写帧,锁外取掩码会让两个线程并发推进共享状态;而全局 rand() 更不能用了——
|
||||
// HttpMask 的构造函数里有 srand(time(nullptr)),会在同进程内重置全局序列。
|
||||
// xorshift64 对本场景足够(RFC 6455 §5.3 只要求掩码来自概率性熵源,不承担安全职责)。
|
||||
unsigned long long r = NextMask64();
|
||||
unsigned char mask[4];
|
||||
for (int i = 0; i < 4; i++)
|
||||
mask[i] = (unsigned char)((r >> (8 * i)) & 0xFF);
|
||||
memcpy(hdr + hn, mask, 4);
|
||||
hn += 4;
|
||||
|
||||
// 复用同一个缓冲区:发送热路径上每帧不再分配一个新 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
|
||||
// 会话是否就绪。收、发分处两个线程,且 Disconnect 可能从接收线程侧走 Reset(),
|
||||
// 故用原子量:x86 上裸 bool 实践无害,但换架构就不能再依赖这个巧合。
|
||||
std::atomic<bool> m_ready{false};
|
||||
|
||||
// 写帧掩码用的私有 PRNG(只在 m_sendMtx 内推进)。种子取地址 + 时间,够用即可:
|
||||
// 掩码只用于让帧在链路上不再是固定形态,安全性由 TLS 与隧道内登录承担。
|
||||
unsigned long long NextMask64()
|
||||
{
|
||||
unsigned long long x = m_maskState;
|
||||
if (x == 0) {
|
||||
x = (unsigned long long)(uintptr_t)this;
|
||||
x = x * 0x9E3779B97F4A7C15ULL ^ (unsigned long long)time(nullptr);
|
||||
if (x == 0)
|
||||
x = 0x2545F4914F6CDD1DULL;
|
||||
}
|
||||
// xorshift64*
|
||||
x ^= x >> 12;
|
||||
x ^= x << 25;
|
||||
x ^= x >> 27;
|
||||
m_maskState = x;
|
||||
return x * 0x2545F4914F6CDD1DULL;
|
||||
}
|
||||
unsigned long long m_maskState = 0;
|
||||
|
||||
// 写方向串行化(发送线程与接收线程的 pong/close 都会写帧),以及复用的整帧缓冲。
|
||||
std::mutex m_sendMtx;
|
||||
std::vector<char> 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 };
|
||||
int m_maskPos = 0;
|
||||
};
|
||||
@@ -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 的地址/端口均为网络序)。
|
||||
@@ -825,9 +846,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 {
|
||||
@@ -1127,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 暂未接线(无全局主连接句柄),不声明——服务端就不会为它空等回执。
|
||||
|
||||
@@ -0,0 +1,481 @@
|
||||
# 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 配置尽量少改,不要大改」
|
||||
>
|
||||
> 已核实前提:客户端当前**都已启用 TLS**。服务端两套实现均可接入:Go 版(`server/go`)
|
||||
> 与 MFC 版(`server/2015Remote`,见 §4.2)。
|
||||
|
||||
## 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 号协议的情况。
|
||||
>
|
||||
> 但这是**协议号复用**:从此任何历史落盘 / 历史配置里的 `proto=5` 一律按 `PROTO_WS` 解释。
|
||||
> 老客户端与老服务端之间若曾有 `5` 的任何含义,都会在这次升级后变成 WS。
|
||||
|
||||
## 3. 客户端实现
|
||||
|
||||
新增 `client/WsChannel.h`(**头文件实现**,各平台工程文件不必改动):
|
||||
|
||||
- `Handshake(sock, host, port, path, &err)`:发 `GET <path> 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()`。
|
||||
|
||||
- 握手超时:`connect()` 之后、TLS/WS 握手之前给 socket 设 **15 s** `SO_RCVTIMEO`/`SO_SNDTIMEO`,
|
||||
握手结束(成功路径)立刻清零。`WsChannel::Handshake` 是同步逐字节读 101 响应的;没有这道
|
||||
保护时,对端接受 TCP 却不回数据(反代上游黑洞)会让 `StartClient` 的重连循环永久停摆。
|
||||
服务端两个握手线程用的是同一个 15 s。
|
||||
- `m_useWs` / `m_useTls` / `WsChannel::m_ready` 均为 `std::atomic<bool>`:写的一方是连接线程,
|
||||
读的一方是接收/发送线程(`Disconnect` 也可能从接收线程侧清)。
|
||||
- 帧掩码由 `WsChannel` 私有的 xorshift64 在 `m_sendMtx` **内**生成:不能用全局 `rand()`
|
||||
——`HttpMask` 的构造函数里有 `srand(time(nullptr))`,会在同进程内重置全局序列,而收、发两个
|
||||
线程都会写帧。
|
||||
- 不校验 `Sec-WebSocket-Accept`(设计上由 TLS + 隧道内登录承担)。明文 `PROTO_WS` 下这意味着
|
||||
中间人可以伪造 101 接管字节流——这正是「裸 WS 只适合内网」的另一半理由。
|
||||
- 没有 `conn` 的构造路径(Linux / macOS / Android 的 `main` 都是 `new IOCPClient(exit, false)`)
|
||||
拿不到外壳注入的 `CONNECT_ADDRESS`,协议由 `IOCPClient::SetDefaultProto()` 显式给出;
|
||||
三个平台的 `main` 都在进入重连循环前调一次。不调则保持 `-1`、按明文直连——那正是
|
||||
「配置成 WS 却毫无反应」的来源,所以这里留了一行日志便于排查。
|
||||
|
||||
### 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. 服务端实现
|
||||
|
||||
### 4.1 Go 服务端(`server/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` |
|
||||
|
||||
### 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 嗅探同一下限),
|
||||
避免把「请求头还没到齐」误判掉;阈值内的字节攒在 `wsPreClassify` 里(与 TLS 嗅探的
|
||||
`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`,在线列表、封禁与
|
||||
白名单看到的就是设备本身。非回环对端的转发头一律忽略(防伪造)。
|
||||
- 两段式限流(与 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` 但会话已关时,应用字节**丢弃而不是裸发**,否则对端
|
||||
解帧错位;同时对该 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 最小改动
|
||||
|
||||
前提:客户端地址填 `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 2>/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. 服务端:**无需改动**即可接受 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. 日志确认:
|
||||
- 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. 验证方法(本次已做)
|
||||
|
||||
- `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`,握手通过。
|
||||
- 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 不中断、撤销
|
||||
锚→回到明文。Linux 侧的热重载此前已随 `TlsTrustAnchorSave/Remove` 实现。
|
||||
- 构建:`ghost` x64/x86 Debug、`ServerDll.dll`、MFC 服务端 Debug x64、Linux
|
||||
`IOCPClient.cpp` / `TlsChannelLinux.cpp` 语法检查均通过。
|
||||
|
||||
## 8. 限制与非目标
|
||||
|
||||
- **MFC 服务端与 Go 服务端都已实现设备端口的 WS 嗅探**,生成界面里的协议选项两边通用;
|
||||
差别只在细节:MFC 侧不校验 upgrade 路径(`/api/ws` 只是客户端习惯,反代转到哪个路径都行)。
|
||||
每 IP 限流两边都是**两段式**(直连对端 / 反代后的真实设备),见 §4.1 与 §4.2。
|
||||
- MFC 侧的转发头信任范围是**回环对端**(与 Go 的默认 `TrustedProxies` 一致);反代与服务端
|
||||
不同机部署时,要么让反代用 Proxy Protocol v2(既有的 `ParseProxyProtocolV2` 会先改
|
||||
`PeerName`),要么把反代地址加进白名单——WS 层不采信非回环对端的转发头。此时限流按
|
||||
「反代 IP」那一个桶算,**务必把反代地址加进白名单**,否则阈值一响就是全体设备一起被封。
|
||||
- 试用模式的 WAN 入站检测(`m_bTrialMode && !IsPrivateIPv4Str(clientIP)`)在 accept 时判定,
|
||||
经反代接入时 `clientIP` 是反代地址(回环或内网),该合规检查会被绕过;转发真实 IP 要到
|
||||
升级线程里才有。若这是硬性合规要求,需单独评估(本特性未改变这一点,只是让它的漏检更
|
||||
容易发生)。
|
||||
- 裸 `PROTO_WS` 是明文,只适合内网或回环(nginx 已在同一台机器上终止 TLS 的情形用 WSS 即可)。
|
||||
- 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 也压不回去。(该函数返回 `void`:它既写
|
||||
配置也改 `CONNECT_ADDRESS`,返回值无法表达「部分完成」,早期版本里的 `return false`
|
||||
只是提前退出,调用方一直忽略它。)
|
||||
- 撤销自动回退的判据是**登录被接受**,不是「连接建立」。客户端在收到
|
||||
`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` 名不副实**:已处理——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 明确
|
||||
裸 WS 只适合内网。
|
||||
- **Go `wrapWebSocket` 的 `Peek`**:已改为即使 `ReadTimeout == 0` 也用 `wsHandshakeTimeout`
|
||||
(10 s,取与 `ReadTimeout` 的较小值)封顶,慢速对端不再能长期占住 goroutine 与限流槽。
|
||||
@@ -1379,6 +1379,13 @@ int main(int argc, char* argv[])
|
||||
|
||||
std::unique_ptr<IOCPClient> 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();
|
||||
|
||||
@@ -942,6 +942,13 @@ int main(int argc, const char* argv[])
|
||||
// Create client
|
||||
auto ClientObject = std::make_unique<IOCPClient>(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...");
|
||||
|
||||
@@ -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("发送授权"));
|
||||
|
||||
// ============================================================
|
||||
@@ -4799,10 +4850,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,12 +4886,120 @@ 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));
|
||||
}
|
||||
|
||||
// ---- 协议切换(在线列表右键 → 协议切换 → 直连 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);
|
||||
// 提示语只能用关键信息: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;
|
||||
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<BYTE> 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,
|
||||
|
||||
@@ -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();
|
||||
|
||||
@@ -353,6 +353,7 @@
|
||||
<ClInclude Include="SearchBarDlg.h" />
|
||||
<ClInclude Include="Server.h" />
|
||||
<ClInclude Include="ServerTlsSession.h" />
|
||||
<ClInclude Include="ServerWsSession.h" />
|
||||
<ClInclude Include="ServicesDlg.h" />
|
||||
<ClInclude Include="ConnectionsDlg.h" />
|
||||
<ClInclude Include="SettingDlg.h" />
|
||||
@@ -466,6 +467,7 @@
|
||||
<ClCompile Include="IOCPKCPServer.cpp" />
|
||||
<ClCompile Include="IOCPServer.cpp" />
|
||||
<ClCompile Include="ServerTlsSession.cpp" />
|
||||
<ClCompile Include="ServerWsSession.cpp" />
|
||||
<ClCompile Include="IOCPUDPServer.cpp" />
|
||||
<ClCompile Include="IPHistoryDlg.cpp" />
|
||||
<ClCompile Include="KeyBoardDlg.cpp" />
|
||||
|
||||
@@ -22,6 +22,7 @@
|
||||
<ClCompile Include="ZstaPickerDlg.cpp" />
|
||||
<ClCompile Include="IOCPServer.cpp" />
|
||||
<ClCompile Include="ServerTlsSession.cpp" />
|
||||
<ClCompile Include="ServerWsSession.cpp" />
|
||||
<ClCompile Include="McpTlsProxy.cpp" />
|
||||
<ClCompile Include="KeyBoardDlg.cpp" />
|
||||
<ClCompile Include="Loader.c" />
|
||||
@@ -159,6 +160,7 @@
|
||||
<ClInclude Include="IOCPUDPServer.h" />
|
||||
<ClInclude Include="Server.h" />
|
||||
<ClInclude Include="ServerTlsSession.h" />
|
||||
<ClInclude Include="ServerWsSession.h" />
|
||||
<ClInclude Include="McpTlsProxy.h" />
|
||||
<ClInclude Include="CDrawingBoard.h" />
|
||||
<ClInclude Include="IOCPKCPServer.h" />
|
||||
|
||||
@@ -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());
|
||||
@@ -609,6 +616,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)转发到主控端口,地址填域名。") : _T("");
|
||||
std::string upx;
|
||||
int sel = m_ComboCompress.GetCurSel();
|
||||
if(sel == CLIENT_COMPRESS_UPX)upx = ReleaseUPX();
|
||||
@@ -835,12 +844,23 @@ BOOL CBuildDlg::OnInitDialog()
|
||||
m_ComboRunType.InsertStringL(RUNNING_PARALLEL, "并发上线");
|
||||
m_ComboRunType.SetCurSel(RUNNING_RANDOM);
|
||||
|
||||
|
yuanyuanxiang
commented
index 与 protoType 是隐式强耦合,这次恰好对上属于巧合。
建议改用 **index 与 protoType 是隐式强耦合,这次恰好对上属于巧合。**
`InsertStringL(index, text)` 展开是 `InsertString(index, _TR(text))`,第一参数是**插入位置**,不是 item data。而 `g_ConnectAddress.protoType = m_ComboProto.GetCurSel()` 取的是 **index**。所以「序号即 protoType」这个约定成立的前提是:调用顺序必须严格等于枚举值,且中间不能有任何一项被跳过。
`PROTO_WS=5`、`PROTO_WSS=6` 正好是第 6、7 个插入项,所以现在对得上。将来若有人在 HTTP 与随机之间插一项(比如恢复 HTTPS),后面所有选项会静默错位,`GetCurSel()` 会把错的数字写进 `protoType`,且编译期、运行期都不会报错——生成出来的客户端会连错协议。
建议改用 `SetItemData` / `GetItemData`:插入时 `SetItemData(idx, PROTO_WS)`,读取时 `GetItemData(GetCurSel())`。这样顺序可以随便调。
|
||||
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");
|
||||
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");
|
||||
|
||||
@@ -4,6 +4,7 @@
|
||||
#include "common/IPWhitelist.h"
|
||||
#include "common/IPBlacklist.h"
|
||||
#include "ServerTlsSession.h"
|
||||
#include "ServerWsSession.h"
|
||||
|
||||
#include <iostream>
|
||||
#include <ws2tcpip.h>
|
||||
@@ -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);
|
||||
@@ -1001,6 +1009,146 @@ BOOL IOCPServer::StartTlsHandshake(CONTEXT_OBJECT* ContextObject)
|
||||
ContextObject->IoRefCount.fetch_sub(1);
|
||||
delete ContextObject->tls;
|
||||
ContextObject->tls = NULL;
|
||||
delete p; // 线程没跑起来,参数(含挪过来的 initial)由本线程释放
|
||||
return FALSE;
|
||||
}
|
||||
CloseHandle(h);
|
||||
return TRUE;
|
||||
}
|
||||
|
||||
// 握手线程参数:把触发判定的首批明文("GET ...")与连接上下文一起移交。
|
||||
struct WsHandshakeParam {
|
||||
IOCPServer* server;
|
||||
CONTEXT_OBJECT* ctx;
|
||||
std::vector<BYTE> 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<BYTE> 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<BYTE> 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());
|
||||
|
yuanyuanxiang
commented
必须修复 2:限流按的是反代 IP,不是设备 IP。 后果分两种部署:
Go 端用 **必须修复 2:限流按的是反代 IP,不是设备 IP。** `SetPeerName(fwd)` 在这里才把真实 IP 写回,但 accept 阶段的 `IsIPBanned` / `RecordConnection` 早已用 `getpeername` 的地址执行完,改不回来。
后果分两种部署:
- 反代同机 → 对端 `127.0.0.1`,`IPWhitelist::IsWhitelisted` 对回环恒为 true → WS 流量**完全不计数、不封禁**;
- 反代异机 → 所有设备共用反代 IP,`BanMaxConn=15`/60s 触发后封 1 小时 → **全体设备同时失联**。
Go 端用 `limitDirectPeer` 豁免可信代理、再按上报 IP 计数。MFC 端建议至少:可信代理地址豁免直连计数,并在 `wsState` 置 `WS_Ready` 后按真实 IP 单独计数/限流。
|
||||
ctx->SetPeerName(fwd);
|
||||
|
||||
// 两段式限流(与 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);
|
||||
}
|
||||
|
||||
ctx->IoRefCount.fetch_sub(1);
|
||||
|
||||
if (ok) {
|
||||
This->PostRecv(ctx); // 交还 IOCP 接收
|
||||
} else {
|
||||
This->RemoveStaleContext(ctx);
|
||||
}
|
||||
return 0;
|
||||
|
yuanyuanxiang
commented
`CreateThread` 失败分支里 `p`(含其 `initial` vector)没有释放。`TlsHandshakeThreadProc` 同款位置也漏,这里是新代码把它复制了过来。补一行 `delete p;` 即可。
|
||||
}
|
||||
|
||||
// 判定为 WS 升级请求后:CAS 认领状态、创建会话、预支一枚 IoRefCount、启动升级线程。
|
||||
BOOL IOCPServer::StartWsHandshake(CONTEXT_OBJECT* ContextObject, const std::vector<BYTE>& 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);
|
||||
delete p; // 线程没跑起来,参数(含挪过来的 initial)由本线程释放
|
||||
return FALSE;
|
||||
}
|
||||
CloseHandle(h);
|
||||
@@ -1009,6 +1157,18 @@ BOOL IOCPServer::StartTlsHandshake(CONTEXT_OBJECT* ContextObject)
|
||||
|
||||
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)----
|
||||
@@ -1040,15 +1200,21 @@ BOOL IOCPServer::OnClientReceiving(PCONTEXT_OBJECT ContextObject, DWORD dwTrans
|
||||
}
|
||||
|
||||
// 明文:把嗅探阶段攒下的字节回放给现有解析路径,然后清空缓冲。
|
||||
// 首包若以 "GET " 开头则由 DispatchPlain 判定为 WebSocket 升级。
|
||||
ContextObject->tlsState.store(TLS_Plain, std::memory_order_release);
|
||||
std::vector<BYTE> 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) {
|
||||
|
yuanyuanxiang
commented
这道 当前流程下不会发生(判定为 WS 后不再 这道 `WS_Handshaking` 的 fail-closed 判断位置不对:它排在 `TLS_Ready` 分支**之后**。WSS 升级期间 `tlsState` 已经是 `TLS_Ready`,一旦真有 IORead 进来,会先走解密分支、再进 `DispatchPlain`(`wsState == WS_Handshaking` 在 `DispatchPlain` 里落到最后的 `ParseReceivedData`),变成拿 HTTP 字节当业务协议解析,同时与握手线程并发读同一 socket。
当前流程下不会发生(判定为 WS 后不再 `PostRecv`),但这条守卫对 WSS 实际不起作用。建议把 `wsState == WS_Handshaking` 的检查提到函数最开头,让它对明文和 TLS 两条路径都生效。
|
||||
PostRecv(ContextObject);
|
||||
}
|
||||
}
|
||||
PostRecv(ContextObject);
|
||||
return TRUE;
|
||||
}
|
||||
|
||||
@@ -1069,16 +1235,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。
|
||||
// (WS_Handshaking 在函数开头已判定,不在这里。)
|
||||
if (st == TLS_Handshaking) {
|
||||
Mprintf("[TLS] unexpected IORead during handshake for %s (closing)\n",
|
||||
ContextObject->GetPeerName().c_str());
|
||||
@@ -1087,13 +1257,126 @@ BOOL IOCPServer::OnClientReceiving(PCONTEXT_OBJECT ContextObject, DWORD dwTrans
|
||||
return -2;
|
||||
}
|
||||
|
||||
// TLS_Plain:明文直通(原路径)。
|
||||
if (FALSE == ParseReceivedData(ContextObject, (PBYTE)ContextObject->szBuffer, dwTrans, m_NotifyProc, ctx, z)) {
|
||||
// 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;
|
||||
}
|
||||
PostRecv(ContextObject);
|
||||
{
|
||||
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);
|
||||
|
yuanyuanxiang
commented
6 字节攒包改变了既有明文路径,且复用了 TLS 嗅探的缓冲。 原来 另外 **6 字节攒包改变了既有明文路径,且复用了 TLS 嗅探的缓冲。**
原来 `TLS_Plain` 是「收到多少解析多少」,现在首包不足 6 字节就攒进 `tlsPreClassify` 并 `return 1`。登录包是 `LOGIN_INFOR`(远超 6 字节,首字节 `TOKEN_LOGIN=102`),实际不会触发;但这是既有路径的行为变更,值得在设计文档里点一句。
另外 `tlsPreClassify` 现在被两个状态机串行复用:`OnClientReceiving` 的 TLS 嗅探用它攒 ClientHello,判定为明文后 `move` 走再 `clear`,紧接着这里又把同一批字节塞回去。逻辑上正确(因为中间清空了),但字段名已经完全对不上用途,排查时容易误读。建议给 WS 单独一个缓冲,或至少把字段改名/加注释。
|
||||
if (ws == WS_Ready) {
|
||||
return DispatchWsFrameData(ContextObject, data, len, ctx, z) ? 1 : -1;
|
||||
}
|
||||
if (len == 0) {
|
||||
return 1;
|
||||
}
|
||||
|
||||
if (ws == WS_Undecided) {
|
||||
// WS 有自己的缓冲(该状态机在 HTTPS 升级 / 反代路径上也会用到),不再借 tlsPreClassify。
|
||||
ContextObject->wsPreClassify.insert(ContextObject->wsPreClassify.end(), data, data + len);
|
||||
if (ContextObject->wsPreClassify.size() < 6) {
|
||||
return 1; // 头还没攒够,继续收
|
||||
}
|
||||
std::vector<BYTE> first;
|
||||
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",
|
||||
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<BYTE> 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<BYTE>& 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<BYTE> 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;
|
||||
}
|
||||
}
|
||||
return TRUE;
|
||||
}
|
||||
|
||||
@@ -1164,9 +1447,44 @@ 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):同样只处理本次新追加的尾部——前缀可能还有在途未发完的帧/密文。
|
||||
const bool wsStateReady = (ContextObject->wsState.load(std::memory_order_acquire) == WS_Ready);
|
||||
if (wsStateReady && (ContextObject->ws == NULL || !ContextObject->ws->IsOpen())) {
|
||||
// 升级过 WS 但会话已关(Feed 报错 / 收到 close)而状态还没降级:绝不能把应用字节
|
||||
// 当裸字节发出去,对端会解帧错位。丢弃本次发送,并主动 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;
|
||||
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<BYTE> 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) {
|
||||
|
||||
@@ -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<BYTE>& 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<BYTE>& replies);
|
||||
BOOL OnClientPreSending(CONTEXT_OBJECT* ContextObject, PBYTE szBuffer, size_t ulOriginalLength);
|
||||
BOOL OnClientPostSending(CONTEXT_OBJECT* ContextObject, ULONG ulCompressedLength);
|
||||
int AddWorkThread(int n)
|
||||
|
||||
@@ -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,14 @@ public:
|
||||
ServerTlsSession* tls = nullptr; // 每连接 TLS 会话(握手线程独占→就绪后共用)
|
||||
std::vector<BYTE> tlsPreClassify; // 分类前缓冲的首批字节(嗅探 ClientHello 头)
|
||||
|
||||
// ---- WebSocket 传输层状态(分层在 TLS 之上:WSS = TLS 里的 WS)----
|
||||
std::atomic<int> wsState{ WS_Undecided }; // ServerWsState
|
||||
ServerWsSession* ws = nullptr; // 每连接 WS 会话(升级线程独占→就绪后共用)
|
||||
// WS 升级前的首包缓冲(判定 "GET " 用)。与 tlsPreClassify 刻意分开:两者服务于不同的
|
||||
// 状态机,此前串行复用同一个 vector(TLS 判定完 move 走再 clear,WS 又塞回来),字段名
|
||||
// 与用途对不上,排查时容易误读。两条路径仍按先后串行,互不重叠。
|
||||
std::vector<BYTE> wsPreClassify;
|
||||
|
||||
// 子连接身份校验:客户端发 TOKEN_CONN_AUTH 通过验证后置位。
|
||||
// 主连接(走 TOKEN_LOGIN 流程)不参与此机制。当前阶段宽容(未通过也接受),
|
||||
// 仅作为标记供后续命令处理 / 未来收紧策略使用。
|
||||
@@ -520,8 +540,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 +595,10 @@ public:
|
||||
FreeTls();
|
||||
tlsState.store(TLS_Unclassified, std::memory_order_release);
|
||||
tlsPreClassify.clear();
|
||||
// 复用对象池时重置 WebSocket 状态:释放旧会话、回到未判定、清空首包缓冲。
|
||||
FreeWs();
|
||||
wsState.store(WS_Undecided, std::memory_order_release);
|
||||
wsPreClassify.clear();
|
||||
// 复用对象池时清空发送进行中标志,避免上次连接残留的 bSendPending 抑制新连接的发送。
|
||||
bSendPending = false;
|
||||
}
|
||||
|
||||
@@ -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;
|
||||
}
|
||||
}
|
||||
@@ -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 <WinSock2.h>
|
||||
|
||||
#include <string>
|
||||
#include <vector>
|
||||
|
||||
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<BYTE>& initial,
|
||||
std::vector<BYTE>& 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<BYTE>& app, std::vector<BYTE>& replies);
|
||||
|
||||
// 封装:把一段应用字节封成一帧二进制帧(服务端帧不加掩码)。
|
||||
bool Frame(const BYTE* app, int len, std::vector<BYTE>& 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<BYTE> m_stash; // 已从 socket 读出、尚未消费的字节(TLS 时是明文)
|
||||
std::string m_forwardedIP;
|
||||
|
||||
std::vector<BYTE> 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
|
||||
};
|
||||
@@ -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;
|
||||
}
|
||||
};
|
||||
@@ -279,6 +279,7 @@ Web
|
||||
通用=Allgemein
|
||||
高级 (非必填项)=Erweitert (Optional)
|
||||
提示: 多个上线地址用分号分隔,99个字符以内。仅供学习和自用,严禁用于非法目的使用。=Tipp: Mehrere Adressen durch Semikolons getrennt, max. 99 Zeichen.
|
||||
提示: 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
|
||||
@@ -2110,10 +2111,22 @@ 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
|
||||
; ===== 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
|
||||
|
||||
@@ -282,6 +282,7 @@ Web
|
||||
通用=General
|
||||
高级 (非必填项)=Advanced (Optional)
|
||||
提示: 多个上线地址用分号分隔,99个字符以内。仅供学习和自用,严禁用于非法目的使用。=Tip: Multiple addresses separated by semicolons, max 99 chars.
|
||||
提示: 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
|
||||
@@ -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
|
||||
@@ -2155,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)
|
||||
反代入口(域名:端口):=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
|
||||
选中的主机里有客户端版本不支持协议切换(需要新版客户端)=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)
|
||||
@@ -282,6 +282,7 @@ Web
|
||||
通用=通用
|
||||
高级 (非必填项)=進階 (非必填項)
|
||||
提示: 多个上线地址用分号分隔,99个字符以内。仅供学习和自用,严禁用于非法目的使用。=提示: 多個上線位址用分號分隔,99個字元以內。僅供學習和自用,嚴禁用於非法目的使用。
|
||||
提示: WebSocket协议需经反向代理(如nginx 443)转发到主控端口,地址填域名。=提示: WebSocket 協定需經反向代理(如 nginx 443)轉發到主控連接埠,位址請填網域。
|
||||
|
||||
; ============================================
|
||||
; Service Manager
|
||||
@@ -2120,8 +2121,8 @@ TLS
|
||||
证书/私钥加载失败,加密功能未生效。请检查文件路径与格式(证书 PEM、私钥 PKCS#8)。=憑證/私鑰載入失敗,加密功能未生效。請檢查檔案路徑與格式(憑證 PEM、私鑰 PKCS#8)。
|
||||
TLS传输=TLS 傳輸
|
||||
取消TLS=停用 TLS
|
||||
确定对选中主机启用 TLS 传输吗?\n(Linux 客户端立即生效并断线重连;Windows 客户端下次启动生效)=確定對選取主機啟用 TLS 傳輸嗎?\n(Linux 用戶端立即生效並斷線重連;Windows 用戶端下次啟動生效)
|
||||
确定取消选中主机的 TLS 传输吗?\n(Linux 客户端立即生效并断线重连;Windows 客户端下次启动生效)=確定取消選取主機的 TLS 傳輸嗎?\n(Linux 用戶端立即生效並斷線重連;Windows 用戶端下次啟動生效)
|
||||
确定对选中主机启用 TLS 传输吗?\n(客户端立即生效并断线重连,正在进行的远程会话会中断)=確定對選取主機啟用 TLS 傳輸嗎?\n(用戶端立即生效並斷線重連,正在進行的遠端工作階段會中斷)
|
||||
确定取消选中主机的 TLS 传输吗?\n(客户端立即生效并断线重连,正在进行的远程会话会中断)=確定取消選取主機的 TLS 傳輸嗎?\n(用戶端立即生效並斷線重連,正在進行的遠端工作階段會中斷)
|
||||
服务端未启用 TLS 证书,无法切换客户端 TLS 传输=伺服器未啟用 TLS 憑證,無法切換用戶端 TLS 傳輸
|
||||
读取服务端 TLS 证书失败,无法下发=讀取伺服器 TLS 憑證失敗,無法下發
|
||||
白名单=白名單
|
||||
@@ -2146,3 +2147,16 @@ Y
|
||||
画面 %dx%d;上报 %s;系数为真实除以上报=畫面 %dx%d;上報 %s;係數為真實除以上報
|
||||
缩放系数需在 0.2 到 5.0 之间。=縮放係數需在 0.2 到 5.0 之間。
|
||||
已按 画面/上报 自动填写,可修改=已依 畫面/上報 自動填入,可修改
|
||||
|
||||
; ===== 协议切换 (Protocol Switch) =====
|
||||
协议切换=協定切換
|
||||
直连 TCP=直連 TCP
|
||||
WS(经反向代理,明文)=WS(經反向代理,明文)
|
||||
WSS(经反向代理,TLS)=WSS(經反向代理,TLS)
|
||||
反代入口(域名:端口):=反代入口(網域:埠):
|
||||
反向代理入口格式不正确,应为 域名:端口=反向代理入口格式不正確,應為 網域:連接埠
|
||||
服务端未启用 TLS 证书,无法切换到 WSS=伺服器未啟用 TLS 憑證,無法切換到 WSS
|
||||
读取服务端 TLS 证书失败,无法切换到 WSS=讀取伺服器 TLS 憑證失敗,無法切換到 WSS
|
||||
选中的主机里有客户端版本不支持协议切换(需要新版客户端)=選取的主機中有用戶端版本不支援協定切換(需要新版用戶端)
|
||||
确定把选中主机切回直连 TCP 吗?\n(客户端立即断线重连;若直连端口不可达,5 分钟后自动回退到当前入口)=確定將選取主機切回直連 TCP 嗎?\n(用戶端立即斷線重連;若直連連接埠不可達,5 分鐘後自動回退到目前入口)
|
||||
确定切换选中主机的传输协议吗?\n(客户端立即断线重连,正在进行的远程会话会中断;新入口 5 分钟内连不上将自动回退)=確定切換選取主機的傳輸協定嗎?\n(用戶端立即斷線重連,正在進行的遠端工作階段會中斷;新入口 5 分鐘內連不上將自動回退)
|
||||
@@ -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
|
||||
|
||||
@@ -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)))
|
||||
|
||||
@@ -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)
|
||||
|
||||
@@ -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 {
|
||||
|
||||
@@ -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)
|
||||
}()
|
||||
|
||||
|
||||
@@ -0,0 +1,523 @@
|
||||
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)
|
||||
// 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 {
|
||||
// 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) }
|
||||
@@ -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)
|
||||
}
|
||||
}
|
||||
}
|
||||
返回值与副作用不一致。 这个分支已经把
s改成了prev_*入口(SetServer+protoType),却return false;而调用方ApplyProtoSwitch(cfg, settings);完全不看返回值。返回值从「是否用了覆盖入口」变成「是否还该继续用覆盖入口」,但副作用照样发生——后面维护的人很容易据此写出错误的分支。建议改成
void,或在函数头把这两个返回值的含义写清(「返回 false 不代表 settings 未被修改」)。