想象你在组织一场寻宝活动。你不想让任何一个队员独吞宝藏，于是把绘制着完整路线的藏宝图剪成不计其数的碎片，分给所有队员。单独看任何一片，都只是毫无意义的纸角；但只要凑够足够的碎片，完整的路线就会神奇地浮现。更妙的是，探险途中需要不断合并路线——计算“两段路线的平均长度”，或者“某条岔路的交叉位置”——而这些计算可以在碎片层面直接完成，不需要任何人把地图拼给对方看。这就是安全多方计算（MPC）的核心梦想：即使大家不交换秘密，也能一起算出秘密的函数结果。BGW协议正是实现这个梦想的第一个通用方案。它由 Ben-Or、Goldwasser 和 Wigderson 于 1988 年提出，用一次多项式“剪地图”、用门限机制控制“拼图人数”、用安全加法和安全乘法完成“碎片上的运算”，并区分了两类破坏者：粗心记错的队友和蓄意撒谎的队友。读完这篇文章，你会理解这整套拼图游戏的设计逻辑，以及它是如何支撑起今天联邦学习与隐私计算的天空。

岗位关联

对AI从业者而言，BGW协议是理解隐私计算与联邦学习安全聚合的数学地基——掌握它，你就能看懂主流隐私保护系统的设计取舍。

目录
  1. 可视化演示
  2. 秘密分享：把藏宝图拆成碎片
  3. 门限方案：几块碎片能拼出地图
  4. 安全加法：各自标注，不用商量
  5. 安全乘法：必须交换一次情报
  6. 安全模型：有人记错，还是有人撒谎
  7. 隐私计算应用：现实世界的藏宝图
  8. AI 应用场景
  9. Python 演示
  10. 常见误区
  11. 面试题

可视化演示

动态演示BGW协议的核心机制，通过源头/管道/节点/终端四种模式展示关键概念与交互流程。

本节配有交互动效（进入视口后自动加载，约 3KB）。

BGW协议：BGW协 BGW协议的设计目标与安全多方 Shamir秘密分享与门限方案 核心机制可视化 BGW协议整体架构与关键组件

秘密分享：把藏宝图拆成碎片

藏宝队长不想让任何一个队员独吞宝藏，便把画着路线的藏宝图剪成许多不规则的碎片分给队员。任何一片单独看都是毫无意义的纸角，可当碎片凑到一定数量，路线就会完整浮现。BGW协议的第一步——秘密分享——就是“剪地图”这个动作，只是它剪的是数学而非纸张。

Shamir秘密分享用一条t次多项式承载秘密。秘密s放在常数项，其余t个系数在有限域中随机选取。每位参与者 i 拿到一个点 (x_i, y_i=f(x_i)) 作为“碎片”。因为t次多项式需要t+1个点才能唯一确定，任意t个点凑在一起也无法获得关于s的任何信息——这正是“碎片单独无意义”的数学保证。

队长分发下去的不是地图本身，而是一串串被拆散的点；只有足够多的点才能重新勾画出那条通往宝藏的隐形路线。这个初始动作，成就了整个BGW协议的基础。

f(x)=s+a1x+a2x2+⋯+atxt\displaystyle f(x) = s + a_1 x + a_2 x^2 + \cdots + a_t x^t
这条多项式就是那条“隐形路线”：常数项是宝藏位置，其余系数则是路线中随机起伏的弯道，把真正的方向层层掩盖。
  1. 多项式定义选定一个次数为 t 的多项式作为秘密的载体，t 越大，路线越曲折、越难被猜出。
    f(x)=s+a1x+a2x2+⋯+atxt\displaystyle f(x) = s + a_1 x + a_2 x^2 + \cdots + a_t x^t
  2. 常数项陷阱把秘密 s 存放在 f(0)，即多项式与 y 轴的交点处；任何人想直接从碎片看出 s 都不可能。
    s=f(0)\displaystyle s = f(0)
  3. 随机系数a₁ 到 a_t 从有限域中均匀随机抽取。它们的作用是“搅浑水”，让少量碎片暴露不出任何结构。
    a1,…,at←RFp\displaystyle a_1,\dots,a_t \xleftarrow{R} \mathbb{F}_p
  4. 份额分发每位参与者拿到自己的横坐标 x_i 和对应的纵坐标 y_i=f(x_i)，这组成他的“地图碎片”。
    yi=f(xi)\displaystyle y_i = f(x_i)

门限方案：几块碎片能拼出地图

探险队内部有条铁律：要查看完整路线，必须至少 t+1 名队员同时把碎片摆在桌上。少于这个数，谁也说不清路线怎么走。这就是“门限”——协作的启动条件：人不够，地图永远是谜。

t次多项式会被t+1个点唯一锁定，重构用拉格朗日插值：任选 t+1 个份额点，构造“只在某个点取1、在其余点取0”的基多项式，再将各点的纵坐标 y_i 加权求和，便得到 f(0)=s。门限t直接决定隐私强度：t 越小，凑齐碎片越容易，安全余量也越少；t 越大，抗勾结能力越强，但重构门槛也随之升高。

门限像拼图桌上的“凑齐人数”规则：人数不够时地图永远是谜，够数时路线立刻现身。这把“安全”从口号变成可调的参数——想要多安全，就把门限设多高。

s=∑i∈Syi∏j∈S, j≠i−xjxi−xj\displaystyle s = \sum_{i \in S} y_i \prod_{j \in S,\, j \neq i} \frac{-x_j}{x_i - x_j}
公式把“至少几个人拼图”翻译成数学语言：选出一个 t+1 人的子集 S，用每个碎片的纵坐标乘以一个权重，加权和就是秘密。
  1. 取点集合从所有参与方中任选一个大小为 t+1 的子集 S，只有这个规模才能定住 t 次多项式。
    S={i1,i2,…,it+1}\displaystyle S = \{i_1, i_2, \dots, i_{t+1}\}
  2. 构造基多项式对每个 i，构造一个在 x_i 处取 1、在其余选中点取 0 的辅助多项式，它像“标签”一样标识出哪个碎片在说话。
    ℓi(x)=∏j∈S,j≠ix−xjxi−xj\displaystyle \ell_i(x) = \prod_{j \in S, j \neq i} \frac{x - x_j}{x_i - x_j}
  3. 代入零点因为我们要恢复的是 s=f(0)，所以把 x=0 代入基多项式，得到每个碎片对应的权重。
    ℓi(0)=∏j∈S,j≠i−xjxi−xj\displaystyle \ell_i(0) = \prod_{j \in S, j \neq i} \frac{-x_j}{x_i - x_j}
  4. 加权求和秘密 s 是各纵坐标 y_i 关于这些权重的线性组合，插值的本质就是“按权重拼图”。
    s=∑i∈Syi ℓi(0)\displaystyle s = \sum_{i \in S} y_i \,\ell_i(0)

安全加法：各自标注，不用商量

两支小队各持一张路线的碎片。队长想知道两条路线的“平均走向”，按直觉似乎必须把碎片交换一遍才能合并。BGW告诉大家：每个人在自己的碎片上做加法就行，根本不需要和对面交换任何一张碎片。

若 [a] 和 [b] 分别是两个秘密的 t 次多项式分享，那么每个参与方直接计算 y_i + z_i，得到的 n 个新点合起来恰好是 a+b 的共享。原因很简单：两个 t 次多项式相加仍是 t 次多项式，依然只需 t+1 个份额就能重构。这就是加法同态——共享域上的加法等于秘密域上的加法，安全且零通信。

加法揭示了BGW的优雅一面：有些运算在碎片世界里可以零成本完成，如同两堆碎片各自对位拼接，不需要把任何原始碎片递到别人手里。这也是联邦学习中梯度聚合能大规模落地的关键原因。

[a+b]i=[a]i+[b]i=yi+zi(modp)\displaystyle [a+b]_i = [a]_i + [b]_i = y_i + z_i \pmod{p}
直观理解：两堆碎片各自按“相同的位置编号”对位相加，拼出来的总路线天然正确，全程不需要把原片递给任何人。
  1. 同点相加每个参与方在相同的横坐标上，将自己的纵坐标与他人份额的纵坐标相加，得到新份额。
    yi+zi\displaystyle y_i + z_i
  2. 度不变两个 t 次多项式之和的次数不超过 t，门限结构原样保留，无需重新设置门限。
    deg⁡(f+g)≤t\displaystyle \deg(f+g) \le t
  3. 零通信整个加法过程由各方本地完成，没有一条消息在网络上传输，这就是“安全加法”的免费午餐。
    [a+b]=[a]+[b]\displaystyle [a+b] = [a] + [b]

安全乘法：必须交换一次情报

加法可以不交换碎片，乘法却绕不开一次“情报交换”——就像合路时两队的碎片必须交叉叠加一次，但叠加后要用一层“随机噪点”重新涂抹，让别人看不出底料。这就是BGW协议中最精巧的设计。

份额相乘后 c_i = y_i·z_i，对应多项式的次数从 t 翻倍到 2t。此时需要 2t+1 个份额才能重构，门限被破坏，协议的安全参数失效。为此，每个参与方把 c_i 当作一个新的秘密，用一个全新的 t 次随机多项式重新分享（reshare）；再让所有参与方收集这些子份额并重构，最终得到秘密 c 的合法 t 次分享。这个过程俗称“降次修复”。

乘法中的交互是BGW无法完全“免费”的部分，但正是这次刻意设计的“交叉 + 重涂”，让乘法既正确又安全。理解这一点，就理解了为什么安全多方计算系统总是把通信开销当作核心成本。

ci=yi⋅zi,[c]=Reshare(c1,c2,…,cn)\displaystyle c_i = y_i \cdot z_i, \qquad [c] = \text{Reshare}(c_1, c_2, \dots, c_n)
乘法好比一次“交叉叠纸”：碎片必须相互碰面，但碰面后会立刻被随机切割重新封装，叠痕里不会留下任何一方原料的气息。
  1. 本地相乘每个参与方把自己的两个份额纵坐标相乘，得到 c_i，这是乘法的“粗坯”。
    ci=yi⋅zi\displaystyle c_i = y_i \cdot z_i
  2. 度翻倍乘积多项式的次数变成 2t，原有的 t 门限不再够用，这就是乘法比加法难的根本原因。
    deg⁡(f⋅g)=2t\displaystyle \deg(f \cdot g) = 2t
  3. 随机重分享每个参与方把 c_i 作为新秘密，构造新的 t 次随机多项式，再把子份额分发给所有人。
    hi(x)=ci+r1x+r2x2+⋯+rtxt\displaystyle h_i(x) = c_i + r_1 x + r_2 x^2 + \cdots + r_t x^t
  4. 收集与重构各方收集足够子份额后，恢复出 c 的 t 次分享，从而重新获得合法的门限结构。
    [c]=Recover{hi(xj)}\displaystyle [c] = \text{Recover}\{h_i(x_j)\}

安全模型：有人记错，还是有人撒谎

拼图途中最怕两类队友：一类只是粗心，记错自己碎片上的坐标（被动攻击者）；另一类存心搞破坏，故意给出错误的碎片（主动攻击者）。BGW协议对两类情况的防备能力完全不同，这是选型时必须读懂的安全刻度。

被动（半诚实）安全假设敌手只偷看、不篡改，协议在 t < n/2 时安全，即敌手不能控制超过一半的参与方。主动（恶意）安全假设敌手可任意伪造份额、中途离场或发送错误消息，此时要求 t < n/3，并配合一致性校验（如多项式承诺、随机验证）识别谎报者。BGW的经典之处，正是在统一框架下同时给出了两套安全边界。

粗心的队友好防，撒谎的队友难防，这是所有“拼图游戏”的通则。设计隐私计算系统时，先想清楚对手是“看了一眼”还是“存心使坏”，再决定采用哪条边界——这比堆砌密码算法更关键。

n≥2t+1(被动),n≥3t+1(主动)\displaystyle n \ge 2t+1 \quad(\text{被动}), \qquad n \ge 3t+1 \quad(\text{主动})
直觉类比：要纠出“记错的粗心队友”，过半诚实即可；要揭穿“故意撒谎的坏人”，必须凑足三分之二的诚实者才能投票压制。
  1. 被动界半诚实模型下，只要敌手控制的参与方少于一半，秘密的随机性就无法被窥破。
    t<n2\displaystyle t < \frac{n}{2}
  2. 主动界恶意模型下，敌手可以主动破坏协议，需要更多冗余才能校验并纠错，因此门限收紧到三分之一。
    t<n3\displaystyle t < \frac{n}{3}
  3. 安全含义主动安全需要接近三倍的诚实参与方支撑，这也是实际系统为抵御恶意攻击付出的“人数代价”。

隐私计算应用：现实世界的藏宝图

把探险队换成今天的数据机构：医院、银行、电商，各自握着用户的“藏宝图”（病案、账单、消费记录），它们都想联合统计，却绝不愿向对方交出地图。BGW协议正是解决这个矛盾的数学桥梁，也是隐私计算的重要底座。

联邦学习中，各参与方将本地梯度按Shamir分享，用BGW安全加法聚合出全局梯度，推送到各端；联合统计中，各机构分享统计量后做安全加法与乘法，得到汇总结果而不暴露原始数据；数据交易所中，数据以份额形式参与计算，买方只能拿到计算结果，拿不到原始数据。BGW的代价是通信量随参与方数量上升，因此实用系统常把它与同态加密、可信执行环境结合以优化性能。

从探险队到数据孤岛，BGW把“拼图”的智慧带进了现实——大家想求解，但不必交出地图。这正是隐私计算在医疗、金融、政务领域落地时最核心的承诺。

Yˉ=1N∑i=1N[yi],重构得到全局均值\displaystyle \bar{Y} = \frac{1}{N}\sum_{i=1}^{N} [y_i], \qquad \text{重构得到全局均值}
把公式翻译成大白话：每家机构交出自己的“加密碎片”，大家把碎片相加，再除以机构数——最终只露出平均值，谁也没看到别人的明细。
  1. 秘密投票每个参与方把本地数据 y_i 用 Shamir 秘密分享拆成碎片发给其他方。
    yi↦[yi]=(x1,yi1),(x2,yi2),…\displaystyle y_i \mapsto [y_i] = (x_1,y_{i1}), (x_2,y_{i2}), \dots
  2. 安全求和每个参与方对收到的所有碎片做本地加法，得到总和的一份合法份额。
    [Y]=∑i=1N[yi]\displaystyle [Y] = \sum_{i=1}^{N} [y_i]
  3. 公开平均任选 t+1 个份额重构出总值，再除以机构数 N，得到全局均值，整个过程无人接触原始数据。
    Yˉ=YN\displaystyle \bar{Y} = \frac{Y}{N}

AI 应用场景

场景一：跨机构联邦统计（医疗联合队列分析）

阶段：数据准备与特征工程

解决的问题：多家医院想统计“某种药物的不良反应率”，传统做法需要把电子病历集中到一方，既违反数据合规又泄露患者隐私。AI 接入 BGW 协议后，每家医院把统计指标做秘密分享，用安全加法汇总得到全局统计量，全程不离开各自数据域。

具体案例：某城市 5 家三甲医院联合建立罕见病队列，使用 BGW 协议的 Shamir 分享模块对患者年龄、用药频次做安全聚合，最终得到平均年龄与用药分布。任何一家医院都无法反推其他医院的单条记录，但统计结论对所有参与方透明。

场景二：联邦学习中的梯度安全聚合

阶段：模型训练与聚合

解决的问题：联邦学习需要把各参与方的梯度汇总到中心服务器，传统方案中服务器可窥见梯度，反向推断训练数据。AI 系统引入 BGW 的安全加法后，每个客户端将梯度做秘密分享，服务器只能获得聚合结果而无法获取任何单方梯度。

具体案例：某金融机构与 3 家电商联合训练反欺诈模型，客户端将梯度分为若干份额上传，经 BGW 乘法与加法完成聚合。实验表明，聚合精度与明文聚合几乎一致，而梯度泄露风险被显著降低。

Python 演示

python56 行
import random P = 101  # 素数模 class SecretSharing:    def __init__(self, secret, degree, prime=P):        self.secret = secret % prime        self.degree = degree        self.prime = prime        self.coeffs = [self.secret] + [random.randrange(prime) for _ in range(degree)]     def share(self, x):        y = 0        for c in reversed(self.coeffs):            y = (y * x + c) % self.prime        return (x, y)     @staticmethod    def lagrange_zero(shares, prime=P):        s = 0        for i, (xi, yi) in enumerate(shares):            num = 1            den = 1            for j, (xj, _) in enumerate(shares):                if i == j:                    continue                num = (num * (-xj)) % prime                den = (den * (xi - xj)) % prime            s = (s + yi * num * pow(den, -1, prime)) % prime        return s  def add_shares(share_a, share_b, prime=P):    return (share_a[0], (share_a[1] + share_b[1]) % prime)  def mul_shares(share_a, share_b, prime=P):    return (share_a[0], (share_a[1] * share_b[1]) % prime)  if __name__ == "__main__":    print("== BGW 协议演示 ==")    a_ss = SecretSharing(secret=7, degree=2)    b_ss = SecretSharing(secret=9, degree=2)    xs = [1, 2, 3, 4, 5]    shares_a = [a_ss.share(x) for x in xs]    shares_b = [b_ss.share(x) for x in xs]     print("用前3个份额重构 a:", SecretSharing.lagrange_zero(shares_a[:3]))    print("用前3个份额重构 b:", SecretSharing.lagrange_zero(shares_b[:3]))     add_local = [add_shares(shares_a[i], shares_b[i]) for i in range(len(xs))]    print("安全加法 a+b =", SecretSharing.lagrange_zero(add_local[:3]))     mul_local = [mul_shares(shares_a[i], shares_b[i]) for i in range(len(xs))]    print("本地乘法后度变为4，需全部5个份额重构 a*b =", SecretSharing.lagrange_zero(mul_local))
目的：演示 BGW 的两大支柱——Shamir 秘密分享（重构门限）与安全加法/乘法在有限域上的行为。
  1. SecretSharing(secret=7, degree=2)用二次多项式包装秘密7，对应“藏宝图碎片”的生成。
  2. self.coeffs = [self.secret] + [random.randrange(prime) for _ in range(degree)]常数项放秘密，其余系数随机，这是“常数项陷阱”的实现。
  3. for c in reversed(self.coeffs): y = (y * x + c) % self.prime霍纳法则求 f(x)，算出一个坐标点即一片碎片。
  4. lagrange_zero(shares[:3])用前3个份额（t+1）重构秘密，验证门限机制的数学保证。
  5. pow(den, -1, prime)计算分母在有限域上的模逆元，这是拉格朗日插值在素数域中的“除法”。
  6. add_shares(...)份额相加实现安全加法，本地完成、零通信，程序里没有任何网络调用。
  7. mul_shares(...)本地相乘后次数翻倍为 4，所以需要5个份额才能重构，呼应“度翻倍问题”。

常见误区

误区很多人以为 Shamir 秘密分享就是 BGW 协议，学会拆份额和重构就等于掌握了安全多方计算。实际编码中也只写了 share 和 reconstruct，没有处理计算。

正解秘密分享只是“藏宝图的剪裁与拼接”，BGW 的完整价值在于“在碎片上做计算”——安全加法和安全乘法才让多方协作成为可能。乘法需要重分享和交互，远比分享本身复杂；只懂份额分发，做不了联邦学习聚合。

为何常见：秘密分享是最直观、最容易被可视化的环节，教程常常只演示拆与拼，导致学习者误以为重构即终点，忽略了协议真正困难的计算部分。

误区直觉上节点越多越安全，于是有些人认为只要参与者数量足够大，BGW 就自动安全，不需要调整门限参数。

正解安全性由门限 t 与安全模型共同决定。被动安全要求 t<n/2，主动安全要求 t<n/3；参与者变多只是扩大了 n，如果不相应限制 t，敌手控制的参与者数量也可能同步增加。BGW 的安全是“相对比例的保证”，不是“绝对人数的堆积”。

为何常见：人们习惯用人数衡量防御强度，但密码协议关心的是敌手最多能控制多少比例，就像拼图防作弊关键在“最低拼图人数”，而不是在场总人数。

误区初学者常把“被动安全”理解成没有攻击者，把“主动安全”理解成有攻击者，从而误判协议防护能力。

正解两种模型都假设存在攻击者，区别在于攻击者的行为边界。被动（半诚实）攻击者只偷看所有消息但遵守协议；主动（恶意）攻击者可以篡改消息、伪造份额、中途退出。因此主动安全需要更强的冗余（t<n/3）和一致性校验，这是质的区别。

为何常见：“被动”“主动”字面容易让人联想“是否发生攻击”，而忽略它们描述的是敌手的能力模型，而非攻击是否真实存在。

误区看到 BGW 的安全加法可以本地完成，有人推断乘法也可以本地相乘直接得到合法分享，不需要任何交互。

正解乘法的难点在于份额相乘后多项式次数从 t 翻倍到 2t，门限结构被破坏。必须经过一轮“随机重分享”把结果降回 t 次，这需要参与者之间交换子份额。BGW 中加法零通信、乘法必交互，是协议设计的核心特征。

为何常见：加法零通信的优雅容易形成思维定式，让人误以为所有运算都免费；实际上面向计算的安全协议，通信成本主要就花在乘法上。

面试题

Q1. Shamir 秘密分享中，秘密 s 藏在多项式的哪个位置？

单选题 · easy

  • A.常数项之中← 正确答案
  • B.一次项系数里
  • C.最高次项系数里
  • D.全部系数的平均值

答案：A。秘密 s 被放在 f(0)，即常数项。一次项、最高次项甚至所有系数平均都不等于 f(0)。这就像藏宝图的“终点坐标”被藏在地图与纵轴的交点处，其他系数只是随机弯路。

Q2. 一个 t 次多项式至少需要几个点才能被唯一确定？

单选题 · easy

  • A.t 个点
  • B.t+1 个点← 正确答案
  • C.2t 个点
  • D.2t+1 个点

答案：B。t 次多项式有 t+1 个系数，需要 t+1 个方程才能解出全部未知数。t 个点存在无穷多条候选曲线，正如两片碎片无法唯一拼出地图，只有达到 t+1 才够。

Q3. BGW 协议中安全加法的主要优点是？

单选题 · easy

  • A.参与方零通信开销← 正确答案
  • B.需要广播份额给所有人
  • C.必须由可信第三方执行
  • D.只适用于单比特数据

答案：A。每个参与方在本地把两份份额相加即可，不需要任何网络通信。广播、可信第三方都不必要，BGW 加法也支持任意有限域元素，不只单比特，因此 B 和 D 错误。

Q4. 在主动（恶意）安全模型下，BGW 协议要求门限满足？

单选题 · mid

  • A.t 小于 n 的二分之一
  • B.t 小于 n 的三分之一← 正确答案
  • C.t 小于 n 的四分之一
  • D.t 可以等于 n 的二分之一

答案：B。主动攻击者可伪造份额，需要更多冗余来校验，条件收紧为 n≥3t+1。n/2 是被动（半诚实）模型的边界，n/4 过严，等于 n/2 在主动模型下不安全。

Q5. BGW 安全乘法中，份额相乘后多项式的次数如何变化？

单选题 · mid

  • A.保持不变仍是 t 次
  • B.直接降为 t 次
  • C.翻倍为 2t 次← 正确答案
  • D.取决于秘密取值

答案：C。两个 t 次多项式相乘得到 2t 次多项式，因此需要 2t+1 个份额才能重构，门限被破坏。BGW 正是通过随机重分享把次数降回 t，恢复原门限结构。

Q6. 关于 BGW 协议的正确描述有？

多选题 · mid

  • A.基于 Shamir 秘密分享← 正确答案
  • B.安全乘法需要交互重分享← 正确答案
  • C.安全加法也需要交互通信
  • D.可同时分析被动与主动安全← 正确答案

答案：ABD。BGW 以 Shamir 分享为地基，乘法必须重分享交互，而加法是零通信的，因此 C 错误。BGW 的经典贡献之一就是在统一框架下同时给出被动（t<n/2）与主动（t<n/3）两套安全边界。

Q7. BGW 协议中重构秘密使用的数学工具是？

单选题 · mid

  • A.拉格朗日插值法← 正确答案
  • B.欧拉降幂定理
  • C.离散傅里叶变换
  • D.线性规划求解

答案：A。拉格朗日插值通过构造基多项式，对 t+1 个点加权求和得到 f(0)=s。欧拉定理用于幂运算，傅里叶变换与秘密重构无关，线性规划也不解决插值问题。

Q8. 关于 BGW 被动安全模型 t<n/2 的含义，正确的有？

多选题 · hard

  • A.敌手控制的参与方少于半数← 正确答案
  • B.少于 t 个份额泄露不暴露秘密← 正确答案
  • C.能容忍任意错误结果输出
  • D.多项式次数固定为 t← 正确答案

答案：ABD。被动模型假设敌手只偷看不篡改，因此 C 的“容忍任意错误”属于主动安全范畴。B 是 Shamir 分享的信息论性质：t 个点确定不了 t 次多项式，故不泄露秘密。A、D 都是该模型的正确特征。

Q9. BGW 协议抵御主动攻击者时，除了门限收紧还需要增加什么机制？

单选题 · hard

  • A.各份额一致性校验广播← 正确答案
  • B.使用更大的素数模数
  • C.部署更多的参与节点
  • D.降低多项式的次数门限

答案：A。主动攻击者会伪造份额，必须通过一致性校验（如多项式承诺、随机验证）识别并剔除谎报者。加大素数不影响恶意行为，部署节点不改变比例，降低门限反而削弱安全性。

Q10. BGW 协议在隐私计算中的应用场景包括？

多选题 · extreme

  • A.联邦学习的梯度安全聚合← 正确答案
  • B.数据交易中的联合统计← 正确答案
  • C.加速 GPU 并行推理运算
  • D.保护参与方的梯度隐私性← 正确答案

答案：ABD。BGW 的加法天然适合梯度聚合，秘密分享适合联合统计，份额化计算能保护梯度隐私。它是安全计算协议而非加速硬件运算的技术，因此 C 错误。