重叠原理

x86-64 指令结构:可选前缀 → 操作码 → 可选操作数。多字节指令的中间字节可能恰好是合法的单字节操作码。

字节序列

6A  51  58  48 FF C0  C3

共 7 字节,各字节含义取决于解码起点。

用 od 查看原始字节

python3 -c "import sys; sys.stdout.buffer.write(bytes([
    0x6A, 0x51, 0x58, 0x48, 0xFF, 0xC0, 0xC3]))" > overlap.bin

od -A x -t x1 overlap.bin

字节逐条解析

offset 0: 0x6A  → push imm8 操作码(需要 1 字节立即数)
offset 1: 0x51  → 作为立即数被 push 消耗
offset 2: 0x58  → pop rax 操作码
offset 3: 0x48  → REX.W 前缀
offset 4: 0xFF  → inc/dec 操作码组
offset 5: 0xC0  → ModRM: mod=11, reg=000(/0), rm=000 → inc rax
offset 6: 0xC3  → ret 操作码

从 offset 0 解码(执行流 A)

CPU 从 offset 0 开始读取:

offset

字节

解码结果

0-1

6A 51

push 0x51 — 操作码 6A + 立即数 51

2

58

pop rax

3-5

48 FF C0

inc rax — REX.W + inc /0

6

C3

ret

从 offset 1 解码(执行流 B)

CPU 从 offset 1 开始读取:

offset

字节

解码结果

1

51

push rcx — 51 本身是 push rcx 的操作码

2

58

pop rax

3-5

48 FF C0

inc rax

6

C3

ret

重叠点

offset 1 的字节 0x51 同时是两个不同含义:

执行流 A: 0x6A 是操作码, 0x51 是被消耗的操作数(立即数)
执行流 B: 0x51 自身就是操作码(push rcx)

从 offset 2 起两条流共享相同的指令序列(pop rax; inc rax; ret),但 offset 0-1 的差异已经产生了不同的栈效果和不同的返回值。

objdump 反编译验证

生成二进制文件并反汇编:

python3 -c "import sys; sys.stdout.buffer.write(bytes([
    0x6A, 0x51, 0x58, 0x48, 0xFF, 0xC0, 0xC3]))" > overlap.bin

echo "--- 执行流 A(入口 +0)---"
objdump -D -b binary -m i386:x86-64 --start-address=0 overlap.bin

echo "--- 执行流 B(入口 +1)---"
objdump -D -b binary -m i386:x86-64 --start-address=1 overlap.bin

从 +0 开始,6A 51 被解码为 push $0x51,字节 0x51 是立即数。从 +1 开始,51 被独立解码为 push %rcx,它是操作码。同一段内存,两种解码结果。

Python 手动解码验证

创建decode.py​

code = bytes([0x6A, 0x51, 0x58, 0x48, 0xFF, 0xC0, 0xC3])

print("Stream A decode (entry +0):")
print("  offset 0: 0x6A = push imm8 opcode")
print("  offset 1: 0x51 = immediate operand (consumed by push)")
print("  offset 2: 0x58 = pop rax")
print("  offset 3-5: 0x48 0xFF 0xC0 = REX.W + inc /0 rax")
print("  offset 6: 0xC3 = ret")
print()
print("Stream B decode (entry +1):")
print("  offset 1: 0x51 = push rcx opcode")
print("  offset 2: 0x58 = pop rax")
print("  offset 3-5: 0x48 0xFF 0xC0 = REX.W + inc /0 rax")
print("  offset 6: 0xC3 = ret")
print()
print("Overlap: byte 0x51 at offset 1")
print("  In A: immediate operand of push")
print("  In B: opcode of push rcx")

执行行为逐条分析

执行流 A(入口 +0)

push 0x51      ; rsp -= 8, 栈顶写入 0x51
pop rax        ; rax = 0x51, rsp += 8
inc rax        ; rax = 0x52
ret            ; 弹出返回地址,正常返回

栈变化:

  1. push 0x51:rsp 减 8,将 0x51 压入栈
  2. pop rax:从栈顶取出 0x51 放入 rax,rsp 加 8
  3. push 和 pop 配对,栈完全平衡

返回值:rax = 0x52

执行流 B(入口 +1)

push rcx       ; rsp -= 8, 栈顶写入 rcx 的当前值
pop rax        ; rax = rcx 的当前值, rsp += 8
inc rax        ; rax = rcx + 1
ret            ; 弹出返回地址,正常返回

栈变化:

  1. push rcx:rsp 减 8,将 rcx 压入栈
  2. pop rax:从栈顶取出 rcx 放入 rax,rsp 加 8
  3. push 和 pop 配对,栈平衡

返回值:rax = rcx + 1,取决于调用时 rcx 的值

两条流执行不同的指令序列(push imm8 vs push rcx),返回不同的值,但共享同一段 7 字节内存。

执行测试

创建run_overlap.c​

#include <stdio.h>
#include <string.h>
#include <sys/mman.h>

static const unsigned char code[] = {
    0x6A, 0x51,             /* push 0x51     */
    0x58,                   /* pop rax       */
    0x48, 0xFF, 0xC0,       /* inc rax       */
    0xC3,                   /* ret           */
};

typedef long long (*fn_t)(void);

int main(void) {
    void *exec = mmap(NULL, sizeof(code),
                      PROT_READ | PROT_WRITE | PROT_EXEC,
                      MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
    memcpy(exec, code, sizeof(code));

    /* 执行流 A:入口 +0 */
    fn_t stream_a = (fn_t)((unsigned char *)exec + 0);
    printf("A (+0): rax = 0x%llx\n", stream_a());

    /* 执行流 B:入口 +1,rcx 置 0 使返回值可预测 */
    long long r_b;
    __asm__ volatile (
        "xor %%rcx, %%rcx\n"
        "call *%[e]\n"
        : "=a"(r_b)
        : [e] "r"((unsigned char *)exec + 1)
        : "rcx", "r11", "memory"
    );
    printf("B (+1): rax = 0x%llx\n", r_b);
    return 0;
}

编译运行:

gcc -O1 -o run_overlap run_overlap.c && ./run_overlap

执行流 A 返回 0x52(push 0x51 → pop rax → inc)。执行流 B 返回 0x1(rcx = 0 → push rcx → pop rax → inc)。同一段 7 字节,两种行为。

条件分支扩展:syscall 路径与干净返回

单字节重叠展示了字节二义性。条件分支可以在同一段机器码中切换两条完整的执行路径,一条包含 syscall,另一条直接返回。

字节布局

20 字节,各字节含义:

offset  字节                指令                      说明
00:     74 0E               jz +14 → offset 16       条件跳转
02:     48 31 FF            xor rdi, rdi             rdi = 0 (fd=0)
05:     48 C7 C0 01 00..    mov rax, 1               rax = 1 (write)
0C:     0F 05               syscall                  write(0, NULL, 0)
0E:     EB 03               jmp +3 → offset 13       跳过干净路径
10:     48 31 C0            xor rax, rax             rax = 0 ← 干净路径入口
13:     C3                  ret                      返回

注意 offset 的计算:

  • jz +14:指令长度 2 字节(offset 0-1),跳转目标 = 0 + 2 + 14 = 16
  • jmp +3:指令长度 2 字节(offset 0E-0F),跳转目标 = 0x0E + 2 + 3 = 0x13

两条执行流

执行流 A(入口 +0,ZF=0 不跳转)

offset 00: jz not taken           ; ZF=0,不跳转,继续执行
offset 02: xor rdi, rdi           ; rdi = 0
offset 05: mov rax, 1             ; rax = 1 (syscall nr: write)
offset 0C: syscall                ; write(0, NULL, 0) → 返回错误码
offset 0E: jmp +3 → 13            ; 跳过 offset 10 处的干净路径
offset 13: ret                    ; 返回 syscall 的错误码

syscall 参数:

  • rdi = 0(fd = stdin)
  • rsi = 未初始化(buffer 地址无效)
  • rdx = 未初始化(length)
  • 内核返回 -EFAULT(-14)或 -EBADF(-9),取决于内核版本检查参数的顺序

执行流 B(入口 +16)

offset 10: xor rax, rax           ; rax = 0
offset 13: ret                    ; 返回 0

不执行 syscall,直接返回 0。

完整代码与验证

用od 查看原始字节

python3 -c "import sys; sys.stdout.buffer.write(bytes([
    0x74, 0x0E,
    0x48, 0x31, 0xFF,
    0x48, 0xC7, 0xC0, 0x01, 0x00, 0x00, 0x00,
    0x0F, 0x05,
    0xEB, 0x03,
    0x48, 0x31, 0xC0,
    0xC3]))" > overlap_b.bin

od -A x -t x1 overlap_b.bin

objdump 反汇编验证

python3 -c "import sys; sys.stdout.buffer.write(bytes([
    0x74, 0x0E,
    0x48, 0x31, 0xFF,
    0x48, 0xC7, 0xC0, 0x01, 0x00, 0x00, 0x00,
    0x0F, 0x05,
    0xEB, 0x03,
    0x48, 0x31, 0xC0,
    0xC3]))" > overlap_b.bin

echo "--- 执行流 A(完整反汇编)---"
objdump -D -b binary -m i386:x86-64 --start-address=0 overlap_b.bin

echo "--- 执行流 B(入口 +16)---"
objdump -D -b binary -m i386:x86-64 --start-address=16 overlap_b.bin

整反汇编显示两条路径共存于同一段内存:

  • offset 0x00-0x0E:syscall 路径(jz → xor → mov → syscall → jmp)
  • offset 0x10-0x13:干净路径(xor → ret)
  • offset 0x0E 的 jmp 0x13 跳过了干净路径的 xor rax, rax,直接从 syscall 跳到 ret

执行测试

创建run_overlap2.c​

#include <stdio.h>
#include <string.h>
#include <sys/mman.h>

static const unsigned char code_b[] = {
    0x74, 0x0E,
    0x48, 0x31, 0xFF,
    0x48, 0xC7, 0xC0, 0x01, 0x00, 0x00, 0x00,
    0x0F, 0x05,
    0xEB, 0x03,
    0x48, 0x31, 0xC0,
    0xC3,
};

typedef long long (*fn_t)(void);

int main(void) {
    void *exec = mmap(NULL, sizeof(code_b),
                      PROT_READ | PROT_WRITE | PROT_EXEC,
                      MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
    memcpy(exec, code_b, sizeof(code_b));

    /* 执行流 A:ZF=0,触发 syscall */
    long long r_a;
    __asm__ volatile (
        "cmp $1, %%ecx\n"
        "call *%[e]\n"
        : "=a"(r_a)
        : [e] "r"((unsigned char *)exec + 0)
        : "r11", "memory"
    );
    printf("A (+0):  rax = %lld  (syscall 返回错误码)\n", r_a);

    /* 执行流 B:入口 +16,直接返回 0 */
    fn_t stream_b = (fn_t)((unsigned char *)exec + 16);
    printf("B (+16): rax = %lld  (无 syscall)\n", stream_b());
    return 0;
}

​

gcc -O1 -o run_overlap2 run_overlap2.c && ./run_overlap2

同一段 20 字节的内存,包含 syscall 指令和绕过 syscall 的路径。调用入口决定执行哪条流。

静态分析工具的盲区

静态反汇编工具(objdump、IDA、Ghidra 等)默认从函数入口线性扫描。对于第一个例子,从 offset 0 扫描的结果是:

   0:   push   $0x51
   2:   pop    %rax
   3:   inc    %rax
   6:   ret

工具看到的是执行流 A。如果代码中存在间接跳转(如 call *%rax),且跳转目标是 offset +1,CPU 执行的是执行流 B。但 objdump 不会从 offset 1 开始独立分析,因此 push rcx 在反汇编输出中不可见。

对于第二个例子,objdump 的完整反汇编显示了所有指令,包括 offset 0x10 处的干净路径。但 jmp 0x13 跳过了 xor rax, rax,这意味着:

  • 执行流 A 经过 syscall 后,通过 jmp 直接跳到 ret
  • offset 0x10 处的 xor rax, rax 只有在 jz 跳转(ZF=1)时才会执行

用 objdump 的 --stop-address 隔离指令

echo "=== offset 0-6(执行流 A 的指令)==="
objdump -D -b binary -m i386:x86-64 --start-address=0 --stop-address=7 overlap.bin

echo "=== offset 1-6(执行流 B 的指令)==="
objdump -D -b binary -m i386:x86-64 --start-address=1 --stop-address=7 overlap.bin

--stop-address=N 限制反汇编到 offset N 之前,可以精确控制显示的字节范围,便于逐字节检查两条流的差异。

代码完整性校验的局限

基于哈希的代码完整性校验对固定字节序列计算摘要。两段不同的执行流共享同一段字节,哈希相同。

md5sum overlap.bin overlap_b.bin

校验通过并不意味着执行的指令序列符合预期。

函数指针偏移

如果程序中存在函数指针,且攻击者可以控制函数指针的值,可以将执行流切换到偏移后的地址。

创建func_ptr_demo.c

#include <stdio.h>
#include <string.h>
#include <sys/mman.h>

static const unsigned char code[] = {
    0x6A, 0x51,             /* push 0x51     */
    0x58,                   /* pop rax       */
    0x48, 0xFF, 0xC0,       /* inc rax       */
    0xC3,                   /* ret           */
};

typedef long long (*fn_t)(void);

int main(void) {
    void *exec = mmap(NULL, sizeof(code),
                      PROT_READ | PROT_WRITE | PROT_EXEC,
                      MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
    memcpy(exec, code, sizeof(code));

    /* 正常调用:offset +0 */
    fn_t func_ptr = (fn_t)exec;
    printf("Normal call (+0): rax = 0x%llx\n", func_ptr());

    /* 偏移调用:offset +1 */
    fn_t offset_ptr = (fn_t)((unsigned char *)exec + 1);
    long long r;
    __asm__ volatile (
        "xor %%rcx, %%rcx\n"
        "call *%[e]\n"
        : "=a"(r)
        : [e] "r"(offset_ptr)
        : "rcx", "r11", "memory"
    );
    printf("Offset call (+1): rax = 0x%llx\n", r);

    return 0;
}

编译运行

gcc -O1 -o func_ptr_demo func_ptr_demo.c && ./func_ptr_demo


攻击者通过控制函数指针的目标地址(偏移 1 字节或更多),将执行流切换到隐藏的指令序列。这种偏移不需要修改任何内存中的字节——只需要改变跳转目标。

防御方式

CFI(控制流完整性):在间接跳转和调用处插入检查,确保目标地址是合法的函数入口。偏移后的入口不是合法入口,CFI 会拦截。

函数入口对齐:编译器将函数对齐到特定边界(如 16 字节),并在入口之间填充 nop 或 int3。偏移后的地址落在填充区域,触发异常而非执行隐藏指令。GCC 的 -falign-functions 和 -fcf-protection 提供部分保护。

代码签名与运行时校验:不仅校验字节哈希,还在运行时通过单步调试(ptrace 或硬件断点)验证实际执行的指令序列与预期一致。

BTI / shadow stack:ARMv8.5 的 BTI(Branch Target Identification)和 x86 的 CET(Control-flow Enforcement Technology)通过硬件机制限制间接跳转目标,使偏移后的入口无法通过硬件检查。