隐私计算 2.9 秘密共享应用于横向联邦学习

1 简介

1.1 横向联邦学习

横向联邦学习也称为按样本划分的联邦学习，主要应用于各个参与方的数据集有相同的特征空间和不同的样本空间的场景，例如两个地区的城市商业银行可能在各自的地区拥有非常不同的客户群体，所以他们的客户交集非常小，并且数据集有不同的样本ID，然而他们的业务模型却非常相似，因此他们的数据集的特征空间是相同的。由此，这两家银行就可以联合起来进行横向联邦学习以构建更好的风控模型。

1.2 相关工作

谷歌联邦学习研发团队在ACM CCS 2017学术大会上提出的一种高效的安全聚合方法，利用秘密共享技术使服务器能够安全地聚合来自不同用户的梯度，同时单个用户的梯度不会被泄露。
Practical secure aggregation for privacy-preserving machine learning
源代码见：https://github.com/ammartahir24/SecureAggregation

2 Practical secure aggregation for privacy-preserving machine learning分析

2.1 论文的动机

机器学习模型通常会包含大量的神经网络参数，而在联邦学习的场景中，用户在本地训练好模型后，需要将这些参数上传至服务器进行聚合，但直接上传是存在隐私泄露的风险的，因此需要将所有参数进行加密再进行聚合。

我们知道加密解密的运算时间是不容忽视的，特别是在训练深度学习神经网络时，模型参数可能达到上千个甚至上万个，对这些模型参数加密并满足同态的性质是一个极具挑战的任务。

2.2 贡献

• （1）支持高维向量的加密；
• （2）即使每一轮有新的用户加入，该方案也能保持高效的通信；
• （3）能够应付用户掉线的情况；
• （4）在以服务器为中介的、未经身份验证的网络模型的约束下提供最强的安全性。

2.3 预备知识

将涉及到秘密共享、密钥协商、认证加密、伪随机数生成、数字签名、公钥基础设施等知识。

2.3.1 Key Agreement 密钥协商

核心为Diffie-Hellman密钥交换，两个用户可以协商一个共享密钥：

• $\mathrm{K}\mathrm{A}.\mathrm{p}\mathrm{a}\mathrm{r}\mathrm{a}\mathrm{m}(k)$：生成一些公共参数 $pp$。
• $\mathrm{K}\mathrm{A}.\mathrm{g}\mathrm{e}\mathrm{n}(pp)$ ：参与方 $u$ 根据 $pp$ 生成私-公密钥对 $\left(s_u^{SK},s_u^{PK}\right)$。
• $\mathrm{K}\mathrm{A}.\mathrm{a}\mathrm{g}\mathrm{r}\mathrm{e}\mathrm{e}\left(s_u^{SK},s_v^{PK}\right)$：用户使用自身的私钥 $s_u^{SK}$ 和所有其他用户 $v$ 的公钥 $s_v^{PK}$ 生成 $u$ 和 $v$ 之间的私有共享密钥 $s_{u,v}$ 。 在DH密钥协商中使用了哈希函数的密钥协商方案。

2.3.2 Secret Sharing 秘密共享

核心为shamir的$(t,n)$秘密分享方案，将要分享的秘密参数$s$通过多项式分成$n$份，只有满足至少$t$份份额才可解密得到$s$：

• $\mathrm{S}\mathrm{S}.\mathrm{s}\mathrm{h}\mathrm{a}\mathrm{r}\mathrm{e}(s,t,\mathcal{U})$：共享算法，输入为秘密 $s$ ，代表用户ID的 $n$ 个域元素的集合 $\mathcal{U}$ ，和一个阈值 $t\le |\mathcal{U}|$ ，输出为共享 $s_u$ 的集合，其中 $u\in \mathcal{U}$。
• $\mathrm{S}\mathrm{S}.\mathrm{r}\mathrm{e}\mathrm{c}\mathrm{o}\mathrm{n}\left({\left\{\left(u,s_u\right)\right\}}_{u\in \mathcal{V}},t\right)$：重构函数，输入为阈值 $t$ ，参与共享的用户子集 $\mathcal{V}\subseteq \mathcal{U}$ 且满足 $|\mathcal{V}|\ge t$ ，输出为域元素 $s$。

2.3.3 加密、哈希、签名

PRG可以理解为Hash，加密和签名为密码学基本工具。

• 加密：
  – $\mathrm{A}\mathrm{E}.\mathrm{e}\mathrm{n}\mathrm{c}$：认证加密的加密算法，输入为密钥key和消息message，输出为密文ciphertext。
  – $\mathrm{A}\mathrm{E}.\mathrm{d}\mathrm{e}\mathrm{c}$：认证加密的解密算法，输入为密文ciphertext和密钥key，输出为原始明文或者是错误一个符号。
• 哈希：
  – $\mathrm{PRG}(b)$：以 $b$ 为随机种子的伪随机数生成算法。
• 签名机制：
  – $\mathrm{S}\mathrm{I}\mathrm{G}.\mathrm{g}\mathrm{e}\mathrm{n}(k)$：以安全参数 $k$ 作为输入，输出为一个私钥 $d^{SK}$ 和一个公钥 $d^{PK}$ 。
  – $\mathrm{S}\mathrm{I}\mathrm{G}.\mathrm{s}\mathrm{i}\mathrm{g}\mathrm{n}\left(d^{SK},m\right)$：以私钥 $d^{SK}$ 和消息 $m$ 作为输入，输出为签名 $\sigma$ 。
  – $\mathrm{S}\mathrm{I}\mathrm{G}.\mathrm{v}\mathrm{e}\mathrm{r}\left(d^{PK},m,\sigma \right)$ ：输入为公钥 $d^{PK}$ ，消息 $m$ 和签名 $\sigma$ ，验证签名的合法性。

2.4 协议构造

该方案假设用户id有序，且以下算法是以单次聚合的角度进行讨论，但我们知道机器学习需要多次聚合才能收敛到阈值，因此以下讨论的步骤需要在每一次聚合时执行。

2.4.1 加密构思

加密的设计方案如下所示：
$${\mathbf{y}}_u={\mathbf{x}}_u+\sum _{v\in \mathcal{U}:u<v}{\mathbf{s}}_{u,v}-\sum _{v\in \mathcal{U}:u>v}{\mathbf{s}}_{v,u}(\mathrm{m}\mathrm{o}\mathrm{d}R)$$
其中$s_{u,v}$ 为用户 $u$ 通过与每一个其他用户进行$\mathrm{K}\mathrm{A}.\mathrm{a}\mathrm{g}\mathrm{r}\mathrm{e}\mathrm{e}(s_u^{SK},s_v^{PK})$ (Key Agreement)得到，若当前用户$u$的id大于$v$的id则加密时相加，否则相减。直观的可以得到，当所有用户上传参数后，这些加密 的参数自然而然能够抵消。
问题1： 这种方法显然存在问题，首先就是巨大的计算和通信开销，为了保证加密参数的随机性，这种 方法需要对每个模型参数都进行一次$\mathrm{KA}$协商，那么通信代价为 $\mathbf{O}\left({\mathbf{N}}^{\ast }\mathbf{d}\right)$ ，其中$\mathbf{N}$为用户总数， $\mathrm{d}$ 为向量 维度(模型参数总数)。
解决方案1： 论文中对加密方式进行了改造，如下所示:
$${\mathbf{y}}_u={\mathbf{x}}_u+\sum _{v\in \mathcal{U}:u<v}\mathrm{PRG}\left(s_{u,v}\right)-\sum _{v\in \mathcal{U}:u>v}\mathrm{PRG}\left(s_{v,u}\right)(\mathrm{m}\mathrm{o}\mathrm{d}R)$$
其中，$\mathrm{PRG}$就代表哈希，这个式子含义为当所有用户都使用同一个哈希函数并遵循一定的规则，就能实现每一对用户都只需要协商一次$\mathrm{KA}$，并将该值哈希 $\mathrm{d}$ 次实现加密式子的随机性，便能实现 $\mathbf{O}\left(\mathbf{N}\right)$ 的 通信代价。
问题2： 如何解决掉线问题？
解决方案2： 论文使用了shamir大神的秘密共享方案，用户 $u$ 将自己的私钥 $s_u^{SK}$ 作为 秘密共享参数，把不同的份额分发给其他用户，在聚合阶段若用户 $u$ 掉线，那么通过其他至少$t$个用 户便能恢复出密钥。
问题3： 看似已经解决了所有问题，但是考虑这种情况，若用户$u$很晩才将参数上传，但此时服务器判定用 户$u$已经掉线并让其他用户恢复了该用户的私钥，那么此时便能破解用户$u$的参数。考虑更坏的情 况，好奇的服务器可以撒谎用户$u$掉线，这样一来，方案还无法构成足够的安全。
最终方案：
$$\begin{array}{rl}{\mathbf{y}}_u={\mathbf{x}}_u& +\mathbf{P}\mathbf{R}\mathbf{G}\left({\mathbf{b}}_u\right)\\ & +\sum _{v\in \mathcal{U}:u<v}\mathrm{PRG}\left(s_{u,v}\right)\\ & -\sum _{v\in \mathcal{U}:u>v}\mathbf{P}\mathbf{R}\mathbf{G}\left(s_{v,u}\right)(\mathrm{m}\mathrm{o}\mathrm{d}R)\end{array}$$
其中$b_u$为用户$u$自行添加的秘密参数，和 $s_u$ 一样需要将不同的份额分发给其他用户，但是区别就在于 $b_u$是若用户$u$在线才恢复，而$s_u$ 是用户$u$掉线时恢复，如此一来，一个诚实的用户 $v$便不会同时提交用户$u$的两个秘密份额。

2.4.2 方案具体流程

以用户$u$作为视角作为讨论，其余的用户$u$执行的操作与用户相同。

Setup

• 各方都被赋予了安全参数 $k$ , 用户数$n$ 和一个门限值$t$ , honestly generated $pp\leftarrow \mathrm{K}\mathrm{A}.\mathrm{g}\mathrm{e}\mathrm{n}(k)$ , 参数$m$和$R$，则 ${\mathbb{Z}}_R^m$ 是对输入进行采样的空间, 和一个用于秘密分享的字段$\mathbb{F}$ 。所有用户还具有与服务器的私有身份验证通道。
• 所有用户 $u$ 都会从受信任的第三方收到他们的签名密钥 $d_u^{SK}$，以及绑定到每个用户身份 $v$ 的验证密钥 $d_v^{PK}$。

Round 0 (AdvertiseKeys)

用户$u$：

• 产生密钥对$\left(c_u^{PK},c_u^{SK}\right)\leftarrow \mathrm{KA}\cdot \mathrm{gen}(pp),\left(s_u^{PK},s_u^{SK}\right)\leftarrow \mathrm{KA}\cdot \mathrm{gen}(pp)$以及签名${\sigma }_u\leftarrow \mathrm{SIG}\cdot \mathrm{sign}\left(d_u^{SK},c_u^{PK}\Vert s_u^{PK}\right)$；
• 将公钥及签名$\left(c_u^{PK}\Vert s_u^{PK}\Vert {\sigma }_u\right)$ 发送给服务器，服务器将公钥路由给其他用 户；
• 其他用户拿到用户 $u$ 的公钥后与自己的私钥 $\left(c_v^{SK},s_v^{SK}\right)$ 结合便能得到两个共享密钥： $c_{u,v}$ 用来后续加密传输的信息，$s_{u,v}$ 用来加密模型参数。

服务器：

• 从上一轮的个人用户中收集至少 $t$ 条消息（用${\mathcal{U}}_1$表示这组用户）。 否则，中止;
• 向 ${\mathcal{U}}_1$ 列表中的所有用户广播 ${\left\{\left(v,c_v^{PK},s_v^{PK},{\sigma }_v\right)\right\}}_{v\in {\mathcal{U}}_1}$;

Round 1 (ShareKeys)

将$b_u$ 与 $s_u$的秘密份额通过Round 0得到的$c_{u,v}$加密发送给对应的其他用户。
用户$u$：

• 接收由服务器广播得到的列表 ${\left\{\left(v,c_v^{PK},s_v^{PK},{\sigma }_v\right)\right\}}_{v\in {\mathcal{U}}_1}$ 。 判断以下条件是否满足：$\left|{\mathcal{U}}_1\right|\ge t$，所有的公钥对都是不同的，并且 $\forall v\in {\mathcal{U}}_1,\mathrm{S}\mathrm{I}\mathrm{G}.\mathrm{v}\mathrm{e}\mathrm{r}\left(d_v^{PK},c_v^{PK}\Vert s_v^{PK},{\sigma }_u\right)=1$；
• 采样一个随机元素 $b_u\leftarrow \mathbb{F}$（用作 PRG 的种子）;
• 生成 t -out-of- $\left|{\mathcal{U}}_1\right|$ $s_u^{SK}$ 的份额：${\left\{\left(v,s_{u,v}^{SK}\right)\right\}}_{v\in {\mathcal{U}}_1}\leftarrow \mathrm{S}\mathrm{S}.\mathrm{s}\mathrm{h}\mathrm{a}\mathrm{r}\mathrm{e}\left(s_u^{SK},t,{\mathcal{U}}_1\right)$;
• 生成 t -out-of- $\left|{\mathcal{U}}_1\right|$ $b_u$ 的份额：${\left\{\left(v,b_{u,v}\right)\right\}}_{v\in {\mathcal{U}}_1}\leftarrow \mathrm{S}\mathrm{S}.\mathrm{s}\mathrm{h}\mathrm{a}\mathrm{r}\mathrm{e}\left(b_u,t,{\mathcal{U}}_1\right)$;
• 对于每个其他用户 $v\in {\mathcal{U}}_1\backslash \{u\}$ ，计算 $e_{u,v}\leftarrow \mathrm{A}\mathrm{E}.\mathrm{e}\mathrm{n}\mathrm{c}\left(\mathrm{K}\mathrm{A}.\mathrm{a}\mathrm{g}\mathrm{r}\mathrm{e}\mathrm{e}\left(c_u^{SK},c_v^{PK}\right),u\Vert v\Vert s_{u,v}^{SK}\Vert b_{u,v}\right)$;
• 如果上述任何操作（断言、签名验证、密钥协商、加密）失败，则中止;
• 将所有密文 $e_{u,v}$ 发送到服务器（每个都隐含地包含寻址信息 $u,v$ 作为元数据）;
• 存储本轮收到的所有消息和生成的值，然后进入下一轮。

服务器：

• 收集至少 $t$ 个用户的密文列表（用 ${\mathcal{U}}_2\subseteq {\mathcal{U}}_1$ 这组用户表示）；
• 向每个用户 $u\in {\mathcal{U}}_2$ 发送为其加密的所有密文： ${\left\{e_{u,v}\right\}}_{v\in {\mathcal{U}}_2}$ 并进入下一轮。

Round 2 (MaskedInputCollection)

• 从服务端收到其他用户发送给自己的秘密份额后，根据收到的用户列表，计算$\mathrm{PRG}\left(s_{u,v}\right)$ 和$\mathrm{PRG}(b_u)$，注意这是每个参数都需要哈希一次，保证每个位置上的参数加密的数都是随机的。
• 计算完成后将加密后的参数上传给服务器。

Round 3

• 服务器将收到的模型参数进行聚合并将掉线用户列表发送给所有用户，用户通过该列表上传掉线用户的秘密份额 $s_j^{\prime }$ 和在线用户的秘密份额 $b_i^{\prime }$；
• 服务器收到至少$t$个用户上传的份额后恢复对应参数，得到聚合结果。

2.4.3 其它

从上述的方案我们可以得知，服务器主要做的路由的作用，完成用户之间信息的交换，因此服务器有能力对不同的用户宣称不同的用户掉线，借此来试图破解shamir秘密共享中的多项式，因此原论文还加了一轮一致性检测，感兴趣的朋友可以去原论文看看~。

参考文献：
内容大部分借鉴了
http://joeybarry.cn/practical-secure-aggregation/