45、弹性系统的算法多样性探索

弹性系统的算法多样性探索

在软件开发领域，算法多样性对于构建弹性系统至关重要。本文将深入探讨算法多样性的相关概念、评估方法以及实验结果，旨在为提升系统的弹性和安全性提供有价值的参考。

多样性度量指标

为了衡量不同程序之间的差异，我们引入了几个重要的多样性度量指标。

跟踪多样性（Trace Diversity）

跟踪多样性用于衡量两个程序执行的字节码指令序列的相似性。具体操作步骤如下：
1. 使用标准的Python trace模块获取源代码级别的跟踪信息。
2. 将源代码级别的跟踪信息转换为字节码跟踪信息。在转换过程中，可以指定一个“黑名单”，忽略某些模块，例如在实验中我们会忽略bootstrap和trace等系统模块。
3. 对于跟踪信息中提到的每一行源代码（通过文件名和行号标识），将对应的.py文件编译为.pyc文件。
4. 使用marshal模块加载.pyc文件，获取代码对象。
5. 多次使用dis（反汇编器）模块，将整个程序的字节码作为Instruction对象列表获取。
6. 利用Instruction对象中的源代码行号信息，确定与该文件中每行源代码对应的指令序列。
7. 在要比较的跟踪信息中，仅包含每个Instruction的操作码（opcode）和参数（argument）属性，其他属性（如is_jump_target）相对不太重要。
8. 通过计算两个跟踪信息之间的Levenshtein距离（编辑距离），并将其除以它们的平均长度进行归一化，以此量化两个跟踪信息的相似性。

输入访问多样性（Input Access Diversity）

输入访问多样性衡量两个程序对输入数据的访问序列的相似性。具体实现步骤如下：
1. 核心是通过重写适当类的__getattribute__方法，拦截对选定对象属性的访问。在我们的使用场景中，重写的方法会记录访问信息，然后调用原始的__getattribute__方法。
2. 对于用户定义的类，可以通过在类中插入__getattribute__的定义来实现。但对于常见的内置类型（如int、string和tuple），这种方法并不适用。
3. 针对每个内置类，我们定义一个新的类，例如为int定义tracked_int类，该类继承自内置类并重写__getattribute__方法。
4. 由于CPython运行时系统中的C代码有时会直接访问内置类型的属性，导致某些对tracked_int属性的访问未被记录。为了解决这个问题，我们扩展tracked_int类，重写所有访问整数值的int方法，如__add__、 eq 、__le__等。
5. 当x是tracked_int时，像x + y这样的表达式现在会编译为使用CALL_FUNCTION指令显式调用x的__add__方法，并传入参数y。tracked_int.__add__方法会记录对第一个参数（self）的访问，对第二个参数调用__getattribute__方法（如果它是tracked_int，则会记录对它的访问），然后调用内置的__add__方法。
6. 为了进一步解决问题，如果x是普通的int类型，CALL_FUNCTION会调用内置的__add__方法，该方法由C代码实现，访问第二个参数时不会调用__getattribute__方法。因此，我们修改程序，将剩余的int使用替换为新的类my_int，该类继承自int并重写每个双参数方法，在调用原始方法之前先对第二个参数调用__getattribute__方法。通过赋值int = my_int，将int的名称绑定到我们的类my_int上。同时，将源代码中的字面量替换为构造函数调用，例如将1替换为int(1)。
7. 对于Python和DistAlgo程序，输入访问跟踪的其余方面有所不同：
- Python程序 ：用户通过修改程序，使要跟踪的对象成为跟踪类的实例。我们的跟踪器类提供了一个方法，可以递归遍历对象或集合（字典、列表、元组或集合），将所有可跟踪的内置类型实例替换为跟踪类型实例。在基准程序中，插入一两个对该方法的调用即可。跟踪对象通过按对象创建顺序分配的序列号进行标识，当跟踪对象用于读取输入数据时，这些标识符在不同变体的日志中具有意义，因为变体接收相同的输入并按相同顺序读取。
- DistAlgo程序 ：所有消息自动被视为输入，如有其他输入，处理方式与Python程序相同。消息中可跟踪的内置类型实例会自动替换为跟踪类型实例。我们的跟踪器类继承自DistAlgo的进程类，并自动插入为给定程序中每个进程类的父类，它重写process.send方法，将消息中所有可跟踪的内置类型实例替换为跟踪类型实例。为了为接收到的消息中的跟踪对象创建有意义的标识符，我们使用元组（host, procNum, msgNum, objNum），其中host是发送方所在的主机，procNum标识相对于主机的发送进程，msgNum标识相对于发送进程的消息，objNum标识消息中的对象。为避免依赖无法跨执行有意义比较的标准进程标识符，我们按进程创建顺序分配序列号来标识进程，跟踪器类重写process.setup方法来分配进程序列号，并将下一个可用的进程序列号存储在本地文件中。msgNum是每个发送方按消息发送顺序分配的序列号，对象序列号objNum按深度优先遍历消息时遇到对象的顺序分配给消息中的每个对象。DistAlgo程序的输入访问日志还包含与接收事件对应的条目，以便确定在处理特定消息时访问了特定的数据项（可能是在先前消息中接收并存储在数据结构中的）。

实验评估

我们使用Python 3.7.2和DistAlgo 1.1.0b13对几种顺序和分布式算法进行了评估。对于每个问题和每个多样性指标，我们通过以下三种方式测量实现的多样性：
1. 仅算法多样性 ：对每对算法的多样性指标进行平均。
2. 仅实现级多样性（ILD） ：对每个算法与其ILD变体（即通过对其应用ILD转换获得的变体）的多样性指标进行平均。
3. 两种多样性结合 ：对每个算法与另一个算法的ILD变体的多样性指标进行平均。

实现级多样性（ILD）转换

我们通过应用以下典型的ILD转换来创建ILD：
1. NOP插入 ：在每行代码后，以0.05的概率插入一个pass语句。
2. 指令重排序 ：对于每两个相邻的独立代码行，以0.5的概率交换它们。
3. 分支重排序 ：对于每个if语句，以0.5的概率交换分支并取反条件（如果没有else分支，则假设存在else: pass）。
4. 函数（包括接收处理程序）重排序 ：对于每两个相邻的独立def语句，以0.5的概率交换它们。
5. 参数重排序 ：对于每个函数（不包括run、setup和接收处理程序），交换前两个参数、第三个和第四个参数等。
6. 字段重排序 ：通过交换初始化每个类字段的赋值语句中的前两个、第三个和第四个等，对这些赋值语句进行重排序。

顺序算法实验结果

我们在以下问题上使用了多种算法进行实验：
1. 图可达性 ：包括原始（迭代）算法、增量算法和基于规则的算法（使用特定方法从规则生成）。
2. 汉诺塔问题 ：原始递归算法、优化递归算法、优化迭代算法和带交换的优化迭代算法。
3. 最长公共子序列（LCS） ：原始递归算法、优化递归算法和优化迭代算法。
4. 模式搜索 ：朴素算法、Knuth Morris Pratt（KMP）算法和Rabin Karp算法。
5. 排序 ：堆排序、快速排序、插入排序和归并排序。
6. 树搜索 ：AVL树的递归和迭代算法、B树的递归算法、红黑树的迭代算法以及（不平衡）二叉搜索树的递归和迭代算法。

实验结果如下表所示：
| Metric | Level | Reach (3 variants) | Hanoi (4 variants) | LCS (3 variants) | Pat. search (3 variants) | Sort (4 variants) | Tree search (6 variants) | Avg. |
| ---- | ---- | ---- | ---- | ---- | ---- | ---- | ---- | ---- |
| Code Diversity | algo | 0.80 | 0.58 | 0.65 | 0.81 | 0.79 | 0.83 | 0.74 |
| | impl | 0.40 | 0.39 | 0.66 | 0.52 | 0.32 | 0.63 | 0.49 |
| | both | 0.80 | 0.65 | 0.82 | 0.83 | 0.80 | 0.89 | 0.80 |
| Input Access Diversity | algo | 1.04 | 0.54 | 0.58 | 0.28 | 0.77 | 0.35 | 0.59 |
| | impl | 0 | 0.18 | 0.82 | 0.21 | 0 | 0 | 0.20 |
| | both | 1.04 | 0.57 | 1.12 | 0.28 | 0.77 | 0.36 | 0.69 |
| Trace Diversity | algo | 1.45 | 0.42 | 1.22 | 0.69 | 0.81 | 0.80 | 0.90 |
| | impl | 0.05 | 0.30 | 0.60 | 0.23 | 0.11 | 0.14 | 0.23 |
| | both | 1.45 | 0.45 | 1.39 | 0.70 | 0.82 | 0.82 | 0.94 |

从表中最后一列可以看出，对于所有三个指标，算法多样性产生的多样性比ILD更多，两者结合产生的多样性更多。

分布式算法实验结果

我们在以下分布式算法上进行了实验：
1. 两阶段提交（2PC）
2. Hirschberg - Sinclair的领导者选举（HSleader）
3. Lamport的分布式互斥（Lamutex）
4. Lamport的基本Paxos算法
5. Ricart - Agrawala的分布式互斥（RAmutex）

每个算法有两个变体，一个使用对消息历史的高级查询，另一个显式维护这些查询的结果（以及相关的中间结果和辅助值），并在赋值语句中更新它们，特别是在接收处理程序中。在测量动态指标时，为避免由于平台调度可变性导致的变体之间的虚假差异，我们使用同步执行并行运行所有变体（对于除2PC之外的程序，由于在同步执行的程序转换与输入访问跟踪之间的交互中仍存在一个我们正在解决的bug，在测量输入访问多样性时，我们改为分别运行变体，但每个变体都使用相同的注入消息延迟模式，这些延迟大于平台的调度可变性，旨在避免消息传递顺序中的竞争）。

实验结果如下表所示：
| Metric | Level | 2PC | HSleader | Lamutex | Paxos | RAmutex | Average |
| ---- | ---- | ---- | ---- | ---- | ---- | ---- | ---- |
| Code Diversity | algo | 0.56 | 0.66 | 0.50 | 0.68 | 0.53 | 0.59 |
| | impl | 0.19 | 0.18 | 0.08 | 0.30 | 0.27 | 0.21 |
| | both | 0.59 | 0.68 | 0.53 | 0.68 | 0.54 | 0.60 |
| Input Access Diversity | algo | 1.10 | 0.47 | 0.21 | 0.28 | 0.61 | 0.53 |
| | impl | 0.08 | 0.04 | 0 | 0.03 | 0.17 | 0.06 |
| | both | 1.09 | 0.52 | 0.21 | 0.30 | 0.61 | 0.55 |
| Trace Diversity | algo | 0.20 | 0.35 | 0.13 | 0.54 | 0.21 | 0.29 |
| | impl | 0.06 | 0.03 | 0.02 | 0.13 | 0.04 | 0.06 |
| | both | 0.20 | 0.36 | 0.14 | 0.52 | 0.21 | 0.29 |

从表中最后一列可以看出，对于所有三个指标，算法多样性产生的多样性明显比ILD更多。ILD产生的跟踪多样性明显小于其产生的输入访问多样性，这并不矛盾，因为两者都是以比率形式测量的，输入访问仅占字节码跟踪中记录的程序全部活动的一小部分。分布式算法的算法多样性的跟踪多样性结果明显小于顺序算法，因为跟踪信息包括未进行多样化处理的DistAlgo网络运行时库的执行。

相关工作分析

现有自动化软件多样性技术主要创建实现级多样性，通过应用相对简单的局部变换或一些复杂的全局变换（如指令集随机化）来改变实现细节，但不改变算法。这些变换虽然完全自动化且更易于应用于大型程序，但无法创建算法多样性，例如不会改变程序使用输入的模式。

大多数用于弹性的自动化软件多样性工作针对C程序或（反汇编的）机器代码进行转换，以更广泛地适用于系统代码。也有一些针对JIT编译的高级语言程序的自动化多样性工作，例如librando用于Java和JavaScript，INSeRT用于JavaScript，这些低级别方法适合创建实现级多样性。而我们的方法直接对高级程序进行多样化处理以创建算法多样性。

N版本编程通过从相同的需求规格开始，由独立的团队分别进行手动设计和实现，创建系统（或组件）的N个版本，并并行运行这些版本。其目标是在存在设计故障时实现弹性，因为独立团队不太可能犯相同的设计错误。我们的工作与其他软件多样性工作一样，旨在减轻软件漏洞，而不是解决设计错误。这两种技术可以结合使用以同时解决这两个问题。N版本编程可能会引入算法多样性，但无法进行有效控制，且需要大量的手动工作。相比之下，我们的方法基于系统增量化的程序转换和优化方法创建变体，该方法指导过程，有助于控制引入的多样性程度，并有助于确保正确性，我们的程序转换系统InvTS提供了半自动化支持，显著减少了手动工作。

同步执行在容错领域得到了广泛研究，通常被称为N版本执行。N版本执行框架通常在系统调用级别工作，因此可以应用于在给定操作系统上运行的软件，而不考虑应用程序编程语言。我们的同步执行框架仅适用于用DistAlgo编写的应用程序，但它更具可移植性且更轻量级。它可以在DistAlgo支持的任何操作系统（Windows、macOS、Linux和Android）上使用，而基于系统调用的方法高度依赖于操作系统，例如Varan和Bunshin是针对Ubuntu的N版本执行框架。由于单个高级同步事件通常由多个系统调用实现，因此我们的框架更轻量级。

多样性技术评估方法

常见的评估实现级多样性技术的方法有以下几种：
1. 基于内存相关攻击成功概率的评估 ：根据攻击者猜测多样化程序所需的信息（例如特定对象的地址或两个特定对象地址之间的差异）以及由于多样性转换中的随机化导致的该类型信息的可能值数量，估计成功进行内存相关攻击（如缓冲区溢出或格式字符串攻击）的概率。
2. 针对ROP攻击防御的评估 ：使用覆盖率指标衡量转换重新定位的ROP小工具的比例，有时还使用熵指标衡量ROP小工具可能的新位置数量，反映攻击者正确猜测新位置的概率。

然而，这些基于低级语言特定漏洞的方法不适用于评估解释型语言（如Java和Python）的多样性。

综上所述，算法多样性在构建弹性系统中具有重要作用，我们的方法通过结合算法多样性和实现级多样性，能够有效提升系统的多样性和弹性。同时，我们的同步执行框架和程序转换系统为创建和评估多样性提供了有效的支持。未来，我们可以进一步探索更复杂的实现级多样性技术，并将其应用于更多类型的算法和系统中。

弹性系统的算法多样性探索

多样性技术的应用与拓展

在实际应用中，算法多样性和实现级多样性的结合为系统的弹性和安全性带来了显著提升。我们可以将这些技术应用到更多的场景中，进一步拓展其价值。

云服务中的应用

在云服务环境中，多个用户共享计算资源，软件漏洞可能导致严重的安全问题。通过引入算法多样性和实现级多样性，可以降低不同用户之间的干扰和攻击风险。例如，在云存储服务中，不同用户的数据处理可以采用不同的算法和实现方式，即使某个算法或实现存在漏洞，也不会影响其他用户的数据安全。

物联网设备中的应用

物联网设备通常资源有限，且面临着各种安全威胁。利用算法多样性和实现级多样性，可以在不增加过多资源开销的情况下，提高设备的安全性。例如，在智能家居设备中，不同设备的通信协议和数据处理算法可以多样化，减少被攻击的可能性。

未来研究方向

虽然我们已经在算法多样性方面取得了一定的成果，但仍有许多领域值得进一步探索。

更复杂的实现级多样性技术

目前我们使用的实现级多样性转换相对简单，未来可以研究更复杂的技术，如代码混淆、动态代码生成等。这些技术可以进一步增加程序的多样性，但需要解决实现复杂度和性能开销的问题。

跨语言和跨平台的多样性

随着软件系统的复杂性增加，跨语言和跨平台的开发变得越来越普遍。未来的研究可以关注如何在不同语言和平台之间实现算法多样性和实现级多样性，以提高整个系统的弹性。

与人工智能的结合

人工智能技术在软件领域的应用越来越广泛，将算法多样性与人工智能相结合，可以为系统的安全性和弹性带来新的突破。例如，利用机器学习算法自动生成多样化的程序变体，或者使用深度学习模型检测和防范软件漏洞。

总结

本文深入探讨了算法多样性在弹性系统中的应用，通过引入跟踪多样性、输入访问多样性等度量指标，对顺序和分布式算法进行了实验评估。实验结果表明，算法多样性和实现级多样性的结合能够显著提高系统的多样性和弹性。

同时，我们分析了相关工作，指出了现有技术的局限性，并提出了我们的方法的优势。我们的方法直接对高级程序进行多样化处理，能够创建算法多样性，并且通过同步执行框架和程序转换系统，减少了手动工作，提高了效率。

最后，我们讨论了多样性技术的应用场景和未来研究方向，为进一步提升系统的弹性和安全性提供了有价值的参考。通过不断探索和创新，我们相信算法多样性将在软件领域发挥越来越重要的作用。

以下是一个mermaid格式的流程图，展示了我们创建算法多样性和实现级多样性的整体流程：

graph LR
    A[需求分析] --> B[选择算法]
    B --> C[应用ILD转换]
    C --> D[生成变体]
    D --> E[同步执行]
    E --> F[多样性评估]
    F --> G{多样性是否满足要求}
    G -- 是 --> H[部署系统]
    G -- 否 --> C

在这个流程中，我们首先进行需求分析，选择合适的算法。然后应用实现级多样性转换生成变体，通过同步执行和多样性评估来检查多样性是否满足要求。如果不满足，继续进行ILD转换，直到达到满意的多样性水平，最后部署系统。

通过这种方式，我们可以有效地创建具有高多样性和弹性的系统，为软件的安全性和可靠性提供有力保障。