算术秘密分享（Arithmetic Share）

秘密分享的基本概念

秘密的拥有者有一个秘密的数$s$。拥有者需要将自己的秘密分享给$n$个参与者，每个参与者得到一份分享值。通常要求单个的参与者不能得到秘密$s$的任何信息，但是多个参与者可以通过公布自己的分享值，重建秘密$s$.

秘密分享在隐私计算中有比较多的应用，比如百万富翁问题、隐私求和等等。根据多少个参与者可以重建秘密，可以将秘密分享分为门限秘密分享和门限秘密分享。门限秘密是指当至少有$t(1<t<n)$个用户公布分享值的时候，秘密可以被重建，少于$t$个用户不能得到任何信息。非门限的秘密分享是必须当所有的参与者都公布自己的分享值的时候，秘密才能被重建。下面主要讨论非门限秘密分享的常见两种形式：算术秘密分享和布尔秘密分享（也叫做二进制秘密分享）。

算术秘密分享

算术秘密分享通常是指在整数环${\mathbb{Z}}_p$上的分享，其中$p>1$. 这里的秘密$s\in [0,p)$是一个整数。

分享

首先，在环${\mathbb{Z}}_p$上均匀随机采样，得到$n-1$个随机数$x_1,x_2,\cdots ,x_{n-1}$.然后计算$x_n=s-x_1-x_2-\cdots -x_{n-1}\mathrm{mod}p$，将$x_i$发送给$P_i$就完成了分享。

重建

每一个参与者$P_i$将自己的分享值$x_i$公布，然后计算$s={\sum }_{i=1}^n{x}_i\mathrm{mod}p$.

同态加法

加法是简单的，假设秘密$s$给参与者$P_i$的分享值为$x_i^s$，秘密$t$给参与者$P_i$的分享值为$x_i^t$，那么秘密分享的同态加法是指在不泄露和重建秘密$s,t$的情况下，每个参与者得到秘密$s+t$的分享。
同态加法的计算不需要交互，每个参与者$P_i$在本地计算$x_i^{s+t}=x_i^s+x_i^t\mathrm{mod}p$.
则$x_i^{s+t}$就是秘密$s+t\mathrm{mod}p$在参与者$P_i$的分享值。

同态乘法

相对来说，乘法要比加法麻烦一点。需要用不经意传输OT，或者Beaver Triples.这里介绍乘法三元组（Beaver Triples）的方法，因为相对OT来说更容易理解一点。
乘法三元组是说，我们在进行乘法计算之前，预先得到$a,b,c$的分享，并且满足$c=ab$. 这里的乘法三元组可以由秘密的拥有者计算。秘密拥有者采用两个随机的元素$a,b\in {\mathbb{Z}}_p$，并计算$c=ab\mathrm{mod}p$，然后将$a,b,c$分享给参与者。

假设$a$的分享值为$x_i^a$，$b$的分享值为$x_i^b$，$c$的分享值为$x_i^c$.
我们下面讨论如何使用乘法三元组去同态计算$st\mathrm{mod}p$的秘密分享。
首先$P_i$计算$x_i^s+x_i^a\mathrm{mod}p$和$x_i^t+x_i^b\mathrm{mod}p$，然后将计算结果发送给其他参与者。
当每个参与者都计算完成后，这时，$P_i$就有了$x_j^s+x_j^a\mathrm{mod}p$和$x_j^t+x_j^b\mathrm{mod}p$，其中$j=1,2,\cdots ,n$.所以，$P_i$可以得到$A=s+a\mathrm{mod}p={\sum }_{j=1}^n(x_j^s+x_j^a)\mathrm{mod}p$和$B=t+b\mathrm{mod}p={\sum }_{j=1}^n(x_j^t+x_j^b)\mathrm{mod}p$.

接下来，$P_i$在本地计算$x_i^{st}=A{x}_i^t-B{x}_i^a+c_i\mathrm{mod}p$.

证明如下：
$\begin{array}{rl}\sum _{i=1}^n{x}_i^{st}\mathrm{mod}p=& \sum _{i=1}^n(A{x}_i^t-B{x}_i^a+c_i)\mathrm{mod}p\\ =& At-Ba+c\mathrm{mod}p\\ =& (s+a)t-(t+b)a+c\mathrm{mod}p\\ =& st\mathrm{mod}p.\end{array}$

需要注意的是，一个乘法三元组应该只被使用一次，否则可能会泄露某些信息。

布尔秘密分享

布尔秘密分享是一种特殊的算术秘密分享，也就是当$p=2$时的算术秘密分享。
当$p=2$时，具有很多特殊的性质。我们可以将之与电路门对应起来。其中加法就是异或门，乘法就是与门。通过这种对应，我们可以利用电路门的特性，可以很方便的计算一些非线性函数。

示例代码

'''
It is a toy example for showing how arithmetic share works
---by zyf
'''
import numpy as np

# s is the secret share that you want to share
# n is the number of palyers
# p is the order of the integer finite ring
def share(s,n,p):
    x=np.random.randint(0,p,size=n)
    x[n-1]=(s-np.sum(x[:n-1]))%p
    return x

# shares is the shared values
def reconstruct(shares,p):
    return np.sum(shares)%p

# the addition of shares
def hadd(x1, x2,p):
    res=(x1+x2)%p
    return res

# the multiplication  of shares
# sa is the shared values of a
# sb is the shared values of b
# sc is the shared values of c
# c=ab mod p
def hmul(x1,x2,xa,xb,xc,p):
    xA=hadd(x1,xa,p)
    xB=hadd(x2,xb,p)
    A=reconstruct(xA,p)
    B=reconstruct(xB,p)
    res=(A*x2-B*xa+xc)%p
    return res

if __name__=="__main__":
    n_test=10
    for i in range(n_test):
        s1=np.random.randint(0,100)
        s2=np.random.randint(0,100)
        p=np.random.randint(s1*s2+max(s1,s2),2*s1*s2+2*max(s1,s2))
        n=np.random.randint(3,10)
        x1=share(s1,n,p)
        x2=share(s2,n,p)
        
        x_add=hadd(x1,x2,p)
        print("The sum is ",s1+s2)
        re_sum=reconstruct(x_add,p)
        print("The re sum is ",re_sum)
        
        a=np.random.randint(0,p)
        b=np.random.randint(0,p)
        c=a*b%p
        xa=share(a,n,p)
        xb=share(b,n,p)
        xc=share(c,n,p)
        x_mul=hmul(x1,x2,xa,xb,xc,p)
        print("The mul is ",s1*s2)
        re_mul=reconstruct(x_mul,p)
        print("The re mul is ",re_mul)