第 4 章 安全模型
上一章介绍的协议具有完美的正确性和完美的隐私性，但它要求所有参与方都遵循协议的规定，这类敌手被称为半诚实的敌手(semi-honest adversary)，这类协议被称为半诚实安全/被动安全的(semi-honest secure/passively secure)协议。在第9章中，我们还将介绍一些协议，即使这些协议的参与方未遵循协议，也能保持正确性和隐私性，这类敌手被称为恶意敌手(malicious adversary)，这类协议被称为是恶意安全/主动安全的(maliciously secure/actively secure)协议。在证明这些协议的恶意安全性之前，我们需要一个形式化的定义来说明恶意安全性具体指什么。
本章，我们将介绍一个密码学的安全模型——通用可组合框架(Universal Composability framework, UC framework) [Canetti, 2001]。这个模型中，被证明为安全的协议无论在什么运行环境下使用，都仍然能保持安全；也就是说，它可以与任何协议“通用地”组合使用。这一优秀的性质确保了模块化设计协议的安全性，因而受到密码学家的广泛青睐。
在介绍通用可组合框架的细节之前，我们首先延续上一章中对隐私性的讨论，进一步探讨如何以类似的方式定义恶意安全性。然后，我们将说明为什么需要通过一个共同的定义来定义这两个属性，并引出通用可组合框架的基本思想。
隐私性与恶意安全性
定义隐私性
（注：本节参考了书 [CDN, 2015]，Section 4.1. Reproduced with permission of the Licensor through PLSclear.）让我们回顾一下，第3章中是怎样非形式化地定义隐私性的。 我们首先需要选取一组被攻陷方 \(C \subset \{P_1, …, P_n\}\)，它们的数量最多为 \(t\) (\(|C| \leq t\)). 然后选取 \((x_1, … , x_n)\)，并以此为输入运行协议。 令 \(\text{view}_{j}\) 是协议运行中参与方 \(P_j\) 的视图，\(\{ \text{view}_{j} \}_{P_j \in C}\) 的值正好构成了在协议运行过程中泄露给被攻陷方 \(C\) 的信息（在安全性分析中，我们假设所有被攻陷方会互相串通）。 隐私性的定义是，泄露的信息不会让被攻陷方得到任何他们不应该得到的信息。
显然，被攻陷方必然会得到他们自己的输入和输出，因此我们称 \(\{ x_j, y_j \}_{P_j \in C}\) 为允许值。而 \(\{ \text{view}_{j} \}_{P_j \in C}\) 的值是被攻陷方在协议运行过程中看到的所有信息，我们称其为泄漏值。
隐私性的非形式化的定义如下：
这个说法仍有些模糊：如何定义一个值 \(V_1\) 不包含比另一个值 \(V_2\) 更多的信息呢？试想，如果 \(V_1\) 可以仅从 \(V_2\) 计算出来，那么显然 \(V_1\) 不包含比 \(V_2\) 更多的信息。然而，这样定义太宽泛了，特别是当我们考虑密码学的安全性时。例如，假设 \(V_2 = n\) 是公开的，其中 \(n = pq\) 是两个大素数 \(p, q\) 的乘积，定义 \(V_1 = (p, q)\). 由于整数的素因数是唯一的，从 \(V_2 = n\) 计算出 \(V_1 = (p, q)\) 当然是可能的。然而，如果分解大整数是一个困难的问题（使用RSA公钥加密时，我们希望如此），那么可以公开 \(n\) 并期望 \(p, q\) 仍然保密。
从这个角度看，\(V_2 = (p, q)\) 包含的信息比 \(V_1 = n\) 更多。因此，从密码学的角度，如果 \(V_1\) 可以从 \(V_2\) 高效地计算出来，我们就说 \(V_1\) 不包含比 \(V_2\) 更多的信息。
沿着这条思路，我们得到了一个更加明确的隐私性定义：
为了形式化地说明泄露值可以从允许值“高效地计算”，我们需要给出一个多项式时间的算法，它以允许值作为输入，输出泄露值。这个算法被称为模拟器(simulator)。这里，请读者注意，视图 \(\text{view}_{j}\) 是由协议中的参与方生成的，他们可以做出随机选择，所以 \(\{\text{view}_{j}\}_{P_j \in C}\) 实际上不是一个固定值，而是一个随机变量。模拟器也将使用内部随机性输出一个随机变量。至此，我们给出隐私性的形式化定义：
这里我们需要暂停一下，探讨一个微妙的细节：“分布”具体指的是什么？我们将通过一个例子来展示，这里的“分布”需要考虑它与诚实方输出的联合分布。
考虑一个“很愚蠢”的功能 \(\mathcal{F}\)，它有两个参与方 \(P_1\) 和 \(P_2\)，\(\mathcal{F}\) 使 \(P_1\) 获得一个随机比特，\(P_2\) 什么也没有获得。显然，我们可以构造一个协议：\(P_1\) 选择一个随机比特并输出，\(P_2\) 什么也不做。这是一个实现 \(\mathcal{F}\) 的安全的协议。
现在我们定义一个不安全的协议：\(P_1\) 选择一个随机比特并输出，并把它发送给 \(P_2\). 显然，这个协议中 \(P_2\) 获得了他不应该获得的信息，是不安全的。然而，如果我们不考虑被攻陷方的视图与诚实方的输出的联合分布，我们会惊讶地发现，（当 \(P_1\) 是诚实方，\(P_2\) 被攻陷时）\(P_2\) 的视图竟然是可模拟的！模拟器 \(\mathcal{S}\) 只需要生成一个随机比特，它与 \(P_1\) 选择的随机比特具有完全相同的分布！也就是说，一个显然不安全的协议，如果只考虑被攻陷方的视图能否被模拟，竟然可以被证明是安全的！
这里的问题在于：我们必须考虑被攻陷方的视图与诚实方输出的联合分布。回到这个例子，模拟值、泄漏值、\(P_1\) 的输出都是一个随机比特，但是它们还满足“泄漏值等于 \(P_1\) 的输出”这个关系。如果仅仅满足模拟值与泄露值分布相同，并不能保证“模拟值也等于 \(P_1\) 的输出”。抽象地来说，这样的模拟并不能充分体现泄漏值所泄露的信息。因此，我们需要考虑被攻陷方的视图与诚实方输出的联合分布。回到上面的例子，当我们考虑联合分布时，模拟器输出的随机比特与 \(P_1\) 输出的随机比特有1/2的概率不相同，也就是有1/2的概率会模拟失败。这就符合协议不安全的直觉了。
幸运的是，在接下来介绍的通用可组合安全框架中，这一点被很好地刻画了。这里，我们可以告诉读者以下结论：如果要实现的功能是有随机性的，例如上面例子中的 \(\mathcal{F}\)，那么我们必须考虑被攻陷方的视图与诚实方输出的联合分布；如果要实现的功能是确定性的(deterministic)，即输出完全由输入所确定，不包含随机性，此时可以仅考虑被攻陷方自己的视图（注：直观地说，当实现的是确定性功能时，诚实方的输出是确定的值，因此如果模拟值与泄漏值有不可区分的分布，那么当考虑它们与诚实方输出的联合分布时，仍然不可区分；而实现概率功能时，诚实方的输出是一个随机变量，此时如果模拟值与泄漏值有不可区分的分布，并不能保证它们与诚实方输出的联合分布也不可区分。）。
定义恶意安全性
接下来，我们探讨如何定义恶意安全性(malicious security)。恶意安全性考虑的是敌手的攻击会对协议产生怎样的影响，即协议的输出可能因为敌手的恶意行为而有所不同。也就是说，这种攻击是为了造成影响而不仅仅是为了获取信息。因此，在定义中我们采用与隐私性相同的思路，但是以“影响”而不是“信息”作为基本的度量单位。
在考虑恶意安全性时，被攻陷方是拜占庭式的(Byzantine)，这意味着我们对它们的行为没有任何假设。具体来说，假设敌手控制了被攻陷方，每当需要他们按照协议规定的方式计算并发送某些消息时，敌手可以指示他们发送任何其他消息。而协议设计者需要确保无论敌手的行为如何，协议都能正确工作。
在进入下一步的讨论之前，我们先看两个启发性的例子。
例 4.1. 考虑图 3.1中的半诚实安全的电路计算协议，在三方和 \(t=1\) 的设定下运行。参与方计算函数 \(f(x_1,x_2,x_3) = (x_1 x_2 x_3, x_2, x_3)\). 也就是说，\(P_1\) 要得到 \(x_1 x_2 x_3\)，而其他参与方只能得到他们自己的输入。假设 \(P_1\) 被攻陷，\(P_1\) 将其输入 \(x_1\) 替换为 \(x'_1 = 1\)；也就是说，在输入分享阶段，它做了 \(1\) 的秘密分享。然后它诚实地运行协议的其余部分。最终 \(P_1\) 将得到 \(y_1 = x'_1 x_2 x_3 = 1 \cdot x_2 x_3 = x_2 x_3\). □
这个例子说明，\(P_1\) 可以通过这种方式始终得到 \(x_2 x_3\) 的值。请读者思考，这是不是一个安全问题？如果是，原因是什么？
例 4.2. 还是考虑图 3.1中的半诚实安全的电路计算协议，在三方和 \(t=1\) 的设定下运行。参与方计算函数 \(f(x_1,x_2,x_3) = (x_1 x_2 x_3, x_2, x_3)\). 假设我们按照这样的顺序安排电路中的门，首先计算 \([u]_t = [x_1 x_2]_t\)，然后计算 \([y_1]_t = [u x_3]_t\). 最后，在输出阶段，参与方将他们在 \([y_1]_t\) 中的所有份额发送给 \(P_1\)（注：\(P_2\)和\(P_3\)可以直接输出他们的输入，虽然协议会对他们的输入进行秘密分享然后再重建。）. 我们仍然假设 \(P_1\) 被攻陷。现在，假设 \(P_1\) 在输入共享阶段使用输入 \(x'_1 = 0\) 并遵循协议，然后，在执行乘法协议计算 \([u]_t = [x'_1 x_2]_t\) 时，各参与方在本地计算多项式 \(h\)，其中 \(h(0) = x'_1 x_2\). 然而，\(P_1\) 没有按照协议规定的方式分发 \([h(\alpha_1)]_t\)，而是分发了 \([r_1^{−1} + h(\alpha_1)]_t\)，其中 \(r_1\) 是重组向量中的第一个元素。这意味着结果变成了
由于 \(x'_1 = 0\)，所以最后一个等号成立。然后，\(P_1\) 在乘法协议中诚实地计算 \([y_1]_t = [u x_3]_t\)，并遵循输出重建阶段的协议。最终，\(P_1\) 将得到 \(y_1 = u x_3 = 1 \cdot x_3 = x_3\). □
这个例子说明，\(P_1\) 可以通过这种方式始终得到 \(x_3\) 的值。请读者思考，这是不是一个安全问题？如果是，原因是什么？
笼统地说，如果敌手无法通过影响协议来获得任何好处，那么这个协议就是恶意安全的。然而，需要注意的是，如果敌手能够接管某个参与方 \(P_i\)，那么有一种影响是不可避免的，就是“输入替换”。例如，如果敌手控制了参与方 \(P_1\)，那么它当然可以强迫 \(P_1\) 在协议中使用另一个值 \(x'_1\) 作为输入，而不是 \(x_1\). 于是，协议将计算 \(f(x'_1,x_2,…,x_n)\) 而不是 \(f(x_1,x_2,…,x_n)\). 这与诚实的 \(P_1\) 使用输入 \(x'_1\) 运行协议的情况完全一致，这显然是无法避免的。在函数计算协议中，唯一允许的影响就是输入替换。
为了精确地定义什么是允许的影响，在安全多方计算中，我们通常会定义一个解决问题的理想方式。然后，我们可以说，在这个理想的世界中，任何可能的影响都是允许的影响。我们可以想象一个完全可信的硬件盒子，允许每个参与方 \(P_i\) 安全地向盒子输入 \(x_i\)，而其他参与方对 \(x_i\) 一无所知。然后盒子计算 \((y_1,…,y_n) = f(x_1,…,x_n)\) 并秘密地将 \(y_i\) 输出给 \(P_i\). 随后，盒子便会爆炸，其内部状态永远丢失。很容易看出，在这个理想世界中，被攻陷方所拥有的唯一权力就是把他们的输入集合起来，然后向盒子发送替代输入；也就是说，他们只能进行输入替换。
在实际运行协议时，敌手产生的影响称为实际影响。在具有安全信道的网络上运行安全函数计算协议时，敌手的实际影响是他可以代表一个或多个被攻陷方向诚实方发送任意消息。
现在，我们采用与定义隐私性时类似的思路。如果无论敌手如何使用他的实际影响，效果始终对应于允许的影响，那么我们就说协议是恶意安全的。这表明无论实际影响有何效果，我们都可以使用允许的影响获得相同的效果。这引出了我们定义恶意安全性的第一次尝试：
回想一下，在定义隐私性时，我们要求协议的泄露值可以从允许值高效地计算出来。为了使恶意安全性的定义更加精确，我们将重用这种方法。也就是说，恶意安全性要求对于每个攻击协议的敌手，都可以高效地计算出一种具有相同效果的允许影响。计算这种允许影响的算法被称为模拟器(simulator)。
对于安全函数计算协议，这个定义意味着，对于每次攻击导致了输出 \((y'_1,…,y'_n)\)，模拟器都能够高效地计算出被攻陷方的输入替换，将其输入函数计算的理想盒子后，能给出相同的输出 \((y'_1,…,y'_n)\).
回到前面讲的两个例子。在第一个例子中，\(P_1\) 对协议的影响是始终得到 \(x_2 x_3\). 这不是安全问题，因为 \(P_1\) 可以通过将 \(x_1 = 1\) 作为输入来获得这个结果，所以这是允许的影响。在第二个例子中，\(P_1\) 对协议的影响是始终得到 \(x_3\). 这是一个安全问题，因为没有输入替换可以让 \(P_1\) 始终得到 \(x_3\).（为了更直观地理解，可以考虑 \(P_2\) 输入为0的情况，此时，无论 \(P_1\) 的输入如何选择，结果都将是0，因而 \(P_1\) 不可能得到 \(x_3\) 的任何信息。然而，在这个攻击中，不管 \(P_2\) 的输入值是多少，\(P_1\) 都能得到 \(x_3\).）
同时获得隐私性和恶意安全性
刚刚讲的后一种攻击乍一看是对正确性的攻击：\(P_1\) 违背了协议使得协议输出了错误的结果。然而，它实际上也是对隐私性的攻击：错误的结果对 \(P_1\) 泄露了 \(P_3\) 的输入，这本应该是保密的。正确性和隐私性以这种方式相互联系，我们不应该孤立地考虑它们。
那么，安全性完整的正式定义应该是什么呢？应该存在一个单一的模拟器，同时保证隐私性和恶意安全性。这意味着模拟器接收敌手试图影响真实协议的行为，并高效地将其转化为允许的影响（输入替换）；同时，它接收允许值，并高效地向敌手模拟泄露值。如果可以构造这样的模拟器，它本质上表明敌手在攻击中可能获得的任何东西，都可以通过定义上允许的方式获得。
通用可组合框架概述
现在，我们要将刚才讨论的关于隐私性和恶意安全性的直观想法变成形式化的定义。通用可组合框架~[Canetti, 2001]
所采用的方法是将参与方视为计算实体。
在通用可组合框架中，每个参与方是一个交互式图灵机(interactive Turing machine, ITM)。交互式图灵机在图灵机的基础上增加了一组输入纸带和输出纸带，它们是ITM之间相互通信的方式。每个ITM还拥有唯一的身份(identity)。在假设存在安全信道的场景下，当某个ITM \(P_1\) 在它的输出纸带上输出消息 \(m\) 和接收方 \(P_2\)，并执行“发送”命令，那么ITM \(P_2\) 将会在它的输入纸带上收到消息 \(m\) 和发送方 \(P_1\).
直观上，ITM类似于具有开放端口的计算机，在这些端口上它可以接收和发送消息。一个技术区别在于：ITM还有一个长度为1比特的激活纸带(activation tape)，只有当收到消息时，激活纸带被置为1，它才会执行操作、改变状态。在协议开始时，一个称为敌手 \(\mathcal{A}\) 的特殊的ITM首先被激活，它执行一系列操作后，发送消息给下一个ITM使其被激活. 当一个ITM \(P_1\) 被激活时，它读取在输入纸带上的消息，然后可能会执行一些计算、改变状态，最后它发送消息给下一个ITM，结束自己的激活。如果 \(P_1\) 在激活结束时没有发送消息来激活下一个ITM，那么敌手 \(\mathcal{A}\) 会再次被激活。因此，一个协议的运行过程就是许多ITM依次被激活，运行协议。注意，在每一个时刻，只有一个ITM在运行（处于激活状态），这就像一个激活令牌在ITM之间传递。
理想功能。 正如上文讨论恶意安全性时所讲，为了规定协议应该如何工作，需要定义一个实现协议的理想方式 \(\mathcal{F}\). \(\mathcal{F}\) 总是具有正确的输入输出行为，只泄露允许的值，并且只受到允许的影响。我们称 \(\mathcal{F}\) 为理想功能(ideal functionality)，它承担了类似于可信第三方的角色，其唯一任务是具有正确的输入输出行为，以便我们将协议 \(\Pi\) 与 \(\mathcal{F}\) 进行比较。
理想敌手（模拟器）。 当我们尝试将协议 \(\Pi\) 和理想功能 \(\mathcal{F}\) 进行比较时，我们立即遇到了以下问题：根据理想功能 \(\mathcal{F}\) 的定义，它只允许非常有限的信息泄露和敌手影响。但是，协议 \(\Pi\) 包括 \(n\) 个参与方 \(P_1,…,P_n\)，这些参与方需要使用信道 \(\mathcal{C}\) 连接。所有的参与方、信道 \(\mathcal{C}\) 都可能会泄露信息、受到敌手影响。例如，当敌手攻陷(corrupt)参与方 \(P_i\) 时，它就获得了 \(P_i\) 的所有信息；敌手还可以通过影响信道 \(\mathcal{C}\) 来阻碍一些消息的发送和接收。但对于理想功能 \(\mathcal{F}\)，不存在参与方 \(P_i\)，也不存在信道 \(\mathcal{C}\) 的外部接口。
因此，我们不能期望 \(\Pi\) 和 \(\mathcal{F}\) 在行为上等价，因为从外部看来，它们的接口完全不同。参与方和信道 \(\mathcal{C}\) 的外部接口似乎会允许比 \(\mathcal{F}\) 更多的泄露和影响。
为了解决这个问题，我们引入理想敌手（又叫“模拟器”）。模拟器 \(\mathcal{S}\) 是一个连接到理想功能 \(\mathcal{F}\) 的交互式图灵机。也就是说，它看到 \(\mathcal{F}\) 泄露的信息并对 \(\mathcal{F}\) 施加允许的影响。同时，它需要模拟 \(\Pi\) 中所有参与方以及信道 \(\mathcal{C}\) 的所有外部接口。在理想世界中，模拟器 \(\mathcal{S}\) 在其内部运行真实敌手 \(\mathcal{A}\)，如此一来，在真实敌手 \(\mathcal{A}\) 的视角中，模拟器 \(\mathcal{S}\) 和协议 \(\Pi\) 至少具有了相同的外部接口。现在，我们可以合理地要求：\(\Pi\) 和 \(\mathcal{S}^\mathcal{F}\) 应当在行为上等价，这里 \(\mathcal{S}^\mathcal{F}\) 表示 \(\mathcal{S}\) 可以与 \(\mathcal{F}\)互相通信。由于 \(\mathcal{S}\) 需要模拟所有参与方和外部资源（例如信道 \(\mathcal{C}\)），所以 \(\mathcal{S}\) 被称为模拟器。
请注意，\(\Pi\) 和 \(\mathcal{S}^\mathcal{F}\) 能否在行为上等价在很大程度上取决于模拟器 \(\mathcal{S}\). 模拟器 \(\mathcal{S}\) 的目的是使理想世界与真实协议对任何区分器看起来相同。也就是说，它将敌手对协议的影响转换为对理想功能的允许影响；同时，它看到理想功能的泄露值，然后必须在协议中模拟对应的泄露值。并且，它的模拟方式必须使得真实敌手 \(\mathcal{A}\) 无法区分自己是在与协议 \(\Pi\) 交互还是在与模拟器 \(\mathcal{S}\) 交互。这恰恰符合我们之前对隐私性和恶意安全性的非正式定义。注意，这里我们还没有正式讨论如何模拟敌手攻陷参与方。我们将在给出完整定义时回答这个问题。
不可区分性。 至此，我们已经了解了通用可组合框架的基本思想和概况。但是，这里还有一个问题：在设计通用可组合框架时，我们希望协议在任意组合时都是安全的；当运行一个协议时，如何模拟协议可能面对的所有外部情况呢？通用可组合框架引入了一个新的实体——环境(environment)\(\mathcal{Z}\). 环境 \(\mathcal{Z}\) 是一个特殊的交互式图灵机，它的基本功能是为协议的参与方提供输入，另外，它可以与敌手 \(\mathcal{A}\) 实时通信，通过向敌手 \(\mathcal{A}\) 发送指令来决定攻击协议的方式。
我们前面讲到，在协议运行的每一个时刻，只有一个交互式图灵机被激活。在引入环境 \(\mathcal{Z}\) 后，我们现在可以给出协议运行的完整流程：协议运行开始时，\(\mathcal{Z}\) 被激活，\(\mathcal{Z}\) 可以向参与方发送一些输入，或向敌手 \(\mathcal{A}\) 发送一些指令，然后敌手 \(\mathcal{A}\) 指定下一个被激活的参与方；当参与方被激活时，它会遵循协议，执行协议规定的程序；当敌手 \(\mathcal{A}\) 被激活时，它可以攻陷一些参与方，获取它们的信息，并代替被攻陷方执行操作；执行完成后，环境 \(\mathcal{Z}\) 又被激活，它可以再次向参与方发送输入，或向敌手 \(\mathcal{A}\) 发送指令；如此不断继续，环境 \(\mathcal{Z}\) 控制着协议运行的所有过程；……；协议运行结束时，参与方会将协议的输出发送给环境 \(\mathcal{Z}\)；当环境 \(\mathcal{Z}\) 完成所有的操作后，它会输出一比特的随机变量 \(b \in \{0,1\}\).
上面描述的是真实世界中协议的运行过程。在理想世界中，参与方不运行协议，环境 \(\mathcal{Z}\) 发送给参与方的输入都被直接转发给理想功能 \(\mathcal{F}\)，\(\mathcal{F}\) 发送给参与方的输出都直接转发给环境 \(\mathcal{Z}\)；此时，环境 \(\mathcal{Z}\) 的攻击指令发送给理想敌手（模拟器）\(\mathcal{S}\)，再由 \(\mathcal{S}\) 转发给敌手 \(\mathcal{A}\)；敌手 \(\mathcal{A}\) 攻陷的也不是真正的协议参与方，而是模拟器 \(\mathcal{S}\) 模拟的参与方。换句话说，理想世界中 \(\mathcal{A}\) 看到的所有东西都是 \(\mathcal{S}\) 模拟出来的。协议运行结束时，环境 \(\mathcal{Z}\) 同样会输出一比特的随机变量 \(b \in \{0,1\}\).
安全性的定义如下。用 \(\operatorname{exec}_{\Pi,\mathcal{A},\mathcal{Z}}\) 表示环境 \(\mathcal{Z}\) 与协议 \(\Pi\) 和敌手 \(\mathcal{A}\) 交互后输出的随机变量；\(\operatorname{exec}_{\mathcal{F},\mathcal{S}^\mathcal{A},\mathcal{Z}}\) 表示环境 \(\mathcal{Z}\) 与理想功能 \(\mathcal{F}\) 和模拟器 \(\mathcal{S}\) 交互后输出的随机变量。如果 \(\operatorname{exec}_{\Pi,\mathcal{A},\mathcal{Z}}\) 和 \(\operatorname{exec}_{\mathcal{F},\mathcal{S}^\mathcal{A},\mathcal{Z}}\) 有不可区分的分布，即 \(\mathcal{Z}\) 总是无法区分自己在理想世界还是真实世界，那么我们就说协议 \(\Pi\) 安全地实现了理想功能 \(\mathcal{F}\). 这表示协议 \(\Pi\) 和理想功能 \(\mathcal{F}\) 一样安全。
注意，这里的环境 \(\mathcal{Z}\) 实际上扮演了理想世界和真实世界的区分器，并且环境 \(\mathcal{Z}\) 可以任意地选择协议的输入和攻击的方式，这就模拟了协议所面对的所有可能的外部环境。如果 \(\mathcal{Z}\) 总是无法区分理想世界和真实世界，这就意味着在任何情况下，敌手 \(\mathcal{A}\) 对协议的攻击都被模拟器 \(\mathcal{S}\) 转化为了对理想功能 \(\mathcal{F}\) 的攻击，同时，协议泄露的信息也都被模拟器 \(\mathcal{S}\) 从允许的泄露信息中高效计算出来。那么，协议 \(\Pi\) 至少和 \(\mathcal{F}\) 一样安全。这里我们不能说协议 \(\Pi\) 就是安全的，而是 \(\Pi\) 至少和 \(\mathcal{F}\) 一样安全，因为 \(\mathcal{F} \)实际上定义了协议满足的安全性（包括泄漏的信息和允许的影响）。
通用可组合定理。 通用可组合模型广受欢迎的一个重要原因是通用可组合定理。通用可组合定理表明，如果 \(\Pi\) 是用于完成某个任务的安全协议（由理想功能 \(\mathcal{F}\) 定义），那么在任何情境下，都可以安全地将协议 \(\Pi\) 用来完成该任务。更具体地说，如果某个协议在使用 \(\mathcal{F}\) 作为外部资源时是安全的，那么将 \(\mathcal{F}\) 替换为协议 \(\Pi\)，该协议仍然是安全的。这允许我们将某个复杂协议 \(\Pi_\mathsf{CMPLX}\) 的一部分抽象成较为简单的子协议 \(\Pi\)，然后证明两个简化了的命题：（1）当使用理想功能 \(\mathcal{F}\) 作为资源时，\(\Pi_\mathsf{CMPLX}\) 是安全的；（2）协议 \(\Pi\) 安全地实现了 \(\mathcal{F}\). 然后，根据通用可组合定理可知，当 \(\Pi_\mathsf{CMPLX}\) 使用 \(\Pi\) 作为子协议而不是使用 \(\mathcal{F}\) 时，它也是安全的。
形式化模型——通用可组合框架
上一节，我们讨论了通用可组合框架~[Canetti, 2001]
的设计思想， 本节介绍通用可组合框架的具体细节。（注：本节参考了书~[Boneh, 2023]，Sections 23.5.1~ 23.5.6.）
真实协议及其运行
考虑一个有 \(n\) 个参与方的协议的运行过程：\(n\) 个参与方 \(P_1, \ldots, P_n\) 在运行某个协议 \(\Pi\). 我们假设每个参与方 \(P_i\) 都清楚自己的唯一索引 \(i\). 此外，存在一个敌手 \(\mathcal{A}\). 我们先考虑恶意敌手的情况。稍后，在「定义半诚实安全性」一节中，我们将讨论半诚实敌手的情况。对于被攻陷的参与方(corrupted party)，我们将其行为纳入 \(\mathcal{A}\) 的行为逻辑之中。这模拟了被攻陷方可能与敌手串通的情况，因此可以将被攻陷方的行为视为 \(\mathcal{A}\) 的行为来简化模型。 我们假设所有参与方通过一个异步通信网络 \(\mathcal{C}\) 进行通信。通常假设 \(\mathcal{C}\) 能够提供安全的点对点信道，每个点对点信道都提供了消息隐私性和完整性。在本节内容中，我们不深入讨论它的实现细节，而是抽象化地将 \(\mathcal{C}\) 视为提供物理层面安全的点对点信道。尽管 \(\mathcal{C}\) 提供了消息隐私性和完整性，敌手仍然可以获得一些参与方使用信道的信息，并对其施加一定的控制：
当任何参与方通过信道发送消息时，敌手会知道这一事实，并得知消息的长度、发送方和预定的接收方。这反映了即使在加密通信中，加密消息的长度仍可能被泄露，以及在现实网络环境中，通常可以观察到消息的发送方与接收方。
敌手拥有决定消息是否以及何时被传递的能力。因为我们将 \(\mathcal{C}\) 视为异步通信网络，其中消息的传递时间和顺序未被保证。我们允许敌手调度消息传递的顺序。
敌手无法获得关于消息的其他信息，也不能修改消息内容或发送方，并且不能将消息转发给非预定的接收方。
在我们的模型中，还包括了一个关键组成部分——环境，用符号 \(\mathcal{Z}\) 表示。环境的角色极其重要：它不仅为诚实的参与方提供输入并收集其输出，还负责在协议运行前确定哪些参与方是诚实的，哪些已被攻陷。此外，环境在协议运行的过程中可以与敌手 \(\mathcal{A}\) 进行交互和协作。这样的设计模拟了真实世界中，系统外部的因素可能会影响协议参与方的行为和状态。
图 4.2展示了真实协议运行的基本结构，具体如下：
真实协议及其运行 · 插图
真实协议运行，图中包括异步的安全信道 \(\mathcal{C}\)，敌手 \(\mathcal{A}\)，环境 \(\mathcal{Z}\)，诚实方 \(P_1, P_2\)，被攻陷方 \(P_3, P_4\)
在图 4.2中，共有4个参与方，\(P_1, …, P_4\)，其中我们假设参与方 \(P_3\) 和 \(P_4\) 是被攻陷的，并且他们的行为现在由敌手 \(\mathcal{A}\) 控制。
通信网络 \(\mathcal{C}\) 有4条线路，分别连接到4个参与方。由于参与方 \(P_3\) 和 \(P_4\) 被纳入到 \(\mathcal{A}\) 中，因此，原本连接 \(P_3\) 和 \(P_4\) 的通信线路现在直接与 \(\mathcal{A}\) 相连。这种安排允许 \(\mathcal{A}\) 向 \(P_1\) 发送消息，仿佛这些消息是从 \(P_3\) 发出的（仅需通过标记为3的线路即可）。同理，\(\mathcal{A}\) 也可以接收 \(P_1\) 发往 \(P_3\) 的消息。我们将这些线路称为 \(\mathcal{C}-\mathrm{I}/\mathrm{O}\) 线。
在 \(\mathcal{A}\) 和 \(\mathcal{C}\) 之间还有一条“控制线”，我们称之为 \(\mathcal{C}\)-控制线。这条线路允许 \(\mathcal{A}\) 接收到“泄露消息”，这些消息向 \(\mathcal{A}\) 泄露了关于诚实方发送消息的信息。通过这条线路，\(\mathcal{A}\) 还能够发送“控制消息”给 \(\mathcal{C}\)，以指示 \(\mathcal{C}\) 何时将消息传递给诚实方。
对于环境 \(\mathcal{Z}\)，它与诚实方 \(P_1\) 和 \(P_2\) 连接。通过这些连接，环境能够向诚实方发送协议输入并接收输出，我们将这些连接称为 \(\mathcal{Z}-\mathrm{I}/\mathrm{O}\) 线。环境和 \(\mathcal{A}\) 之间还有一条控制线，即 \(\mathcal{A}\)-控制线，允许二者直接通信。通过这条线路，\(\mathcal{Z}\) 可以发送“控制消息”给 \(\mathcal{A}\)，为其提供下一步行动的指导，同时 \(\mathcal{Z}\) 也可能接收来自 \(\mathcal{A}\) 的“泄露消息”，这些消息包含了协议所泄露的信息。
真实协议的运行机制
下面，我们介绍真实协议的运行机制。在真实协议的运行过程中，多台机器依次执行一系列操作，每台机器代表一个实体。通用可组合模型规定，任何时刻只有一台机器可以执行操作。这个限制虽然看似限制了并发性，但实际上它能够模拟多个机器的并发运行。因为我们允许敌手 \(\mathcal{A}\) 控制消息传递的顺序，因而他可以精确地控制各机器交替执行计算的过程来模拟并发运行时任何可能的顺序。
在运行一定时间后，当前运行的机器将生成的消息发送给第二台机器。此时，原机器暂停运行，而第二台机器继续运行。这种交替执行的模式在整个协议过程中持续进行。初始阶段，\(\mathcal{Z}\) 开始运行并确定一组被攻陷方，这是所有参与方 \(P_1, …, P_n\) 的一个子集。\(\mathcal{Z}\) 将这些信息记录在一个特殊的纸带上，该纸带对 \(\mathcal{A}\) 和 \(\mathcal{C}\) 是可见的，但对诚实方不可见，也就是说诚实方并不知道哪些参与方是被攻陷的。当 \(\mathcal{Z}\) 结束运行时，协议运行也随之结束。\(\mathcal{Z}\) 在运行结束之前将一个比特写入一条特殊的输出纸带。
我们讨论一下机器间所有可能的消息类型：
\(\mathcal{Z}\) 可以沿着 \(\mathcal{Z}-\mathrm{I}/\mathrm{O}\) 线向任何诚实方 \(P_i\) 传递协议输入。
\(\mathcal{Z}\) 可以沿着 \(\mathcal{A}\)-控制线向 \(\mathcal{A}\) 传递控制消息。
诚实方 \(P_i\) 或代表被攻陷方 \(P_i\) 的 \(\mathcal{A}\) 可以沿着对应的 \(\mathcal{C}-\mathrm{I}/\mathrm{O}\) 线向 \(\mathcal{C}\) 传递发送消息请求。请求格式为(\(\operatorname{Send}\), \(\left.\left(j_1, m_1\right),\left(j_2, m_2\right), …\right)\)，其中 \(j_k\) 是消息的预期接收方，\(m_k\) 是消息内容。
\(\mathcal{A}\) 可以沿着 \(\mathcal{C}\)-控制线发送传递消息的指令。指令格式为(\(\operatorname{Deliver}\), \(k\))，其中 \(k\) 是待传递消息的索引，具体细节将在下面描述。
\(\mathcal{A}\) 可以沿着 \(\mathcal{A}\)-控制线向 \(\mathcal{Z}\) 传递泄露消息。
诚实方 \(P_i\) 可以沿着 \(\mathcal{Z}-\mathrm{I}/\mathrm{O}\) 线向 \(\mathcal{Z}\) 传递协议输出。
当通信网络 \(\mathcal{C}\) 通过 \(\mathcal{C}-\mathrm{I}/\mathrm{O}\) 线接收到参与方 \(P_i\)（\(P_i\) 可能是诚实的也可能是被攻陷的）的发送消息请求(\(\operatorname{Send}\), \(\left.\left(j_1, m_1\right),\left(j_2, m_2\right), …\right)\) 后，它会将 \((i, j_1, m_1),(i, j_2, m_2), …\) 的元组添加到内部列表buf中（初始为空），并沿着 \(\mathcal{C}\)-控制线向\(\mathcal{A}\) 传递泄露消息(\(\operatorname{Sent}\), \(\left.i,\left(j_1, \operatorname{len}\left(m_1\right)\right),\left(j_2, \operatorname{len}\left(m_2\right)\right), …\right)\)，其中 \(\operatorname{len}\left(m\right)\) 表示消息 \(m\) 的长度。
在沿着 \(\mathcal{C}\)-控制线从 \(\mathcal{A}\) 接收到传递消息请求(\(\operatorname{Deliver}\), \(k\))后，通信网络 \(\mathcal{C}\) 执行以下操作：如果buf中的第 \(k\) 个元组是\((i, j, m)\)，它会沿着对应于 \(P_j\) 的 \(\mathcal{C}-\mathrm{I}/\mathrm{O}\) 线传递消息(\(\operatorname{Receive}\), \(i, m\))，这会将消息 \(m\) 传递给 \(P_j\)（如果 \(P_j\) 是诚实的）或 \(\mathcal{A}\)（如果 \(P_j\) 是被攻陷的）；如果没有第 \(k\) 个元组，\(\mathcal{C}\) 会沿着 \(\mathcal{C}\)-控制线向 \(\mathcal{A}\) 报告错误。
敌手与诚实方的通信
目前我们介绍的模型中，敌手 \(\mathcal{A}\) 无法直接与诚实方 \(P_i\) 交互：所有此类交互都是通过安全网络 \(\mathcal{C}\) 间接进行的。我们也可以允许敌手与诚实方直接交互：它是一种模型的变体，在这种变体中，模型没有内置的安全通信网络 \(\mathcal{C}\)，所有的消息都发送给敌手，这模拟了不安全的通信网络。参与方需要使用其他的方式（例如，公钥基础设施）来构建安全的通信信道。
平凡敌手
为了叙述的简洁性，我们定义一种特殊的敌手 \(\mathcal{A}_{\text {triv}}\)，称为“平凡敌手”。平凡敌手仅充当了环境和其他机器之间的“路由器”：它接收来自 \(\mathcal{Z}\) 的控制消息，并忠实地遵循这些消息的指示，将特定消息沿指定的路线发送到特定机器。此外，\(\mathcal{A}_{\text {triv}}\) 将接收到的其他机器的消息都转发给 \(\mathcal{Z}\)，同时附带着该消息来源于哪个机器的信息。
运行时间考虑
在讨论密码协议的安全性时，我们常常考虑的是高效的敌手，即敌手的运行时间是多项式的。 这里，我们严格定义在通用可组合框架下，什么是高效的协议、敌手和环境。
如果环境 \(\mathcal{Z}\) 的运行时间是关于安全参数的多项式（这个多项式可能依赖于 \(\mathcal{Z}\)），那么我们说环境 \(\mathcal{Z}\) 是良好的。
如果在任何良好的环境 \(\mathcal{Z}\) 下，每个诚实方 \(P_i\) 以及敌手 \(\mathcal{A}\) 的总运行时间（以压倒性的概率）是关于安全参数和 \(\mathcal{Z}\) 发送的消息长度的多项式（这个多项式依赖于 \(\Pi\) 和 \(\mathcal{A}\)，但不依赖于 \(\mathcal{Z}\)），那么我们说敌手 \(\mathcal{A}\) 与协议 \(\Pi\) 是兼容的。
有了这两个定义，如果 \(\mathcal{Z}\) 是良好的且 \(\mathcal{A}\) 与 \(\Pi\) 是兼容的，那么所有机器的运行时间总和也仍然（以压倒性的概率）是关于安全参数的多项式（这个多项式依赖于 \(\Pi, \mathcal{A}, \mathcal{Z}\)）。因此，我们给出如下定义。
如果平凡敌手与协议 \(\Pi\) 是兼容的，那么我们称 \(\Pi\) 是高效的。
这个定义表明，一个高效的协议中所有机器的运行时间，是关于环境 \(\mathcal{Z}\) 的输入长度的多项式。该定义有足够的灵活性，它允许协议处理来自环境的无限数量的请求。
理想协议及其运行
接下来，我们将介绍理想协议的运行过程。与真实协议的运行过程相比，主要的变化包括：
理想世界中有一个不同的敌手 \(\mathcal{S}\)，我们称之为模拟器。
理想世界引入了理想功能 \(\mathcal{F}\) 代替通信网络。理想功能是根据协议要解决的问题而定义的。例如，针对安全函数计算问题的理想功能接收所有参与方（无论是诚实的还是被攻陷的）的输入，进行函数计算，然后把结果输出给所有参与方。然而，对于不同的任务和协议，我们需要设计不同的理想功能。
诚实方本身在协议中不起主动作用：他们将从环境 \(\mathcal{Z}\) 接收到的任何输入直接传递给 \(\mathcal{F}\)，并将从 \(\mathcal{F}\) 收到的任何输出直接传递给 \(\mathcal{Z}\).
图 4.1说明了理想协议运行的基本拓扑结构。在理想协议中，\(\mathcal{F}-\mathrm{I}/\mathrm{O}\) 线替代了 \(\mathcal{C}-\mathrm{I}/\mathrm{O}\) 线：对于诚实方，这些线路直接与环境相连；而对于被攻陷方，则连接到模拟器 \(\mathcal{S}\). \(\mathcal{F}\)-控制线连接模拟器 \(\mathcal{S}\) 与理想功能 \(\mathcal{F}\)，替代了通信网络的 \(\mathcal{C}\)-控制线。\(\mathcal{S}\)-控制线连接环境 \(\mathcal{Z}\) 与模拟器 \(\mathcal{S}\)，替代了 \(\mathcal{A}\)-控制线。
理想协议及其运行 · 插图
理想协议运行，图中包括理想功能 \(\mathcal{F}\)，模拟器 \(\mathcal{S}\)，环境 \(\mathcal{Z}\)，诚实方 \(P_1, P_2\)，被攻陷方 \(P_3, P_4\)
理想协议的运行机制
下面，我们介绍理想协议的运行机制，它与真实协议的运行过程相似。协议开始时，环境 \(\mathcal{Z}\) 开始运行并确定参与方 \(P_1, \ldots, P_n\) 中哪些是被攻陷的。相关信息会被记录在一条特殊的纸带上，这个纸带对模拟器 \(\mathcal{S}\) 和理想功能 \(\mathcal{F}\) 是可见的。然后，协议随着各个机器的交替运行而进行。当 \(\mathcal{Z}\) 停止运行时，协议的运行也随之结束。在运行结束之前，\(\mathcal{Z}\) 将一个比特写入一条特殊的输出纸带。
同样，我们讨论一下机器之间可能传递的所有消息类型：
\(\mathcal{Z}\) 可以通过 \(\mathcal{Z}-\mathrm{I}/\mathrm{O}\) 线路向任何诚实方 \(P_i\) 传递协议输入，这些输入会直接转发给理想功能 \(\mathcal{F}\).
\(\mathcal{Z}\) 能够通过 \(\mathcal{S}\)-控制线向模拟器 \(\mathcal{S}\) 传递控制消息。
模拟器 \(\mathcal{S}\) 可通过被攻陷方对应的 \(\mathcal{F}-\mathrm{I}/\mathrm{O}\) 线向理想功能 \(\mathcal{F}\) 传递协议输入，或者通过 \(\mathcal{F}\)-控制线传递控制消息给 \(\mathcal{F}\).
模拟器 \(\mathcal{S}\) 可以通过 \(\mathcal{S}\)-控制线向环境 \(\mathcal{Z}\) 传递泄漏信息。
\(\mathcal{F}\) 可以执行以下任一操作：
通过与诚实方相连接的 \(\mathcal{F}-\mathrm{I}/\mathrm{O}\) 线向环境 \(\mathcal{Z}\) 传递协议输出；
通过与被攻陷方相连接的 \(\mathcal{F}-\mathrm{I}/\mathrm{O}\) 线向模拟器 \(\mathcal{S}\) 传递协议输出；
通过 \(\mathcal{F}\)-控制线向模拟器 \(\mathcal{S}\) 传递泄露信息。
运行时间考虑
与真实协议类似，我们要求限制理想功能、模拟器和环境是高效的。定义如下：
有了这个定义，如果 \(\mathcal{Z}\) 是良好的，且模拟器 \(\mathcal{S}\) 与理想功能 \(\mathcal{F}\) 兼容，那么所有相关机器的总运行时间将（以压倒性概率）是关于安全参数的多项式（这个多项式依赖于 \(\mathcal{F}, \mathcal{S}, \mathcal{Z}\)）。
安全函数计算的理想功能
接下来，我们来探讨一下安全函数计算问题(secure function evaluation, sfe)的理想功能 \(\mathcal{F}_{\mathsf{sfe}}\) 的具体定义。宏观地看，\(\mathcal{F}_{\mathsf{sfe}}\) 接收所有参与方（包括诚实方和被攻陷方）的协议输入，并将计算后的结果输出给相应的参与方。\(\mathcal{F}_{\mathsf{sfe}}\) 扮演的是一个“可信第三方”的角色，它负责正确计算所有输出，并确保除了将结果传递给被攻陷方外，不泄露任何额外信息给敌手。需要注意的是，\(\mathcal{F}_{\mathsf{sfe}}\) 允许敌手控制诚实方的输出接收时机和条件。并且，\(\mathcal{F}_{\mathsf{sfe}}\) 并不保证所有诚实方都能接收到输出（因此，有可能被攻陷方已经获得了输出，而诚实方没有获得输出）。
\(\mathcal{F}_{\mathsf{sfe}}\) 更形式化的描述如下。首先，假设待计算的函数是公开确定的。一个函数通常可以用布尔电路或算术电路来表示。我们用输入导线和输出导线来表示函数的输入和输出。假设每条输入导线都标有：
一个标识该输入导线的 \(inputID\).
一个索引，指示哪个参与方需要为该导线提供输入值。
同样地，每条输出导线都标有：
一个标识该输出导线的 \(outputID\).
接收该输出的参与方的索引列表。
理想功能 \(\mathcal{F}_{\mathsf{sfe}}\) 的工作方式如下：
理想功能 \(\mathcal{F}_{\mathsf{sfe}}\) 可以通过 \(\mathcal{F}_{\mathsf{sfe}}-\mathrm{I}/\mathrm{O}\) 线接收协议输入，无论是来自诚实方 \(P_i\) 还是来自代表被攻陷方 \(P_i\) 的敌手 \(\mathcal{S}\). 协议输入是格式为(\(\operatorname{Input}\), \(inputID\), \(x\))的元组。前提是，参与方 \(P_i\) 必须是指定的为该输入导线提供输入值的参与方，并且必须还没有提供输入值。\(\mathcal{F}_{\mathsf{sfe}}\) 记录元组(\(\operatorname{Input}\), \(inputID\), \(x\))，并通过 \(\mathcal{F}_{\mathsf{sfe}}\)-控制线向 \(\mathcal{S}\) 发送泄露消息(\(\operatorname{Input}\), \(inputID\))。
理想功能 \(\mathcal{F}_{\mathsf{sfe}}\) 可以接收 \(\mathcal{S}\) 通过 \(\mathcal{F}_{\mathsf{sfe}}\)-控制线发送的控制消息，格式为(\(\operatorname{Output}\), \(outputID\), \(i\))。前提条件是所有参与方（诚实的与被攻陷的）都已提供输入，且 \(i\) 在该输出值指定的接收方列表中。然后，\(\mathcal{F}_{\mathsf{sfe}}\) 计算适当的输出值 \(y\)，并通过参与方 \(P_i\) 对应的 \(\mathcal{F}_{\mathsf{sfe}}-\mathrm{I}/\mathrm{O}\) 线发送元组(\(\operatorname{Output}\), \(outputID\), \(y\))，如果 \(P_i\) 是诚实的，则直接发给 \(P_i\)；若是被攻陷的，则发给 \(\mathcal{S}\).
注：当理想功能收到或发送消息时，它必须知道对应的消息发送方或消息接收方。因此，为了表达的简洁性，我们通常会采用如下句式来描述一个理想功能：当收到来自 \(P_i\) 的消息 \((\operatorname{Input}, x)\) 时，执行……（描述收到消息）；当……时，将 \((\operatorname{Output}, y)\) 发送给 \(P_i\)（描述发送消息）。本书后文中定义理想功能时，也会采用这样的表述方式。
概率功能。 目前为止，我们讨论的是为确定性函数设计的理想功能 \(\mathcal{F}_{\mathsf{sfe}}\). 我们也可以将 \(\mathcal{F}_{\mathsf{sfe}}\) 的概念扩展，使其支持概率性函数。概率性函数的不同之处在于，除了常规输入之外，它们还需要额外的随机输入，这些随机输入由理想功能 \(\mathcal{F}_{\mathsf{sfe}}\) 自行生成。
UC-安全实现
现在，我们正式给出协议 \(\Pi\) 在通用可组合框架下安全地实现理想功能 \(\mathcal{F}\) 的定义，称为“UC-安全实现”。这里的UC是Universally Composable的缩写，指通用可组合。
我们用 \(\operatorname{exec}_{\Pi,\mathcal{A},\mathcal{Z}}\) 表示环境 \(\mathcal{Z}\) 在真实世界中与协议 \(\Pi\)、敌手 \(\mathcal{A}\) 交互后输出的随机变量。
我们用 \(\operatorname{exec}_{\mathcal{F},\mathcal{S},\mathcal{Z}}\) 表示环境 \(\mathcal{Z}\) 在理想世界中与理想功能 \(\mathcal{F}\)、模拟器 \(\mathcal{S}\) 交互后输出的随机变量。
我们使用 \(X \approx Y\) 来表示两个随机变量 \(X\) 和 \(Y\) 是不可区分的（参见第 基本术语和符号节），当 \(X\) 和 \(Y\) 是0/1随机变量时，这等价于说 \(|\operatorname{Pr}[X=1]-\operatorname{Pr}[Y=1]|\) 是可忽略的。
我们先给出协议对于特定敌手的安全性的定义：
图 4.5给出了定义 4.2的示意图。图 4.3是真实世界，其中用 \(\Pi\) 标记的云朵表示运行协议 \(\Pi\) 的机器 \(P_1, P_2, …, P_n\). 这些机器与环境 \(\mathcal{Z}\)、通信网络 \(\mathcal{C}\) 以及敌手 \(\mathcal{A}\) 直接交互。同时，敌手 \(\mathcal{A}\) 也能够直接与环境以及通信网络进行交互。
图 4.4是理想世界。在此情况下，环境 \(\mathcal{Z}\) 不再与诚实机器直接交互，而是与理想功能 \(\mathcal{F}\) 进行交互；同时，环境与敌手 \(\mathcal{A}\) 的直接交互也被替换为与模拟器 \(\mathcal{S}\) 的交互。此外，模拟器和理想功能也可以直接交互。根据定义 4.2，任何环境 \(\mathcal{Z}\) 都不能高效地区分真实世界和理想世界。
UC-安全实现 · 插图
真实世界
.png)
理想世界
.png)
定义4.2.2的示意图
下面，我们将定义扩展到对于所有可能的敌手的安全性，它定义了一个安全协议所应具备的属性：
这个定义表示：协议 \(\Pi\) 安全地实现了理想功能 \(\mathcal{F}\)，当且仅当对于任何兼容的敌手 \(\mathcal{A}\)，都存在一个与 \(\mathcal{F}\) 兼容的模拟器 \(\mathcal{S}\)（该模拟器可能依赖于 \(\mathcal{A}\)），使得对于每个良好的环境 \(\mathcal{Z}\)，都有 \(\operatorname{exec}_{\Pi,\mathcal{A},\mathcal{Z}} \approx \operatorname{exec}_{\mathcal{F},\mathcal{S},\mathcal{Z}}\).
这个安全定义的直观含义是：无论敌手 \(\mathcal{A}\) 如何尝试攻击真实协议 \(\Pi\)，造成的损害都不会超过另一敌手 \(\mathcal{S}\)（该敌手可能依赖于 \(\mathcal{A}\)）在理想模型中攻击理想功能所能造成的损害。例如，在安全函数计算的场景中，可以看出理想功能 \(\mathcal{F}_{\mathsf{sfe}}\) 确保了隐私性、正确性和输入独立性。如果某个协议 \(\Pi_{\mathsf{sfe}}\) UC-安全实现了 \(\mathcal{F}_{\mathsf{sfe}}\)，那么它也一定满足隐私性、正确性和输入独立性。
在进行协议的安全性证明时，有一个非常实用的定理：
UC-安全实现 · 插图
\(\operatorname{exec}_{\Pi,\mathcal{A},\mathcal{Z}}\)
.png)
\(\operatorname{exec}_{\Pi,\mathcal{A}_{\text {triv}},\mathcal{A} | \mathcal{Z}}\)
.png)
\(\operatorname{exec}_{\mathcal{F},\mathcal{S}_{\text {triv}},\mathcal{A} | \mathcal{Z}}\)
.png)
\(\operatorname{exec}_{\mathcal{F},\mathcal{S}_{\text {triv}} | \mathcal{A},\mathcal{Z}}\)
.png)
定理4.1的证明图
证明概要：假设 \(\Pi\) 安全地实现了对于平凡敌手的 \(\mathcal{F}\)，则存在一个与 \(\mathcal{F}\) 兼容的模拟器 \(\mathcal{S}_{\text {triv}}\)，使得对于每个良好的环境 \(\mathcal{Z}\)，都有 \(\operatorname{exec}_{\Pi,\mathcal{A}_{\text {triv}},\mathcal{Z}} \approx \operatorname{exec}_{\mathcal{F}, \mathcal{S}_{\text {triv}}, \mathcal{Z}}\).
现在考虑与 \(\Pi\) 兼容的任意敌手 \(\mathcal{A}\). 我们的目标是证明 \(\Pi\) 对于 \(\mathcal{A}\) 安全地实现了 \(\mathcal{F}\). 考虑一个良好的环境 \(\mathcal{Z}\)，它通过 \(\mathcal{A}\)-控制线与 \(\mathcal{A}\) 交互。我们可以构造一个新的环境 \(\mathcal{A} | \mathcal{Z}\)，将 \(\mathcal{A}\) 嵌入到 \(\mathcal{Z}\) 中。环境 \(\mathcal{A} | \mathcal{Z}\) 通过 \(\mathcal{A}_{\text {triv}}\)-控制线与平凡敌手交互，运行 \(\mathcal{A}\) 和 \(\mathcal{Z}\) 的代码（这里必须确保 \(\mathcal{A} | \mathcal{Z}\) 是良好的）。那么 \(\operatorname{exec}_{\Pi,\mathcal{A},\mathcal{Z}} \approx \operatorname{exec}_{\Pi,\mathcal{A}_{\text {triv}}, \mathcal{A} | \mathcal{Z}}\)，因为它们运行的代码是完全一样的。如图 4.6和图 4.7所示。
最后，我们可以构造一个新的模拟器 \(\mathcal{S}_{\text {triv}} | \mathcal{A}\)，将 \(\mathcal{A}\) 嵌入到 \(\mathcal{S}_{\text {triv}}\) 中。模拟器 \(\mathcal{S}_{\text {triv}} | \mathcal{A}\) 通过 \(\mathcal{A}\)-控制线与环境交互，运行 \(\mathcal{S}_{\text {triv}}\) 和 \(\mathcal{A}\) 的代码。可以看出，在这两种情况下（图 4.8和图 4.9），环境 \(\mathcal{Z}\) 的视图是完全一样的，因此 \(\operatorname{exec}_{\mathcal{F},\mathcal{S}_{\text {triv}},\mathcal{A} | \mathcal{Z}} \approx \operatorname{exec}_{\mathcal{F}, \mathcal{S}_{\text {triv}} | \mathcal{A},\mathcal{Z}}\)（并且 \(\mathcal{S}_{\text {triv}} | \mathcal{A}\) 与 \(\mathcal{F}\) 兼容）。
这表明 \(\operatorname{exec}_{\Pi,\mathcal{A},\mathcal{Z}} \approx \operatorname{exec}_{\mathcal{F}, \mathcal{S}_{\text {triv}} | \mathcal{A},\mathcal{Z}}\). 也就是说，对于任何敌手 \(\mathcal{A}\)，存在模拟器 \(\mathcal{S} = \mathcal{S}_{\text{triv}} | \mathcal{A}\) 使得环境 \(\mathcal{Z}\) 无法区分真实世界和理想世界。由此，我们得出结论，协议 \(\Pi\) 对于每个敌手 \(\mathcal{A}\) 都安全地实现了理想功能 \(\mathcal{F}\)，即 \(\Pi\) UC-安全实现了 \(\mathcal{F}\). □
这个定理表明，为了证明 \(\Pi\) 安全地实现了 \(\mathcal{F}\)，我们不需要为每一个可能的敌手分别构造模拟器，只需要为平凡敌手构造一个模拟器即可。
UC-安全实现的效果
UC-安全实现是一个非常强的安全概念，本节将通过几个定理来阐述它的重要性质。这里，我们只介绍概念性的证明思路，但不进行形式化的完整证明，因为那将过于抽象和晦涩。
并发组合的安全性
UC-安全实现的一个显著优势是，它确保了协议即便在多个实例并发运行的情况下也能保持安全性。 为了准确描述这一结果，我们需要对真实协议运行和理想协议运行的概念进行扩展，以涵盖多个协议实例并发运行的情况。这一扩展的基本要点包括：
每个真实协议实例都配备有一个独立的通信网络。
每个理想协议实例都对应有一个独立的理想功能实体。
参见图 4.11和图 4.12，它们将图 4.2和图 4.1扩展到两个协议实例并发运行的情形。在这些示例中，四个参与方 \(P_1, …, P_4\) 正在运行同一协议 \(\Pi\) 的两个独立实例。无论是在真实运行还是理想运行中，参与方 \(P_1\) 和 \(P_2\) 均为诚实方，而 \(P_3\) 和 \(P_4\) 都是被攻陷方。
并发组合的安全性 · 插图
两个真实协议实例并发运行
并发组合的安全性 · 插图
两个理想协议实例并发运行
需要注意的是，由于图 4.11中出现的两个通信网络是独立的，如果第一个实例中的 \(P_1\) 向第一实例中的 \(P_2\) 发送消息，敌手无法将该消息转发给第二个实例中的 \(P_2\). 同理，在图 4.12展示的理想运行场景中，由于两个理想功能是独立的，模拟器\(\mathcal{S}\)无法在这两个理想功能之间制造任何交互行为。
为了模拟这一点，我们为每个协议实例分配一个唯一的“会话ID”(session ID, \(\mathsf{sid}\))，并将其包括在每一条协议消息中。以安全函数计算功能 \(\mathcal{F}_{\mathsf{sfe}}\) 为例，在并发运行的情形下，它接收的输入格式为 \((\operatorname{Input}, \mathsf{sid}, inputID, x)\)，输出格式为 \((\operatorname{Output}, \mathsf{sid}, outputID, y)\). 在研究如何模拟多个协议或同一协议的多个实例的运行时，引入“会话ID”的概念至关重要。所有参与方都可以通过它来识别消息属于哪个协议实例。在真实世界运行中，每个机器 \(P_i\) 不仅要用其索引 \(i\) 初始化，还要用其会话ID进行标识。同样，在理想世界运行中，每个理想功能也需要根据其会话ID进行初始化。
我们可以证明以下定理：
并发组合的安全性 · 插图
真实世界
.png)
混合世界
.png)
理想世界
.png)
定理4.2的证明图
证明概要：这里我们不深入讨论有关运行时间的问题，它可以通过一些简单（但稍显枯燥）的分析得以证明。我们将重点放在安全性上。
假设单实例安全性成立，即存在一个与 \(\mathcal{F}\) 兼容的模拟器 \(\mathcal{S}_{\text{triv}}\)，使得对于每个与平凡敌手 \(\mathcal{A}_{\text{triv}}\) 进行交互的良好的单实例环境 \(\mathcal{Z}\)，都有 \(\operatorname{exec}_{\Pi, \mathcal{A}_{\text {triv}},\mathcal{Z}} \approx \operatorname{exec}_{\mathcal{F}, \mathcal{S}_{\text {triv}},\mathcal{Z}}\).
证明过程本质上是一个混合论证(hybrid argument)。为简单起见，我们仅用两个协议实例来说明证明思路。根据定理 4.1的推广，我们可以假设多实例真实世界中的敌手是平凡敌手，它只是在环境和其他机器之间传递消息，如图 4.13所示。未标记的方框代表简单的路由机，底部的路由机会根据消息中的会话ID，将来自 \(\mathcal{Z}\) 的消息转发到上方的未标记方框。
基于单实例安全性，我们可以将第一个真实世界协议实例替换为其对应的理想世界协议实例，如图 4.14所示。为了形式化这一步骤，我们定义了一个单实例环境 \(\mathcal{Z}_{1}\)，它封装了第二个协议实例（如图中的虚线框所示）。单实例安全性保证 \(\operatorname{exec}_{\Pi, \mathcal{A}_{\text {triv}},\mathcal{Z}_{1}} \approx \operatorname{exec}_{\mathcal{F}, \mathcal{S}_{\text {triv}},\mathcal{Z}_{1}}\)，这表明多实例环境 \(\mathcal{Z}\) 无法区分图 4.13中的真实世界与图 4.14中的混合世界。
再次利用单实例安全性，我们同样可以将第二个真实世界协议实例替换为其对应的理想世界协议实例。这如图 4.15所示。为了形式化地证明这一步，我们定义了另一个单实例环境 \(\mathcal{Z}_{2}\)，它封装了第一个协议实例(如图中虚线框所示)。单实例安全性意味着 \(\operatorname{exec}_{\Pi, \mathcal{A}_{\text {triv}}, \mathcal{Z}_{2}} \approx \operatorname{exec}_{\mathcal{F}, \mathcal{S}_{\text {triv}}, \mathcal{Z}_{2}}\)，这意味着多实例环境 \(\mathcal{Z}\) 无法区分图 4.14中的混合世界和图 4.15中的理想世界。
最后，我们定义理想世界中的多实例模拟器，它由简单的消息路由机制和两个单实例模拟器 \(\mathcal{S}_{\text {triv}}\) 的副本组成。结合上述分析，环境 \(\mathcal{Z}\) 无法区分自己在图 4.13的真实世界还是在图 4.15的理想世界。定理得证。 □
子协议组合的安全性
安全实现的另一个效果是，我们可以在更大的协议中使用安全协议作为子协议，而不会影响整体协议的安全性。 同样地，我们在这里仅简要介绍定理的证明思路，而不进行形式化的完整证明。 假设我们设计了一个协议 \(\Pi\)，我们想证明 \(\Pi\) 安全地实现了某个理想功能 \(\mathcal{F}\). 进一步假设，\(\Pi\) 中使用了另一个协议 \(\Pi^*\) 作为子协议，而 \(\Pi^*\) 已被证明安全地实现了另一个理想功能 \(\mathcal{F}^*\).
我们采用模块化的证明方法。首先考虑一个混合协议 \(\Pi_{\mathcal{F}^*}\)，在该协议中，子协议 \(\Pi^*\) 被其相应的理想功能 \(\mathcal{F}^*\) 所替代。通常， \(\Pi_{\mathcal{F}^*}\) 比 \(\Pi\) 本身要简单得多，也更容易分析，因为它移除了 \(\Pi^*\) 的所有实现细节。那么，我们有如下结论：如果混合协议 \(\Pi_{\mathcal{F}^*}\) 安全地实现了 \(\mathcal{F}\)，那么这意味着 \(\Pi\) 安全地实现了 \(\mathcal{F}\).
参考图 4.19可以获得更直观的理解。在图 4.17中，协议 \(\Pi\) 使用协议 \(\Pi^*\) 作为子协议。为了简洁，这里假设只有两个参与方，并且未画出敌手和环境。标记为 \(P_1\) 和 \(P_2\) 的机器运行了 \(\Pi\) 的“顶部”部分（即不包括子协议 \(\Pi^*\) 的部分），它们通过安全通信网络 \(\mathcal{C}\) 作为对等方进行通信。标记为 \(P_1^*\) 和 \(P_2^*\) 的机器运行子协议 \(\Pi^*\)，它们通过另外的通信网络 \(\mathcal{C}^*\) 作为对等方进行通信。机器 \(P_1\) 和 \(P_1^*\) 都属于第一个参与方，可以将它们视为在同一台计算机上运行的两个不同程序，因此 \(P_1\) 可以直接向 \(P_1^*\) 提供输入，并从 \(P_1^*\) 接收输出。同理，机器 \(P_2\) 和 \(P_2^*\) 都属于第二个参与方。
图 4.18呈现了被称为混合协议的 \(\Pi_{\mathcal{F}^*}\). 之所以称其为混合协议，是因为它既有真实世界的元素(\(P_1\)、\(P_2\) 和 \(\mathcal{C}\))，也有理想世界的元素(理想功能 \(\mathcal{F}^*\))。在这个混合协议中，输入不是由 \(P_1\) 传递给 \(P_1^*\)，而是直接传递给理想功能 \(\mathcal{F}^*\). 类似地， \(P_1\) 不是从 \(P_1^*\) 接收输出，而是直接从理想功能 \(\mathcal{F}^*\) 接收输出。
子协议组合的安全性 · 插图
这种混合协议的运行模型在本质上与真实世界协议运行非常相似，不同之处在于现在同时存在通信网络 \(\mathcal{C}\) 和理想功能 \(\mathcal{F}^*\).
可以证明以下定理：
协议 \(\Pi\)
.png)
协议 \(\Pi_{\mathcal{F}^*}\)
.png)
混合协议
子协议组合的安全性 · 插图
真实世界
.png)
混合世界
.png)
理想世界
.png)
定理4.3的证明图
证明概要：首先，由于 \(\Pi^*\) 安全地实现了 \(\mathcal{F}^*\)，因此存在与 \(\mathcal{F}^*\) 兼容的模拟器 \(\mathcal{S}_{\text{triv}}^*\)，使得对于每个良好的环境 \(\mathcal{Z}\)，我们有 \(\operatorname{exec}_{\Pi^*, \mathcal{A}^*_{\text {triv}}, \mathcal{Z}} \approx \operatorname{exec}_{\mathcal{F}^*, \mathcal{S}_{\text {triv}}^*, \mathcal{Z}}\). 这里， \(\mathcal{A}_{\text {triv}}^*\) 是与 \(\Pi^*\) 交互的平凡敌手。
其次，由于 \(\Pi_{\mathcal{F}^*}\) 安全地实现了 \(\mathcal{F}\)，因此对于任何与 \(\Pi_{\mathcal{F}^*}\) 兼容的敌手 \(\mathcal{A}\)，都存在一个与 \(\mathcal{F}\) 兼容的模拟器 \(\mathcal{S}\)，使得对于任意一个良好的环境 \(\mathcal{Z}\)，都有 \(\operatorname{exec}_{\Pi_{\mathcal{F}^*}, \mathcal{A}, \mathcal{Z}} \approx \operatorname{exec}_{\mathcal{F}, \mathcal{S}, \mathcal{Z}}\).
接下来的证明本质上是一个混合论证。根据定理 4.1的推广，我们可以假设在协议 \(\Pi\) 的真实世界运行中面临的敌手是平凡敌手，如图 4.20所示。图中，被标记为 \(\Pi^*\) 的云朵表示运行子协议 \(\Pi^*\) 的诚实机器，被标记为 \(\Pi_{\text {top }}\) 的云朵代表运行 \(\Pi\) 的“顶部”(即不包括子协议 \(\Pi^*\) 的部分)的诚实机器。未标记的方框代表了一个简单的路由机制，被标记为 \(\mathcal{A}_{\text{triv}}^*\) 的方框是与子协议 \(\Pi^*\) 交互的平凡敌手。未标记的方框会根据消息中的会话ID，将来自 \(\mathcal{Z}\) 的消息路由至 \(\Pi_{\text{top}}\) 或 \(\mathcal{A}_{\text{triv}}^*\).
由于 \(\Pi^*\) 安全地实现了 \(\mathcal{F}^*\)，我们可以用 \(\mathcal{F}^*\) 替换 \(\Pi^*\)，如图 4.21所示。为了形式化地证明这一步，我们定义了一个环境 \(\mathcal{Z}_{\text {top }}\)，它封装了 \(\Pi_{\text {top }}\)(如图中标记为 \(\mathcal{Z}_{\text {top }}\) 的虚线框所示)。 \(\Pi^*\) 能够安全地实现 \(\mathcal{F}^*\) 这一事实意味着 \(\operatorname{exec}_{\Pi^*, \mathcal{A}_{\text {triv}}^*, \mathcal{Z}_{\text {top }}} \approx \operatorname{exec}_{\mathcal{F}^*, \mathcal{S}_{\text {triv}}^*, \mathcal{Z}_{\text {top }}}\)，这意味着环境 \(\mathcal{Z}\) 无法区分图 4.20中的真实世界和图 4.21中的混合世界。
由于 \(\Pi_{\mathcal{F}^*}\) 安全地实现了 \(\mathcal{F}\)，我们可以用 \(\mathcal{F}\) 替换 \(\Pi_{\mathcal{F}^*}\)，如图 4.22所示。为了形式化地证明这一步，我们定义了一个敌手 \(\mathcal{A}\)，它包括路由器和 \(\mathcal{S}_{\text {triv}}^*\)(如图中标记为 \(\mathcal{A}\) 的虚线框所示)。 \(\Pi_{\mathcal{F}^*}\)能够安全地实现 \(\mathcal{F}\) 意味着 \(\operatorname{exec}_{\Pi_{\mathcal{F}^*}, \mathcal{A}, \mathcal{Z}} \approx \operatorname{exec}_{\mathcal{F}, \mathcal{S}, \mathcal{Z}}\)，表明环境 \(\mathcal{Z}\) 无法区分图 4.21中的混合世界与图 4.22中的理想世界。
综上所述，环境 \(\mathcal{Z}\) 无法区分图 4.20中的真实世界与图 4.22中的理想世界，即 \(\Pi\) UC-安全实现了 \(\mathcal{F}\). 定理得证。 □
子协议组合定理在更一般的场景下依然成立。例如，协议 \(\Pi\) 的一个实例可能会调用子协议 \(\Pi^*\) 的多个实例，这些子协议实例可能是并发运行的。与定理 4.3的证明中使用的方法类似，我们可以将每个子协议 \(\Pi^*\) 的实例替换为理想功能 \(\mathcal{F}^*\) 的一个实例，从而得到相应的混合协议 \(\Pi_{\mathcal{F}^*}\). 定理 4.3在这种更一般的场景中同样适用。
安全实现的传递性
在「并发组合的安全性」一节中，我们介绍了混合协议的概念，这种协议是由运行诚实方代码的普通机器和理想功能的组合而成。真实协议是一种特殊的混合协议，它仅使用了表示安全通信网络的理想功能 \(\mathcal{C}\). 理想协议也是一种特殊的混合协议，其中机器只在环境和理想功能之间传递输入和输出。因此，包括真实世界和理想世界中的所有协议都可以被看作混合协议。
UC-安全实现的概念也可以扩展至任意混合协议。对于两个混合协议 \(\Pi\) 和 \(\Pi^{\prime}\)，如果对于每一个与 \(\Pi\) 兼容的敌手 \(\mathcal{A}\)，都存在一个依赖于 \(\mathcal{A}\) 且与 \(\Pi^{\prime}\) 兼容的敌手 \(\mathcal{A}^{\prime}\)，使得对于任何行为良好的环境 \(\mathcal{Z}\)，都有 \(\operatorname{exec}_{\Pi, \mathcal{A}, \mathcal{Z} } \approx \operatorname{exec}_{\Pi^{\prime}, \mathcal{A}^{\prime}, \mathcal{Z}}\)，则我们说 \(\Pi\) UC-安全实现了 \(\Pi^{\prime}\). 在这种情况下，我们没有必要在术语和符号上区分敌手和模拟器。
证明概要：首先，协议 \(\Pi\) 能够安全地实现协议 \(\Pi^{\prime}\)，这意味着对于每个与 \(\Pi\) 兼容的敌手 \(\mathcal{A}\)，都存在一个与 \(\Pi^{\prime}\) 兼容的敌手 \(\mathcal{A}^{\prime}\)，使得 \(\operatorname{exec}_{\Pi,\mathcal{A},\mathcal{Z}} \approx \operatorname{exec}_{\Pi^{\prime}, \mathcal{A}^{\prime}, \mathcal{Z}}\). 其次，\(\Pi^{\prime}\) 安全实现了 \(\Pi^{\prime \prime}\)，这意味着对于每个与 \(\Pi^{\prime}\) 兼容的敌手 \(\mathcal{A}^{\prime}\)，都存在一个与 \(\Pi^{\prime \prime}\) 兼容的敌手 \(\mathcal{A}^{\prime \prime}\)，使得 \(\operatorname{exec}_{\Pi^{\prime}, \mathcal{A}^{\prime}, \mathcal{Z}} \approx \operatorname{exec}_{\Pi^{\prime \prime}, \mathcal{A}^{\prime \prime}, \mathcal{Z}}\). 由此可得，对于每个与 \(\Pi\) 兼容的敌手 \(\mathcal{A}\)，都存在一个与 \(\Pi^{\prime \prime}\) 兼容的敌手 \(\mathcal{A}^{\prime}\)，使得 \(\operatorname{exec}_{\Pi,\mathcal{A},\mathcal{Z}} \approx \operatorname{exec}_{\Pi^{\prime \prime}, \mathcal{A}^{\prime \prime}, \mathcal{Z}}\). □
定义半诚实安全性
在定义半诚实安全性时，需要对真实世界中的敌手（以及理想世界中的模拟器）的行为增加一些限制，我们称这个修改后的框架为受限框架。幸运的是，我们仍然可以在原有的框架内定义受限的敌手（或模拟器）的概念，而无需从头开始定义一个新的受限框架。
定义受限框架
受限框架的真实世界。首先，我们讨论受限框架的真实世界。与无限制框架不同，在受限框架中，被攻陷方不是简单地被并入敌手，而是使用独立于敌手的实体来表示。此外，就像诚实方一样，被攻陷方直接从环境接收其输入，并将其输出直接传递给环境。它们运行的是协议的“诚实但泄露”的版本，即它们完全按照协议运行，但会向敌手报告以下信息：
从通信网络接收到的所有消息。
它们生成的所有随机比特串（假设所有随机性最终都源自这些比特串）。
这些报告是具有一些特殊规则的特殊消息。具体来说，在收到报告后，合法的敌手必须做出以下行动之一：
立即将控制权交还给报告的发送方。
向环境发送一个或多个报告序列，然后将控制权交还给报告的发送方。
此外，合法的环境必须遵守以下规则：在收到敌手的报告时，它必须立即将控制权交还给敌手，或者停止运行。
上述规则本质上说明，在受限框架中，敌手（以及环境）只能够在不中断正常协议流程的前提下，持续监控被攻陷方的内部状态。
受限框架中，通信网络\(\mathcal{C}\)的行为与无限制框架中的行为一致，但敌手与 \(\mathcal{C}\) 的交互仅限于 \(\mathcal{C}\)-控制线，而不能通过 \(\mathcal{C}-\mathrm{I}/\mathrm{O}\) 线。只有诚实方和被攻陷方可以通过 \(\mathcal{C}-\mathrm{I}/\mathrm{O}\) 线与 \(\mathcal{C}\) 通信。不过，敌手仍然可以决定是否以及何时将消息传递给任何参与方(诚实方或被攻陷方)；但它既不能知道或更改在两个诚实方之间发送的消息内容，也不能更改从被攻陷方发送到任何其他方的任何消息的内容。当然，敌手能够知道发往被攻陷方的消息内容以及被攻陷方发出的消息内容。
相同地，我们可以定义平凡敌手 \(\mathcal{A}_{\text{triv}}\)，它只按照环境的指示行动。不过，由于在这个框架中敌手无法控制被攻陷方，当被攻陷方向 \(\mathcal{A}_{\text{triv}}\) 报告信息时，\(\mathcal{A}_{\text{triv}}\) 仅能将这些信息直接发送给环境。
受限框架的理想世界。在受限框架的理想世界中，所有 \(\mathcal{F}-\mathrm{I}/\mathrm{O}\) 线直接将环境 \(\mathcal{Z}\)连接到理想功能\(\mathcal{F}\). 这意味着模拟器 \(\mathcal{S}\) 不能更改被攻陷方的输入或输出。然而，与真实世界相对应，理想世界的被攻陷方是“诚实但泄露信息”的。这意味着当理想世界的被攻陷方从环境 \(\mathcal{Z}\) 收到输入或从理想功能 \(\mathcal{F}\) 收到输出时，这些消息也会发送给模拟器 \(\mathcal{S}\).
安全定义及其效果
定义 4.2和定义 4.3都可以直接应用到受限框架：为了与无限制框架相区分，对于定义 4.2，我们说 \(\Pi\) 对于半诚实的敌手 \(\mathcal{A}\) 安全实现了 \(\mathcal{F}\)；对于定义 4.3，我们说 \(\Pi\) 对于半诚实敌手UC-安全实现了 \(\mathcal{F}\).
很容易发现，平凡敌手的完备性定理（定理 4.1）、并发组合定理（定理 4.2）、子协议组合定理（定理 4.3）以及传递性定理（定理 4.4）也能在受限框架中以完全相同的方式证明，本质上只是将“UC-安全实现”替换为“对于半诚实敌手UC-安全实现”。
不同类型的攻陷方式
在前面的定义中，环境 \(\mathcal{Z}\) 需要在协议开始之前就确定一组被攻陷方，这种攻陷方式称为“静态攻陷”(static corruption)。有时，我们需要考虑具有更强能力的敌手，他可以在协议运行过程中决定被攻陷的参与方；甚至，他可以中途取消对一些参与方的攻陷，转而攻陷其他参与方。这两种攻陷方式分别称为“适应性攻陷”(adaptive corruption)和“可移动攻陷”(mobile corruption)。下面，我们分别介绍这两种攻陷方式。
适应性攻陷
在适应性攻陷模型下，环境 \(\mathcal{Z}\) 无需在协议开始前确定被攻陷方，它可以在协议运行过程中进行攻陷。具体而言，以真实世界的参与方 \(P_i\) 为例，当它被攻陷前，它作为诚实方执行协议操作；在某个时刻，环境 \(\mathcal{Z}\) 可以指示敌手 \(\mathcal{A}\) 向 \(P_i\) 发送一条 \((\operatorname{Corrupt})\) 指令，此后 \(P_i\) 由 \(\mathcal{A}\) 所控制，\(\mathcal{A}\) 可以看见 \(P_i\) 收到的所有消息且 \(P_i\) 的行为纳入 \(\mathcal{A}\) 的行为逻辑之中。同样地，这个攻陷信息会被记录在一个特殊的纸带上，该纸带对 \(\mathcal{A}\) 和通信网络 \(\mathcal{C}\) 可见。在理想世界中，此时模拟器 \(\mathcal{S}\) 也可以对应地攻陷理想世界的 \(P_i\)，此后 \(\mathcal{S}\) 可以获得 \(P_i\) 的输出并代表 \(P_i\) 提供输入。
需要注意的是，当 \(P_i\) 被攻陷时，\(\mathcal{A}\) 是否能得到 \(P_i\) 的历史状态取决于模型的设置。在有“安全擦除”(secure erasure)的设置下，\(P_i\) 可以在被攻陷时“安全擦除”历史数据，从而避免敌手 \(\mathcal{A}\) 得到其历史信息。在没有“安全擦除”的设置下，\(\mathcal{A}\) 在攻陷 \(P_i\) 时将看到其完整的历史状态。
可移动攻陷与主动安全
上面所讲的“静态攻陷”和“适应性攻陷”都是“永久的”攻陷，也就是说，当敌手攻陷某个参与方之后，该参与方就一直处于被攻陷状态直到协议结束。还有一种攻陷方式，称为“可移动攻陷”(mobile corruption)，它允许参与方从被攻陷状态恢复并重新获得安全性。能够抵御“可移动攻陷”的安全性通常被称为主动安全(proactive security)。
在这个模型下，某个被攻陷方 \(P_i\) 可以收到来自敌手 \(\mathcal{A}\) 的一条 \((\operatorname{Recover})\) 指令。此后，\(P_i\) 停止向 \(\mathcal{A}\) 泄漏他接收到的消息，也停止遵循 \(\mathcal{A}\) 的指令。同样，这个恢复信息会被记录在一个特殊的纸带上，该纸带对 \(\mathcal{A}\) 和通信网络 \(\mathcal{C}\) 可见。在理想世界中，此时模拟器 \(\mathcal{S}\) 也相应地停止对理想世界中 \(P_i\) 的控制，此后 \(\mathcal{S}\) 不再可以获得 \(P_i\) 的输出并代表 \(P_i\) 提供输入。
注意，一个具有“主动安全”的协议，必须具有某种恢复机制。因为当某个被攻陷参与方 \(P_i\) 收到 \((\operatorname{Recover})\) 指令时，它的内部状态为空，也就是说，\(P_i\) 对此时协议处于哪个阶段等信息一无所知。因此，这个时候 \(P_i\) 必须通过协议的某种恢复机制得到关于协议的信息，重建自己的内部状态，然后作为诚实方继续运行协议。
本章思考题
通用可组合框架中的“环境”\(\mathcal{Z}\) 在现实中包括什么？
在通用可组合框架中，模拟器 \(\mathcal{S}\) 需要完成哪两个关键任务？这些任务是如何反映输入的隐私性和输出结果的正确性的？
在通用可组合框架中，一个协议的子协议实例或者一个协议所调用的理想功能能否被其他协议调用？为什么？
学习笔记
记录协议细节、模拟器构造与图中记号对照。