♧ Godown 安全知识树

LoudSunRun 动态堆栈欺骗:伪造 RtlUserThreadStart/BaseThreadInitThunk 帧 + kernel32 jmp [rbx] gadget,为任意函数调用构造假调用栈

pentest/c2 · verified

一句话结论

在 Windows x64 上,LoudSunRun 式"动态堆栈欺骗"让任意函数调用(printf、Sleep、NtAllocateVirtualMemory 等)在发起时带上一整条伪造的线程调用栈:按 .pdata 展开信息算出 RtlUserThreadStart+offset、BaseThreadInitThunk+offset 与 kernel32 内一条 jmp qword ptr [rbx] gadget 的帧大小,在当前栈上新造这三帧,把保存原始寄存器/返回地址/SSN 的 PRM 上下文放进 rbx,然后 jmp(而非 call)目标函数;目标函数返回时落到 gadget,经 jmp [rbx] 进入 Fixup,加回假栈空间、恢复寄存器后跳回真实返回地址,于是栈回溯从头到尾只看得到系统模块帧。

原理

  • 目标与检测面:EDR 常在 ntdll 导出函数的用户态 hook 或 ETW 回调里遍历调用栈,检查发起敏感 API 的模块/返回地址是否可疑。本手法在"任意函数即将发起"的时刻主动重建一条从 RtlUserThreadStart→BaseThreadInitThunk→系统函数→目标函数 的完整假调用链,而不是等到 Sleep 期间才改栈,因此对每一次敏感调用都生效。
  • x64 回溯规则:回溯器从当前 RIP 出发,按 PE 的 .pdata(RUNTIME_FUNCTION→UNWIND_INFO→UNWIND_CODE)解读每帧序言对 RSP/RBP 的修改并逐帧上溯,返回地址落在哪个模块、函数内什么位置是判定依据。只要假帧的大小与真实系统函数的展开信息一致、写入的返回地址又落在合法系统模块内,回溯器就会走完这条链而不报错。
  • gadget 选择与帧大小计算:FindGadget 在 kernel32 的可执行段内按字节扫描 FF 23(jmp qword ptr [rbx]),这类指令出现在正常函数内部/尾声附近,因此回溯时“系统函数中间地址”看起来合理;CalculateFunctionStackSizeWrapper 用 RtlLookupFunctionEntry 找到地址所属 RUNTIME_FUNCTION,解析 UNWIND_INFO 的 UnwindOp(UWOP_ALLOC_SMALL/UWOP_ALLOC_LARGE/UWOP_PUSH_NONVOL 等)累加出该函数的栈帧大小,用于 sub rsp, size 的精确步进。
  • PRM 上下文结构:一块普通内存结构保存 Fixup、原始返回地址、原始 rbx/rdi/rsi/r12-r15、三个假帧的栈大小与返回地址、SSN、gadget 地址等(按 8 字节字段依次排列,Fixup 位于偏移 0,原始返回地址位于偏移 8)。伪造期间 PRM 指针放在 rbx,gadget 的 jmp [rbx] 因而跳到 Fixup 字段。
  • 构造阶段:Spoof 入口先 pop rax 把真实返回地址从栈上取下(这使 Spoof 自身在回溯器眼里成为“叶子函数”,其返回地址位置让位给后面的假帧),把 rdi/rsi 等寄存器存入 PRM,并把 PRM 指针载入 rdi、目标函数地址载入 rsi;随后 sub rsp, 0x200 分配工作区并 push 0 写入哨兵截断原来的调用者栈,再依次 sub rsp, RUTS_ss/mov [rsp], RUTS_retaddr、sub rsp, BTIT_ss/mov [rsp], BTIT_retaddr、sub rsp, Gadget_ss/mov [rsp], gadget 造出三帧(由高到低)。
  • 为什么用 jmp 而不是 call:call 会在栈上再压一个本模块的返回地址并被回溯发现;直接 jmp 目标函数时目标函数的返回地址就是假 gadget 帧顶部的值,真实执行流与回溯链彻底分离。目标函数执行期间栈顶依次是“gadget → BaseThreadInitThunk → RtlUserThreadStart”,没有任何 LoudSunRun 模块的帧。
  • 返回阶段:目标函数 ret 落到 jmp [rbx] gadget,rbx 指向 PRM,于是跳进 Fixup;Fixup 先把 rsp 加回 0x200 + Gadget_ss + BTIT_ss + RUTS_ss,再从 PRM 恢复 rbx/rdi/rsi/r12-r15,最后 jmp qword ptr [PRM+8] 回到原始返回地址,调用者无感。
  • 多参数支持:Spoof 的前 4 个参数转发给目标函数的前 4 个寄存器参数;第 5 个参数是 PRM 指针、第 6 个是目标函数、第 7 个是“额外参数个数”。处理循环以原调用者栈上的第 5 个参数位置 [rsp+0x30] 为源、以“0x200 + push 0 的 8 字节 + 三个假帧大小 − 0x20”为基址算出假栈上的目标槽位(第一个栈参数位于 rsp+0x28,之后每个 +8),用 push [r10]; pop [r15] 逐个搬运,因此任意参数个数的函数都能被包装。
  • 间接系统调用集成:调用 Nt 系列函数时,可在 jmp 前把 SSN 写入 rax、把 rcx 复制进 r10(syscall 调用约定),目标地址传 pNtAllocateVirtualMemory+0x12 这类 ntdll 内 syscall 指令地址,使 syscall、ret 都执行在 ntdll 中,同时干掉“syscall 指令不在 ntdll”与“调用栈无合法模块”两类特征。
  • 偏移校准:RtlUserThreadStart 与 BaseThreadInitThunk 的“线程底部帧”偏移随 Windows 版本/Build 不同(示例机器上分别为 +0x21 与 +0x14,另一环境下 RtlUserThreadStart 为 +0x28),必须先在实际目标系统上用 Process Hacker/x64dbg 观察真实线程栈取得,不能硬编码。

触发条件

  • Windows x64 用户态代码执行(通常为 loader/implant 内),能在当前线程上控制 RSP 与通用寄存器。
  • 能解析模块 .pdata/UNWIND_INFO(RtlLookupFunctionEntry 或自实现解析),并能定位 kernel32 中的 jmp qword ptr [rbx] 指令。
  • 已针对目标 Windows 版本校准 RtlUserThreadStart/BaseThreadInitThunk 的栈底帧偏移。
  • 目标函数遵循 x64 调用约定,且调用期间不依赖调用者栈上未被保存/搬运的局部数据;进程未启用 CET shadow stack 等硬件级返回地址保护。

利用步骤

  1. 用调试器/Process Hacker 在目标系统上找一个真实线程的栈底帧,记下 RtlUserThreadStart+off1 与 BaseThreadInitThunk+off2(如 +0x21 / +0x14,随版本变化)。
  2. 在 kernel32 可执行段扫描 FF 23 得到 jmp qword ptr [rbx] gadget;用 .pdata/UNWIND_INFO 算出 gadget 所属函数、RtlUserThreadStart+off1、BaseThreadInitThunk+off2 的帧大小。
  3. 准备 PRM 上下文,填入三个假帧的栈大小/返回地址、gadget 地址、SSN 与寄存器保存槽。
  4. Spoof 入口 pop 真实返回地址并保存 rdi/rsi/r12-r15;把 PRM 指针放入 rdi、目标函数放入 rsi;按需把额外栈参数从原调用者栈搬到假栈对应槽位。
  5. sub rsp,0x200、push 0 截断旧栈,依次铺设 RtlUserThreadStart、BaseThreadInitThunk、gadget 三帧。
  6. 把真实返回地址、原 rbx 与 Fixup 地址写入 PRM,rbx 指向 PRM;若用间接系统调用,rcx→r10、SSN→rax,目标地址取 ntdll syscall 指令。
  7. jmp 目标函数;函数返回后落 gadget→Fixup,恢复栈与寄存器,跳回原返回地址。
  8. 用 Process Hacker 验证:调用期间线程栈应为“目标函数(如 msvcrt!printf)→ kernel32 某系统函数+固定偏移(gadget)→ BaseThreadInitThunk+off2 → RtlUserThreadStart+off1”,不得出现调用方模块的帧。

PoC

以下为按文章代码结构重写的最小示意(非完整可编译代码),展示 PRM 布局与 Spoof 的关键汇编流程:

typedef struct {           // PRM
    void *fixup;           // +0   Fixup 地址,rbx 指向本结构时 jmp [rbx] 命中这里
    void *og_retaddr;      // +8   原始返回地址
    void *rbx, *rdi;       // +16, +24
    void *btit_ss, *btit_retaddr;   // +32, +40
    void *gadget_ss;       // +48
    void *ruts_ss, *ruts_retaddr;   // +56, +64
    void *ssn;             // +72
    void *trampoline;      // +80  gadget 地址
    void *rsi, *r12, *r13, *r14, *r15; // +88..+120
} PRM;

// 初始化:gadget = scan(kernel32, "\xFF\x23"); ss = unwind_frame_size(fn);
// p.trampoline = gadget; p.gadget_ss = ss(gadget);
// p.ruts_retaddr = RtlUserThreadStart + off1; p.ruts_ss = ss(ruts_retaddr);
// p.btit_retaddr = BaseThreadInitThunk + off2; p.btit_ss = ss(btit_retaddr);

Spoof("hello %d\n", 1, 0, 0, &p, pPrintf, 0);   // 7 个固定参数
Spoof(4000, 0, 0, 0, &p, pSleep, 0);
p.ssn = SSN_NtAllocateVirtualMemory;
Spoof((void*)-1, &base, 0, &size, &p, pNtAllocateVirtualMemory + 0x12, 2);

Spoof 的核心流程(x64 汇编要点):

Spoof proc
    pop  rax                  ; 真实返回地址,rsp 回到调用者栈
    mov  rdi, [rsp+20h]       ; 第 5 个参数 PRM(pop 后各参数偏移 -8)
    mov  rsi, [rsp+28h]       ; 第 6 个参数 目标函数
    ; [略] 保存 OG rdi/rsi/r12-r15 到 PRM(含 OG r12),载入 PRM 指针→rdi、目标函数→rsi
    mov  r12, rax             ; 用非易失寄存器暂存原始返回地址
    mov  rbx, rdi
    ; 额外参数循环:r10 初值 rsp+30h,循环内先 +8 再读(首个读到第 8 个参数),
    ; r14 计算假栈上的目标偏移,push [r10]; pop [r15] 逐个搬运
    sub  rsp, 200h
    push 0                    ; 哨兵,截断原调用者栈
    sub  rsp, [rdi+38h]       ; RUTS 帧
    mov  r11, [rdi+40h]
    mov  [rsp], r11
    sub  rsp, [rdi+20h]       ; BTIT 帧
    mov  r11, [rdi+28h]
    mov  [rsp], r11
    sub  rsp, [rdi+30h]       ; gadget 帧
    mov  r11, [rdi+50h]
    mov  [rsp], r11
    mov  [rdi+8], r12         ; 原返回地址
    lea  r11, [fixup]
    mov  [rdi], r11           ; PRM->fixup
    mov  rbx, rdi             ; rbx = PRM
    mov  r10, rcx
    mov  rax, [rdi+48h]       ; SSN(直接调用时无意义)
    mov  r11, rsi
    jmp  r11                  ; jmp 而非 call
fixup:
    mov  rcx, rbx
    add  rsp, 200h
    add  rsp, [rbx+30h]
    add  rsp, [rbx+20h]
    add  rsp, [rbx+38h]
    ; 从 PRM 恢复 rbx/rdi/rsi/r12-r15
    jmp  qword ptr [rcx+8]    ; 回原始返回地址
Spoof endp

变体与关联

  • SilentMoonwalk/StackMoonwalk 系:用 UWOP_SET_FPREG/UWOP_PUSH_NONVOL 展开码让回溯器“自愿”把 RSP 切到攻击者假栈,追求整条链可无异常展开;本框架则直接用真实系统函数的帧大小拼三帧,实现更小、参数支持更通用,两者可组合。
  • jmp [rbp+0x48] 尾声 gadget 变体:把跳板换成 jmp qword ptr [rbp+0x48] 等尾声型指令、把 Fixup 指针放在 [rbp+0x48],机制相同,只是寄存器/偏移不同。
  • 间接系统调用:本框架把 SSN 放 rax、rcx 放 r10 后跳到 ntdll 内 syscall 指令(如 pNtAllocateVirtualMemory+0x12),可与任意 Nt 函数组合;单独使用时即常见的间接 syscall 绕过 ntdll hook 手法。
  • 静态/睡眠期欺骗(返回地址截断、sleepmask 改 CONTEXT):只在 Sleep 窗口或某一帧上做手脚;本卡是“每次调用都主动伪造”,检测面更广、实现成本更高。
  • 手工校准:先在 x64dbg 中手动在某函数栈底写入两帧 RtlUserThreadStart+offset 并用 Process Hacker 查看,可快速确认目标系统的线程底帧偏移,是写 Spoof 代码前的必要步骤。

检测与防御

  • 返回地址前指令校验:本手法用 jmp 而非 call 进入目标函数,假 gadget 帧的返回地址指向 jmp [rbx] 指令本身,其“前一指令”通常不是 call;EDR 可对回溯到的每个返回地址检查前一指令是否为 call(需排除尾调用/转发 thunk 的正常情况),不满足即高度可疑。
  • 帧地址合理性:假帧返回地址虽落在系统模块内,但常见为 RtlUserThreadStart+0x21、BaseThreadInitThunk+0x14 这类固定函数内偏移;可结合线程真实入口 Win32StartAddress、线程栈底/栈范围与 RtlVirtualUnwind 结果做交叉校验。
  • 栈布局一致性:检查调用链中系统函数的帧大小是否与 .pdata 展开信息吻合、返回地址是否指向函数中间非调用点、RSP 是否在该线程已提交栈区间内。
  • 硬件/内核侧:启用 CET shadow stack(硬件支持时)使伪造返回地址无法通过 ret 校验;使用 Intel PT/ETW-TI 做硬件级控制流与内核栈回溯,不依赖用户态栈;对 jmp [rbx] gadget 密集出现的模块区域做代码完整性/异常跳转监控。
  • 缓解:对高风险进程启用 Arbitrary Code Guard/CIG、阻止私有可执行内存与未签名模块加载,降低 loader 先执行起来的前提。
  • 溯源:Process Hacker 等用户态工具看到的栈可被完整欺骗,不能作为唯一证据;需结合内核 ETW、内存扫描(未备份可执行页)、模块签名与磁盘文件比对。