利用 x86-64 单字节指令重叠构造双重执行流与绕过分析
x86-64 采用变长指令编码,单条指令长度 1-15 字节。同一段字节序列从不同偏移开始解码,指令边界会发生漂移,同一段内存可以被解析为两组完全不同的指令。 7 字节即可构造出两条执行流:返回值不同、栈效果不同、指令序列不同,但占用完全相同的内存区域。
重叠原理
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 |
|
|
2 |
|
|
3-5 |
|
|
6 |
|
|
从 offset 1 解码(执行流 B)
CPU 从 offset 1 开始读取:
offset | 字节 | 解码结果 |
1 |
|
|
2 |
|
|
3-5 |
|
|
6 |
|
|
重叠点
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 ; 弹出返回地址,正常返回栈变化:
push 0x51:rsp 减 8,将 0x51 压入栈pop rax:从栈顶取出 0x51 放入 rax,rsp 加 8- push 和 pop 配对,栈完全平衡
返回值:rax = 0x52
执行流 B(入口 +1)
push rcx ; rsp -= 8, 栈顶写入 rcx 的当前值
pop rax ; rax = rcx 的当前值, rsp += 8
inc rax ; rax = rcx + 1
ret ; 弹出返回地址,正常返回栈变化:
push rcx:rsp 减 8,将 rcx 压入栈pop rax:从栈顶取出 rcx 放入 rax,rsp 加 8- 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 = 16jmp +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)通过硬件机制限制间接跳转目标,使偏移后的入口无法通过硬件检查。