Secure Multi-party Computation安全多方计算

原创于 2025-11-21 13:38:42 发布 · 404 阅读

10 ·

CC 4.0 BY-SA版权

文章标签：

#安全多方计算 #MPC #秘密共享

AI助手已提取文章相关产品：

Secure Multi-party Computation 安全多方计算：原理、关键技术与应用场景深度解析

在数据成为“新石油”的今天，谁掌握了高质量的数据，谁就拥有了智能时代的入场券。但问题来了——我们真的能随意使用这些数据吗？🏥🏦📊
医院想用患者数据训练疾病预测模型，银行想联合识别跨机构欺诈行为，广告平台想分析用户转化路径……可每一条数据背后，都是隐私红线和合规雷区。

于是，一个看似矛盾的需求浮现出来： 既要算，又不能看 。
怎么在不看到对方数据的前提下，还能一起把结果算出来？

这正是 安全多方计算（Secure Multi-party Computation, MPC） 的使命。它不是魔法，却比魔法更神奇——让多个互不信任的参与方，在“闭着眼”的情况下，共同完成一次精准的协同计算。🎯

想象这样一个场景：两位富豪想比谁更有钱，但都不愿透露自己的资产数额。传统做法是找一个可信中介来统计，但如果这个中介泄密呢？MPC 的答案是： 根本不需要中介 。他们可以通过一套加密协议，只告诉彼此“谁更多”，而其余信息一概不知。这就是所谓的“ 数据可用不可见 ”。

这种能力听起来像科幻，但它早已落地。从跨境反洗钱到多中心医疗研究，从隐私广告归因到区块链上的秘密投票，MPC 正悄悄构建起下一代数据协作的信任基石。

那么，它是如何做到的？核心在于三种“密码学积木”： 秘密共享、混淆电路、不经意传输 。它们就像乐高块，可以拼出任意复杂的隐私保护计算逻辑。

先来看看最基础也最优雅的一块积木—— 秘密共享（Secret Sharing） 。它的思想简单却深刻：把一个秘密拆成几份，单份毫无意义，集齐足够份数才能还原。最常见的形式是 Shamir 的门限方案（Threshold Scheme），基于多项式插值实现。

举个例子，你想把数字 12345 分给 5 个人，规定至少 3 人合作才能恢复原数。怎么做？你构造一个二次多项式 $ f(x) $，让它满足 $ f(0) = 12345 $，然后分别告诉每个人 $ f(1), f(2), …, f(5) $。由于低于三个点无法唯一确定一条抛物线，哪怕有人拿到两个份额，也看不出任何端倪。而一旦三人聚首，通过拉格朗日插值就能轻松还原 $ f(0) $。

更妙的是，这种共享还支持“同态性”——你可以对碎片直接做加法！比如 A 持有 $[a_1]$，B 持有 $[a_2]$，他们各自本地相加就能得到 $[a_1+a_2]$，无需暴露原始值。乘法则稍微复杂些，需要借助预生成的 Beaver 三元组来保持安全性。

下面是个 Python 小实验，演示了 Shamir SSS 的基本流程：

from typing import List, Tuple
import random

_PRIME = 2**19 - 1  # 小素数用于演示

def share_secret(secret: int, n: int, t: int) -> List[Tuple[int, int]]:
    """生成n个份额，其中t+1个可重构"""
    coeffs = [secret] + [random.randint(0, _PRIME) for _ in range(t)]
    def eval_poly(x):
        y = 0
        for coeff in reversed(coeffs):
            y = (y * x + coeff) % _PRIME
        return y
    return [(i, eval_poly(i)) for i in range(1, n+1)]

def reconstruct(shares: List[Tuple[int, int]], t: int) -> int:
    """使用拉格朗日插值重构秘密"""
    total = 0
    for i, (xi, yi) in enumerate(shares[:t+1]):
        numerator, denominator = 1, 1
        for j, (xj, _) in enumerate(shares[:t+1]):
            if i != j:
                numerator = (numerator * (0 - xj)) % _PRIME
                denominator = (denominator * (xi - xj)) % _PRIME
        lagr_coeff = (numerator * pow(denominator, -1, _PRIME)) % _PRIME
        total = (total + yi * lagr_coeff) % _PRIME
    return total

# 示例使用
secret = 12345
shares = share_secret(secret, n=5, t=2)
recovered = reconstruct(shares[:3], t=2)
print(f"原始秘密: {secret}, 重构结果: {recovered}")  # 输出一致 ✅

当然，真实系统不会用这么小的素数，也不会自己造轮子。生产级应用通常依赖经过审计的库如 py-secretsharing 或集成进 SPDZ、ABY 等框架中。

如果说秘密共享是“数学之美”，那 混淆电路（Garbled Circuit, GC） 就更像一场精密的密码魔术。它由图灵奖得主 Yao 提出，专为两方安全计算设计。其核心思想是：把整个计算过程变成一张布满加密“黑箱”的电路图，每一扇门都被打乱并加密，只有持有正确“钥匙”的人才能一步步解开。

整个流程大概是这样：
1. 一方（生成者）将目标函数编译成布尔电路（AND/XOR门组成）；
2. 给每个输入位分配两个随机标签（代表0和1）；
3. 对每个逻辑门生成“混淆表”——本质上是对真值表的双重加密；
4. 另一方（求值者）通过不经意传输（OT）获取对应自己输入的标签；
5. 然后像解谜一样逐层解密，最终得到输出标签，并映射回明文结果。

最关键的是，求值者在整个过程中只能看到与自己路径相关的加密条目，根本无法反推出对方的输入或电路结构本身。整个过程如同在一个漆黑的迷宫中行走，你只知道下一步怎么走，但从不知道地图长什么样。🧩

虽然 GC 非常适合两方低延迟场景（比如安全比较、决策树推理），但它有个明显短板：通信开销随电路规模线性增长，且每个电路只能用一次。因此，对于大规模数值计算并不高效。

为了提升性能，工程实践中常采用混合策略——线性部分用算术共享快速处理，非线性部分（如比较、激活函数）切到 GC 执行。ABY 框架就是这一思路的典范。

来看一段 ABY 的 C++ 示例，实现两方安全比较 $ a > b ? $：

#include "abycore/aby/abyparty.h"
#include "abycore/circuit/arithmetic_circuit.h"

int main() {
    e_role role = SERVER; // SERVER or CLIENT
    uint32_t bitlen = 32;
    seclvl seclvl_param = SL_128;

    // 初始化MPC参与方
    ABYParty* party = new ABYParty(role, "127.0.0.1", 7766, seclvl_param, bitlen, S_ARITH);

    // 定义共享变量 a 和 b
    share* s_a = party->GetCircuit(ARITHMETIC_CIRCUIT)->PutSharedINGate(bitlen, 0);
    share* s_b = party->GetCircuit(ARITHMETIC_CIRCUIT)->PutSharedINGate(bitlen, 0);

    // 执行安全比较 a > b ?
    share* result = party->GetCircuit(ARITHMETIC_CIRCUIT)->PutGTGate(s_a, s_b);

    // 输出结果并重建
    uint32_t out = 0;
    party->GetCircuit(ARITHMETIC_CIRCUIT)->PutOUTGate(result, ALL);
    party->ExecCircuit();

    // 获取解密后的比较结果
    party->GetCircuit(ARITHMETIC_CIRCUIT)->GetSharedOUTVector(&out, 1);

    std::cout << "Is a > b? " << (out ? "Yes" : "No") << std::endl;

    delete party;
    return 0;
}

这段代码简洁地展示了 MPC 的典型模式：输入通过 PutSharedINGate 被秘密分割，计算在加密状态下进行，最后调用 ExecCircuit() 触发通信与协同运算。整个过程无需第三方介入，安全性建立在密码学假设之上。

⚠️ 注意：真实部署时应启用恶意安全模式，并结合 TLS 通道防止中间人攻击。

实际系统的架构往往更为复杂。典型的 MPC 架构包含五个层次：

graph TD
    A[参与方A] --> B[MPC Runtime Engine]
    B --> C[通信网络]
    C --> D[MPC Runtime Engine]
    D --> E[参与方B]

    subgraph 数据层
        A_Data[本地原始数据]
    end

    subgraph 协议层
        OT[不经意传输]
        SS[秘密共享]
        GC[混淆电路]
        BT[Beaver三元组]
    end

    subgraph 电路层
        Circuit[布尔/算术电路]
    end

    subgraph 通信层
        Net[TCP/gRPC + 批处理]
    end

    subgraph 应用接口层
        API[SQL-like 查询语言 / SDK]
    end

    A_Data --> B
    B --> OT & SS & GC & BT
    OT & SS & GC & BT --> Circuit
    Circuit --> Net
    Net --> API

各层协同工作，将高层业务逻辑转化为底层安全协议执行。例如，在联合征信评分场景中，两家银行希望比较客户信用分但不泄露具体数值。流程如下：