Shamir秘密分享的基本形式（同态加、同态乘）

Shamir秘密分享简介

Shamir秘密分享，指的是Shamir在1979年的文章《How to share a secret》[1] 中提出的门限秘密分享方案。该方案利用多项式求值和多项式插值，在有限域${\mathbb{Z}}_p$中构造门限方案分享秘密值。该方案是信息论安全的，并且可以抵抗半诚实的合谋攻击。

假设$p$是一个素数，${\mathbb{Z}}_p=\{0,1,2,\cdots ,p-1\}$是一个由整数构成的有限域，即${\mathbb{Z}}_p$中的元素对于模$p$加法构成一个交换群，${\mathbb{Z}}_p^{\ast }=\{1,2,\cdots ,p-1\}$中的元素对于模$p$乘法构成一个交换群，乘法对加法具有分配律。下面的运算都是有限域${\mathbb{Z}}_p$中的运算，也就是模$p$运算。

定义一个系数模$p$的$t-1$次多项式$f(x)=s+c_{1}x+c_2{x}^2+\cdots +c_{t-1}{x}^{t-1}$是关于秘密$s$的秘密多项式。其中$c_1,\cdots ,c_{t-1}$是${\mathbb{Z}}_p$中均匀随机选取的随机数。(有$\frac{1}{p}$的概率使得$c_{t-1}$为0，也就是$f(x)$的次数小于$t-1$，但是由于$c_{t-1}$也是秘密的，所以，其他人并不知道秘密多项式的次数，并不影响安全性)

在${\mathbb{Z}}_p$中选取$n(n\ge t)$个不同的数$\{x_1,x_2,\cdots ,x_n\}$（$x_i$不为0），并计算$y_1=f(x_1),y_2=f(x_2),\cdots ,y_n=f(x_n)$.每个用户$P_i$获得$(x_i,y_i)$。这样就构成了一个$(t,n)$门限秘密分享方案。只有至少$t$个用户才能恢复出秘密的多项式，从而知道秘密$s$ 。根据代数学基本定理，$t$个用户可以插值得到唯一的多项式。而 $t-1$个多项式只能得到最多$t-2$次多项式。由系数的随机性，$t-1$个用户得不到任何$s$的信息。

有限域上的拉格朗日插值

秘密的恢复或者重建是简单的，通过多项式的插值就可以完成。最常见的就是通过拉格朗日插值法，求秘密多项式$f(x)$。

定义拉格朗日基函数$l_i(x)=({\prod }_{i\ne j}(x-x_j))÷({\prod }_{i\ne j}(x_i-x_j))$。容易验证$l_i(x)$在$x_i$处的值为1，而在$x_j(j\ne i)$处的值为0.

不妨设$P_1,P_2,\cdots ,P_k(t\le k\le n)$想要重建秘密。多项式$f(x)={\sum }_{i=1}^k{y}_i{l}_i(x)$.

同态加法

假设$s_1$的秘密多项式为$f_1(x)$，其分享值为$(x_1,y_1),(x_2,y_2),\cdots ,(x_n,y_n)$，$s_2$的秘密多项式为$f_2(x)$，其分享值为$(x_1,z_1),(x_2,z_2),\cdots ,(x_n,z_n)$.

则，$P_1,P_2,\cdots ,P_n$可以在不重建秘密的情况下，计算$s_1+s_2$的秘密分享值。

每个用户$P_i$在本地计算$y_i+z_i$，则对于$P_i$来说，$s_1+s_2$的秘密分享值是$(x_i,y_i+z_i)$.

同态乘法

注意到多项式的乘法会导致多项式的次数增加，所以我们需要$n\ge 2t+1$.

首先，和加法类似，每个用户$P_i$在本地计算$y_i\times z_i$，则对于$P_i$来说，$s_1\times s_2$的秘密分享值是$(x_i,y_i\times z_i)$.

然后我们需要额外的步骤，使得新的秘密多项式的次数也是$t-1$.

实际上，根据拉格朗日插值，秘密多项式$f(x)={\sum }_{i=1}^n{y}_i{l}_i(x)$，那么秘密$s=f(0)={\sum }_{i=1}^n{y}_i{l}_i(0)$. 由于$l_i(x)$是可以公开的，所以用户$P_i$可以在本地计算$y_i{l}_i(0)$.

$P_i$重新采样随机数，构造一个$t-1$次的多项式$q_i(x)=y_i{l}_i(0)+c_{1,i}x+c_{2,i}{x}^2+\cdots +c_{t-1,i}{x}^{t-1}$. 现在，$s_1\times s_2$的新的秘密多项式等于${\sum }_{i=1}^n{q}_i(x)$.

$P_i$计算$q_i(x_1),q_i(x_2),\cdots ,q_i(x_n)$，然后将$q_i(x_j)$发送给$P_j$.

在收到其他用户发送来的值后，$P_i$计算$y_i^{\prime }={\sum }_{j=1}^n{q}_j(x_i)$作为$s_1\times s_2$在$x_i$处的分享值。

示例代码

'''
It is an example for showing how shamir secret share works
---by zyf
'''
import gmpy2
import time

# secret is the secret you want to share
# t is the threshold, the secret polynomial degree is t-1
# xs are the ids for users
# p define the finite field
def create_share(secret,t,xs,p)-> list:
    shares=[secret for _ in xs]
    st=gmpy2.random_state(time.time_ns())
    n=len(xs)
    for i in range(t):
        c=gmpy2.mpz_random(st,p)
        if i==0:
            xt=[i for i in xs]
        else:
            for j in range(n):
                xt[j]=xt[j]*xs[j]%p
        for j in range(n):
            shares[j]=(shares[j]+xt[j]*c%p)%p
    return shares

#compute l_i(0)
def compute_l0(xs,p):
    n=len(xs)
    l0=[1 for _ in range(n)]
    for i in range(n):
        for j in range(n):
            if i==j:
                continue
            l0[i]=(l0[i]*(p-xs[j])*gmpy2.invert(xs[i]-xs[j],p))%p
    return l0

#reconstruct secret
def reconstruct(shares,xs,p):
    l0=compute_l0(xs,p)
    secret=0
    for i in range(len(xs)):
        secret=(secret+shares[i]*l0[i])%p
    return secret


#add
def add(shares1,shares2,p):
    n=len(shares1)
    res=[(shares1[i]+shares2[i])%p for i in range(n)]
    return res

#mul
def mul(shares1,shares2,xs,t,p):
    l0=compute_l0(xs,p)
    n=len(xs)
    tshare=[(shares1[i]*shares2[i]*l0[i])%p for i in range(n)]
    qi={}
    for i in range(n):
        qi[i]=create_share(tshare[i],t,xs,p)
    res=[0 for _ in range(n)]
    for i in range(n):
        for j in range(n):
            res[i]=(res[i]+qi[j][i])%p
    return res


if __name__=="__main__":
    n=12
    t=5
    import numpy as np
    for i in range(10):
        s1=np.random.randint(2,10023)
        s2=np.random.randint(2,10023)
        print("s is ",s1," s2 is ",s2)
        p=gmpy2.next_prime((s1*s1*s2*s2+1)*3)
        xs=[i+1 for i in range(n)]
        sh1=create_share(s1,t,xs,p)
        sh2=create_share(s2,t,xs,p)
        add12=add(sh1,sh2,p)
        print("s1+s2 is ",s1+s2)
        print("re ",reconstruct(add12,xs,p))
        
        mul12=mul(sh1,sh2,xs,t,p)
        print("s1*s2 is ",s1*s2)
        print("re ",reconstruct(mul12,xs,p))
        
        mul112=mul(mul12,sh1,xs,t,p)
        print("s1*s2 is ",s1*s1*s2)
        print("re ",reconstruct(mul112,xs,p))
        
        rs1=reconstruct(sh1,xs,p)
        print("reconstructed ",rs1)
        print(s1==rs1)
    

参考文献

[1] Shamir, Adi. “How to share a secret.” Communications of the ACM 22.11 (1979): 612-613.
[2] Goldwasser, S., M. Ben-Or, and A. Wigderson. “Completeness theorems for non-cryptographic fault-tolerant distributed computing.” Proc. of the 20th STOC. 1988.