• 网络靶场实战-物联网安全qiling框架初探

    背景

    Qiling Framework是一个基于Python的二进制分析、模拟和虚拟化框架。它可以用于动态分析和仿真运行不同操作系统、处理器和体系结构下的二进制文件。除此之外，Qiling框架还提供了易于使用的API和插件系统，方便使用者进行二进制分析和漏洞挖掘等工作。其创始人是一名IoT Hacker，创建qiling的初衷便是解决在研究IoT时遇到的种种问题，这也是为什么上一小节说qiling框架比unicorn框架更加适合IoT研究初学者。

    qiling使用基础

    qiling框架和AFLplusplus安装

    1. sudo apt-get update
    2. sudo apt-get install -y build-essential python3-dev automake cmake git flex bison libglib2.0-dev libpixman-1-dev python3-setuptools cargo libgtk-3-dev
    3. sudo apt-get install -y lld-14 llvm-14 llvm-14-dev clang-14
    4. sudo apt-get install -y gcc-$(gcc --version|head -n1|sed 's/\..*//'|sed 's/.* //')-plugin-dev libstdc++-$(gcc --version|head -n1|sed 's/\..*//'|sed 's/.* //')-dev
    5. pip3 install qiling
    6. git clone https://github.com/AFLplusplus/AFLplusplus
    7. make -C AFLplusplus
    8. cd AFLplusplus/unicorn_mode
    9. ./build_unicorn_support.sh

    程序仿真

        首先我们需要克隆qiling仓库，仓库中一些实例脚本可供我们学习。

    git clone --recurse-submodules https://github.com/qilingframework/qiling.git

        一个简单的示例：

    1. #include 
    2. #include 
    3. # gcc test.c -o test
    4. # 注意：编译程序的主机libc需要与rootfs glibc版本(libc-2.7.so)相对应，其他架构同理
    5. int main(){
    6.    printf("hello world!");
    7.    return 0;
    8. }

        使用qiling编写一个简单的仿真脚本。

    1. from qiling import *
    2. from qiling.const import QL_VERBOSE
    3. # 导入qiling模块和qiling.const模块中的QL_VERBOSE常量
    4.  
    5. if __name__ == "__main__":
    6.    #创建Qiling对象，实例中三个参数分别为：path(仿真程序路径)、rootfs(仿真程序文件系统目录)和verbose(输出信息参数),除此外还可以设置env和log_plain参数。
    7.   ql = Qiling(["./x8664_linux_symlink/test"], "./x8664_linux_symlink",verbose=QL_VERBOSE.DEBUG)
    8.    #运行Qiling对象的run()方法，开始执行仿真程序
    9.   ql.run()

        这里的verbose(输出信息参数)有如下级别及其作用:

    图片

    图片

    VFS劫持

        x86_fetch_urandom程序的作用为打开/dev/urandom文件，生成随机数。当qiling仿真x86_fetch_urandom程序时，环境需要用到仿真文件系统，我们就需要用到VFS劫持，这样就可以模拟修改文件系统。下面的代码中为仿真虚拟路径 "/dev/urandom" 会被映射到宿主系统上的现有"/dev/urandom"文件。当模拟程序将访问 /dev/random 时，将改为访问映射文件。

    1. from qiling import Qiling
    2.  
    3. if __name__ == "__main__":
    4.   ql = Qiling(["x86_linux/bin/x86_fetch_urandom"], "x86_linux")
    5.  
    6.   ql.add_fs_mapper(r'/dev/urandom', r'/dev/urandom')
    7.   ql.verbose=0
    8.   ql.run()

    图片

        如果我们想要控制虚拟文件'/dev/urandom'的交互结果，可以继承QlFsMappedObject类，并可自定义read、write、fstat、ioctl、readline等方法。

    1. from qiling import Qiling
    2. from qiling.os.mapper import QlFsMappedObject
    3.  
    4. class FakeUrandom(QlFsMappedObject):
    5.   def read(self, size: int) -> bytes:
    6.       return b"\x01" #可以修改读取返回结果
    7.  
    8.   def fstat(self) -> int:
    9.       return -1
    10.  
    11.   def close(self) -> int:
    12.       return 0
    13.  
    14. if __name__ == "__main__":
    15.   ql = Qiling(["x86_linux/bin/x86_fetch_urandom"], "x86_linux")
    16.   ql.add_fs_mapper(r'/dev/urandom', FakeUrandom())
    17.   ql.run()

    图片

    函数hook

        下面示例中，我们给str1和str2俩个变量内存中分别复制"abcdef"和"ABCDEF"字符串。正常执行完毕后会打印出"str1 大于 str2"。我们可以使用qiling框架劫持strcmp实现为hook strcmp函数的效果，使其执行到不同分支的结果。

    1. #include <stdio.h>
    2. #include <string.h>
    3.  
    4. //cd ./x8664_linux/
    5. //gcc demo.c -o test
    6.  
    7. int main ()
    8. {
    9.   char str1[15];
    10.   char str2[15];
    11.   int ret;
    12.  
    13.   strcpy(str1, "abcdef");
    14.   strcpy(str2, "ABCDEF");
    15.   ret = strcmp(str1, str2);
    16.  
    17.   if(ret < 0)
    18.   {
    19.      printf("str1 小于 str2");
    20.   }
    21.   else if(ret > 0)
    22.   {
    23.      printf("str1 大于 str2");
    24.   }
    25.   else
    26.   {
    27.      printf("str1 等于 str2");
    28.   }
    29.   return(0);
    30. }

        以下代码为hook strcmp函数，并通过修改rax寄存器改变执行流程。

    1. from qiling import *
    2. from qiling.const import *
    3.  
    4. # 自定义strcmp hook函数。当程序执行strcmp函数退出时，会调用此函数，并且在比较完毕后，将 rax 寄存器的值修改为 0，表示相等。
    5. def hook_strcmp(ql,*args):
    6. # qiling框架的寄存器取值为ql.arch.reg.xxx
    7.   rax = ql.arch.regs.rax
    8.   print("hook_addr_rax:",hex(rax))
    9.   ql.arch.regs.eax = 0 # 0:等于; -1:小于 ;1:大于
    10.  
    11. # 使用 ql.os.set_api 函数为 strcmp 设置hook函数，第一个参数为要hook的函数名，第二个参数为自定义hook函数，第三个参数为hook类型，这里为退出时触发hook函数。
    12. def hook_func(ql):
    13.   ql.os.set_api('strcmp',hook_strcmp,QL_INTERCEPT.EXIT) # 也可以使用ql.hook_address()函数进行hook，使用方法为ql.hook_address(hook_strcmp,0xXXXXXXXX)
    14.  
    15. if __name__ == "__main__":
    16.   ql = Qiling(["./x8664_linux/test"],"./x8664_linux",verbose=QL_VERBOSE.DEBUG)
    17.   hook_func(ql)
    18.   #ql.debugger = "gdb:0.0.0.0:12345"
    19.   ql.run()

    图片

        定义hook函数时hook类型参数有以下三种：

    图片

    qiling使用实例

    使用qiling解密CTF赛题

        当我们掌握了最基础的三个用法后，我们可以测试一个简单的例子来加深对qiling框架的理解。以上一小节中unicorn解密ctf题目为例，我们先简单写一个运行脚本。这里的ql.debugger="gdb:0.0.0.0:12345"为开启gdbserver服务，我们可以使用ida或者gdb进行调试。

    图片

        简单运行后发现程序和上一小节中unicorn的运行状况类似。由于这里我设置了multithead为True，所以这里会比上一小节中unicorn的解密速度快不少。但是还是在有限时间内只输出4个字符。

    图片

        当我们将verbose设置为QL_VERBOSE.DISASM便可观察模拟执行的汇编指令，根据汇编指令我们明显看到程序在call 0x400670处进行了递归调用(或使用调试器调试查看)，导致解密时间非常长。所以我们需要进行代码优化，思路为使用栈空间来保存一个不同输入参数以及对应计算结果的字典来避免重复计算。

    图片

       这里qiling由于是由unicorn开发而来，所以很多用法和unicorn相似。

    1. from qiling import *
    2. from qiling.const import *
    3. from pwn import *
    4.  
    5. def hook_start(ql):
    6.     arg0 = ql.arch.regs.rdi
    7.     r_rsi = ql.arch.regs.rsi
    8.     arg1 = u32(ql.mem.read(r_rsi,4))
    9.     if (arg0,arg1) in direct:
    10.         (ret_rax,ret_ref) = direct[(arg0,arg1)]
    11.         ql.arch.regs.rax = ret_rax
    12.         ql.mem.write(r_rsi,p32(ret_ref))
    13.         ql.arch.regs.rip = 0x400582
    14.     else:
    15.         ql.arch.stack_push(r_rsi)
    16.         ql.arch.stack_push(arg1)
    17.         ql.arch.stack_push(arg0)
    18.  
    19. def hook_end(ql):
    20.     arg0 = ql.arch.stack_pop()
    21.     arg1 = ql.arch.stack_pop()
    22.     r_rsi = ql.arch.stack_pop()
    23.     ret_rax = ql.arch.regs.rax
    24.     ret_ref = u32(ql.mem.read(r_rsi,4))
    25.     direct[(arg0,arg1)] = (ret_rax,ret_ref)
    26.  
    27. def solve(ql):
    28.     start_address = 0x400670
    29.     end_address = 0x4006f1
    30.     end_address2 = 0x400709
    31.     ql.hook_address(hook_start,start_address)
    32.     ql.hook_address(hook_end,end_address)
    33.     ql.hook_address(hook_end,end_address2)
    34.  
    35. if __name__ == '__main__':
    36.     path = ["./x8664_linux_symlink/test"]
    37.     rootfs = "./x8664_linux_symlink"
    38.     direct = {}
    39.     ql = Qiling(path, rootfs,verbose=QL_VERBOSE.DEFAULT)
    40.     solve(ql)
    41.     ql.run()

    运行后便会打印出解密结果。

    图片

        除了上一小节中的ctf题目掌握qiling的使用外，我们还可通过qilinglab来加深对qiling框架的使用。qilingLab是由11个小挑战组成的二进制程序，用来帮助新手快速熟悉和掌握 Qiling 框架的基本用法。官方提供了aarch64程序的解题方法，我们根据这个作为参考解密一下x86_64架构的练习程序。

        x86_64程序下载(https://www.shielder.com/attachments/qilinglab-x86_64)

        首先运行程序，给我们提示，challenges会造成程序崩溃，只有当我们解出相应challenge后才会显示信息。

    图片

        我们可以通过ida逆向以及编写qiling脚本进行动态调试来完成这些challenge。

    图片

        最终的解密脚本如下：

    1. from qiling import *
    2. from pwn import *
    3. from qiling.const import *
    4. from qiling.os.mapper import QlFsMappedObject
    5. import os
    6. import struct
    7.  
    8. def hook_cpuid(ql, address, size):
    9.     if ql.mem.read(address, size) == b'\x0F\xA2':
    10.         regs = ql.arch.regs
    11.         regs.ebx = 0x696C6951
    12.         regs.ecx = 0x614C676E
    13.         regs.edx = 0x20202062
    14.         regs.rip += 2
    15.  
    16. def challenge11(ql):
    17.     begin, end = 0, 0
    18.     for info in ql.mem.map_info:
    19.         #print("=====")
    20.         #print(info)
    21.         #print("=====")
    22.         if info[2] == 5 and 'qilinglab-x86_64' in info[3]:
    23.             begin, end = info[:2]
    24.             #print("begin_addr",begin)
    25.             #print("end_addr",end)
    26.     ql.hook_code(hook_cpuid, begin=begin, end=end)
    27.  
    28. class cmdline(QlFsMappedObject):
    29.     def read(self, expected_len):
    30.         return b'qilinglab'
    31.  
    32.     def close(self):
    33.         return 0
    34.  
    35. def challenge10(ql):
    36.     ql.add_fs_mapper('/proc/self/cmdline', cmdline())
    37.  
    38.  
    39. def hook_tolower(ql):
    40.     return 0
    41.  
    42. def challenge9(ql):
    43.     ql.os.set_api('tolower', hook_tolower)
    44.  
    45. def find_and_patch(ql, *args, **kw):
    46.     MAGIC = 0x3DFCD6EA00000539
    47.     magic_addrs = ql.mem.search(p64(MAGIC))
    48.     #print("magic_address:",hex(magic_addrs))
    49.  
    50.     for magic_addr in magic_addrs:
    51.         malloc1_addr = magic_addr - 8
    52.         malloc1_data = ql.mem.read(malloc1_addr, 24)
    53.         string_addr, _ , check_addr = struct.unpack("QQQ",malloc1_data)
    54.  
    55.         if ql.mem.string(string_addr) == "Random data":
    56.             ql.mem.write(check_addr, b"\x01")
    57.             break
    58.  
    59. def challenge8(ql):
    60.     base_addr = ql.mem.get_lib_base(os.path.split(ql.path)[-1])
    61.     #print("base_addr",hex(base_addr))
    62.     ql.hook_address(find_and_patch, base_addr+0xFB5)
    63.  
    64. def hook_sleep(ql):
    65.     return 0
    66.  
    67. def challenge7(ql):
    68.     ql.os.set_api('sleep',hook_sleep)
    69.  
    70. def hook_rax(ql):
    71.     ql.arch.regs.rax = 0
    72.  
    73. def challenge6(ql):
    74.     base_addr = ql.mem.get_lib_base(os.path.split(ql.path)[-1])
    75.     #print("base_addr",hex(base_addr))
    76.     hook_addr = base_addr + 0xF16
    77.     ql.hook_address(hook_rax, hook_addr)
    78.  
    79. def hook_rand(ql):
    80.     ql.arch.regs.rax = 0
    81.  
    82. def challenge5(ql):
    83.     ql.os.set_api('rand',hook_rand)
    84.  
    85. def enter_forbidden_loop_hook(ql):
    86.     ql.arch.regs.eax = 1
    87.  
    88. def challenge4(ql):
    89.     base = ql.mem.get_lib_base(os.path.split(ql.path)[-1])
    90.     hook_addr = base + 0xE43
    91.     print("qiling binary hookaddr:",hex(hook_addr))
    92.     ql.hook_address(enter_forbidden_loop_hook, hook_addr)
    93.  
    94. class FakeUrandom(QlFsMappedObject):
    95.     def read(self, size: int) -> bytes:
    96.         if size == 1:
    97.             return b"\x42"
    98.         else:
    99.             return b"\x41" * size
    100.  
    101.     def close(self) -> int:
    102.         return 0
    103.  
    104. def hook_getrandom(ql, buf, buflen, flags):
    105.     if buflen == 32:
    106.         data = b'\x41' * buflen # b'\x41' = A
    107.         ql.mem.write(buf, data)
    108.         ql.os.set_syscall_return(buflen)
    109.     else:
    110.         ql.os.set_syscall_return(-1)
    111.  
    112. def challenge3(ql):
    113.     ql.add_fs_mapper(r'/dev/urandom', FakeUrandom())
    114.     ql.os.set_syscall("getrandom", hook_getrandom)
    115.  
    116. def my_uname_on_exit_hook(ql, *args):
    117.     rdi = ql.arch.regs.rdi
    118.     print(f"utsname address: {hex(rdi)}")
    119.     ql.mem.write(rdi, b'QilingOS\x00')
    120.     ql.mem.write(rdi + 65 * 3, b'ChallengeStart\x00')
    121.  
    122. def challenge2(ql):
    123.     ql.os.set_api("uname", my_uname_on_exit_hook, QL_INTERCEPT.EXIT)
    124.  
    125. def challenge1(ql):
    126.     ql.mem.map(0x1000, 0x1000, info='challenge1')
    127.     ql.mem.write(0x1337, p16(1337))
    128.  
    129. if __name__ == '__main__':
    130.     path = ["./x8664_linux/qilinglab-x86_64"]
    131.     rootfs = "./x8664_linux"
    132.     ql = Qiling(path, rootfs,verbose=QL_VERBOSE.OFF)
    133.     challenge1(ql)
    134.     challenge2(ql)
    135.     challenge3(ql)
    136.     challenge4(ql)
    137.     challenge5(ql)
    138.     challenge6(ql)
    139.     challenge7(ql)
    140.     challenge8(ql)
    141.     challenge9(ql)
    142.     challenge10(ql)
    143.     challenge11(ql)
    144.     #ql.debugger = "gdb:0.0.0.0:12345"
    145.     ql.run()

        运行后，所有的challenge都会显示SOLVED。

    图片

    qiling设备仿真

        qiling提供了路由器仿真案例，该脚本路径为qiling/example路径下

    1. #!/usr/bin/env python3
    2. # 1. Download AC15 Firmware from https://down.tenda.com.cn/uploadfile/AC15/US_AC15V1.0BR_V15.03.05.19_multi_TD01.zip
    3. # 2. unzip
    4. # 3. binwalk -e US_AC15V1.0BR_V15.03.05.19_multi_TD01.bin
    5. # 4. locate squashfs-root
    6. # 5. rm -rf webroot && mv webroot_ro webroot
    7. #
    8. # notes: we are using rootfs in this example, so rootfs = squashfs-root
    9. #
    10. import os, socket, threading
    11. import sys
    12. sys.path.append("../../../")
    13. from qiling import Qiling
    14. # 从qiling.const中导入QL_VERBOSE，指定qiling的日志输出级别
    15. from qiling.const import QL_VERBOSE
    16.  
    17.  
    18. # 定义patcher函数，用于跳过网卡信息检测。在前面小节我们仿真tenda路由器时，路由器httpd程序在初始化网络时会检查网卡名称是否为br0。这里脚本直接将代码执行前内存中的br0字符串替换成了lo，从而跳过检查。
    19. def patcher(ql: Qiling):
    20.     br0_addr = ql.mem.search("br0".encode() + b'\x00')
    21.     for addr in br0_addr:
    22.         ql.mem.write(addr, b'lo\x00')
    23.  
    24. # 定义nvram_listener函数，使用该函数监听Unix套接字，并在收到消息时返回数据。
    25. def nvram_listener():
    26.     server_address = 'rootfs/var/cfm_socket'
    27.     data = ""
    28.     try:
    29.         os.unlink(server_address)
    30.     except OSError:
    31.         if os.path.exists(server_address):
    32.             raise
    33.  
    34.     sock = socket.socket(socket.AF_UNIX,socket.SOCK_STREAM)
    35.     sock.bind(server_address)
    36.     sock.listen(1)
    37.     while True:
    38.         connection, _ = sock.accept()
    39.         try:
    40.             while True:
    41.                 data += str(connection.recv(1024))
    42.                 if "lan.webiplansslen" in data:
    43.                     connection.send('192.168.170.169'.encode())
    44.                 else:
    45.                     break
    46.                 data = ""
    47.         finally:
    48.             connection.close()
    49.  
    50. # 定义myvfork函数，仿真程序在执行系统调用vfork时被调用，返回值0。
    51. def myvfork(ql: Qiling):
    52.     regreturn = 0
    53.     ql.log.info("vfork() = %d" % regreturn)
    54.     return regreturn
    55. # 仿真主函数，生成qiling实例和添加VFS映射。
    56. def my_sandbox(path, rootfs):
    57.     print("path:",path)
    58.     print("rootfs",rootfs)
    59.     ql = Qiling(path, rootfs, verbose=QL_VERBOSE.DEBUG)
    60.     print("ql:",ql)
    61.     ql.add_fs_mapper("/dev/urandom","/dev/urandom")
    62.     ql.hook_address(patcher, ql.loader.elf_entry)
    63.     ql.debugger = False
    64.     if ql.debugger == True:
    65.         ql.os.set_syscall("vfork", myvfork) # vfork函数返回0时，debugger可正常调试。
    66.     ql.run()
    67.  
    68. if __name__ == "__main__":
    69.   # 创建后台运行的线程并执行，以便收到Unix套接字的消息时进行响应。
    70.     nvram_listener_therad = threading.Thread(target=nvram_listener, daemon=True)
    71.     nvram_listener_therad.start()
    72.   # 运行仿真实例
    73.     my_sandbox(["rootfs/bin/httpd"], "rootfs")

        当我们运行脚本后，会显示路由器的ip和端口，当我们发现本地的8080正在监听时，说明设备已经仿真成功。

    图片

        仿真成功后可访问http://localhost:8080查看效果：

    图片

        在后面的小节中，我们会学习对仿真路由器设备进行fuzz。其中最为重要的一步便是编写仿真脚本，后续在我们分析好固件程序中要fuzz地址范围后，只有仿真设备可以顺利触发保存快照的功能，才可保证fuzz的正确性。

    qiling fuzz

        qiling框架可以使用AFLplusplus对arm架构程序进行fuzz测试，测试代码如下：

    1. #include <stdio.h>
    2. #include <stdlib.h>
    3. #include <string.h>
    4. // Program that will crash easily.
    5. #define SIZE (10)
    6.  
    7. int fun(int i)
    8. {
    9.     char *buf = malloc(SIZE);
    10.     char buf2[SIZE];
    11.     
    12.     while ((*buf = getc(stdin)) == 'A')
    13.     {
    14.         buf[i++] = *buf;
    15.     }
    16.     strncpy(buf2, buf, i);
    17.     puts(buf2);
    18.     return 0;
    19. }
    20.  
    21. int main(int argc, char **argv)
    22. {
    23.     return fun(argc);
    24. }

        qiling提供的fuzz脚本如下：

    1. #!/usr/bin/env python3
    2. """
    3. Simple example of how to use Qiling together with AFLplusplus.
    4. This is tested with the recent Qiling framework (the one you cloned),
    5. afl++ from https://github.com/AFLplusplus/AFLplusplus
    7. After building afl++, make sure you install `unicorn_mode/setup_unicorn.sh`
    9. Then, run this file using afl++ unicorn mode with
    10. afl-fuzz -i ./afl_inputs -o ./afl_outputs -m none -U -- python3 ./fuzz_x8664_linux.py @@
    11. """
    12.                                                                                                                                                                                               
    13. # No more need for importing unicornafl, try ql.afl_fuzz instead!
    14.  
    15. import sys, os
    16. from binascii import hexlify
    17. sys.path.append("../../..")
    18. from qiling import *
    19. from qiling.extensions import pipe
    20. from qiling.extensions.afl import ql_afl_fuzz
    21.  
    22. def main(input_file, enable_trace=False):
    23.     ql = Qiling(["./arm_fuzz"], "../../rootfs/arm_qnx", console=enable_trace)
    24.     # 设置ql的标准输入为进程的标准输入
    25.     ql.os.stdin = pipe.SimpleInStream(sys.stdin.fileno())
    26.   # 如果没有启用控制台追踪，则将标准输出和标准错误流设置为Null
    27.     if not enable_trace:
    28.         ql.os.stdout = pipe.NullOutStream(sys.stdout.fileno())
    29.         ql.os.stderr = pipe.NullOutStream(sys.stderr.fileno())
    30.  
    31.     def place_input_callback(ql: Qiling, input: bytes, _: int):
    32.       # 设置fuzz输入点
    33.         ql.os.stdin.write(input)
    34.         return True
    35.  
    36.     def start_afl(_ql: Qiling):
    37.       # 设置fuzz实例
    38.         ql_afl_fuzz(_ql, input_file=input_file, place_input_callback=place_input_callback, exits=[ql.os.exit_point])
    39.  
    40.   # 获取libc的基地址
    41.     LIBC_BASE = int(ql.profile.get("OS32", "interp_address"), 16)
    42.     # 设置hook函数，用于处理SignalKill信号
    43.     ql.hook_address(callback=lambda x: os.abort(), address=LIBC_BASE + 0x38170)
    44.     # main函数地址
    45.     main_addr = 0x08048aa0
    46.     # 设置hook函数，在main函数运行时调用start_afl函数
    47.     ql.hook_address(callback=start_afl, address=main_addr)
    48.   
    49.   # 若启用控制台追踪，则将设置相关信息输出
    50.     if enable_trace:
    51.         # The following lines are only for `-t` debug output
    52.         md = ql.arch.disassembler
    53.         count = [0]
    54.         def spaced_hex(data):
    55.             return b' '.join(hexlify(data)[i:i+2] for i in range(0, len(hexlify(data)), 2)).decode('utf-8')
    56.  
    57.         def disasm(count, ql, address, size):
    58.             buf = ql.mem.read(address, size)
    59.             try:
    60.                 for i in md.disasm(buf, address):
    61.                     return "{:08X}\t{:08X}: {:24s} {:10s} {:16s}".format(count[0], i.address, spaced_hex(buf), i.mnemonic,
    62.                                                                         i.op_str)
    63.             except:
    64.                 import traceback
    65.                 print(traceback.format_exc())
    66.  
    67.         def trace_cb(ql, address, size, count):
    68.             rtn = '{:100s}'.format(disasm(count, ql, address, size))
    69.             print(rtn)
    70.             count[0] += 1
    71.  
    72.         ql.hook_code(trace_cb, count)
    73.  
    74.     # okay, ready to roll.
    75.     # try:
    76.     ql.run()
    77.     # except Exception as ex:
    78.     # # Probable unicorn memory error. Treat as crash.
    79.     # print(ex)
    80.     # os.abort()
    81.     os._exit(0) # that's a looot faster than tidying up.
    82.                                                                                                                                                                                               
    84. if __name__ == "__main__":
    85.     if len(sys.argv) == 1:
    86.         raise ValueError("No input file provided.")
    87.     if len(sys.argv) > 2 and sys.argv[1] == "-t":
    88.         main(sys.argv[2], enable_trace=True)
    89.     else:
    90.         main(sys.argv[1])

        AFLplusplus执行脚本如下：

    1. #!/usr/bin/sh
    2. AFL_AUTORESUME=1 AFL_PATH="$(realpath ../../../AFLplusplus)" PATH="$AFL_PATH:$PATH" afl-fuzz -i afl_inputs -o afl_outputs -U -- python3 ./fuzz_arm_qnx.py @@

        运行后fuzz.sh后，便会出现afl++ 运行界面，等待几秒后便出现crash。

    图片

        crash的变异数据存放在afl_outputs目录下，我们可以使用xxd id:000000,xxxxxx命令查看变异数据。

    1. #xxd id:000000,sig:06,src:000000,time:4112,execs:1077,op:havoc,rep:8 
    2. 00000000: 4141 4141 4141 4141 4141 4141 ff7f 4241 AAAAAAAAAAAA..BA
    3. 00000010: 4141 4145 4141 be41 4dff 0000 0041 4141 AAAEAA.AM....AAA
    4. 00000020: 41

    总结

    在这一小节中，我们简单学习了qiling框架，我们使用ctf例题以及qilinglab的11个闯关题目进行练习，熟练掌握了qiling框架的基础使用。后面的小节中，我们将使用qiling框架对仿真设备进行实例fuzz测试。

  • 相关阅读:
    红菜苔炒腊肉
    阿里10年架构师：由Java多线程+MySQL+JVM出发怎样做好职业规划？
    嵌入式Linux入门-代码重定位和清除bss段讲解
    点云从入门到精通技术详解100篇-基于点云的刺梨果实三维建模 及其生物力学特性研究（中）
    重学JavaSE 第14章 : 泛型、自定义泛型、泛型通配符
    Java8中Optional解决空指针异常
    从智能门锁，看3D视觉的安全性突围
    Docker--容器挂载
    鸿蒙Harmony应用开发—ArkTS声明式开发（通用属性：尺寸设置）
    2022/7/30
  • 原文地址：https://blog.csdn.net/We8__/article/details/138185518