Patch Based Vulnerability Matching for Binary Programs

Patch Based Vulnerability Matching for Binary Programs

名词解释

1-day vulnerability： Vulnerability whose patch has been released is called as 1-day
vulnerability. It would be exploited to attack the users who fail to adopt the latest security patches.（补丁已经发布的漏洞称为1天漏洞。它会被用来攻击那些没有采用最新安全补丁的用户。）

1 INTRODUCTION

Challenges

1. However, it is difficult for the current function matching solutions to differentiate vulnerable and patched functions, since patches usually introduce subtle changes to fix vulnerabilities. The patched functions would be identified as vulnerable, resulting in high false positive rates in detecting vulnerabilities. As a result, these works require security experts to manually analyze potential vulnerable functions to find the genuine ones, which is time-consuming.（但是，目前的函数匹配解决方案很难区分漏洞函数和补丁函数，因为补丁通常会引入细微的变化来修复漏洞。修补后的函数会被识别为漏洞，导致漏洞检测的假阳性率很高。因此，这些工作需要安全专家手动分析潜在的漏洞函数，以找到真正的漏洞函数，这是非常耗时的。）
2. On the one hand, approaches need to be tolerant enough to identify vulnerable functions even with the presence of vulnerability-irrelevant small code changes like function upgrades and compiler optimizations.（一方面，方法需要有足够的容忍度来识别漏洞函数，即使存在与漏洞无关的小代码更改
   如函数更新和编译器优化等。）
3. On the other hand, approaches also need to be precise enough to filter out those already patched functions.（另一方面，方法也需要足够精确，以过滤掉那些已经修补的函数。）

Three properties

• P1. The approach needs to be accurate in identifying the patches in the target functions.（该方法需要准确地识别目标函数中的补丁。）
• P2. The approach needs to be scalable for large real-world programs.（这种方法需要具有可扩展性，以适应现实世界中的大型程序。）
• P3. The approach should use no information from the source code to work in closed source program binaries.（这种方法不应该使用来自源代码的任何信息来在封闭源代码程序二进制文件中工作。）

Binary X-Ray (BinXray).

• For P1. To accurately identify patched functions and detect real vulnerable functions, BinXray introduces two-step signature matching approach. First, to narrow the searching space, BinXray generates the function signature from the functions with known vulnerabilities, and uses the signatures to search for suspicious target functions in the binaries through matching. Second, it generates patch signatures by comparing the differences between the vulnerable functions and their patched versions. The patch signatures will be used to identify the patched functions from the suspicious target functions. To extract accurate patch signatures, we propose a structural basic block mapping algorithm to locate the changed and unchanged basic blocks between two functions. BinXray makes patch prediction based on the length sensitive similarity matching of the patch signature with the target function.（为了准确地识别补丁函数和检测真正的漏洞函数， BinXray 提出了两步签名匹配方法。首先，为缩小搜索空间，BinXray从已知漏洞的函数中生成函数签名，并利用签名进行匹配，搜索二进制文件中可疑的目标函数。其次，通过比较漏洞函数与其补丁版本之间的差异，生成补丁签名。补丁签名将用于从可疑的目标函数中识别补丁函数。为了提取准确的补丁签名，我们提出了一种结构化的基本块映射算法来定位两个函数之间已改变和未改变的基本块。BinXray基于补丁签名与目标函数的长度敏感相似度匹配进行补丁预测。 ）
• For P2. To improve the scalability, BinXray proposes patch signature extraction algorithm, which only captures essential parts
  of the patching semantics. Since most of the security patches only induce small changes within a few basic blocks in binary pro-
  grams, BinXray locates the areas which only consist of the changes induced by patching vulnerabilities, and generates patch signatures based on them instead of generating signatures at the granularity of the whole function. This can also greatly improves the matching speed. Moreover, changes in other parts of the functions won’t be included in signatures, which are irrelevant to vulnerabilities. Thus, they will not affect the predicting results, leading to a more robust prediction against the noises from other changes.（为了提高可扩展性，BinXray提出了补丁签名提取算法，该算法只捕获补丁语义的关键部分。因为大部分的安全补丁仅在二进制程序的几个基本块内引起微小的变化，BinXray定位的地方仅包含由修补漏洞引起的变化，并基于这些生成补丁签名，而不是基于整个函数粒度生成签名。这也可以极大地提高匹配速度。此外，函数其他部分的更改不会包含在签名中，这与漏洞无关。因此，它们不会影响预测结果，从而使预测对其他变化的干扰更有鲁棒性。）
• For P3. From signature generation to patch identification,BinXray performs all the analysis at binary level. Therefore, it does not need any source code information which makes it suitable for programs without source code, such as firmware or third-party libraries. （从签名生成到补丁识别，BinXray的所有分析都在二进制级别上执行。因此，它不需要任何源代码信息，这使得它适合没有源代码的程序，如固件或第三方库。）

2 OVERVIEW

Motivating Example

use the HeartBleed bug (CVE-2014-0160) in OpenSSL as the running example. It occurs in dtls1_process_heartbeat() function.

图1(a)是漏洞函数（version 1.0.1f）的CFG。图1(b)是补丁函数（version 1.0.1g）的CFG。
补丁在源代码中添加了一个检查，使得图1(b)中出现了六个新的基本块，$E^{\prime },F^{\prime },G^{\prime },L^{\prime },M^{\prime },N^{\prime }$。 另外，由于打补丁， 在图1(b)中另外四个基本块，$A^{\prime },C^{\prime },D^{\prime },I^{\prime }$，也出现了略微的改变。
Given an unknown binary executable which may contain this function, we want to know whether the HeartBleed bug exists or not. If a traditional function matching approach is adopted and the vulnerable function in Figure 1(a) is used as the matching target, the corresponding function in the unknown binary may be matched. For instance, the patched function in Figure 1(b) can be matched,since they share a large number of common blocks $B^{\prime },H^{\prime },P^{\prime },J^{\prime },K^{\prime },O^{\prime },Q^{\prime },R^{\prime },S^{\prime },T^{\prime }$ and $U^{\prime }$′ with the same structure. However, it is unclear whether the matched function has been patched or not, since the two functions have a high degree of similarity, so tedious manual examination is usually necessary to differentiate genuine and spurious one.
（给定一个可能包含这个函数的未知二进制可执行文件，我们想知道HeartBleed bug是否存在。如果采用传统的函数匹配方法，并将图1(a)中的漏洞函数作为匹配目标，则可以匹配未知二进制中的对应函数。例如，图1(b)中的补丁函数可以匹配，因为它们共享大量公共基本块$B^{\prime },H^{\prime },P^{\prime },J^{\prime },K^{\prime },O^{\prime },Q^{\prime },R^{\prime },S^{\prime },T^{\prime },U^{\prime }$′ 并且具有相似的结构。然而，匹配的函数是否已经打补丁并不清楚，因为这两个函数具有高度的相似性，所以通常需要繁琐的人工检查来区分真假。）

Approach Overview

Figure 2 shows the overview of our approach, named BinXray.
VF:a vulnerable function （漏洞函数）
PF:a patched version of the same function, called patched function（相同函数的补丁版本，叫做补丁函数）
TF:a target function（目标函数）
Taking the binary code of a vulnerable function (VF), a patched version of the same function, called patched function (PF), and a target program as inputs, the goal of BinXray is to effectively and efficiently check whether the target program has any functions (TF) that are similar to the vulnerable function but have not been patched yet. For each CVE, VF is the function before the patch commit. PF is the function after it. By diffing VF and PF, BinXray can generate the patch signature. TF is detected by the function matching algorithm using VF as the signature in the target binary. The core components of BinXray are: target function matching, patch signature generation, and patch presence identification.（以漏洞函数（VF）的二进制代码、同一函数的补丁版本(称为补丁函数（PF）)和目标程序为输入，BinXray的目标是有效和高效地检查目标程序是否有任何与漏洞函数相似相似但尚未打补丁的函数（TF）。对于每一个CVE， VF是补丁提交之前的函数。PF是之后的函数。通过区分VF和PF，BinXray可以生成补丁签名。TF由函数匹配算法使用VF作为目标二进制文件中的签名来检测。BinXray的核心部分是:目标函数匹配、补丁签名生成和补丁存在识别。）

Terms and Acronyms

Term	Acronym	Description
Vulnerable Function	VF	A function that contains a vulnerability
Patched Function	PF	A function whose vulnerability has been patched
Target Function	TF	A function to be checked whether the vulnerability has been patched or not
Basic Block	BB	A sequence of consecutive instructions without any branching
Changed Basic Block	CBB	A block that has been changed, added, or deleted in the differences between a VF and its PF
Boundary Basic Block	BBB	A block that is the parent or the child of a CBB, or the root or leave of a CFG
Trace	-	A sequence of consecutive BBs without any loops
Valid Trace	VT	A sequence of consecutive basic blocks that starts and ends with some BBBs, crosses at least one CBB, without any loops

Target Function Matching.

BinXray generates lightweight function signatures and leverages function matching algorithm to quickly identify target functions (TFs) that are similar to the VF. Note that these TFs may not have been patched. The matching algorithm uses syntactic and structural information of VF, as the function signature, to identify TFs. Hence it is scalable and accurate enough to identify TFs.
（BinXray生成轻量级函数签名，并利用函数匹配算法来快速识别与VF相似的目标函数。请注意，这些TF可能尚未打补丁。该匹配算法使用VF的语法和结构信息作为函数特征来识别TF。因此，它足够可扩展和准确地识别TF。）

Patch Signature Generation.

BinXray automatically generates binary level patch signatures from the normalized binary code of the given VF and PF. Instead of incorporating the entire function into the signature, it first creates a mapping between the basic blocks(BBs) of two functions, from which BinXray identifies Changed Basic Blocks (CBBs) and computes two sets of valid traces (VTs): one set $T_1$ from the CBBs of the VF and one set $T_2$ from the CBBs of the PF. The two trace sets $(T_1,T_2)$ are regarded as a patch signature.（BinXray根据给定VF和PF的规范化二进制代码自动生成二进制级别的补丁签名。而不是将整个函数纳入签名,它首先创建一个两个函数内的基本块(BBs) 之间的映射,从BinXray识别改变的基本块 (CBBs)并且计算两组有效的路径 (VTs):一组$T_1$来自于VF的CBBs 和一组$T_2$来自于PF的CBBs。两个路径集$(T_1,T_2)$被视为一个补丁的签名。）

Patch Presence Identification.

BinXray determines whether each identified TF has been patched or not, by matching it with the patch signature. If the TF is more close to VF than PF, it is considered to be vulnerable. Otherwise, it is considered to be patched.（BinXray通过匹配补丁签名来确定每个已识别的TF是否已打补丁。如果TF比起PF更接近VF，则被认为是漏洞。否则被视为已打补丁。）

3 METHODOLOGY

Target Function Matching（目标函数匹配）

输入：一个目标程序，一个VF（漏洞函数）以及它的PF（补丁函数）

为了减少时间消耗，我们首先通过在目标程序中定位类似于VF（漏洞函数）的TFs（目标函数）来缩小搜索范围，执行补丁存在识别。

我们采用轻量级技术进行目标函数匹配。
出于可扩展性考虑，我们使用函数的语法和结构信息来构造函数签名，并检查两个函数是否相似。语法信息由二进制指令中的助记符序列、函数调用和常数值组成。结构信息由指令数、基本块、分支和控制流图组成。

使用函数签名，Target Function Matching实现了识别TFs（目标函数）的高精度。这是因为漏洞函数通常很大，其语法和结构信息丰富且独特，这使得我们可以将它们与其他函数区分开来。因此，尽管轻量级技术为了可伸缩性而牺牲了一点准确性，但是在我们的实验中，结果对于补丁存在识别来说仍然是足够准确的。请注意，这个目标函数匹配不是这项工作的贡献，因此它可能类似于其他现有的方法。我们包含它是因为我们想展示我们框架的完整工作流程。

Patch Signature Generation（补丁签名生成）

在补丁签名生成中，BinXray首先计算VF（漏洞函数）的二进制代码与其对应的PF（补丁函数）之间的差异，然后生成补丁签名，该签名将用于补丁存在识别。
它由三个子组件组成: Binary Instruction Normalization 二进制指令规范化、basic block mapping基本块匹配和valid trace generation有效路径生成。

Binary Instruction Normalization. 二进制指令规范化

Problem：程序的源代码由编译器编译成二进制指令。由于编译优化、寄存器分配和赋值、地址移位以及其他编译设置，两个相似或相同函数的二进制指令在编译后可能不相似。
由于BinXray通过利用漏洞函数和补丁函数之间的差异生成补丁签名，因此消除编译器引入的更改非常重要。否则，生成的补丁签名将包含许多不相关的更改 。因此，使用规范化来减少编译器引入的更改。

BinXray applies three normalization rules to binary instructions:
address normalization: replacing concrete addresses by a symbolic term “address” （用符号术语“address”代替具体地址）
call 0x80488094 $\to$ call address
memory normalization: replacing indirect memory access by a symbolic term “mem” (用符号术语“mem”代替间接地址访问)
mov [ebp], edx $\to$ mov mem, edx
register normalization: replacing concrete registers by a symbolic term “reg”(用符号术语“reg”代替具体的寄存器。)
mov ebp, esp $\to$ mov, reg, reg

值得一提的是，BinXray不规范常数，因为一些补丁可能只为了修复漏洞而更改常数，例如，增加缓冲区大小以修复缓冲区溢出漏洞。常量规范化将防止BinXray捕获这种补丁。

Basic Block Mapping. 基本块映射

基本块映射试图在两个函数之间映射相同的基本块。这是一种计算函数差异的技术，其中不匹配的块被视为差异。

现有方法问题：如果一个函数中有几个重复的块具有相同的哈希值，它们可能无法将该块与正确的块相匹配。
例如，Figure 3，block1 和 block1’是相同的，block2，block3 和 block3’ 是相同的，block2’ 是从block2 修改得来的，和其他的不同。现有的方法可以匹配 block1 和 block1’。但是他们可能会错误匹配 block2 和 block3’，因为他们有着相同的hash值Figure 3(b)。不准确的映射将显著影响生成的补丁签名的有效性。因此，我们提出了一种新的基本块映射算法，该算法利用基本块的语法和上下文信息来缓解哈希冲突问题(即不同的基本块具有相同的哈希值)。我们的方法可以完成像Figure 3©那样的映射，其中 block2 和 block2’可以被正确地识别为CBB（Changed Basic Block）。我们手动验证36个真实案例，在一个函数中出现重复的块。实验结果表明，该算法优于现有的映射算法

我们的基本块映射算法首先计算两个函数的基本块的哈希值，基于他们标准化的指令。然后将所有哈希值相同的基本块放在同一个篮子里。之后，如果一个篮子正好有两个分别来自不同函数的基本块，这两个基本块就匹配。如果一个篮子只有来自一个函数的基本块，那么这些基本块肯定是changed basic blocks (CBB)（被改变的基本块。）如果一个篮子有来自两个函数的多个块，那么连接这些基本块之间的映射是不重要的。为了解决这个问题，我们利用它们的结构信息，并提出了一个贪婪算法来建立两个基本块之间的映射使用相似性分数。对于一个篮子中来自两个不同函数的每对基本块，BinXray使用它们的结构信息计算它们之间的相似性分数(注意，它们的语法信息已经被编码为哈希值)。两个基本块的相似性分数通过计算它们相邻基本块中的标准化指令序列的编辑距离来计算。如果一个基本块有一个以上的相邻基本块，相似度分数将根据控制流进行加权。入度的聚集权归一化为与出度相同。在获得基本块的成对相似性分数后，所有的对将被放入矩阵中。BinXray从矩阵中迭代选择一对相似度分数最高的基本块，将其视为一对匹配的基本块，并将其从矩阵中移除，直到不再有一对基本块可以匹配。最后，矩阵中剩余的所有基本块都被视为CBB。在一个篮子中计算基本块映射后，信息将作为其他基本块的上下文传播到其他篮子。

示例：假设在一个篮子里面有七个基本块， Ba, Bb, Bc, B1, B2, B3, and B4,Ba, Bb, Bc来自于漏洞函数，其他的（B1, B2, B3, and B4）来自于对应的补丁函数。
计算得到的相似度如 Figure 4(a)所示。
贪婪算法首先选择相似性得分最高的一对(Bb，B3)，并将其从矩阵中移除，得到如Figure 4(b)所示的矩阵。重复这个过程，基本块对（Ba,B4）和（Bc,B2）被匹配了，结果矩阵如 Figure 4© 和 Figure 4(d) 所示。最后，剩余的基本块是来自补丁函数的B1，它被认为是CBB。

Valid Trace Generation. 有效的轨迹生成

为了精确表达给定VF（漏洞函数）和PF（补丁函数）的补丁签名，BinXray生成两组有效轨迹，一组用于VF（漏洞函数），另一组用于PF（补丁函数）。根据漏洞函数和补丁函数之间的基本块映射结果，定位这两个函数的所有CBB。

BinXray标识每个CBB的边界基本块(BBB)，其中BBB是CBB的相邻基本块，而不是CBB，或者是函数的CFG的根或叶。
Boundary Basic Block（BBB）：A block that is the parent or the child of a CBB, or the root or leave of a CFG.

A valid trace (VT) is a sequence of consecutive basic blocks that starts and ends with some BBBs, crosses at least one CBB, without any loops.
有效轨迹(VT)是一系列连续的基本块，以一些BBB开始和结束，穿过至少一个CBB，没有任何循环。
如果存在一个循环，我们将对它进行平坦化(将循环视为迭代一次)，这样它们就不会影响轨迹的数量。因为BinXray主要依赖语法信息，所以展平循环是一个很好的选择，它不会太多地改变语法。为了建立VT，我们把所有的CBB和BBB放入到一个连通图。所有的BBB都是图的根节点和叶节点；CBB是内部节点。
我们用 $T_1$ 表示漏洞函数的有效轨迹集合，$T_2$ 表示补丁函数的有效轨迹集合。

示例：
运行示例，

version1.0.1f 的函数 *dtls1_process_heartbeat()*的CBB是A，C，D，F， BBB是B，E， K，G。
补丁函数的CBB是 A’,C’,D’,E’,F’,G’,I’,L’,M’,N’，BBB是B’,H,P,J,U。

有效轨迹(VT)是一系列连续的基本块，以一些BBB开始和结束，穿过至少一个CBB，没有任何循环。

version1.0.1f 的函数 *dtls1_process_heartbeat()*的VT是：
$A\to B$
$A\to C\to D\to E$
$A\to C\to D\to G$
$A\to C\to K$
$B\to C\to D\to E$
$B\to C\to D\to G$
$B\to C\to K$
$E\to F\to G$

补丁函数的VT是：
$A^{\prime }\to B^{\prime }$
$A^{\prime }\to C^{\prime }\to L^{\prime }\to U^{\prime }$
$A^{\prime }\to C^{\prime }\to D^{\prime }\to M^{\prime }\to U^{\prime }$
$A^{\prime }\to C^{\prime }\to D^{\prime }\to E^{\prime }\to F^{\prime }\to N^{\prime }\to U^{\prime }$
$A^{\prime }\to C^{\prime }\to D^{\prime }\to E^{\prime }\to F^{\prime }\to G^{\prime }\to H^{\prime }$
$A^{\prime }\to C^{\prime }\to D^{\prime }\to E^{\prime }\to F^{\prime }\to G^{\prime }\to J^{\prime }$
$A^{\prime }\to C^{\prime }\to D^{\prime }\to E^{\prime }\to P^{\prime }$
$B^{\prime }\to C^{\prime }\to L^{\prime }\to U^{\prime }$
$B^{\prime }\to C^{\prime }\to D^{\prime }\to M^{\prime }\to U^{\prime }$
$B^{\prime }\to C^{\prime }\to D^{\prime }\to E^{\prime }\to F^{\prime }\to N^{\prime }\to U^{\prime }$
$B^{\prime }\to C^{\prime }\to D^{\prime }\to E^{\prime }\to F^{\prime }\to G^{\prime }\to H^{\prime }$
$B^{\prime }\to C^{\prime }\to D^{\prime }\to E^{\prime }\to F^{\prime }\to G^{\prime }\to J^{\prime }$
$B^{\prime }\to C^{\prime }\to D^{\prime }\to E^{\prime }\to P^{\prime }$
$H^{\prime }\to I^{\prime }\to J^{\prime }$

通过合并首尾相连的VT，可以优化VT集合。
将CBB和BBB合并组成的VT的好处是双重的。

首先，它确定了漏洞修补导致的变化。

Figure 5展示了作为示例现实世界的漏洞CVE-2015-1790。
左边的CFG展示了相关的函数 PKCS7_dataDecode() （OpenSSL 1.0.1 l）.
右边部分在三个连续的版本中展示了函数的细节。
在 OpenSSL 1.0.1 l 中，这个函数是易受攻击的，我们视其为目标。
在 1.0.1 m 中，函数被更新了，Area 1中的红色基本块，但是仍然是易受攻击的。
在 1.0.1 n 中，该漏洞已通过在Area 2中添加健全性检查(黄色块)得到修复。

BBB有助于定位目标函数中与补丁签名相关的区域。区域外的更改将被过滤掉。如果我们使用签名来检测目标函数(1.0.1 l)中补丁的存在，根据BBB，将只考虑区域2中的变化。其他变化将被视为噪音，因此它们不会影响补丁存在识别。在这个例子中，使用BBB(绿色块)，BinXray可以专注于改变的(黄色)块，而忽略噪声(红色块)。

其次，它显著减少了签名生成和补丁存在识别中使用的基本块和轨迹的数量。
如 Figure 5所示，函数 PKCS7_dataDecode() 有大约100个基本块，可以形成数千个不同的轨迹。如果我们枚举所有的块和迹来构建签名，那么签名大小将会太大，并且补丁识别过程将会花费很长时间。使用BBB，签名大小减少到5个基本块和2条迹线。实验结果表明，使用BBB显著提高了BinXray的性能。事实上，BinXray甚至可以在不到一秒钟的时间内完成对一个大型函数的分析，而如果整个函数用于构建签名，则需要十多分钟。

Patch Presence Identification（补丁存在识别）

补丁存在标识判断一个TF目标函数是否已经被补丁。关键思想是检查TF是更像VF还是PF。如果TF比PF更像VF，那么TF就被认为漏洞函数，否则就被认为是补丁函数。
补丁存在识别包括四个部分: trace generation 轨迹生成, trace reduction 轨迹约简, similarity comparison 相似性比较 和 decision algorithm 决策算法.

Trace Generation. 轨迹生成
为了匹配目标函数中的补丁签名，BinXray首先从漏洞函数，补丁函数，目标函数中创建四个有效轨迹集合，$T_3,T_4,T_5,T_6$如图6所示，其中($T_1,T_2$)是补丁签名。

为了生成$T_3$和$T_4$，BinXray首先使用Basic Block Mapping的基本块映射算法建立漏洞函数和目标函数之间的映射，然后提取VF和TF的CBBs。与补丁签名生成不同，BinXray 复用在漏洞函数和补丁函数之间生成BBB。它创建了集合$T_3$，将目标函数中的CBB与来自与这些CBB相邻的补丁签名的BBB相结合。可以构造一个或多个局部CFG，并通过遍历这些局部CFG生成轨迹集。同样,它创建设置集合$T_4$通过结合漏洞函数的CBBs与相应的BBBs。使用BBBs的原因是，它确保只有相关的块包含在集合中。如果在函数的其他部分有一些与漏洞无关的CBB，它们将不会形成有效的轨迹，因为它们附近没有BBB。因此，它有助于消除噪音。最后,相同的步骤被应用来获得目标函数的集合$T_5$从补丁函数中获得集合$T_6$通过在目标函数和补丁函数应用匹配。

Trace Reduction. 轨迹约简
为进一步提高预测精度和性能，BinXray将消除无关的轨迹在上述轨迹集($T_4$和$T_6$)。
为 $T_4$ 中每个有效轨迹$t$,如果在 $T_1$ 中不存在任何有效轨迹中包含与 $t$ 相同的CBB, 有效轨迹 $t$ 将从 $T_4$ 中消除，生成一个约简后的有效轨迹集 $T_{41}$。 类似的， BinXray 将从 $T_6$ 中删除不相关的轨迹，通过与 $T_2$对比，生成一个约简后的有效轨迹集 $T_{62}$. 约简确保保留下的 $T_{41}$ 和 $T_{62}$ 将包含补丁签名中的一些 CBBs，这些在补丁存在识别中被认定为是相关的。

示例：
Figure 7 提供了Figure 1中运行示例的补充部分。Figure 7(a) 中的漏洞函数与 Figure 1(a)。Figure 7(b)显示了修改后函数版本即TF。 基本块 P’’ 被添加在 TF，导致了 基本块（I，J）在 Figure 7(a) 被标记为 VF 的CBB。召回BBB (B,E,K,G) 在补丁签名的BBB (B,E,K,G), BinXray为了VF生成了轨迹集合$T_4$, 包括了唯一一个有效轨迹：
$G\to I\to J$

在轨迹约简中，约简集中的每个轨迹都需要包含补丁签名的CBB集中的至少一个块。在 Figure 1(a)，CBB是 A,C,D,F。因此，轨迹 $G\to I\to J$将被移除。 通过去除它，BinXray过滤掉了不相关的轨迹，最终的精度将得到提高。

Similarity Comparison. 相似性比较
BinXray通过计算轨迹集和补丁签名之间的相似度来进行补丁存在识别。为了计算每一对轨迹集的相似度评分，我们首先展示如何计算一对轨迹的相似度评分。对于轨迹对中的每个轨迹，BinXray首先将轨迹中的基本块连接起来，通过删除所有跳转指令形成一个顺序指令轨迹。然后，对两条指令轨迹进行比较，得到相似度评分。分数根据公式(1)计算。

BinXray在两条指令轨迹中计算 Levenshtein distance，用 $edit(t_1,t_2)$表示。然后从轨迹的最大长度减去距离并除以最大长度。得到的分数度量两个轨迹之间的归一化相似性。
在得到每一对轨迹的单独得分后，根据下式计算两个轨迹集之间的最终相似度。

两个轨迹集的相似度分数 $Sim(T_1,T_2)$ 根据轨迹长度进行标准化。分数乘以 $t_1,t_2$， 除以一个基准， 用 $T_1$ 中轨迹的数量乘以 $T_2$ 中所有轨迹的长度加上用 $T_2$ 中轨迹的数量乘以 $T_1$ 中所有轨迹的长度。它确保最终分数在[0,1]范围内缩放。
这个方程保证了较长的轨迹比较短的轨迹贡献更多的权重。较长的轨迹通常是包含补丁信息。因此，它们对相似度评分的贡献应该更大。短迹通常来自函数中的小而孤立的块，这些块可能是带有少量补丁信息的噪声。他们的权重应该更小，这样才不会影响总分。

示例：
Figure 8 显示了相似度计算的两组有效跟踪。BinXray将比较A中的每个轨迹与B中的每个轨迹。根据公式(1)，($A1，B1$)的相似度分数是0.8（5条指令中有4条匹配），($A2，B1$)的相似度分数是0（没有一条指令匹配）。然后，根据公式(2)，基于轨迹长度对总体相似度进行归一化，其长度为0.48(= 0.8∗9/15 + 0∗6/15)。由于归一化，虽然轨迹A2不同于B1，但其对整体相似度评分的影响小于轨迹对(A1,B1)。它通过降低短指令轨迹的权重来帮助减轻噪声。

Decision Algorithm. 决策算法
我们提出了一个判断目标函数是否被修补的决策算法。该算法的核心思想是利用函数的异同来推断函数之间的关系。它在处理部分相似问题时更准确。Figure 6 显示了有效轨迹集之间的关系。每个跟踪集代表了对应函数中与漏洞相关的唯一部分。以下是三种情况:
CASE 1: $T_1$ and $T_2$ are both non-empty. 如果目标函数被修补了，目标函数和漏洞函数之间的差异明显于目标函数和补丁函数之间的差异。否则，如果目标函数是有漏洞的，目标函数和补丁函数的差异会比目标函数与漏洞函数之间的差异更明显。因此，在这种情况下，BinXray 检测 $Sim(T_3,T_2)>Sim(T_5,T_1)$是否成立。如果成立，则我们称目标函数已经被修补，否则，则没有被修补。
CASE 2:$T_1$ is empty and $T_2$ is non-empty. $T_1$ 是空的意味着补丁添加了很多新鲜的代码。如果目标函数已经被修补， $T_3$
会与 $T_2$ 相似，$T_{62}$ 将是空的。 否则，如果目标函数是有漏洞的， $T_{62}$ 将与 $T_2$ 是相似的， $T_3$ 将是空的。 在这种情况下， BinXray 检测 $Sim(T_2,T_3)>Sim(T_2,T_{62})$是否成立。如果成立，则我们称目标函数已经被修补，否则，则没有被修补。
CASE 3:$T_2$ is empty and $T_1$ is non-empty. $T_2$是空的意味着补丁删除了一些代码。与CASE 2 类似， 我们称目标函数被修补了如果 $Sim(T_1,T_{41})>Sim(T_1,T_5)$;否则，是有漏洞的。