安全多方计算性能优化方案

可视化演示

展示卷积核在图像上滑动计算的过程，逐步演示每个位置的加权求和，理解特征图生成的核心原理。

瓶颈分析

云景小区第一次联合计算，满屋子纸条乱飞。王阿姨盯着表发现：代表们大部分时间不是在算数，而是在等人。有人跑一趟腿，大家就得停下来等消息回来；有人带的纸条太多，楼道口都堵住了；还有几位代表用最笨拙的“密码本”心算，一步要磨蹭半天。她终于明白：慢不是某一个环节，而是三件事叠在一起。

放到 MPC 协议里，这三件事对应三个硬指标：通信轮数（R）、通信量（D）、计算开销（C）。通信轮数是协议中各方交替发消息的往返次数，它决定“干等”多久；通信量是每次交换的数据总量，决定带宽够不够；计算开销是本地密码学操作（尤其是公钥运算）的耗时，决定“心算”多久。

三者中，通信轮数往往最不显眼却最致命。局域网 RTT（往返时延）约 0.1ms，看似毫不起眼，但协议动辄几十上百轮；换到跨地域的广域网，RTT 涨到 50ms 量级，轮数直接决定方案能不能用。通信量在大电路或大批量数据下会成为吞吐量天花板；而公钥操作（如大数模幂）比 AES 对称加密慢 2~3 个数量级，是所有参与方共同的负担。

给王阿姨的总账很简单：先数“往返多少次”，再称“每趟多少斤”，最后算“心算多久”。优化如同下棋，先动哪一环，决定了后面每一步的收益。

通信优化

王阿姨的突破口在“跑腿”。她发现每次只传一句话太浪费，于是把话攒起来，一个信封塞五件事；她还发明了“母版 + 复写纸”：先做一张标准问题母版，再用复写纸批量复制，代表们只需填数，不用每次都重新写一遍。跑腿次数从“每事一趟”变成“一趟服务多事”。

这在 MPC 里对应两大方向：减少轮次与压缩消息量。减少轮次靠改动协议结构——GMW 这类秘密分享协议可以将大量独立运算并行到同一轮，使总轮数与电路深度同阶而非与门数量同阶；压缩消息量靠伪随机数生成器（PRG）：双方共享一个随机种子，就能在本地重构对方本该传送的随机串，真正要传的只剩“增量信息”。

最亮眼的工具是 OT 扩展（Oblivious Transfer Extension）。不经意传输（OT）是很多 MPC 协议的“跑腿快递”：发送方持有两个消息，接收方只能取走其中一个，且发送方不知道接收方选的是哪一个。做一次真正的 OT 需要公钥操作，非常昂贵；OT 扩展的思想是：先用 κ 个基础 OT（κ 是安全参数，通常 128）建立“母版”，再通过对称哈希批量扩展出 n 个 OT，n 可以是成千上万，而通信成本几乎不再增长。这就是那张神奇的“复写纸”。

复写纸省下的不只是纸张，而是成百上千次“真跑腿”。通信优化的本质，就是把最贵的消息交换换成便宜的本地计算。

计算优化

跑腿问题解决后，王阿姨又发现代表们“心算”太慢。有人提出：别什么东西都用保险柜三重锁，普通汇总用带锁的信盒就够了——反正碎片化传纸条本身已经防偷看，没必要每一步都上最重的密码器械。

MPC 中的对应原则是：能用轻量级原语，就不用重量级原语。公钥加密、大整数模幂这类“保险柜”只在初始化、密钥交换等少数场合使用；协议主体消息的加密、认证、随机化，完全可以用对称加密和哈希完成。

对称加密有多快？在支持 AES-NI 指令集的现代 CPU 上，AES 单次操作为纳秒级；而 RSA 私钥操作是大数模幂，耗时在毫秒级，两者相差千倍以上。伪随机数生成器（PRG）进一步把“传随机数”变成“传种子”：双方共享种子，就能各自生成相同的随机流，通信量直接减到只剩种子本身。再加上 SIMD 向量化指令和批量模约减，一条指令同时处理多个数据单元，把批量运算摊薄到极致。

王阿姨恍然大悟：锁不一定要全用保险柜，合适的地方用普通锁，整场跑下来能省大半天。计算优化的精髓，是让每一份密码学资源都花在真正必要的地方。

电路优化

统计公式像菜谱，步骤越多，后厨出菜越慢。王阿姨把计算目标摊成一张“步骤图”，发现有些合并动作（比如把两张纸条拼在一起）完全不用跑腿，真正费时的是“乘法”这种需要交叉验证的操作。于是她开始精简菜谱：把要跑腿的步骤减到最少，把步骤链条压到最短。

在 MPC 中，计算要先被编译成电路：布尔电路由 AND/XOR 门组成，适合比较、位运算；算术电路由 ADD/MUL 门组成，适合数值计算。电路深度决定协议至少要来回多少轮，乘法门数量决定总通信量有多大。理解这一点，就抓住了电路优化的牛鼻子。

经典的 Free XOR 技巧让所有 XOR 门的通信量为零：各方在本地对自己的秘密碎片做异或即可，不需要任何消息交换。真正昂贵的是 AND 门和 MUL 门——它们要求参与方交互。于是优化目标变得极其清晰：减少乘法门数量、压低关键路径深度、把可以在本地免费做的操作（XOR/ADD）与必须交互的操作（AND/MUL）区分对待。

省掉跑腿的步骤越多，后厨出菜越快。电路优化就像给菜谱动手术：不是追求“步骤多好看”，而是把最贵的乘法步骤一个个剪掉，同时把链条压短。

预处理加速

王阿姨发现，现场做“速算表”太耗时，于是改成：提前一周在家把空白表格填好，开会时大家只当众核对几个关键数。MPC 同样把协议拆成两个相位：离线（预处理）阶段和在线阶段。离线阶段做重活，在线阶段轻装上阵。

最经典的预处理产物是 Beaver 三元组：离线随机生成三元组 $(a, b, c)$，满足 $c = a \times b$，并分别以秘密分享的形式存放在参与方手中。这三份随机数与真实业务数据完全无关，只是在线阶段的“速算表空白格子”。

要秘密相乘两个数 x 和 y 时，在线阶段先各自打开掩码差值 $\epsilon = x - a$ 和 $\delta = y - b$。因为 a、b 是随机数，公开差值不会泄露 x、y 的任何信息；随后所有人用本地速算表重组成乘积。整个在线过程只需一轮公开差值，所有重计算都被移到了离线阶段——这就是“提前备表”的秘密。

得到公开差值后，所有参与方在本地按公式重组乘积的秘密分享值：

会议现场从“现场推导九九乘法表”变成“翻开提前备好的速算表填数”，这就是预处理带来的恐怖加速。生产级 MPC 中，离线阶段往往在业务低谷期预热完成，在线阶段只负责“对表”。

批处理并行

王阿姨把 10 栋楼的纸条塞进同一个大信封，一次投递处理完所有楼栋；又安排代表们像食堂流水线一样，第一栋算完立刻传给第二栋，不必等全小区同时开工。于是整场统计从“一人一份慢递”变成“整车发货 + 流水线接力”。

批处理将多条数据打包进一次协议执行：批量 OT、批量三元组生成、批量一致性校验，把“每份都要跑一次”的成本摊薄为“一次跑动服务 n 份”。数据并行更进一步：把 n 个数编码进一个大代数表达式，一次模乘完成 n 次乘法；CPU 的 SIMD 向量化指令在此处同样适用。

流水线（Pipeline）把电路按深浅分层，每一层算完立即进入下一层。此时通信与计算相互重叠——第一层在网络上传输时，第二层已经在本地计算，总耗时不再是“各层时间之和”，而是逼近“最深一层 + 层数 × 单层网络往返”的压缩形态。但并行不是万能的：Amdahl 定律告诉我们，串行部分是加速的天花板。

把“一个一个寄”改成“一包一包寄 + 流水线接力”，王阿姨的统计从半天缩到一炷香。批处理与并行的本质，是让每一轮通信和每一次计算都同时服务尽可能多的数据。

混合协议

不同楼栋情况不同：网络条件差的楼希望少跑腿，数据敏感的楼必须上保险箱。王阿姨不再用“一套方案走天下”，而是按需混搭——普通投票用普通信封，敏感预算用保险柜。这叫工程上的“看菜下饭”。

MPC 世界里存在多种协议“交通工具”：秘密分享类协议（如 GMW）计算轻、通信轮数多，适合局域网内的大量数值运算；Yao 混淆电路轮数少但电路规模膨胀，适合高延迟广域网下的两方计算；同态加密计算重但轮数接近常数，适合“一次运算、多次复用”的场景。没有绝对最优，只有对场景最优。

混合协议就是将一个任务拆成多段，分别选择最合身的原语：数值运算走秘密分享，比较逻辑走布尔电路，层与层之间用小小的转换协议衔接。此外，安全级别也可分级：半诚实模型假设各方遵守协议但会偷看中间结果，协议开销低；恶意模型要防主动篡改、证明每一步行为正确，开销陡增数倍到数十倍。实际部署中，机构间有合同约束的场景常选择半诚实 + 事后审计，把性能预算用在该用的地方。

混搭的精髓，就是用便宜的锁锁普通抽屉、用保险柜守最贵重的数字。安全级别不是越高越好，而是恰好够用。

工程实践

故事来到最后一公里：路修得再好，车排班乱了也快不了。王阿姨给跑腿小组配了对讲机、排了双班，把“等跑完才出发”改成“边跑边发下一单”。真正的性能差距，往往就藏在这些排班细节里。

工程实践是让协议在真实网络上跑快的落地技能，包括四个层次：网络适配——为高 RTT 场景压缩交互频率，为高带宽场景优化单轮消息量；并发架构——连接池复用 TCP 连接，双通道收发避免队头阻塞，多线程并行处理多路消息；延迟隐藏——本地计算的同时发起网络请求，让 CPU 与网络互不空等；参数调优——批大小、流水线深度、线程数、重传阈值，都需要按实际网络压测后确定。

生产级框架（如 EMP-Toolkit、SPDZ 等）把这些能力封装成开关，但理解底层原理才懂得怎么拨开关。一个典型的在线阶段，若通信与计算能完全重叠，等待时间就从“两者之和”降为“两者取大”。

方案再漂亮，也要靠这些排班细节落地。王阿姨的快递柜统计终于在一个上午内顺利出数——性能优化的终点，永远是工程系统里的每一毫秒。

AI 应用场景

Python 演示

# -*- coding: utf-8 -*-"""安全多方计算性能优化演示: Beaver三元组预处理 + 批量乘法对比"""import randomimport time  def secret_share(value, parties=2):    """把一个数字拆成 parties 份随机碎片, 求和还原原值."""    shares = [random.randint(-1000, 1000) for _ in range(parties)]    shares[-1] = value - sum(shares[:-1])    return shares  def reconstruct(shares):    """恢复秘密: 求所有碎片之和."""    return sum(shares)  class BeaverTriple:    """预生成三元组 (a, b, c), 满足 c = a * b."""     def __init__(self):        self.a = random.randint(-1000, 1000)        self.b = random.randint(-1000, 1000)        self.c = self.a * self.b  def mpc_multiply(x, y, triple):    """利用三元组完成秘密分享乘法: 在线只需交换两个掩码差值."""    e = x - triple.a          # 打开掩码差值, 不泄露 x    d = y - triple.b          # 打开掩码差值, 不泄露 y    return triple.c + e * triple.b + d * triple.a + e * d  def run_demo():    n = 20000    xs = [random.randint(1, 100) for _ in range(n)]    ys = [random.randint(1, 100) for _ in range(n)]     # 离线阶段: 批量生产三元组, 重活都在这    t0 = time.perf_counter()    triples = [BeaverTriple() for _ in range(n)]    offline_cost = time.perf_counter() - t0     # 在线阶段: 套用速算表, 只做轻量加减乘    t0 = time.perf_counter()    results = [mpc_multiply(x, y, t) for x, y, t in zip(xs, ys, triples)]    online_cost = time.perf_counter() - t0     plain = [a * b for a, b in zip(xs, ys)]    ok = all(abs(r - p) < 1e-6 for r, p in zip(results, plain))    print("批量乘法个数: %d" % n)    print("离线预处理耗时: %.4f 秒" % offline_cost)    print("在线计算耗时: %.4f 秒" % online_cost)    print("在线/离线耗时比: %.2f" % (online_cost / offline_cost))    print("结果验证通过: %s" % ok)  if __name__ == "__main__":    run_demo()

1. shares[-1] = value - sum(shares[:-1])最后一片补齐差值，保证所有碎片相加恰好还原原值，这是秘密分享的“撕纸条”核心。
2. triples = [BeaverTriple() for _ in range(n)]离线批量生产 n 个“速算表”（三元组），属于预处理阶段的重活。
3. e = x - triple.a` / `d = y - triple.b在线阶段只打开掩码差值，a 与 b 是随机数，所以不会泄露 x 与 y。
4. return triple.c + e * triple.b + d * triple.a + e * d本地重组乘积，全程无交互式乘法，这是 Beaver 预处理的加速精髓。
5. online_cost = time.perf_counter() - t0单独统计在线阶段耗时，对比离线耗时即可看到“重活前置”的效果。

常见误区

面试题