论文复现_How Machine Learning Is Solving the Binary Function Similarity Problem

1. 内容概述

前言：此代码库支持 USENIX Security '22 论文 《How Machine Learning Is Solving the Binary Function Similarity Problem》，作者包括 Andrea Marcelli 等人，提供了相关代码、数据集和技术细节。

关键内容：技术报告提供了有关数据集和方法的更多技术细节，供进一步参考。代码库的结构包括以下部分：Binaries（二进制文件），存放已编译的二进制文件及其下载/编译脚本；IDBs（IDA Pro 数据库），存储由 IDA Pro 分析后生成的数据库；DBs（数据集），包含选定函数的数据集、对应的特征以及生成脚本；IDA_scripts（IDA Pro 脚本），用于特征提取的脚本；Models（模型），实现了多种机器学习方法的代码；Results（结果），提供实验结果和提取指标的相关脚本。

使用场景：使用场景包括三种主要方式。复现实验，通过利用 DBs 和 Models 中的现有数据集与模型，按照提供的脚本和 README 文件复现实验结果；测试新方法，使用现有的特征提取和处理工具，在现有数据集上评估新方法的表现；推理新函数，通过 Models 文件夹中的推理工作流，结合 IDA Pro 脚本提取特征，并使用后处理脚本转换数据格式。

2. 二进制文件（Binary）

要下载二进制文件，首先确保系统有大约 15GB 的空闲磁盘空间。然后，可以通过 Google Drive 下载二进制文件，使用 gdrive_download.py Python3 脚本，按照以下步骤操作：

# 安装 Python3 的 virtualenv 环境管理工具：
pip install virtualenv

# 创建一个新的虚拟环境并安装所需的依赖包：
python3 -m venv ../env
source ../env/bin/activate
pip install -r ../requirements.txt

# 下载并解压二进制文件：
python3 ../gdrive_download.py --binaries

# 二进制文件将被解压到以下目录：
Binaries/Dataset-Vulnerability
Binaries/Dataset-1
Binaries/Dataset-2

如果希望从源代码编译二进制文件，可以参考 Dataset-1 的交叉编译说明，见 [编译脚本](Compilation scripts) 文件夹。Dataset-2 和 Dataset-Vulnerability 的二进制文件是 Trex 发布的子集，相关原始数据集可从 此链接 获取。

此文件夹包含编译Dataset-1二进制文件所需的文档和脚本。二进制文件在Ubuntu 18.04和19.04环境中编译，部分编译器工具链由于缺少所需版本而手动编译。编译过程包括设置环境、安装必要的软件包、下载源码、应用补丁和运行自动化编译脚本。支持的架构包括x86、x64、ARM32、ARM64、MIPS32和MIPS64，不同架构使用的编译器版本和配置有所不同。提供了对每种架构的具体配置说明和编译过程中遇到的一些常见问题及解决方法。

3. IDA PRO 数据库（DBs）

该目录包含用于评估不同测试用例中相似度方法的数据集，每个数据集包含选定的函数、相应的特征以及生成它们的脚本。数据集按用途和测试对象组织，包括：Dataset-1，用于训练、验证和测试相似度方法；Dataset-1-CodeCMR，作为Dataset-1的子集，专门用于测试CodeCMR/BinaryAI方法；Dataset-2，用于测试的另一个数据集；以及Dataset-Vulnerability，用于评估相似度方法在“漏洞搜索”测试用例中的效果。

3.1 数据集下载

# 安装Python3的虚拟环境，并激活：
python3 -m venv ../env
source ../env/bin/activate
pip install -r ../requirements.txt

# 使用gdrive_download.py脚本从Google Drive下载并解压特征文件：
python3 ../gdrive_download.py --features

# 下载后的特征将解压到以下目录：
DBs/Dataset-1/
DBs/Dataset-1-CodeCMR/
DBs/Dataset-2/
DBs/Dataset-Vulnerability/

3.2 Dataset-1 介绍

#包含生成数据集和提取特征的说明文件。主要文件和子文件夹如下：
Dataset-1
├── Dataset-1 creation.ipynb: 创建数据集
├── Dataset-1 plots.ipynb: 展示数据集组成
├── Dataset-1 sanity check.ipynb: 验证数据完整性
├── features
│    ├── flowchart_Dataset-1.csv: 包括至少 5 个基本块的函数列表
│    ├── testing
│    │   ├── acfg_disasm_Dataset-1_testing: 通过 IDA 插件提取的特征文件
│    │   ├── acfg_features_Dataset-1_testing: 通过 IDA 插件提取的特征文件
│    │   ├── fss_Dataset-1_testing
│    │   ├── selected_testing_Dataset-1.json
│    │   └── zeek_Dataset-1_testing.json
│    ├── training
│    └── validation
├── pairs
└── testing_Dataset-1.csv

3.3 Dataset-1-CodeCMR 介绍

Dataset-1-CodeCMR是专门用于测试CodeCMR/BinaryAI方法的数据集，其结构与Dataset-1类似。主要包括Dataset-1-CodeCMR creation.ipynb（用于重建数据集）、Dataset-1-CodeCMR example.ipynb（展示如何使用数据）以及多个features/*文件，这些文件包含通过IDA插件提取的特征。

3.4 Dataset-2 介绍

用于测试的第二个数据集（Dataset-2）结构与Dataset-1相似，包含不同的特征文件。其主要包括`Dataset-2 creation.ipynb`（用于重建数据集）和多个`features/*`文件，这些特征文件通过IDA插件提取，涵盖了不同的特征类型，如ACFG、Catalog1、FSS等。

3.5 Dataset-Vulnerability

Dataset-Vulnerability用于评估相似度方法在“漏洞搜索”测试中的效果，结构与其他数据集类似。主要包括Dataset-Vulnerability creation.ipynb（用于重建数据集）和多个features/*文件，这些文件包含通过IDA插件提取的特征。

4. IDA PRO 脚本（IDA_script）

该文件夹包含一个脚本，用于从已编译的二进制文件生成 IDBs（IDA 数据库），以及若干 IDA Pro 插件，用于特征提取。

4.1 系统要求

# 设置 IDA32_PATH 和 IDA_PATH 环境变量，指定 idat 和 idat64 的完整路径。例如：
export IDA_PATH=/home/user/idapro-7.3/idat64
export IDA32_PATH=/home/user/idapro-7.3/idat

# 创建名为 "env" 的新环境
python3 -m venv env
# 进入虚拟环境
source env/bin/activate

# 在当前环境中安装所需的包
pip install -r requirements.txt

# 在 IDA Pro Python2 环境 中安装 Capstone 3.0.4：

pip2 install capstone==3.0.4

# 在 IDA Pro Python3 环境 中安装 networkx 2.5：
pip3 install networkx==2.5

# 导出用于 IDA 插件单元测试的 IDBs：
python3 generate_idbs.py --test

4.2 生成 IDBs

使用 generate_idbs.py 脚本可以自动导出每个数据集的 IDBs，输入为用于处理的数据集对应的标志（如 --db1、--db2、--dbvuln），输出为相应的 IDBs 和日志文（generate_idbs_log.txt）。

# 为 Dataset-Vulnerability 生成 IDBs（该数据集最小，仅包含六个二进制文件）：
python3 generate_idbs.py --dbvuln

# 为 Binaries 文件夹中的所有二进制文件生成 IDBs（此过程可能需要数小时并占用数 GB 的磁盘空间）：
python3 generate_idbs.py --db1 --db2 --dbvuln

4.4 IDA FlowChart

该插件提取每个函数的基本信息，要求函数至少包含五个基本块。输入为包含 IDB 文件的文件夹（-i）和输出 CSV 文件的名称（-o），输出为一个 CSV 文件，包含所有至少有五个基本块的函数。

# 运行插件处理 Dataset-Vulnerability 的 IDBs（要求 IDBs 存放在 IDBs/Dataset-Vulnerability 目录下）：
cd IDA_flowchart
python3 cli_flowchart.py -i ../../IDBs/Dataset-Vulnerability -o flowchart_Dataset-Vulnerability.csv

# 运行单元测试：
python3 -m unittest test_flowchart.py

# 可选 - 测试多个文件
python3 -m unittest test_large_flowchart.py

4.5 IDA ACFG-disasm

该插件为每个选择的函数创建一个带有基本块反汇编的 ACFG。输入为包含选定函数的 JSON 文件（-j）和输出文件夹的名称（-o），输出为每个 IDB 生成一个 JSON 文件（_acfg_disasm.json）。注意，输入 JSON 中的 IDB 文件路径必须是相对路径，Python3 脚本会将其转换为完整路径，以便正确加载 IDB 文件。

# 运行插件处理 Dataset-Vulnerability 测试选定的函数（要求 IDBs 存放在 IDBs/Dataset-Vulnerability 目录下）：
cd IDA_acfg_disasm
python3 cli_acfg_disasm.py -j ../../DBs/Dataset-Vulnerability/features/selected_Dataset-Vulnerability.json -o acfg_disasm_Dataset-Vulnerability


# 运行单元测试：
python3 -m unittest test_acfg_disasm.py

# 可选 - 测试多个文件
python3 -m unittest test_large_acfg_disasm.py

4.6 IDA ACFG-features

该插件为每个选择的函数创建一个带有 Genius/Gemini 特征的 ACFG。输入为包含选定函数的 JSON 文件（-j）和输出文件夹的名称（-o），输出为每个 IDB 生成一个 JSON 文件（_acfg_features.json）。注意，输入 JSON 中的 IDB 文件路径必须是相对路径，Python3 脚本会将其转换为完整路径，以便正确加载 IDB 文件。

# 运行插件处理 Dataset-Vulnerability 测试选定的函数（要求 IDBs 存放在 IDBs/Dataset-Vulnerability 目录下）：
cd IDA_acfg_features
python3 cli_acfg_features.py -j ../../DBs/Dataset-Vulnerability/features/selected_Dataset-Vulnerability.json -o acfg_features_Dataset-Vulnerability

# 运行单元测试：
python3 -m unittest test_acfg_features.py

# 可选 - 测试多个文件
python3 -m unittest test_large_acfg_features.py

5. 模型（Models）

该目录包含了经过测试的多个方法的代码，包括：Asm2vec 和 Doc2vec、BinaryAI / CodeCMR、Catalog1、FunctionSimSearch、GGSNN 和 GMN、GNN-s2v、SAFE、Trex 和 Zeek。

5.1 Asm2vec

Asm2vec 和 Doc2vec 实现由两个部分组成。第一部分接受ACFG disasm数据作为输入，并生成选定函数的随机游走。然后，这些数据作为第二部分的输入，后者实现了机器学习组件。

5.1.1 Part 1

Asm2vec 工具的第一部分是通过一个名为 i2v_preprocessing.py 的 Python3 脚本实现的。我们还提供了一个带有所需依赖项的 Docker 容器。

输入是通过 ACFG disasm IDA 插件提取的 JSON 文件所在的文件夹：

• 对于我们发布的 数据集，JSON 文件已经在 features 目录中提供。请注意，特征可以通过 README 中的说明从 GDrive 下载。
• 要为新的二进制文件集提取特征，请按照 README 中的说明运行 ACFG disasm IDA 插件。

有许多可配置参数，例如：

• -a2v 或 -d2v，指定输出是否与 Asm2vec 或 Doc2vec（PV-DM 或 PV-DBOW）模型兼容
• --num_rwalks、--max_walk_len 和 --max_walk_tokens 用于配置每个随机游走的数量和长度
• --min_frequency 是选择 token 的最小出现次数
• --workers 定义并行进程的数量：数量越高越好，但取决于 CPU 核心数。

该脚本将生成以下输出文件夹：

• 一个名为 random_walks_{model}.csv 的文件，其中包含选定函数的随机游走
• 一个名为 vocabulary.csv 的文件，包含用于训练神经网络的 token 列表
• 一个名为 counter_dict.json 的文件，映射每个 token 的频率计数
• 一个名为 vocabulary_dropped.csv 的文件，包含在分析中丢弃的低频 token 列表
• 一个名为 id2func.json 的文件，映射每个选定函数到一个数字 ID
• 一个名为 i2v_preprocessing.log 的文件，包含分析的日志，可能对调试有帮助。

使用 Docker 的操作步骤：

# 构建 Docker 镜像：
docker build -t asm2vec .

# 在 Docker 容器中运行 i2v_preprocessing.py 脚本：
docker run --rm -v <path_to_the_acfg_disasm_dir>:/input -v <path_to_the_output_dir>:/output -it asm2vec /code/i2v_preprocessing.py -d [--workers 4] [-a2v, -d2v] -i /input -o /output/

# 可以使用以下命令查看所有命令行选项：
docker run --rm -it -v $(pwd):/code asm2vec python3 /code/i2v_preprocessing_v2.py --help

# 为数据集 1 的训练部分运行 i2v_preprocessing.py 脚本并使用 -a2v：
docker run --rm \
  -v $(pwd):/code \
  -v /mnt/c/Users/22845/Desktop/binary_function_similarity-main/IDBs/Dataset-1/acfg_disasm_Dataset-1:/input \
  -v $(pwd)/output_a2v_preprocessing_Dataset-1-training:/output \
  -it asm2vec \
  python3 /code/i2v_preprocessing.py \
  -d -a2v \
  -i /input \
  -o /output \
  --num_rwalks 10 \
  --max_walk_len 500 \
  --max_walk_tokens 50000 \
  --min_frequency 3


# 为数据集 1 的训练部分运行 i2v_preprocessing.py 脚本并使用 -d2v：
docker run --rm \
  -v $(pwd):/code \
  -v /mnt/c/Users/22845/Desktop/binary_function_similarity-main/IDBs/Dataset-1/acfg_disasm_Dataset-1:/input \
  -v $(pwd)/output_a2v_preprocessing_Dataset-1-training:/output \
  -it asm2vec \
  python3 /code/i2v_preprocessing.py \
  -d -d2v\
  -i /input \
  -o /output \
  --num_rwalks 10 \
  --max_walk_len 500 \
  --max_walk_tokens 50000 \
  --min_frequency 3

5.1.2 Part 2

Asm2vec 的机器学习组件是基于 Gensim 3.8 实现的。有关实现的详细信息，请参阅我们创建的 补丁。i2v.py 脚本用于运行 Asm2vec 和 Doc2vec（PV-DM 或 PV-DBOW）模型的训练和推理。第一部分的 Docker 容器也包含了神经网络部分所需的依赖项。

i2v.py 脚本的 输入 包括：

• i2v_preprocessing.py 的输出，包含选择的词汇、随机游走和 token 的频率。
• {model}_checkpoint（仅在推理模式下使用，即在验证和测试期间）。

有许多可配置的参数，例如：

• 使用 --pvdm、--pvdbow 或 --asm2vec 选项选择要使用的模型（训练和推理时必须相同）
• 选择 --train 或 --inference 模式
• 通过 --epochs 参数配置训练的周期数
• 使用 --workers 选项选择并行进程的数量。

i2v.py 脚本中还包含一些硬编码的参数，标记为 # FIXED PARAM。不同参数值的实验需要进一步研究。当在训练模式下运行时，模型将生成以下 输出：

• 一个名为 {model}_checkpoint 的文件，包含训练后的模型备份。这可以在推理时重新使用
•  一个名为 i2v.log 的文件，包含分析日志，可能对调试有帮助。

当在 推理模式 下运行时，模型将生成以下 输出：

• 一个名为 embeddings.csv 的 CSV 文件，包含模型为每个函数生成的嵌入
• 一个名为 i2v.log 的文件，包含分析日志，可能对调试有帮助。

注意：在推理时，Asm2vec 和 Doc2vec 模型需要在多个周期内 更新 内部权重（类似于训练时的操作）。不过，只更新与函数对应的矩阵，而 token 的矩阵保持固定。与其他 传统 机器学习模型的行为不同。

使用 Docker 的操作步骤：

# 运行神经网络模型
docker run --rm -v <path_to_i2v_preprocessing_output_folder>:/input -v $(pwd):/output -it asm2vec /code/i2v.py -d [--asm2vec, --pvdm, --pvdbow] [--train, --inference, --log] -e1 -w4 --inputdir /input/ -o /output/output_folder

# 使用以下命令查看所有命令行选项：
docker run --rm -it asm2vec /code/i2v.py --help

docker run -v $(pwd):/code --rm -it asm2vec /code/i2v_v2.py --help


# 在数据集 1 上训练 Asm2vec 模型：
docker run --rm -v $(pwd)/a2v_preprocessing_Dataset-1-training:/input -v $(pwd):/output -it asm2vec /code/i2v.py -d --asm2vec --train -e1 -w4 --inputdir /input/ -o /output/asm2vec_train_Dataset-1-training

docker run --rm \
    -v $(pwd):/code \
    -v $(pwd)/output_a2v_preprocessing_Dataset-1-training:/input \
    -v $(pwd):/output \
    -it asm2vec \
    /code/i2v_v2.py -d \
    --asm2vec \
    --train \
    -e1 \
    -w4 \
    --inputdir /input/ \
    -o /output/asm2vec_train_Dataset-1-training


# 在数据集 1 的测试数据上运行 Asm2vec 模型并进行推理：
docker run --rm \
    -v $(pwd):/code \
    -v $(pwd)/output_a2v_preprocessing_Dataset-1-training:/input \
    -v $(pwd)/result_a2v_preprocessing_Dataset-1-training/asm2vec_train_Dataset-1-training:/checkpoint \
    -v $(pwd):/output \
    -it asm2vec \
    /code/i2v_v2.py -d \
    --asm2vec \
    --inference \
    -e1 \
    -w4 \
    --inputdir /input/ \
    -c /checkpoint \
    -o /output/test_asm2vec_inference_Dataset-1-testing

5.2 Catalog1

Catalog1实验需要运行一个IDA Pro插件来提取二进制函数的MinHash签名。

# 编译Catalog1库：
(cd catalog1/; make)

IDA Pro插件的输入是包含所选函数的JSON文件（-j）以及输出的CSV文件名称（-o），输出为每个Catalog1签名大小对应的CSV文件（默认：[16, 32, 64, 128]）。需要注意的是，输入JSON中的IDB文件路径必须相对于binary_function_similarity目录，Python3脚本会将相对路径转换为完整路径，以确保IDA Pro能够正确加载IDB。

# 对Dataset-Vulnerability测试中的选定函数运行插件（需要将IDBs放在IDBs/Dataset-Vulnerability目录中）
python .\cli_catalog1.py -j ..\..\DBs\Dataset-1-new\features\testing\selected_testing_Dataset-1.json -o Dataset-1-catalog1

# 运行单元测试：
python3 -m unittest test_catalog1.py

# 可选 - 对多个文件进行测试
python3 -m unittest test_large_catalog1.py

插件将生成一组CSV文件，包含以下列：path（IDB路径）、address（函数地址）、size（函数大小）、catalog_hash_list（Catalog哈希值，使用分号;分隔）以及time（计算函数Catalog1哈希所需的时间）。

# 要计算两个Catalog1签名之间的相似度，可以使用Jaccard相似度，如下所示：
def jaccard_similarity(s1, s2):
    return len(set(s1) & set(s2)) / len(set(s1) | set(s2))

a = [10534612, 42437122, 187632428, 38160894, 167893582, 20517613, 328764745, 40669729]
b = [15508139, 42437122, 83784247, 138119612, 167793573, 29886129, 35551260, 1210122]
print(jaccard_similarity(a, b)) # 0.06666666666666667
print(jaccard_similarity(a, a)) # 1.0

注意：如果函数大小小于4字节，catalog_hash_list列中将插入min_function_size_error。

# Catalog1实现了MinHash算法，库可以用于对任何二进制数据流计算签名：
from catalog1.catalog_fast import sign
from catalog1.catalog_slow import slow_sign

SIG_SIZE = 128 # 示例值：16, 32, 64, 128

binary_data = "..."

# C实现（快速）
signature = sign(binary_data, SIG_SIZE)

# Python3实现
signature_slow = slow_sign(binary_data, SIG_SIZE)

5.3 CodeCMR

BinaryAI / CodeCMR实验包括两个步骤。第一步是一个IDA Pro插件，它接受一个JSON文件作为输入，指定需要进行测试的函数，输出结果为pickle格式的中间文件。第二步是训练一个神经网络，用于识别相似函数。神经网络的输出是每个函数的向量表示。

在运行IDA插件之前，请按照IDA_scripts README中的要求操作。插件的输入为包含所选函数的JSON文件（`-j`）和输出目录（`-o`），输出为每个IDB对应的pickle文件，文件中包含每个在IDB中分析的函数的特征提取后的NetworkX图的序列化版本。需要注意，插件要求IDA Pro反编译许可证，并且IDA Pro要求32位IDA用于反编译32位二进制文件，64位IDA用于反编译64位二进制文件。32位二进制文件需导出为`.idb`格式，64位二进制文件需导出为`.i64`格式。此外，输入JSON中的IDB文件路径必须相对于`binary_function_similarity`目录，Python3脚本会将相对路径转换为完整路径，以确保在IDA Pro中正确加载IDB。示例：对Dataset-1-CodeCMR测试所选函数运行插件（需要64位二进制的`.i64` IDBs和32位二进制的`.idb`）。

# 对Dataset-1-CodeCMR测试所选函数运行插件（需要64位二进制的.i64 IDBs和32位二进制的.idb）：
cd IDA_CodeCMR
python cli_codeCMR.py -j ..\..\..\DBs\Dataset-1-new\features\testing\selected_testing_Dataset-1.json -o Dataset-1-CodeCMR
# 运行单元测试：

python3 -m unittest test_codeCMR.py

5.4 functionsimsearch

FSS（函数相似性搜索）实验包括两个步骤：第一步是IDA Pro插件，接受一个JSON文件作为输入，指定要分析的函数，并输出中间结果为JSON格式；第二步接收第一步生成的JSON文件，输出四个CSV文件，每个文件包含特定配置下的实验结果。该工具基于Thomas Dullien的FunctionSimSearch项目，我们在此基础上派生了代码，并根据需求进行了定制，整合了分析层并调整了Docker容器，具体修改记录在functionsimsearch.patch文件中。

5.4.1 Part 1

在运行IDA插件之前，请按照IDA_scripts README中的要求操作。输入包括包含所选函数的JSON文件（-j）、输出目录（-o）以及（-c）使用Capstone进行反汇编。输出为每个IDB对应一个JSON文件。需要注意的是，输入JSON中的IDB文件路径必须相对于binary_function_similarity目录，Python3脚本会将相对路径转换为完整路径，以确保在IDA Pro中正确加载IDB。

# 对Dataset-Vulnerability测试所选函数运行插件（需要在IDBs/Dataset-Vulnerability目录中的IDB文件）
cd IDA_fss
python cli_fss.py -j ..\..\..\DBs\Dataset-1-new\features\testing\selected_testing_Dataset-1.json -o fss_Dataset-1 -c

# 运行单元测试：
python3 -m unittest test_fss.py

# 可选 - 多文件测试
python3 -m unittest test_large_fss.py

5.4.2 Part 2

输入为通过IDA_fss插件生成的JSON文件目录，输出为四个CSV文件，每个文件包含一个特定配置的实验结果。

构建并允许Docker容器：

# 克隆functionsimsearch仓库并应用补丁：
git clone https://github.com/googleprojectzero/functionsimsearch;
( cd functionsimsearch ; git checkout ec5d9e1224ff915b3dc9e7af19e21e110c25239c ; patch -s -p0 < ../functionsimsearch.patch );
cp fss_simhasher.py ./functionsimsearch/;

# 构建Docker镜像：
docker build -t fss ./functionsimsearch

# 在Docker容器内运行主脚本：

docker run --rm -it fss -v <完整路径-to-输入JSON目录>:/input -v <完整路径-to-输出CSV目录>:/output /fss_simhasher.py

# 在/tmp/fss_csvs中创建四个CSV文件:

docker run --rm -v $(pwd)/testdata/fss_jsons:/input -v /tmp/fss_csvs:/output -it fss /fss_simhasher.py


# 为Dataset-2运行脚本：
docker run --rm -v $(pwd)/../../DBs/Dataset-2/features/fss_Dataset-2:/input -v $(pwd)/../../Results/FunctionSimSearch/Dataset-2:/output -it fss /fss_simhasher.py

5.5 GGSNN-GMN

该文件夹包含了DeepMind的GGSNN和GMN模型的实现。工具由两个部分组成，第一部分接受ACFG disasm数据作为输入，并生成若干中间结果，这些结果将作为第二部分的输入，第二部分实现了机器学习组件。

5.5.1 Part 1

第一部分的工具通过一个名为gnn_preprocessing.py的Python3脚本实现。我们还提供了一个包含所需依赖的Docker容器。

输入：通过ACFG disasm IDA插件提取的JSON文件所在的文件夹：

• 对于我们发布的数据集，JSON文件已经存储在features目录下。请注意，特征文件可以通过GDrive下载，具体操作参见README。
• 要提取新二进制文件的特征，请按照README中的说明运行ACFG disasm IDA插件。
• 一个JSON文件opcodes_dict.json，用于将所选操作码映射到训练数据集中的频率排名。

该脚本将生成以下输出：

• 一个JSON文件opcodes_dict.json，将所选操作码映射到训练数据集中的频率排名（仅在--training模式下运行时生成）。
• 一个JSON文件graph_func_dict_opc_{}.json，包含所选的中间特征。

使用Docker的说明：

# 构建docker镜像：
docker build --no-cache Preprocessing/ -t gnn-preprocessing

# 在docker容器中运行主脚本：
docker run --rm \
    -v <path_to_the_acfg_disasm_dir>:/input \
    -v <path_to_the_training_data>:/training_data \
    -v <path_to_the_output_dir>:/output \
    -it gnn-preprocessing /code/gnn_preprocessing.py -i /input [--training] -o /output

# 通过以下命令查看gnn_preprocessing.py的所有选项：
docker -v $(pwd):/code run --rm -it gnn-preprocessing /code/gnn_preprocessing_v2.py --help

# 在训练模式下运行gnn_preprocessing.py，针对Dataset-1_training：
docker run --rm \
    -v $(pwd):/code \
    -v /mnt/c/Users/22845/Desktop/binary_function_similarity-main/IDBs/Dataset-1/acfg_disasm_Dataset-1:/input \
    -v $(pwd)/Preprocessing/Dataset-1_training:/output \
    -it gnn-preprocessing \
    /code/Preprocessing/gnn_preprocessing_V2.py -i /input --training -o /output


# 在Dataset-1_validation上运行gnn_preprocessing.py：
docker run --rm \
    -v $(pwd):/code \
    -v /mnt/c/Users/22845/Desktop/binary_function_similarity-main/IDBs/Dataset-1/acfg_disasm_Dataset-1:/input \
    -v $(pwd)/Preprocessing/Dataset-1_validation:/output \
    -it gnn-preprocessing \
    /code/Preprocessing/gnn_preprocessing_V2.py -i /input --training -o /output

5.5.2 Part 2

第二部分实现了机器学习组件。我们还提供了一个包含TensorFlow 1.14和其他所需依赖的Docker容器。神经网络模型的输入：

• 用于训练的CSV文件，或者用于验证和测试的函数对。这些文件在我们发布的数据集中已经提供。文件路径在config.py文件中根据数据集类型硬编码。
• 来自第一部分的graph_func_dict_opc_{}.json文件。
• 如果模型在推理模式下使用（即在验证和测试时），则需要提供模型的检查点。

模型将生成以下输出：

• 一组包含选定函数相似度（sim列）的CSV文件，用于验证和测试。
• 一个config.json文件，记录运行测试时使用的配置。该文件用于调试和追踪不同的实验。
• 一个gnn.log日志文件，记录神经网络的日志。可以通过使用--debug (-d)选项来改善日志记录。
• 如果模型正在训练，则会生成模型检查点。

使用Docker的说明：

# 构建docker镜像：
docker build --no-cache NeuralNetwork/ -t gnn-neuralnetwork

# 在Docker容器中运行神经网络：
docker run --rm \
    -v $(pwd)/../../DBs:/input \
    -v $(pwd)/Preprocessing:/preprocessing \
    -v $(pwd)/NeuralNetwork/:/output \
    -it gnn-neuralnetwork /code/gnn.py (--train | --validate | --test) [--num_epochs 10] \
        --model_type {embedding, matching} --training_mode {pair,triplet} \
        --features_type {opc,nofeatures} --dataset {one,two,vuln} \
        -c /code/model_checkpoint \
        -o /output/Dataset-x

# 通过以下命令查看gnn.py的所有选项：
docker -v $(pwd):/code run --rm -it gnn-neuralnetwork /code/gnn_v2.py --help

# 针对Dataset-1进行GGSNN模型（embedding）训练，使用opc特征和pair模式：
docker run --rm \
    -v $(pwd):/code \
    -v /mnt/c/Users/22845/Desktop/binary_function_similarity-main/DBs:/input \
    -v $(pwd)/NeuralNetwork:/output \
    -v $(pwd)/Preprocessing:/preprocessing \
    -it gnn-neuralnetwork \
    /code/NeuralNetwork/gnn_v2.py --train --num_epochs 10 \
        --model_type embedding --training_mode pair \
        --features_type opc --dataset one \
        -c /output/model_checkpoint_$(date +'%Y-%m-%d') \
        -o /output/Dataset-1_training_GGSNN_opc_pair

5.6 GNN-s2v

此文件夹包含基于图神经网络（GNN）和Structure2vec（s2v）方法的实现。代码分为两个部分：第一部分以ACFG disasm或ACFG特征数据为输入，生成一系列中间结果，然后将这些结果作为输入传递给第二部分，后者实现了机器学习组件。

下载模型数据：

# 创建Python3虚拟环境
python3 -m venv ../../env

# 激活Python3虚拟环境
source ../../env/bin/activate

# 下载并解压模型数据到相应目录：
python3 gdrive_model_download.py

# 数据将解压到以下目录：
Pretraining/Dataset-1_training
NeuralNetwork/model_checkpoint_annotations_none_epoch5
NeuralNetwork/model_checkpoint_annotations_numerical_epoch5

5.6.1 Part 1

第一部分实现了两个Python3脚本的预处理步骤，分别是digraph_instructions_embeddings.py和digraph_numerical_features.py。我们还提供了一个带有所需依赖项的Docker容器。

针对《Investigating Graph Embedding Neural Networks with Unsupervised Features Extraction for Binary Analysis》模型的预处理。

为了提取此ML模型所需的特征，请使用digraph_instructions_embeddings.py Python3脚本。

输入：digraph_instructions_embeddings.py的输入是通过ACFG disasm IDA插件提取的JSON文件和预训练的指令嵌入：

• 对于我们发布的数据集，JSON文件已包含在features目录中。请注意，特征可以按照README中的说明从GDrive下载。
• 如果需要为新的二进制文件集提取特征，请按照README中的说明运行ACFG disasm IDA插件。
• 在Pretraining文件夹中，我们提供了汇编指令的词汇表和预训练的指令嵌入。这些嵌入与SAFE模型中使用的嵌入相同，并且是基于Dataset-1的训练部分预训练的。更多信息可以在SAFE README中找到。
• 默认情况下，digraph_instructions_embeddings.py为每个基本块选择前200条指令，但此数量可以通过命令行进行配置。

该脚本将生成以下输出：

• 一个名为digraph_instructions_embeddings_{NUM_INSTRUCTIONS}.json的文件，包含每个选定函数的图表示和特征。
• 一个名为log_coverage.txt的日志文件，提供有关未知指令频率的信息。

针对《Neural network-based graph embedding for cross-platform binary code similarity detection》模型的预处理

为了提取此ML模型所需的特征，请使用digraph_numerical_features.py Python3脚本。

输入：digraph_numerical_features.py的输入是通过ACFG features IDA插件提取的JSON文件：

• 对于我们发布的数据集，JSON文件已包含在features目录中。请注意，特征可以按照README中的说明从GDrive下载。
• 如果需要为新的二进制文件集提取特征，请按照README中的说明运行ACFG features IDA插件。

该脚本将生成以下输出：

•     一个名为digraph_numerical_features.json的文件，包含每个选定函数的图表示和特征。

使用Docker的说明：

# 构建Docker镜像：
docker build Preprocessing/ -t gnn-s2v-preprocessing

# 在Docker容器中运行两个脚本：
docker run \
    --rm \
    -v <path_to_the_acfg_disasm_dir>:/input \
    -v <path_to_the_instruction_embeddings_dir>:/instruction_embeddings \
    -v <path_to_the_output_dir>:/output \
    -it gnn-s2v-preprocessing /code/digraph_instructions_embeddings.py \
        -i /input \
        -d /instruction_embeddings/ins2id.json \
        -o /output/

docker run \
    --rm \
    -v <path_to_the_acfg_features_dir>:/input \
    -v <path_to_the_output_dir>:/output \
    -it gnn-s2v-preprocessing /code/digraph_numerical_features.py \
        -i /input \
        -o /output

# 使用以下命令查看两个脚本的所有选项：
docker -v $(pwd):/code run --rm -it gnn-s2v-preprocessing /code/digraph_instructions_embeddings_v2.py --help

docker -v $(pwd):/code run --rm -it gnn-s2v-preprocessing /code/digraph_numerical_features_v2.py --help


# 在Dataset-Vulnerability上运行digraph_instructions_embeddings.py：
docker run \
    --rm \
    -v $(pwd)/Preprocessing:/code\
    -v "/mnt/c/Users/22845/Desktop/binary_function_similarity-main/IDBs/Dataset-1/acfg_disasm_Dataset-1:/input" \
    -v $(pwd)/Pretraining/Dataset-1_training/:/instruction_embeddings \
    -v $(pwd)/Preprocessing/:/output \
    -it gnn-s2v-preprocessing /code/digraph_instructions_embeddings_v2.py \
        -i /input \
        -d /instruction_embeddings/ins2id.json \
        -o /output/Dataset-1/

# 在Dataset-Vulnerability上运行digraph_numerical_features.py：
docker run \
    --rm \
    -v $(pwd)/Preprocessing:/code\
    -v "/mnt/c/Users/22845/Desktop/binary_function_similarity-main/IDBs/Dataset-1/acfg_features_Dataset-1:/input" \
    -v $(pwd)/Preprocessing/:/output \
    -it gnn-s2v-preprocessing /code/digraph_numerical_features_v2.py \
        -i /input \
        -o /output/Dataset-1/

5.6.2 Part 2

第二部分实现了GNN-s2v方法的机器学习组件。我们还提供了一个带有TensorFlow 1.14和其他所需依赖项的Docker容器。

神经网络模型的输入：

• 用于训练的函数的CSV文件，或用于验证和测试的函数对。这些文件在我们发布的数据集中已经存在。文件路径在config.py文件中硬编码，基于数据集类型。
• 嵌入矩阵embeddings.npy，这是与SAFE模型中使用的相同的预训练指令嵌入。可以按照“下载模型数据”中的说明从GDrive下载。
• 第一部分输出的JSON文件（例如digraph_instructions_embeddings_200.json或digraph_numerical_features.json）。
• 模型检查点（仅在模型处于推理模式下使用，即在验证和测试过程中）。

该模型将生成以下输出：

• 一组包含相似度（列sim）的CSV文件，用于验证和测试中选定的函数。
• 一个config.json文件，其中包含用于运行测试的配置。这包括参数和CSV、JSON文件的路径。该文件对于调试和跟踪不同实验非常有用。
• 一个s2v.log日志文件，记录神经网络的日志。为改善日志记录，可以使用--debug（-d）选项。
• 模型检查点（仅在训练模型时生成）。

使用Docker的说明：

# 构建Docker镜像：
docker build NeuralNetwork/ -t gnn-s2v-neuralnetwork

# 在Docker容器中运行神经网络模型：
docker run --rm \
    -v $(pwd)/../../DBs:/input \
    -v $(pwd)/Pretraining/Dataset-1_training:/instruction_embeddings \
    -v $(pwd)/Preprocessing:/preprocessing \
    -v $(pwd)/NeuralNetwork/:/output \
    -it gnn-s2v-neuralnetwork /code/s2v.py (--train | --validate | --test) [--num_epochs 5] \
        --network_type {annotations,arith_mean,attention_mean,rnn} \
        --features_type {none,numerical,asm} \
        --dataset {one,two,vuln} \
        -c /code/model_checkpoint_$(date +'%Y-%m-%d') \
        -o /output/Dataset-x

# help
docker run --rm -it gnn-s2v-neuralnetwork /code/s2v.py --help

# run the training on the Dataset-1：
docker run --rm \
    -v "/mnt/c/Users/22845/Desktop/binary_function_similarity-main/DBs:/input" \
    -v "$(pwd)/Pretraining/Dataset-1_training:/instruction_embeddings" \
    -v "/mnt/c/Users/22845/Desktop/binary_function_similarity-main/Models/GNN-s2v/Preprocessing:/preprocessing" \
    -v "$(pwd)/NeuralNetwork:/output" \
    -it gnn-s2v-neuralnetwork python3 /code/s2v.py \
        --train \
        --network_type annotations \
        --features_type numerical \
        --num_epochs 5 \
        --dataset one \
        -c /output/model_checkpoint_$(date +'%Y-%m-%d') \
        -o /output/Dataset-1_training

# run the validation on Dataset-1 using the model_checkpoint that we trained on Dataset-1:
docker run --rm \
    -v $(pwd)/../../DBs:/input \
    -v $(pwd)/Pretraining/Dataset-1_training:/instruction_embeddings \
    -v $(pwd)/Preprocessing:/preprocessing \
    -v $(pwd)/NeuralNetwork/:/output \
    -it gnn-s2v-neuralnetwork /code/s2v.py \
        --validate \
        --network_type annotations \
        --features_type numerical \
        --dataset one \
        -c /code/model_checkpoint_annotations_numerical_epoch5/ \
        -o /output/Dataset-1_validation

# run the testing on Dataset-1 using the model_checkpoint that we trained on Dataset-1:
docker run --rm \
    -v $(pwd)/../../DBs:/input \
    -v $(pwd)/Pretraining/Dataset-1_training:/instruction_embeddings \
    -v $(pwd)/Preprocessing:/preprocessing \
    -v $(pwd)/NeuralNetwork/:/output \
    -it gnn-s2v-neuralnetwork /code/s2v.py \
        --test \
        --network_type annotations \
        --features_type numerical \
        --dataset one \
        -c /code/model_checkpoint_annotations_numerical_epoch5/ \
        -o /output/Dataset-1_testing

# run the testing on Dataset-2 using the model_checkpoint that we trained on Dataset-1:
docker run --rm \
    -v $(pwd)/../../DBs:/input \
    -v $(pwd)/Pretraining/Dataset-1_training:/instruction_embeddings \
    -v $(pwd)/Preprocessing:/preprocessing \
    -v $(pwd)/NeuralNetwork/:/output \
    -it gnn-s2v-neuralnetwork /code/s2v.py \
        --test \
        --network_type annotations \
        --features_type numerical \
        --dataset two \
        -c /code/model_checkpoint_annotations_numerical_epoch5/ \
        -o /output/Dataset-2_testing

# run the testing on Dataset-Vulnerability using the model_checkpoint that we trained on Dataset-1:

docker run --rm \
    -v $(pwd)/../../DBs:/input \
    -v $(pwd)/Pretraining/Dataset-1_training:/instruction_embeddings \
    -v $(pwd)/Preprocessing:/preprocessing \
    -v $(pwd)/NeuralNetwork/:/output \
    -it gnn-s2v-neuralnetwork /code/s2v.py \
        --test \
        --network_type annotations \
        --features_type numerical \
        --dataset vuln \
        -c /code/model_checkpoint_annotations_numerical_epoch5/ \
        -o /output/Dataset-Vulnerability_testing

5.7 SAFE

SAFE 工具由三个主要部分组成。第一部分用于创建汇编指令的词汇表并预训练指令嵌入；第二部分以 ACFG disasm 数据为输入，生成一些中间结果；第三部分实现机器学习组件。在准备阶段需要激活python虚拟环境，并下载与解压模型。

# 激活虚拟环境
source ../../env/bin/activate

# 下载并解压模型数据
python3 gdrive_model_download.py

数据最终被解压到一下目录

NeuralNetwork/model_checkpoint
Pretraining/Dataset-1_training

5.7.1 Part 1

第一部分通过名为 safe_pretraining.py 的 Python 脚本实现，同时提供了包含必要依赖的 Docker 容器。此部分使用 Word2Vec 模型（skip-gram）创建汇编指令的词汇表并预训练嵌入。输入 是通过 ACFG disasm IDA 插件提取的 JSON 文件目录：

•     对于发布的 数据集，JSON 文件已经包含在 features 目录中。有关如何从 GDrive 下载功能文件，请参阅 README。
•     如果是新的二进制文件，请按照 README 中的说明使用 ACFG disasm IDA 插件提取特征。

脚本将生成以下 输出：

•     文件 embeddings.npy，包含指令嵌入矩阵，每条指令对应一个嵌入。
•     文件 ins2id.json，映射选定指令到嵌入矩阵中的索引。
•     文件 ins2count.json，记录训练语料库中每条指令的出现次数，仅用于调试。
•     文件 pretraining.txt，包含用于训练指令嵌入的训练语料，仅用于调试。
•     文件 pretraining_unk.txt，包含去除低频词后的训练语料，仅用于调试。

# 构建 Docker 镜像
docker build --no-cache Pretraining/ -t safe-pretraining

# 在 Docker 容器中运行脚本
docker run --rm \
    -v <path_to_the_acfg_disasm_dir>:/input \
    -v <path_to_the_safe_pretraining_output_dir>:/output \
    -it safe-pretraining /code/safe_pretraining.py -i /input -o /output

# 使用以下命令查看 safe_pretraining.py 的所有选项
docker run --rm -it safe-pretraining /code/safe_pretraining.py --help

# 在 Dataset-1 上运行 safe_pretraining.py
docker run --rm \
    -v $(pwd)/../../DBs/Dataset-1/features/training/acfg_disasm_Dataset-1_training:/input \
    -v $(pwd)/Pretraining/:/output \
    -it safe-pretraining /code/safe_pretraining.py -i /input -o /output/Dataset-1_training_$(date +'%Y-%m-%d')

注意：如果仅使用 SAFE 模型进行推理，此步骤可省略。模型数据已包含汇编指令的词汇表和预训练的指令嵌入。

5.7.2 Part 2

SAFE 工具的第二部分通过名为 safe_preprocessing.py 的 Python 脚本实现，同时提供了包含必要依赖的 Docker 容器。

输入：

•     通过 ACFG disasm IDA 插件提取的 JSON 文件目录，详见 第一部分。
•     在 第一部分 中由 safe_pretraining.py 生成的 ins2id.json 文件。
•     每个函数的最大指令数（默认为 250）。

脚本将生成以下 输出：

•     文件 instructions_embeddings_list_{max_instructions}.json，每个函数表示为整数列表，其中每个数字对应嵌入矩阵中的指令索引。
•     文件 log_coverage.txt，记录超过一半指令超出词汇表的函数，仅用于调试。

# 构建 Docker 镜像
docker build --no-cache Preprocessing/ -t safe-preprocessing

# 在 Docker 容器中运行主脚本
docker run --rm \
    -v <path_to_the_acfg_disasm_dir>:/input \
    -v <path_to_the_safe_pretraining_output_dir>:/instruction_embeddings \
    -v <path_to_the_safe_preprocessing_output_dir>:/output \
    -it safe-preprocessing /code/safe_preprocessing.py -i /input -o /output

# 使用以下命令查看 safe_preprocessing.py 的所有选项
docker run --rm -it safe-preprocessing /code/safe_preprocessing.py --help

# 在 Dataset-1_training 上运行 safe_preprocessing.py
docker run --rm \
    -v $(pwd)/../../DBs/Dataset-1/features/training/acfg_disasm_Dataset-1_training:/input \
    -v $(pwd)/Pretraining/Dataset-1_training:/instruction_embeddings \
    -v $(pwd)/Preprocessing:/output \
    -it safe-preprocessing /code/safe_preprocessing.py -i /input -o /output/Dataset-1_training 

5.7.3 Part 3

SAFE 的第三部分实现了机器学习模型，同时提供了包含 TensorFlow 1.14 和其他依赖项的 Docker 容器。

# 构建 Docker 镜像
docker build --no-cache NeuralNetwork/ -t safe-neuralnetwork

# 在 Docker 容器中运行 SAFE 神经网络
docker run --rm \
    -v $(pwd)/../../DBs:/input \
    -v $(pwd)/Pretraining/Dataset-1_training:/instruction_embeddings \
    -v $(pwd)/Preprocessing:/preprocessing \
    -v $(pwd)/NeuralNetwork/:/output \
    -it safe-neuralnetwork /code/safe_nn.py (--train | --validate | --test) [--num_epochs 5] \
        --dataset {one,two,vuln} \
        -c /code/model_checkpoint_$(date +'%Y-%m-%d') \
        -o /output/Dataset-x

# 通过以下命令查看 safe_nn.py 的所有选项
docker run --rm -it safe-neuralnetwork /code/safe_nn.py --help

5.8 Trex

Trex 工具由两个主要部分组成：第一部分以 ACFG disasm 数据为输入，生成一些中间结果；这些结果将作为输入传递给第二部分，第二部分实现机器学习组件。

5.8.1 Part1

Trex 工具由两个主要部分组成：第一部分以 ACFG disasm 数据为输入，生成一些中间结果；这些结果将作工具的第一部分通过名为 generate_function_traces.py 的 Python3 脚本实现。同时，我们提供了包含必要依赖的 Docker 容器。
输入

generate_function_traces.py 的输入是通过 ACFG disasm IDA 插件提取的 JSON 文件目录：

•     对于我们发布的 数据集，JSON 文件已包含在 features 目录中。功能数据可以通过 README 中的说明从 GDrive 下载。
•     如果是新的二进制文件集，请按照 README 的说明运行 ACFG disasm IDA 插件提取特征。

输出

脚本将生成以下输出：

•     一个名为 trex_traces.json 的 JSON 文件，其中包含 Trex 模型所需的函数跟踪数据。为输入传递给第二部分，第二部分实现机器学习组件。

# 构建 Docker 镜像
docker build Preprocessing/ -t trex-preprocessing

# 在 Docker 容器中运行脚本
docker run --rm -v <path_to_the_acfg_disasm_dir>:/input -v <path_to_the_output_dir>:/output -it trex-preprocessing /code/generate_function_traces.py -i /input -o /output/

# 使用以下命令查看脚本的所有命令行选项
docker run --rm -it trex-preprocessing /code/generate_function_traces.py --help

# 在 Dataset-Vulnerability 上运行 generate_function_traces.py
docker run --rm -v $(pwd)/../../DBs/Dataset-Vulnerability/features/acfg_disasm_Dataset-Vulnerability:/input -v $(pwd)/Preprocessing/:/output -it trex-preprocessing /code/generate_function_traces.py -i /input -o /output/Dataset-Vulnerability-trex

# 运行单元测试
docker run --rm -v $(pwd)/Preprocessing/testdata/:/input -v $(pwd)/Preprocessing/testdata/trex_temp:/output -it trex-preprocessing /bin/bash -c "( cd /code && python3 -m unittest test_generate_function_traces.py )"

5.8.2 Part2

机器学习组件通过名为 trex_inference.py 的脚本实现。同时，我们提供了包含必要依赖的 Docker 容器。脚本的输入为：

•     包含函数对的 CSV 文件，用于比较函数对的相似度。对于发布的 数据集，函数对位于 pairs 文件夹中（示例 这里）。
•     在 generate_function_traces.py 脚本中生成的函数跟踪 JSON 文件。
•     训练好的模型目录（Google Drive 链接）。
•     预训练阶段生成的二值化数据目录（Google Drive 链接）。

脚本生成以下输出：

•     输入 CSV 文件的副本（名为 {original_name}.trex_out.csv），其中新增了一列 cs，表示函数对的余弦相似度。

# 构建 Docker 镜像
docker build NeuralNetwork/ -t trex-inference

# 运行推理脚本
docker run --rm -v <path_to_the_function_pairs_folder>:/pairs -v <path_to_the_trex_traces_folder>:/traces -v <path_to_the_output_folder>:/output -it trex-inference conda run --no-capture-output -n trex python3 trex_inference.py --input-pairs /pairs/<name_of_csv_file> --input-traces /traces/trex_traces.json --model-checkpoint-dir checkpoints/similarity/ --data-bin-dir data-bin-sim/similarity/ --output-dir /output/<name_of_output_dir>

# 使用以下命令查看脚本的所有命令行选项
docker run --rm -it trex-inference conda run --no-capture-output -n trex python3 trex_inference.py --help

# 示例
docker run --rm -v $(pwd)/../../DBs/Dataset-Vulnerability/pairs/:/pairs -v $(pwd)/Preprocessing/Dataset-Vulnerability-trex/:/traces -v $(pwd)/NeuralNetwork/:/output -it trex-inference conda run --no-capture-output -n trex python3 trex_inference.py --input-pairs /pairs/pairs_testing_Dataset-Vulnerability.csv --input-traces /traces/trex_traces.json --model-checkpoint-dir checkpoints/similarity/ --data-bin-dir data-bin-sim/similarity/ --output-dir /output/Dataset-Vulnerability-trex

5.9 Zeek

Zeek 工具由两个主要部分组成：第一部分以 ACFG disasm 数据为输入，生成一些中间结果；第二部分则实现机器学习组件。

5.9.1 Part1

Zeek 工具的第一部分通过名为 zeek.py 的 Python3 脚本实现。同时，我们提供了包含必要依赖的 Docker 容器。zeek.py 的输入是通过 ACFG disasm IDA 插件提取的 JSON 文件目录：

•     对于我们发布的 数据集，JSON 文件已包含在 features 目录中。功能数据可以通过 README 中的说明从 GDrive 下载。
•     如果是新的二进制文件集，请按照 README 的说明运行 ACFG disasm IDA 插件提取特征。

脚本将生成以下输出：

•     一个名为 logs 的目录，包含分析的日志，仅用于监控分析进度和调试。
•     一个名为 jsons 的目录，其中每个输入的 ACFG disasm JSON 文件都对应一个 JSON 文件，包含中间结果。
•     一个名为 zeek.json 的文件，将 jsons 目录中所有 JSON 文件合并为一个。这是 Zeek 工具第二部分（机器学习部分）的输入。

# 构建 Docker 镜像
docker build --no-cache Preprocessing/ -t zeek

# 在 Docker 容器中运行主脚本
docker run --rm --name zeek_preprocessing -v <path_to_the_acfg_disasm_dir>:/input -v <path_to_the_zeek_output_dir>:/output -it zeek /code/zeek.py process /input /output [--workers-num 5]

# 使用以下命令查看 zeek.py process 的所有选项
docker run --rm -it zeek /code/zeek.py process --help
docker run --rm -it zeek /code/zeek.py process --help

# 仅用于调试（需要在 Docker 容器中运行）
docker exec -it zeek_preprocessing /bin/bash
/code/zeek.py stats /input /output

# 在 Dataset-Vulnerability 数据集上运行 zeek.py process
docker run --rm --name zeek_preprocessing -v $(pwd)/../../DBs/Dataset-Vulnerability/features/acfg_disasm_Dataset-Vulnerability:/input -v $(pwd)/Preprocessing/zeek_intermediate/Dataset-Vulnerability:/output -it zeek /code/zeek.py process /input /output --workers-num 10

# 运行单元测试
docker run --rm -v $(pwd)/Preprocessing/testdata/:/input -v $(pwd)/Preprocessing/testdata/zeek_intermediate:/output -it zeek /bin/bash -c "( cd /code && python3 -m unittest test_zeek.py )"

5.9.2 Part2

Zeek 工具的第二部分实现了机器学习组件。我们同时提供了包含 TensorFlow 1.14 和其他必要依赖的 Docker 容器。神经网络模型的输入包括：

•     包含用于训练的函数，或用于验证和测试的函数对的 CSV 文件。这些文件已为发布的 数据集 提供。文件路径基于数据集类型硬编码在 config.py 中。
•     在 第一部分 输出的 zeek.json 文件。
•     模型 检查点（仅当模型用于推理模式时，例如在验证和测试时）。

模型将生成以下输出：

•     一组 CSV 文件，其中包含所选验证和测试函数的相似度（列名为 sim）。
•     一个 config.json 文件，记录运行测试时使用的配置，包括输入 CSV 和 JSON 文件的路径。此文件对调试和跟踪不同实验有用。
•     一个 zeek.log 文件，记录神经网络的日志信息。为了改进日志记录，可以使用 --debug（-d）选项。
•     模型检查点（仅当模型被训练时生成）。

• # 构建 Docker 镜像
  docker build --no-cache NeuralNetwork/ -t zeekneuralnetwork
  
  # 在 Docker 容器中运行 Zeek 神经网络
  docker run --rm -v $(pwd)/../../DBs:/input -v $(pwd)/NeuralNetwork/:/output -it zeekneuralnetwork /code/zeek_nn.py [--train] [--test] [--num_epochs 10] [-c /code/model_checkpoint] [--dataset one]  -o /output/Dataset-x
  
  # 在 Dataset-1 上运行训练
  docker run --rm -v $(pwd)/../../DBs:/input -v $(pwd)/NeuralNetwork:/output -it zeekneuralnetwork /code/zeek_nn.py --train --num_epochs 10 -c /code/model_checkpoint_$(date +'%Y-%m-%d') --dataset one -o /output/Dataset-1_training
  
  # 使用我们在 Dataset-1 上训练的 model_checkpoint 测试 Dataset-1
  docker run --rm -v $(pwd)/../../DBs:/input -v $(pwd)/NeuralNetwork/:/output -it zeekneuralnetwork /code/zeek_nn.py --test --dataset one -c /code/model_checkpoint -o /output/Dataset-1_testing