Fix: Report process uptime and harden the login reserved list

The "启动信息" elapsed time was computed by subtracting a client-formatted
wall-clock string from the master's own local time. Windows clients send their
local time, Linux/Android/macOS send Beijing time, so a host whose clock runs
ahead of the master (UTC+8 clients on a UTC+1 master, a fast CMOS clock) gave a
negative difference that was clamped to 0s — permanently, for that host.

Add RES_UPTIME to the login reserved list: the client reports its process
uptime in seconds, a difference between two readings of the same clock, so
timezone and clock skew cancel out. The master adds the connection's alive
time to get the current value, and keeps the old string path as the fallback
for clients that do not send the field. That fallback now also treats MAC as
Beijing time, which was simply missed.

AddReserved() now goes through one bounds-checked append. The separator used
to be written without any length check (an overflow aborts the client, which
installs no invalid parameter handler), and an over-long value now leaves an
empty slot instead of dropping its separator, so positional lookups cannot
shift.

Verified with an ASan/UBSan test over the encoding boundaries and Debug builds
of the client and the master. The Linux/Android/macOS clients only append the
same field at the end of the list; they were not compiled here.

Co-Authored-By: deepseek-flash
This commit is contained in:
yuanyuanxianganddeepseek-flash committed 2026-11-08 21:49:20 +01:00
1 parent 2e34e49186
commit 2cbed0dcdf
6 files changed
+149 -38

No files matched your search

+7
View File
@@ -543,6 +543,10 @@ int DataProcess(void* /*user*/, PBYTE szBuffer, ULONG ulLength)
} }
// ------------------------------------------------------------------ 网络主线程 // ------------------------------------------------------------------ 网络主线程
// 进程已运行秒数(RES_UPTIME)的单调基准。steady_clock 在 Android 上对应
// CLOCK_MONOTONIC,不受系统时间调整影响;库加载即开始计时。
static const auto g_processStartMono = std::chrono::steady_clock::now();
static void ConnectionThread() static void ConnectionThread()
{ {
LOGI("ConnectionThread → %s:%d", g_serverIp.c_str(), g_serverPort); LOGI("ConnectionThread → %s:%d", g_serverIp.c_str(), g_serverPort);
@@ -585,6 +589,9 @@ static void ConnectionThread()
logInfo.AddReserved(std::to_string(g_myClientID).c_str()); logInfo.AddReserved(std::to_string(g_myClientID).c_str());
logInfo.AddReserved((int)getpid()); // PID logInfo.AddReserved((int)getpid()); // PID
logInfo.AddReserved(FormatFileSize(GetFileSize(g_apkPath)).c_str()); // 文件大小 logInfo.AddReserved(FormatFileSize(GetFileSize(g_apkPath)).c_str()); // 文件大小
logInfo.AddReserved(0); // [19] RES_TLS(Android 无 TLS 通道)
logInfo.AddReserved((int)std::chrono::duration_cast<std::chrono::seconds>(
std::chrono::steady_clock::now() - g_processStartMono).count()); // [20] RES_UPTIME
ClientAuth::g_loginMsg = std::string(logInfo.szStartTime) + "|" + std::to_string(g_myClientID); ClientAuth::g_loginMsg = std::string(logInfo.szStartTime) + "|" + std::to_string(g_myClientID);
LOGI("ClientID=%" PRIu64, g_myClientID); LOGI("ClientID=%" PRIu64, g_myClientID);
+27
View File
@@ -126,6 +126,29 @@ std::string getProcessTime()
return buffer; return buffer;
} }
// 进程已运行秒数(RES_UPTIME)。创建时刻和「现在」都取自本机同一块系统时钟,相减
// 会把时区和整机时钟偏移一起抵消——服务端拿自己本地时间去减 szStartTime 时做不到
// 这一点,时钟领先的主机会被算成负数、钳成恒定的 0s。
// 取不到创建时刻时返回空串,服务端据此退回按 szStartTime 计算。
std::string getProcessUptime()
{
FILETIME creationTime, exitTime, kernelTime, userTime;
if (!GetProcessTimes(GetCurrentProcess(), &creationTime, &exitTime, &kernelTime, &userTime))
return "";
ULARGE_INTEGER created, now;
created.LowPart = creationTime.dwLowDateTime;
created.HighPart = creationTime.dwHighDateTime;
FILETIME nowFt;
GetSystemTimeAsFileTime(&nowFt);
now.LowPart = nowFt.dwLowDateTime;
now.HighPart = nowFt.dwHighDateTime;
if (now.QuadPart <= created.QuadPart)
return "0";
return std::to_string((now.QuadPart - created.QuadPart) / 10000000ULL);
}
int getOSBits() int getOSBits()
{ {
SYSTEM_INFO si; SYSTEM_INFO si;
@@ -479,6 +502,10 @@ LOGIN_INFOR GetLoginInfo(DWORD dwSpeed, CONNECT_ADDRESS& conn, const std::string
// (设计文档 §3.7)。 // (设计文档 §3.7)。
LoginInfor.AddReserved(tlsOnWire ? 1 : 0); LoginInfor.AddReserved(tlsOnWire ? 1 : 0);
// [20] RES_UPTIME:登录时刻的进程已运行秒数,服务端用它算「启动信息」里的时长,
// 不再依赖跨机器的墙钟比较(见 getProcessUptime)。
LoginInfor.AddReserved(getProcessUptime().c_str());
// 本机是不是靠「生成时内嵌的锚」在加密:只有这种情况下,关掉服务端 TLS 才会把它 // 本机是不是靠「生成时内嵌的锚」在加密:只有这种情况下,关掉服务端 TLS 才会把它
// 锁死(在线可下发取消、离线永久失联,见 §3.5)。服务端据此在「取消 TLS」前提示。 // 锁死(在线可下发取消、离线永久失联,见 §3.5)。服务端据此在「取消 TLS」前提示。
// 必须按连接取(IsTlsAnchorEmbedded):分享/并行实例向上线到另一台主控时用的是对方 // 必须按连接取(IsTlsAnchorEmbedded):分享/并行实例向上线到另一台主控时用的是对方
+34 -12
View File
@@ -1144,6 +1144,11 @@ enum LOGIN_RES {
RES_PID = 17, // 进程ID RES_PID = 17, // 进程ID
RES_FILESIZE = 18, // 文件大小 RES_FILESIZE = 18, // 文件大小
RES_TLS = 19, // TLS 传输启用标志 0/1 RES_TLS = 19, // TLS 传输启用标志 0/1
// 登录时刻的「进程已运行秒数」。与 RES_* 里任何时间字符串都不同,它是差值而不是
// 时刻:客户端用同源的两次读数相减(Windows 是 GetProcessTimes 与
// GetSystemTimeAsFileTime,Linux/Android 是同一块墙钟),时区与整机时钟偏移自动
// 抵消。服务端优先用它算运行时长,缺失时退回 szStartTime 字符串那套老逻辑。
RES_UPTIME = 20,
RES_MAX, RES_MAX,
}; };
@@ -1205,33 +1210,50 @@ typedef struct LOGIN_INFOR {
} }
void AddReserved(const char* v) void AddReserved(const char* v)
{ {
if (strlen(szReserved)) AppendField(v ? v : "");
strcat_s(szReserved, "|");
if (strlen(szReserved) + strlen(v) < sizeof(szReserved))
strcat_s(szReserved, v);
} }
void AddReserved(int n) void AddReserved(int n)
{ {
if (strlen(szReserved))
strcat_s(szReserved, "|");
char buf[24] = {}; char buf[24] = {};
sprintf_s(buf, "%d", n); sprintf_s(buf, "%d", n);
if (strlen(szReserved) + strlen(buf) < sizeof(szReserved)) AppendField(buf);
strcat_s(szReserved, buf);
} }
void AddReserved(double f) void AddReserved(double f)
{ {
if (strlen(szReserved))
strcat_s(szReserved, "|");
char buf[24] = {}; char buf[24] = {};
sprintf_s(buf, "%.2f", f); sprintf_s(buf, "%.2f", f);
if (strlen(szReserved) + strlen(buf) < sizeof(szReserved)) AppendField(buf);
strcat_s(szReserved, buf);
} }
std::vector<std::string> ParseReserved(int n = 1) const std::vector<std::string> ParseReserved(int n = 1) const
{ {
return StringToVector(szReserved, '|', n); return StringToVector(szReserved, '|', n);
} }
private:
// 追加一个保留字段。szReserved 是「按位置」解析的(服务端用 LOGIN_RES 下标取值),
// 因此这里有两个硬约束:
// 1. 任何一次写入都不能越界。带长度参数的 strcat_s 溢出时会调用 invalid parameter
// handler —— 服务端装了(2015Remote.cpp),客户端没装,在客户端就是直接 abort。
// 2. 值放不下时只留空槽、不能连槽一起丢。少写一个 '|' 会让后面所有字段整体前移
// 一位,服务端就把安装时间读成程序位数、把用户名读成类型……空槽至少位置是对的。
void AppendField(const char* v)
{
const size_t cap = sizeof(szReserved);
// 用 strlen 而不是 strnlen_s:后者是 MSVC 的 Annex K 扩展,Linux/Android 分支
// 没有(commands.h 在该分支只把 strcat_s/sprintf_s 映射到非安全版本)。
// szReserved 与 v 都是 NUL 结尾的,长度不会越界读取。
size_t cur = strlen(szReserved);
if (cur + 1 >= cap)
return; // 已满:连分隔符都放不下
if (cur > 0)
szReserved[cur++] = '|';
szReserved[cur] = '\0';
size_t len = strlen(v);
if (len >= cap - cur)
return; // 值放不下(含结尾 NUL 的空间):留空槽
memcpy(szReserved + cur, v, len);
szReserved[cur + len] = '\0';
}
} LOGIN_INFOR; } LOGIN_INFOR;
inline uint64_t GetUnixMs() inline uint64_t GetUnixMs()
+10
View File
@@ -1048,6 +1048,15 @@ std::string getProcessStartTime()
return ToPekingTimeAsString(&g_processStartTime); return ToPekingTimeAsString(&g_processStartTime);
} }
// 进程已运行秒数(RES_UPTIME):与 getProcessStartTime 同源,都是本机墙钟,相减后
// 时区不影响结果。服务端用它算运行时长,就不必拿自己的时刻去减别的机器的时刻了。
long long getProcessUptimeSeconds()
{
long long up = static_cast<long long>(std::time(nullptr)) -
static_cast<long long>(g_processStartTime);
return up > 0 ? up : 0;
}
// 获取 CPU 核心数 // 获取 CPU 核心数
int getCPUCores() int getCPUCores()
{ {
@@ -1973,6 +1982,7 @@ int main(int argc, char* argv[])
logInfo.AddReserved((int)getpid()); // [17] RES_PID logInfo.AddReserved((int)getpid()); // [17] RES_PID
logInfo.AddReserved(getFileSize(exePath).c_str()); // [18] RES_FILESIZE logInfo.AddReserved(getFileSize(exePath).c_str()); // [18] RES_FILESIZE
logInfo.AddReserved(TlsEnabled() ? 1 : 0); // [19] RES_TLS(有信任锚即 1) logInfo.AddReserved(TlsEnabled() ? 1 : 0); // [19] RES_TLS(有信任锚即 1)
logInfo.AddReserved((int)getProcessUptimeSeconds()); // [20] RES_UPTIME(登录时已运行秒数)
// 服务端签名输入:与服务端 AddList 处签名格式一致(startTime + "|" + clientID) // 服务端签名输入:与服务端 AddList 处签名格式一致(startTime + "|" + clientID)
ClientAuth::g_loginMsg = std::string(logInfo.szStartTime) + "|" + std::to_string(g_myClientID); ClientAuth::g_loginMsg = std::string(logInfo.szStartTime) + "|" + std::to_string(g_myClientID);
+20
View File
@@ -295,6 +295,18 @@ static std::string getExecutablePath()
return ""; return "";
} }
// 进程已运行秒数(RES_UPTIME)的基准:本文件随进程启动即加载,取加载时刻为起点。
// 与同一块本机墙钟的当前时刻相减,时区不影响结果(下面 getTimeString 固定按 UTC+8
// 格式化,服务端无法据此还原出运行时长)。
static const std::time_t g_processStartTime = std::time(nullptr);
static long long getProcessUptimeSeconds()
{
long long up = static_cast<long long>(std::time(nullptr)) -
static_cast<long long>(g_processStartTime);
return up > 0 ? up : 0;
}
// Get current time string (Beijing time, UTC+8) // Get current time string (Beijing time, UTC+8)
static std::string getTimeString() static std::string getTimeString()
{ {
@@ -599,6 +611,14 @@ static void fillLoginInfo(LOGIN_INFOR& info)
} }
info.AddReserved(std::to_string(g_myClientID).c_str()); info.AddReserved(std::to_string(g_myClientID).c_str());
// PID / 文件大小 / TLS:macOS 暂不上报,占位保持位置(服务端按 LOGIN_RES 下标取值,
// 少发一项会让后面所有字段前移)。
info.AddReserved("");
info.AddReserved("");
info.AddReserved("");
// [20] RES_UPTIME:登录时刻的进程已运行秒数,服务端据此算「启动信息」里的时长
info.AddReserved((int)getProcessUptimeSeconds());
// 服务端签名输入:与服务端 AddList 处签名格式一致(startTime + "|" + clientID) // 服务端签名输入:与服务端 AddList 处签名格式一致(startTime + "|" + clientID)
ClientAuth::g_loginMsg = std::string(info.szStartTime) + "|" + std::to_string(g_myClientID); ClientAuth::g_loginMsg = std::string(info.szStartTime) + "|" + std::to_string(g_myClientID);
+51 -26
View File
@@ -10026,33 +10026,52 @@ CString FormatValue(double dValue, LPCTSTR szUnit)
return str; return str;
} }
// 计算「启动信息」里的运行时长。客户端上报的时间字符串没有时区标记:Windows 客户端 // 计算「启动信息」里的运行时长。有两个数据来源:
// 发的是本机本地时间(client/LoginServer.cpp getProcessTime),Linux/Android 发的是 //
// 北京时间(linux/main.cpp 与 common/commands.h 的 ToPekingTimeAsString,恒为 UTC+8)。 // 1. 新客户端的 RES_UPTIME:登录时上报「进程已运行秒数」。它是个差值而不是时刻,
// 因此基准「现在」必须按客户端类型取:LNX/APK 用北京时间的当前时刻,其余用本地时间。 // 客户端用同一块时钟的两次读数相减,时区与整机时钟偏移都抵消了(Windows 见
// 否则服务端不在 UTC+8 时,北京时间会被当成本地时间,得到的启动时间「在未来」——早先 // client/LoginServer.cpp getProcessUptime)。叠加本次上线时长即为当前运行时长,
// 取绝对值后就成了恒定的时区差(UTC+1 服务端上 Linux 主机永远显示 7h)。 // 与主控在哪个时区、客户端时钟准不准都无关。
CString GetElapsedTime(LPCTSTR szBaseTime, bool pekingBase) //
// 2. 老客户端只有 szStartTime 字符串,没有时区标记:Windows 客户端发的是本机本地
// 时间(getProcessTime),Linux/Android/macOS 发的是北京时间(恒为 UTC+8,macOS
// 见 getTimeString 里的 timeZoneForSecondsFromGMT)。因此基准「现在」必须按客户端
// 类型取:LNX/APK/MAC 用北京时间的当前时刻,其余用本地时间。否则服务端不在 UTC+8
// 时,北京时间会被当成本地时间,得到的启动时间「在未来」。
// 这类错值服务端修正不了,只能显示 0s 等客户端升级——上线后就会走第 1 条。
CString GetElapsedTime(LPCTSTR szBaseTime, bool pekingBase, LPCTSTR szUptime, ULONGLONG ulOnlineSec)
{ {
int nYear, nMonth, nDay, nHour, nMin, nSec; __int64 nSeconds = -1;
if (_stscanf_s(szBaseTime, _T("%d-%d-%d %d:%d:%d"), if (szUptime != NULL && szUptime[0] != _T('\0')) {
&nYear, &nMonth, &nDay, &nHour, &nMin, &nSec) != 6) { __int64 nUptime = _ttoi64(szUptime);
return _T("0s"); if (nUptime >= 0) {
nSeconds = nUptime + (__int64)ulOnlineSec;
// 主控自己的时钟回拨会让上线时长算出负数,此时只用客户端上报的值
if (nSeconds < nUptime) nSeconds = nUptime;
}
} }
CTime tmBase(nYear, nMonth, nDay, nHour, nMin, nSec); if (nSeconds < 0) { // 老客户端:退回按时间字符串计算
CTime tmNow; int nYear, nMonth, nDay, nHour, nMin, nSec;
if (pekingBase) { if (_stscanf_s(szBaseTime, _T("%d-%d-%d %d:%d:%d"),
auto t = ToPekingTime(nullptr); &nYear, &nMonth, &nDay, &nHour, &nMin, &nSec) != 6) {
tmNow = CTime(t.tm_year + 1900, t.tm_mon + 1, t.tm_mday, return _T("0s");
t.tm_hour, t.tm_min, t.tm_sec); }
} else {
tmNow = CTime::GetCurrentTime(); CTime tmBase(nYear, nMonth, nDay, nHour, nMin, nSec);
CTime tmNow;
if (pekingBase) {
auto t = ToPekingTime(nullptr);
tmNow = CTime(t.tm_year + 1900, t.tm_mon + 1, t.tm_mday,
t.tm_hour, t.tm_min, t.tm_sec);
} else {
tmNow = CTime::GetCurrentTime();
}
nSeconds = (tmNow - tmBase).GetTotalSeconds();
// 启动时间「在未来」只可能是时区约定/客户端时钟不一致(如老客户端),此时运行时长
// 不可知,钳成 0 而不是取绝对值,免得把时钟偏差当成运行时长显示出来。
if (nSeconds < 0) nSeconds = 0;
} }
__int64 nSeconds = (tmNow - tmBase).GetTotalSeconds();
// 启动时间「在未来」只可能是时区约定/客户端时钟不一致(如老客户端),此时运行时长
// 不可知,钳成 0 而不是取绝对值,免得把时钟偏差当成运行时长显示出来。
if (nSeconds < 0) nSeconds = 0;
if (nSeconds < 60) if (nSeconds < 60)
return FormatValue((double)nSeconds, _T("s")); return FormatValue((double)nSeconds, _T("s"));
@@ -10117,12 +10136,18 @@ void CMy2015RemoteDlg::OnListClick(NMHDR* pNMHDR, LRESULT* pResult)
CString strText; CString strText;
std::string expired = res[RES_EXPIRED_DATE]; std::string expired = res[RES_EXPIRED_DATE];
expired = expired.empty() ? "" : " Expired on " + expired; expired = expired.empty() ? "" : " Expired on " + expired;
// LNX/APK 客户端上报的启动时间是北京时间,基准时刻按此选(见 GetElapsedTime) // LNX/APK 客户端上报的启动时间是北京时间,基准时刻按此选(见 GetElapsedTime);
const bool pekingBase = (res[RES_CLIENT_TYPE] == "LNX" || res[RES_CLIENT_TYPE] == "APK"); // macOS 的 getTimeString() 同样固定按 UTC+8 格式化,一并按北京时间解释。
const bool pekingBase = (res[RES_CLIENT_TYPE] == "LNX" || res[RES_CLIENT_TYPE] == "APK" ||
res[RES_CLIENT_TYPE] == "MAC");
// 新客户端带 RES_UPTIME(登录时已运行秒数),加上本次上线时长即为当前运行时长;
// 老客户端该字段为空,GetElapsedTime 内部退回按启动时间字符串计算。
CString elapsed = GetElapsedTime(startTime, pekingBase, res[RES_UPTIME],
(ULONGLONG)ctx->GetAliveTime());
strText.FormatL(_T("文件路径: %s%s %s%s\r\n系统信息: %s 位 %s 核心 %s GB %s\r\n启动信息: %s %s %s%s %s\r\n上线信息: %s %d %s Master-%s\r\n客户信息: %s"), strText.FormatL(_T("文件路径: %s%s %s%s\r\n系统信息: %s 位 %s 核心 %s GB %s\r\n启动信息: %s %s %s%s %s\r\n上线信息: %s %d %s Master-%s\r\n客户信息: %s"),
res[RES_PROGRAM_BITS].IsEmpty() ? "" : res[RES_PROGRAM_BITS] + _L(" 位 "), res[RES_FILE_PATH], res[RES_EXE_VERSION], processInfo, res[RES_PROGRAM_BITS].IsEmpty() ? "" : res[RES_PROGRAM_BITS] + _L(" 位 "), res[RES_FILE_PATH], res[RES_EXE_VERSION], processInfo,
res[RES_SYSTEM_BITS], res[RES_SYSTEM_CPU], res[RES_SYSTEM_MEM], res[RES_RESOLUTION], startTime, expired.c_str(), res[RES_SYSTEM_BITS], res[RES_SYSTEM_CPU], res[RES_SYSTEM_MEM], res[RES_RESOLUTION], startTime, expired.c_str(),
res[RES_USERNAME], res[RES_ISADMIN] == "1" ? _L("[管理员]") : res[RES_ISADMIN].IsEmpty() ? "" : _L("[非管理员]"), GetElapsedTime(startTime, pekingBase), res[RES_USERNAME], res[RES_ISADMIN] == "1" ? _L("[管理员]") : res[RES_ISADMIN].IsEmpty() ? "" : _L("[非管理员]"), elapsed,
ctx->GetProtocol().c_str(), ctx->GetServerPort(), typMap[type].c_str(), ctx->GetMasterID().c_str(), res[RES_CLIENT_ID]); ctx->GetProtocol().c_str(), ctx->GetServerPort(), typMap[type].c_str(), ctx->GetMasterID().c_str(), res[RES_CLIENT_ID]);
// 地理信息只在加载了本地 IP 库(QQWry/ip2region)时才查询并展示。 // 地理信息只在加载了本地 IP 库(QQWry/ip2region)时才查询并展示。
// 未装库时 m_IPConverter 是网络版 GetGeoLocation(同步外网 HTTP,可达数秒), // 未装库时 m_IPConverter 是网络版 GetGeoLocation(同步外网 HTTP,可达数秒),