Files
SimpleRemoter/common/commands.h
T
yuanyuanxianganddeepseek-flash 445bd8bbb9 Feature: Support the remote terminal on Android hosts
The terminal tools were Windows/Linux only because the Android client had
no COMMAND_SHELL handler: the server opened a shell sub-connection and
the command was silently dropped, leaving exec_command to time out. This
adds the PTY path on the client and the matching server gating.

Client: COMMAND_SHELL on the main connection spawns a terminal thread
that opens an authenticated sub-connection, sends TOKEN_TERMINAL_START
and keeps the PTY alive until the server closes it. common/PTYHandler.h
is reused, with a minSdk-21 openpty built from posix_openpt/grantpt and
/system/bin/sh (mksh) as the shell. A new CLIENT_CAP_TERMINAL bit lets
the server reject old APKs up front with -32005.

Server: the tool masks, instructions and docs matrix accept APK. While
verifying, exec_command left a second echoed copy of the command line in
stdout: mksh forks with ECHO still on, so input written before its line
editor takes over is echoed by the line discipline in addition to the
shell's own redraw. The server now waits for the shell's first output
(the prompt) before sending the command and sentinel, which restores the
single-echo assumption the cleaning step relies on. terminal_exec on a
ready session is unaffected.

Verified on the Android 15 emulator: exec_command returns clean stdout
and real exit codes for id/uname/df/ls (including a failing command),
and terminal_open keeps cwd across commands, pipes work and close is
clean. The committed ghost.apk is stale and must be rebuilt before
release; a rebuilt APK was used for this testing.

Co-Authored-By: deepseek-flash
2026-11-11 21:58:54 +01:00

2214 lines
93 KiB
C++
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
#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 CLIENT_CAP_WINDOW_INFO 0x0100 // 支持 COMMAND_MCP_WINDOW_INFO(带矩形/前后台/最小化状态的窗口列表)与窗口激活(CMD_WINDOW_ACTIVATE_FLAG)
#define CLIENT_CAP_SCREEN_REGION 0x0200 // 支持 COMMAND_SCREEN_PREVIEW_REQ 扩展(区域/窗口/显示器原生分辨率截图)
#define CLIENT_CAP_APK_UPDATE 0x0400 // 支持接收 COMMAND_UPDATE 下发的 APK 并走系统安装器(仅 Android)
#define CLIENT_CAP_SCREEN_CLIPBOARD 0x0800 // 屏幕子连接处理 COMMAND_SCREEN_SET_CLIPBOARD,并把 VK_V 映射成 ACTION_PASTE(仅新版 Android)
#define CLIENT_CAP_LOCK_SCREEN 0x1000 // 屏幕子连接处理 COMMAND_SCREEN_CTRL_ALT_DEL(Android 映射为锁屏 GLOBAL_ACTION_LOCK_SCREEN)
#define CLIENT_CAP_UNINSTALL 0x2000 // 主连接处理 TOKEN_UNINSTALL(Android 拉起系统卸载确认框;Windows 客户端一直支持但不声明)
#define CLIENT_CAP_REMOTE_CHAT 0x4000 // 主连接处理 COMMAND_CHAT(远程交谈子连接;Windows 一直支持但不声明,目前只有新版 Android 声明)
#define CLIENT_CAP_TERMINAL 0x8000 // 主连接处理 COMMAND_SHELL(PTY 终端子连接:exec_command / terminal_*;Linux 一直支持但不声明,目前只有新版 Android 声明)
#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,
// 窗口信息查询(服务端 → 客户端 → 服务端),取代固定 1044 字节、无矩形/前后台信息的
// TOKEN_MACHINE_WINDOWS 旧路径。只有声明 CLIENT_CAP_WINDOW_INFO 的客户端认识。
// 请求: [COMMAND_MCP_WINDOW_INFO][mode:1](mode 0 = 仅可见顶层窗口,按 z 序)
// 响应: [TOKEN_MCP_WINDOW_INFO][mode:1][count:2 LE][WINDOWINFO_MCP * count]
// mode 最高位 0x80 = 列表被单包上限截断(可见窗口多于返回的 count 条),
// 服务端据此报告"列表不完整",不能把没返回的窗口当成不存在。
COMMAND_MCP_WINDOW_INFO = 179,
TOKEN_MCP_WINDOW_INFO = 180,
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, // 平台不支持
SCREEN_PREVIEW_BAD_TARGET = 4, // 目标无效:区域裁剪后为空/窗口不存在或已最小化/显示器序号越界
};
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],可选再跟一个 ScreenCaptureMeta
}; // 头部 16 字节
#pragma pack(pop)
// 截图目标模式(CLIENT_CAP_SCREEN_REGION)。v1 请求没有 mode 字段,等价于 VDESKTOP。
enum ScreenCaptureMode {
SCREEN_CAPTURE_VDESKTOP = 0, // 整个虚拟桌面(v1 行为,可缩放)
SCREEN_CAPTURE_REGION = 1, // 虚拟桌面坐标系里的矩形
SCREEN_CAPTURE_WINDOW = 2, // 按 hwnd 取窗口矩形(最小化窗口无法抓取)
SCREEN_CAPTURE_MONITOR = 3, // 显示器序号(0 = 主显示器,其余按 EnumDisplayMonitors 顺序)
};
// v2 请求扩展:紧跟在 ScreenPreviewReq(前 8 字节保持不变)之后。
// 新服务端只对声明 CLIENT_CAP_SCREEN_REGION 的客户端发 v2;老客户端 memcpy 前 8 字节后
// 忽略追加部分,老服务端永远只发 8 字节,新客户端按包长判断是 v1 还是 v2。
#pragma pack(push, 1)
struct ScreenPreviewReqEx {
uint8_t mode; // ScreenCaptureMode
uint8_t flags; // SCREEN_CAPTURE_F_*
uint16_t monitor; // mode=MONITOR 时的显示器序号
int32_t x, y; // mode=REGION 时的左上角(虚拟桌面坐标,可为负)
int32_t w, h; // mode=REGION 时的宽高(>0)
uint32_t hwnd; // mode=WINDOW 时的窗口句柄
}; // 24 字节
#pragma pack(pop)
#define SCREEN_CAPTURE_F_NATIVE 0x01 // 按源矩形 1:1 抓取,忽略 maxWidth(默认只在 v2 模式下生效)
// v2 响应可选尾块:紧跟在 JPEG 数据之后,声明实际抓取的源矩形,供调用方换算坐标。
// 老服务端只按 header.bytes 取 JPEG,会忽略这段尾块,故可向后兼容。
#define SCREEN_CAPTURE_META_MAGIC 0x324D4353u // 'SCM2'
#pragma pack(push, 1)
struct ScreenCaptureMeta {
uint32_t magic; // SCREEN_CAPTURE_META_MAGIC
int32_t x, y; // 实际抓取的源矩形左上角(虚拟桌面坐标)
int32_t w, h; // 源矩形宽高(缩放前)
uint8_t mode; // ScreenCaptureMode
uint8_t scale; // 缩放百分比(100 = 原生)
uint16_t reserved;
}; // 24 字节
#pragma pack(pop)
static_assert(sizeof(ScreenPreviewReqEx) == 24, "ScreenPreviewReqEx must be 24 bytes");
static_assert(sizeof(ScreenCaptureMeta) == 24, "ScreenCaptureMeta must be 24 bytes");
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 // 操作窗口
// 窗口激活哨兵:代替 SW_* 作为“显示方式”下发,客户端执行真正的置前(最小化先还原,
// 再 AttachThreadInput + BringWindowToTop + SetForegroundWindow)。老客户端会把它当
// 非法 SW 值传给 ShowWindow 而无效果,所以只在 CLIENT_CAP_WINDOW_INFO 能力位下使用。
#define CMD_WINDOW_ACTIVATE_FLAG 0xFFFFFFFFu
// 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;
};
// COMMAND_MCP_WINDOW_INFO 的定长窗口记录(仅 CLIENT_CAP_WINDOW_INFO 客户端发送)。
// 与 WINDOWSINFO 不同:标题是 UTF-8,并带屏幕矩形、z 序和窗口状态位。
#define WINDOWINFO_VISIBLE 0x0001u // IsWindowVisible
#define WINDOWINFO_MINIMIZED 0x0002u // IsIconic
#define WINDOWINFO_MAXIMIZED 0x0004u // IsZoomed
#define WINDOWINFO_FOREGROUND 0x0008u // GetForegroundWindow() == hwnd
#pragma pack(push, 1)
struct WINDOWINFO_MCP {
uint32_t hwnd; // 32 位句柄(被控端为 WOW64 进程,句柄宽度固定 4 字节)
uint32_t pid; // 所属进程 PID
int32_t left; // GetWindowRect,虚拟桌面坐标
int32_t top;
int32_t right;
int32_t bottom;
uint32_t flags; // WINDOWINFO_*
int32_t zorder; // 0 = 最顶层
char title[1024];// UTF-8,NUL 填充
};
#pragma pack(pop)
static_assert(sizeof(WINDOWINFO_MCP) == 1056, "WINDOWINFO_MCP must be exactly 1056 bytes");
// COMMAND_MCP_WINDOW_INFO 响应尾块(可选):虚拟桌面矩形(虚拟桌面坐标)。
// 新客户端在窗口记录之后追加,服务端按包长判定是否存在;老服务端只读 count 条记录、
// 自动忽略尾部。remote_mouse 的 window_hwnd 相对坐标靠它把窗口矩形换算成发送帧归一化坐标。
#define WINDOWINFO_DESKTOP_MAGIC 0x56444350u // 'VDCP'
#pragma pack(push, 1)
struct WINDOWINFO_MCP_DESKTOP {
uint32_t magic;
int32_t left;
int32_t top;
int32_t width;
int32_t height;
};
#pragma pack(pop)
static_assert(sizeof(WINDOWINFO_MCP_DESKTOP) == 20, "WINDOWINFO_MCP_DESKTOP must be exactly 20 bytes");
// 远程交谈
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;
// 窗口信息 RPC(矩形/z 序/前后台)与窗口激活。
caps |= CLIENT_CAP_WINDOW_INFO;
// 区域/窗口/显示器原生分辨率截图(COMMAND_SCREEN_PREVIEW_REQ 的 v2 扩展)。
caps |= CLIENT_CAP_SCREEN_REGION;
#elif defined(__linux__) && !defined(__ANDROID__)
// Linux 客户端作为 C2C 目标端时会回执落盘结果(common/FileTransferV2.h)。
// macOS 暂未接线(无全局主连接句柄),不声明——服务端就不会为它空等回执。
caps |= CLIENT_CAP_C2C_RECV_ACK;
#elif defined(__ANDROID__)
// 收到服务端下发的 APK 后写盘并拉起系统安装器。老 APK 没有这个分支,
// 服务端据此提示「先手动装一次新版」,而不是发一个对方会静默丢弃的包。
caps |= CLIENT_CAP_APK_UPDATE;
// 屏幕子连接写剪贴板(COMMAND_SCREEN_SET_CLIPBOARD)+ VK_V → ACTION_PASTE。
// 更老的 APK 两个分支都没有,收到包只会丢弃,服务端据此提前拒绝而不是假报 ok。
caps |= CLIENT_CAP_SCREEN_CLIPBOARD;
// 锁屏(COMMAND_SCREEN_CTRL_ALT_DEL → GLOBAL_ACTION_LOCK_SCREEN)依赖无障碍服务
// 与 API 28+,和其它运行时能力一样由 main.cpp 登录前探测后追加,不在默认位里声明。
// 卸载主机(TOKEN_UNINSTALL):命令处理是编译进来的,老 APK 收到只会静默丢弃,
// 服务端据此提前拒绝,而不是发一条没人接的命令后假报 ok。
caps |= CLIENT_CAP_UNINSTALL;
// 远程交谈(COMMAND_CHAT → 子连接 + 应用内聊天窗口):同上,老 APK 不认识这条命令。
caps |= CLIENT_CAP_REMOTE_CHAT;
// 远程终端(COMMAND_SHELL → PTY 子连接):老 APK 里 COMMAND_SHELL 是空实现,
// 服务端据此提前拒绝 exec_command / terminal_*,而不是等子连接超时。
caps |= CLIENT_CAP_TERMINAL;
#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;