存在作弊者的 (t,n) 秘密共享方案

存在作弊者的 (t,n) 秘密共享方案

Tip：本文仅根据个人理解进行论文复现，可能存在错误，具体原理详见原论文。
jupyter文件链接：存在作弊者的 (t,n) 秘密共享方案.ipynb
提取码：iahh

1.问题背景

(t,n) 门限秘密共享方案

       密码学中一组参与者的授权子集共同作用才能恢复出秘密的信息保护技术。在 $(t,n)$ 门限秘密共享方案中，一个秘密 $s$ 由分发者分发给 $n$ 个参与者 $p_1,p_2,...,p_n$。当由t个或更多参与者时，可以恢复秘密信息 $s$ ，而 $t-1$ 个或者更少的参与者无法恢复秘密信息 $s$ 。秘密共享能有效地防止系统外敌人的攻击和系统内用户的背叛。常见的 $(t,n)$ 秘密共享方案有 $Shammir$ 秘密共享[1]、 $Asmuth-Bloom$ 秘密共享[2]等。

存在作弊者的 (t,n) 秘密共享方案

       作弊问题是传统秘密共享方案中的一个重要问题。秘密共享计划中的作弊场景最早由 $Tompa$ 和 $Woll$ 提出[3]。他们考虑了一些不诚实的参与者（作弊者）在重建秘密时汇集假秘密碎片的情况。这样，作弊者就可以完全找回一个秘密 $s$，而诚实的参与者只能找回一个伪造的秘密 $s^{,}$。如果将作弊者成功作弊的概率被限制在指定的概率内，即使作弊者是无限强大的，门限方案也被认为是无条件防止作弊的。作弊者的检测和识别对于实现秘密的公平重建非常重要。

2.问题介绍

作弊可检测的秘密共享

       在作弊检测方案中，诚实用户可以检测到作弊行为，但不能识别作弊行为。$McEliess$ 和 $Sarwate$ [4]证明了 $Shamir$ 的方案本身具有检测作弊的能力。任何一组最多包含 $t$ 个作弊者的 $k+2t$ 个参与者都可以检测到谁在作弊。他们也能获得正确的秘密 $s$。然而，这个方案需要超过 $k$ 个参与者来检测谁是作弊者。

作弊可识别的秘密共享

       作弊识别方案为解决诚实用户不仅可以检测到作弊行为，还可以识别作弊用户的作弊问题提供了更强的技术支持。$McEliess$ 和 $Sarwate$ [[4]]证明了 $Shamir$ 的方案本身具有检测作弊的能力。任何一组最多包含 $k$ 个作弊者的 $t+2k$ 个参与者可以检测到谁在作弊。同时也能获得正确的秘密信息 $s$。但是，这个方案需要超过 $t$ 个参与者来识别作弊者是谁。

鲁棒性秘密共享

       健壮性的秘密共享方案即使重建时使用包含错误碎片的碎片集合，也能恢复正确的秘密信息。

3.攻击方案

假设存在以下三种攻击方案：
攻击1： 作弊者可以是不小心错误地提交碎片的诚实用户，也可以是不诚实的，他们在没有任何合作的情况下提交伪造的秘密信息碎片。此攻击的每个伪造碎片只是一个随机整数，与其他份额完全独立。
攻击2： 作弊者是不诚实的用户，他们故意修改自己的碎片，以愚弄诚实的用户。在这种类型的攻击中，我们假设所有用户同步释放他们的碎片。因此，作弊者只能在秘密重构之前相互协作找出他们伪造的碎片，但在知道诚实用户的股票后不能修改他们的碎片(即假设所有碎片都必须同时公开)。在此假设下，只有当作弊者的数量大于或等于阈值t时，作弊者才能成功实施欺骗诚实用户的攻击。
攻击3： 作弊者是不诚实的用户，他们故意修改自己的碎片，以愚弄诚实的股东。在这种类型的攻击中，我们假设所有用户都异步公开他们的碎片。由于用户一次只发行一个碎片，所以作弊者的最佳选择是在所有诚实的用户公开后再公开碎片。作弊者可以相应地修改他们的碎片。这是最坏的情况。

4.解决方案与分析

作弊可检测的秘密共享

方案一

       $LeinHarn$ 和 $LeinHarn$ 提出了一种基于 $Shammir$ 门限方案的作弊检测算法[5]。在 $Shammir$ 门限方案中，通过拉格朗日插值法恢复秘密信息 $s$。如果有超过 $t$ 个的碎片，并且没有伪造的碎片，对于 $t$ 个碎片的所有组合，都应该重构一个相容的多项式。作弊检测是通过检测所有重构秘密中不一致的多项式（或秘密）来确定的。但是，作弊者可以合作构造他们的伪造碎片，欺骗诚实的参与者，使他们相信伪造的秘密才是真正的秘密。

• 算法如下：
  
  • $Input:t,n,J,(s_{J_1},s_{J_2},...,s_{J_k})$ （其中 $J$ 是参与恢复的用户集合，$s_{J_i}$ 是秘密碎片）
    
  • 1.计算 $j$ 个点 $(i,s_{J_1}),(i,s_{J_2}),...,(i,s_{J_j})$ 的拉格朗日插值多项式 $F(x)$。令 $d=F(x)$ 的次数。
    
  • 2.如果 $d=t-1$ , 则 $s=F(0)$ ；否则存在作弊者。
    
  • $Output:$ 不存在作弊者，恢复的秘密是 $s$ ；否则存在作弊者。
    

       检测算法基本原理为：采用拉格朗日插值算法重构多项式时，如果参与重构的点都是真实的，那么最后的多项式次数一定等于秘密信息划分时选取的多项式的次数，为 $t-1$。前 $t$ 个参与者恢复的多项式次数一定等于 $t-1$。超出 $t$ 个参与者参与恢复时，如果是真实的，那么多项式一定包含了该点，所以不会引起次数的变化。一旦参与恢复的点中存在一个伪造点，就会使重构的多项式改变，次数加一。所以可以通过此法检测作弊者的存在。

       该检测算法的前提是有超过门限t的参与者进行恢复秘密信息。但当只有t个参与者且其中存在作弊者时，无法进行检测。这是因为此时不论存在作弊者，必然会增加维度，但由于仅存在 $t$ 个参与者，所以无法通过冗余的参与者进行检测。

       实现代码见附录.1。

方案二

       刘等人[10]提出了一个新的线性 $(t，n)$ 秘密共享方案，该方案在 $OKS$ 假设下具有欺骗检测功能。因为在 $OKS$ 假设下，$t-1$ 个欺骗者不知道秘密的信息，这与 $(t，n)$ 秘密共享的定义是一致的。该方案是在 $Shamir$ 方案的基础上提出的，当只有一个诚实的参与者时，可以检测到其他 $t-1$ 个作弊者的作弊行为。

• 方案如下：
  
  • 秘密信息分发：
    
    • 1. 分发中心在 $GF(P)$ 上选择一个 $(t-1)$ 阶随机多项式，
      $f(x)=s+a_1\ast x+...+a_{t-1}\ast x^{t-1}$
    • 2. 分发中心在 $GF(P)$ 上选择一个随机数 $r$ 和一个 $(t-1)$ 阶多项式，
      $g(x)=b_0+b_1\ast x+...+b_{t-1}\ast x^{t-1}$
      满足 $rs+b_0=0$ 和 $r{a}_1+b_1=0$。
    • 3. 分发中心计算秘密碎片 $v_i=(m_i,d_i)$，$i=1,2,...,n$，其中 $m_i=f(i)$，$d_i=g(i)$。
  • 秘密信息恢复：
    
    • 1. 根据拉格朗日插值法，通过秘密碎片 $(1,m_1),(2,m_2),...,(t,m_t)$ 和 $(1,d_1),(2,d_2),...,(t,d_t)$ 分别恢复 $f(x)$ 和 $g(x)$。
      
    • 2. 设 $a_0,a_1,b_0,b_1$ 分别是 $x^0$ 和 $x$ 在 $f(x)$ 和 $g(x)$ 中的系数。如果存在满足 $r{a}_0+b_0=0$ 和 $r{a}_1+b_1=0$ 的 $r\in Z_p$，则输出 $s=f(0)$。否则，$f(0)$ 为无效秘密，检测到作弊，输出 $\perp$。
      

       完美性证明：

       方案中，秘密 $s$ 利用 $Shamir$ 原有的 $(t，n)$ 秘密共享方案被分成 $n$ 份，显然方案中的 $t$ 份或更多份可以重构秘密 $s$。接下来仅需证明 $t-1$ 个用户不能获取任何有关秘密 $s$ 的信息即可。
       假设：$m^{\ast }(k)$ 是随机选择的第 $k$ 个碎片，那么 $k-1$ 个股东重构 $k-1$ 次多项式 $f_i(x)$。$a_0,a_1$ 是 $f_i(x)$ 中的相应系数。可以把 $b_0，b_1,...,b_{k–1}$ 和 $r^{\prime }$ 作为 $k+1$ 个未知数，建立关于这些未知数的方程：$g_0(i)=d_i，i=1,2,...,k–1$，$r^{\prime }{a_0}^{\prime }+{b_0}^{\prime }=0,r^{\prime }{a_1}^{\prime }+{b_1}^{\prime }=1$。使用穷举法尝试第 $k$ 个碎片时，得到 $Z_p$ 中的每一个值的概率是相同的。因此 $t-1$ 个用户不能获取任何有关秘密 $s$ 的信息。

       可检测性：

       作弊者无法知道原始多项式 $f(x)$ 和 $g(x)$，即不能获取 $m_i$ 和 $d_i$ 之间的关系。作弊者改变其中的某一个，但无法根据生成规则改变另一个值。所以在重构时，恢复出的两个多项式之间不会满足原始多项式之间的关系，即验证错误。当参与重构的 $t$ 个用户中存在最多 $t-1$ 个作弊者时，均能检测出来。

       实现代码见附录.4。

作弊可识别的秘密共享

方案一

       $Kaoru$ $KUROSAWA$ 提出了一种可识别的 $t-$作弊者秘密共享方案[6]。该方案基于线性纠错码和正交数组设计。使用强度为 $t+1$ 的正交数组作为无条件安全的认证码，并将其与 $Shamir$ 的 $(k，n)$ 门限方案和 $McEliess$ 和 $Sarwate$ 提出的线性码[4]相结合。

• 假设最多有 $t$ 个作弊者，定义的模型如下：
  

  • 完备性：任何一组参与者包含至少 $k$ 个诚实的参与者。
    
  • 可靠性：不小于 $k$ 个参与者的子集都可以确定秘密信息的任何部分。
    
  • 可检测性：如果 $k$ 或更多的参与者公开他们的碎片，存在可以高概率地检测谁是作弊者的图灵机 $M$。
    

• 方案如下：
  

  • 1. 分发中心 $D$ 生成秘密碎片 $v_i=({\alpha }_i,{\beta }_i,{\gamma }_i)$, $i=1,2,...,n.$ 与 $Shamir$ 的方案一样，$D$ 在 $GF(P)$ 上选择一个 $(k-1)$ 阶随机多项式，
    $f(x)=s+a_1\ast x+...+a_{k-1}\ast x^{k-1}$
    令 ${\alpha }_i=f(i)$， $i=1,2,..,n.$
    
  • 2. 设 $OA(t+1,np,q)$ 为正交数组（假设公开），$q$ 为素数次方。$D$ 选择一个随机数 $e$，使得 $1\le e\le q^{t+1}$ 。设 ${\beta }_i$ 是 $OA(t+1,np,q)$ 的第 $e$ 行和第 $(i-1)p+{\alpha }_{i}th$ 列元素。
    
  • 3. $D$ 在 $GF(q_{t+1})$ 上随机选择 $t$ 阶多项式，
    $g(x)=e+b_1\ast x+...+b_t\ast x^t$
    令 ${\gamma }_i=g(i)$, $i=1,2,...,n.$
    

方案二

       刘等人提出了一种基于二元多项式的作弊者可识别秘密共享方案[7]。每个用户的碎片是由对称的二元多项式生成的，作弊识别仅基于二元多项式的对称性和插值多项式的线性度。第一种算法可以从 $m$ 个参与秘密重构的用户中识别出作弊者，第二个算法可以在其余 $n-m$ 个未参与秘密重构的用户的协作下获得更强的作弊识别能力。

方案如下：

• 秘密信息分发：
  
  • 1. 分发中心 $D$ 在 $x$ 和 $y$ 中都选择 $k-1$ 次的对称二元多项式 $F(x，y)\in G{F}_{(q)}[X，Y]$，秘密 $s$ 被隐藏在常数项 $s=F(0，0)$ 中。
    
  • 2. 分发中心 $D$ 计算 $n$ 个多项式份额 $f_i(y)=F(i，y)$，$i=1,2,...,n$，并将每个多项式碎片 $f_i(y)$ 发送给用户 $P_i$。
    
• 秘密信息恢复：
  

  • 假设有 $m(m\ge k)$ 个参与者参与秘密信息恢复。
    

  • 算法一：
    

    • 1. 所有 $m$ 个参与者选取两个随机整数 $d_1，d_2>n$，每个参与者 $P_i$，$i\in [1，m]$ 分别计算他的秘密碎片 $v_i=f_i(0)$ 和两个检测份额 $e_{i，1}=f_i(d_1)，e_{i，2}=f_i(d_2)$。
      
    • 2. 所有 $m$ 个参与者一起发布他们的秘密共享和两个检测共享。分别计算 $v_1,v_2,...,v_m$ ，$e_{1,1},e_{2,1},...,e_{m,1}$ 和 $e_{1,2},e_{2,2},...,e_{m,2}$ 上的插值多项式 $g_0(x)$，$g_{d_1}(x)$ 和 $g_{d_2}(x)$。
      
    • 3. 如果三个多项式 $g_0(x)$，$g_{d_1}(1)$ 和 $g_{d_2}(x)$ 的次数最多为 $k-1$。同时 $g_{d_1}(d_2)=g_{d_2}(d_1)$， $g_{d_1}(0)=g_0(d_1)$，$g_{d_2}(0)=g_0(d_2)$。则秘密信息 $s=g_0(0)$，输出秘密信息 $s$，算法结束。
      
    • 4. 如果不满足 $step3$，则表明存在作弊者，需要将其识别出来。所有 $m$ 个用参与者公布他们的多项式份额 $f_i(y)$，$i=1,2,...,m$。所有这 $m$ 个参与者使用以下规则相互投票：
      
      • (1)如果 $f_i(j)=f_j(i)$，$P_i$ 和 $P_j$ 相互投票；
        
      • (2)如果 $f_i(j)\ne f_j(i)$，$P_i$ 和 $P_j$ 不相互投票。
        
    • 5. 设 $V_i$ 表示参与者 $P_i$ 在 $step4$ 之后的投票。任何获得少于 $T=\frac{m+k-5}{2}$ 票 $(V_i<T) $的参与者 $P_i$ 都被识别为作弊者。设 $L$ 是所有作弊者的集合，如果 $m-|L|\ge k$，则由诚实用户的秘密份额重构秘密 $s$，输出 $(s，L)$；否则输出 $(\perp ，L)$。

  • 算法二 ：
    

    • 1. $m(m\ge k)$ 个参与者公布他们的多项式碎片 $f_i(y)$，$i=1,2,...,m$。所有这 $m$ 个用户使用以下规则相互投票：
      
      • (1)如果 $f_i(j)=f_j(i)$，$P_i$ 和 $P_j$ 相互投票；
        
      • (2)如果 $f_i(j)\ne f_j(i)$，$P_i$ 和 $P_j$ 不相互投票。
        
    • 2. 如果没个参与者都获得 $m-1$ 票，则从 $m$ 个秘密共享 $v_i=f_i(0)$， $i=1,2,...,m$ 中的任取 $k$ 个重建秘密 $s$。输出 $(s，\varnothing )$；否则转到 $step3$ 识别作弊者。
    • 3. 发布 $m$ 个多项式碎片 $f{|}_i(y)$，$i=1,2,...,m$ 给其他 $n-m$ 个用户 $P_{m+1},P_{m+2},...,P_n$。每个用户 $P_i，i\in [m+1，n]$ 按以下规则投票给 $P_1,P_2,...,P_m$：
      • (1)如果 $f_j(i)=f_i(j)，j\in [m+1，n]，i\in [1，m]$，$P_j$ 投票给 $P_i$；
      • (2)否则 $P_j$ 不投票给 $P_i$。

    设 $V_i$ 是 $P_i$ 的选票，$i=1,2,...,m$，将 $step1$ 和 $step3$ 中的选票加在一起。如果 $V_i<T=\frac{n+k-3}{2}$，则 $P_i$ 被识别为作弊者。

方案二完美性证明：

       设 $g_0(x)=F(x，0)$，显然 $g_0(x)$ 的次数为 $k-1$，秘密 $s$ 为 $s=F(0，0)=g_0(0)$。此外，每个用户 $P_i$ 具有秘密碎片 $v_i=f_i(0)=F(i，0)$，$i=1,2,...,n$，易得秘密碎片 $v_i$ 是 $g_0(x)$ 产生的碎片，即 $v_i=F(i，0)=g_0(i)$。这与 $Shamir$ 的 $(k，n)$ 秘密共享方案是一致的。因此，方案是一个完美的 $(k，n)$ 门限方案。

方案二作弊检测和识别能力分析：

       · 如果作弊人数 $t$ 满足 $t\le m-k+2$，则算法一可以检测到作弊。

       $step2$ 中，$t$ 个作弊者发布虚假秘密碎片 $v_i^{\ast }\ne vi$。结果表明，$m$ 个公开秘密碎片上的插值多项式 $g_0(x)$ 不等于原来的 $g_0(x)=F(x，0)$。只有当 $g_0(x)$ 的次数最多为 $k-1$ 且 $g_0(d_1)=g_{d_1}(0)$，$g_0(d_2)=g_{d_2}(0)$ 时，欺骗才能成功。如果作弊者随机发布他们的假秘密共享，即攻击1，作弊就很容易被发现。假设这些作弊者勾结在一起（攻击2），他们可以如下伪造他们的假秘密文件。在不失一般性的情况下，$P_1,P_2,...,P_t$ 是作弊者，$P_{t+1},P_{t+2},...,P_m$ 是诚实的参与者。作弊者生成一个 $k-1$ 次多项式 $g_0^{,}(x)\ne 0$，满足 $g_0^{,}(t+1)=g_0^{,}(t+2)=,...,=g_0^{,}(m)=0$，且 $g_0^{,}(d_1)=0$，$g_0^{,}(d_2)=0$。每个作弊者 $P_i$ 伪造一个伪秘密碎片 $v_i^{\ast }=v_i+g_0^{,}(i)$，$i=1,2,...,t$。因此，$v_1^{\ast },v_2^{\ast },\dots ,v_t^{\ast },v_{t+1},v_{t+2},...,v_m$ 上的插值多项式是 $g_0^{\ast }(x)=g_0(x)+g_0^{,}(x)$。因为 $g_0^{,}(d_1)=g_0^{,}(d_2)=0$，所以有 $g_0^{\ast }(d_1)=g_{d_1}(0)$ 和 $g_0^{\ast }(d_2)=g_{d_2}(0)$。所以通过发布伪造秘密碎片 $v_i^{\ast },i=1,2,...,t$ 成功作弊。但是，只有当 $m-t+2\le k-1$ 时，这种方法才有效，否则不存在满足 $g_0^{,}(t+1)=g_0^{,}(t+2)=,...,=g_0^{,}(m)0$，且 $g_0^{,}(d_1)=0，g_0^{,}(d_2)=0$。

       · 如果作弊人数 $t$ 满足 $t<\frac{m-k+3}{2}$，则算法一可以识别出作弊者。

       在 $step3$ 中，每个作弊者最多只能得到 $k+t-4$ 个票，设 $f_i^{\ast }(y)\ne f_i(y)$ 是作弊者 $P_i$ 的伪造多项式碎片。$f_i^{\ast }(y)$ 应与 $step2$ 中公布的 $Ei，1，Ei，2，v\ast i$一致。根据k−一次多项式的性质，f∗i(Y)至多可满足k−3个其他插值点f∗i(J)=fj(I)，j？=i，其中pj

       算法一在公布多项式份额之前公布检测碎片的目的是，作弊者不能随意地伪造他们的伪多项式碎片，伪多项式碎片 $f_i^{\ast }(y)$ 必须与他们公布的秘密碎片和检测碎片一致。在算法一中，如果 $t<\frac{m-k+3}{2}$，则可以识别作弊者。这种识别作弊者的能力与参数 $m$ 和 $k$ 有关，当更多的用户参与秘密重构时，相应地可以识别出更多的作弊者。

       算法一的局限性在于，当参与秘密重构的用户数 $m$ 接近 $k$ 时，识别欺骗者的能力将减弱。例如，当 $m=k$ 或 $m=k+1$ 时，算法一只能识别1个作弊者。因此，在算法一中，如果每个用户计算并发布 $u>2$ 个检测碎片，则可通过 $t<\frac{m-k+u+1}{2}$来增强作弊识别能力。

       · 如果 $t<k$，则可以使用算法二来检测作弊。

       令 $P_1,P_2,...,P_t$ 是作弊者，$P_{t+1},P_{t+2},...,P_M$ 都是诚实的用户。在算法二中，作弊者发布伪多项式碎片 $f_i^{\ast }(y)$，$i=1,2,...t$。如果 $t\ge k$，他们可以在秘密重构之前计算其他诚实用户多项式份额 $f_i(y)$，$i=t+1,t+2,...,m$ ，则可以生成另一个 $k-1$ 次对称多项式 $F^{\ast }(x,y)\ne F(x,y)$，它满足 $f_i(y)=F^{\ast }(i,y)$，$i=t+1,t+2,...,m$，并公布伪造的多项式碎片 $f^{\ast }i(y)=F^{\ast }(i,y)$，$i=1,2,...t$。这样，所有 $m$ 个用户都可以获得 $m-1$ 票，作弊成功。但是，当 $t<k$ 时，作弊者不能预先得到其他诚实用户的多项式碎片，欺骗成功只能通过猜测诚实用户的多项式碎片，概率最大为 $\frac{1}{q}$。此外，在防作弊秘密共享方案中，满足 $t<k$ 的作弊个数是一种共识。算法二可以检测来自任何 $k-1个$ 或更少的作弊者的作弊行为。当算法二检测到作弊时，其他 $n-m$ 个用户参与作弊识别，他们只需投票给 $m$ 个用户，而不公开他们的多项式碎片。

       · 如果 $t<\frac{n-k+1}{2}$，则算法二可以识别出所有 $t$ 个作弊者。

       · 算法一和算法二的选择可以根据应用中的不同要求来决定。例如，如果 $m>>k$，则算法一较好，因为当 $m>k$ 时，算法一在不涉及其他 $n-m$ 个用户的情况下具有较强的作弊识别能力 $t<\frac{m-k+3}{2}$；如果 $m$ 接近 $k$，则可以选择算法二来识别作弊，其能力为 $t<\frac{n-k+1}{2}$，与 $m$ 无关。

       实现代码见附录.2。

鲁棒性秘密共享

       $Roy$ 等人设计了一个简单的 $t-out-of-n$ 秘密共享方案，只要 $t<\frac{n}{2}$，它就可以在 $t$ 个作弊参与者存在的情况下重构秘密，概率最高为 $\delta$ [8]。通过应用 $Carpentieri$ 设计的 $"authentication$ $tag$ $compression"$ 技术改善了鲁棒性秘密共享方案的共享大小。

       消息鉴别码 $(MAC)$：在不假设任何计算困难的情况下验证消息的完整性。

       $Reed-Solomon$ $code$：令 $(a_0,...,a_t)\in F^{t+1}$ 且多项式 $f(x)=a_0+a_{1}x+...+a_t{x}^t$ 的最高次数为 $t$。$C=(f(x_1),f(x_2),...,f(x_n))$ 是消息 $(a_0,...,a_t)$ 的纠错码。$Reed-Solomon$ $code$ 最多可以修正 $e$ 个错误符号，即 $n$ 个求值点 $f(x_i)(1\le i\le n)$ 中的 $e$ 个被修改时，当且仅当 $n\ge t+1+2e$ ，多项式（消息）可以唯一确定。这里使用 $Berlekamp-Welch$ 算法[9]。

       $(t,\delta )$ 鲁棒秘密共享方案：存在一组 $n$ 个参与者，记为 $P=${$P_1,P_2,...,P_n$} 以及两个特殊参与者分发者$(D)$和重构者$(R)$。分享阶段，攻击者最多可以破坏 $t$ 个参与者的碎片。重构阶段，重构者在最多可能有 $t$ 个碎片被破坏的情况下，恢复正确的秘密信息 $s$ 的概率最大为 $\delta$。

       敌手模型：默认分发者$(D)$和重构者$(R)$是诚实的，且秘密碎片的传输是安全的。假设攻击者$(A)$在计算上是无限的、快速的、自适应的，且最多可以破坏 $t<\frac{n}{2}$ 个参与者的碎片。

方案如下：

• 初始化：
  
  • 设 ${\alpha }_i\in F_{2^m}$ {0} 是公开且固定的。且 ${\alpha }_i$ 在 $F_{2^q}$ 中是非零且互不相同的。
• 秘密信息分发：
  
  • 分发者$(D)$随机选取一个最高次数为 $t$ 的多项式 $f(x)\in F_{2^q}[X]$，$f(0)=s$ 是秘密信息。依次计算 $f({\alpha }_i)=s_i$，$i=1,2,...,n$。
  • 如果 $q<m$，令 $l=\frac{m}{q}$，$s_j=s_{j,1}||...||s_{j,l}$。分发者$(D)$随机选取 $d_{i,1},...,d_{i,t}$ 和 $g_{i,j}$。计算
    $$b_{i,j}=\{\begin{array}{ll}{g}_{i,j}{s}_j+{\sum }_{k=1}^t{\alpha }_i^k{d}_{j,k},& forq\ge m\\ {\sum }_{k=1}^l{g}_{i,j}^k{s}_{j,k}+{\sum }_{k=1}^t{\alpha }_i^k{d}_{j,k},& forq<m\end{array}$$
    $j=1,...,i-1,i+1,...,n$，$i=1,...,n$
    
  • 分发者$(D)$给每个参与者$P_i$分发秘密碎片
    $S_i=(s_i,d_{i,1},...,d_{i,t},g_{i,1},...,g_{i,i-1},g_{i,i+1},...,g_{i,n},b_{i,1},...,b_{i,i-1},b_{i,i+1},...,b_{i,n})$
• 秘密信息恢复：
  
  • 每个参与者$P_i$发送 $({s_i}^{\prime },{d_{i,1}}^{\prime },...,{d_{i,t}}^{\prime })$ 给重构者$R$。
  • 每个参与者$P_i$发送 $({g_{i,1}}^{\prime },...,{g_{i,i-1}}^{\prime },{g_{i,i+1}}^{\prime },...,,{g_{i,n}}^{\prime },{b_{i,1}}^{\prime },...,{b_{i,i-1}}^{\prime },{b_{i,i+1}}^{\prime },...,{b_{i,n}}^{\prime })$ 给重构者$R$。
  • 声明一个数组 $v$，如果 $P_i$ 的身份验证标记被 $P_j$ 接受，$v_{i,j}=1$，$i,j\in${$1,2....,n$}；否则，$v_{i,j}=0$。
  • 重构者$(R)$计算最大集合 $L\subseteq${$1,2,...,n$}，$L$ 满足
    $\forall i\in I:|${$j\in I|v_{ij}=1$}$|={\sum }_{j\in I}{v}_{ij}\ge t+1.$
    显然 $L$ 包含了所有诚实的参与者。令 $e=|L|-(t+1)$ 为 $L$ 中作弊者的最大数量。
  • 使用 $Reed-Solomon$ $code$ 的纠错算法（$Berlekamp-Welch$ 算法[9]），重构者 $R$ 计算得到一个最高次数为 $t$ 的多项式 $f(x)\in F_{2^m}[X]$，使得 $L$ 中至少 $(t+1)+\frac{e}{2}$ 个参与者 $P_i$ 满足 $f({\alpha }_i)={s_i}^{\prime }$。
    • 如果不存在这样的多项式，就输出 $\perp$；
    • 否则输出 $s=f(0)$

       在所提出的方案中，可在作弊概率和碎片大小之间权衡。因此，在自然约束下，参数可灵活设置。$q$ 可以小于或大于 $m$。

完美性证明：

       攻击者$A$在共享阶段控制任何 $t$ 个参与者的碎片，都不会得到关于秘密信息 $s$ 的任何信息。

       假设前 $t$ 个参与者 $P_i,...,P_t$ 被修改。根据拉格朗日插值公式，$t+1$ 个参与者可以完全重构一个 $t$ 次多项式。再选取一个 $s_i$，假定 $i=t+1$。估计通过 $(g_{i,t+1},b_{i,t+1})$ 用于每个 $P_i$ 的 $s_{t+1}$ 。

       $(q\ge m):$

       对所有的 $i\in L$，

$b_{i,t+1}=g_{i,t+1}{s}_{t+1}+{\alpha }_i{d}_{t+1,1}+{\alpha }_i^2{d}_{t+1,2}+...+{\alpha }_i^t{d}_{t+1,t}$。
       所以， $b_{i,t+1}-g_{i,t+1}{s}_{t+1}={\alpha }_i{d}_{t+1,1}+{\alpha }_i^2{d}_{t+1,2}+...+{\alpha }_i^t{d}_{t+1,t}$
       显然，对于 $s_{t+1}$ 的所有可能值，线性系统是一致的。可以得出结论，攻击者 $A$可以猜出正确的 $s_{t+1}$ 的概率最多为 $\frac{1}{2^m}$。

        $(q<m):$

       对所有的 $i\in L$， $b_{i,t+1}={\sum }_{k=1}^l{g}_{i,t+1}^k{s}_{t+1,k}+{\sum }_{k=1}^t{\alpha }_i^k{d}_{t+1,k}$。
       所以， $b_{i,t+1}-{\sum }_{k=1}^l{g}_{i,t+1}^k{s}_{t+1,k}={\sum }_{k=1}^t{\alpha }_i^k{d}_{t+1,k}$。
       对于任何固定值 $s_{t+1}=s_{t+1,1}||...||s_{t+1,l}$，可以使用与情况1 $(q\ge m)$ 中相同的参数来证明攻击者 $A$正确猜测 $s_{t+1}$ 的概率最多为 $\frac{1}{2^m}$。

鲁棒性：

       对于任何正整数 $t$，使得 $n=2t+1$，所提出的构造形式为 $(t,\delta )$鲁棒秘密共享方案，用于 $n$ 个参与者共享秘密。同时，
$\delta \le e^{((t+1)ϵ{)}^{\frac{(t+1)}{2}}}$，
$$ϵ=\{\begin{array}{ll}\frac{1}{2^q,}& forq\ge m\\ \frac{l}{2^q,}& forq<m\end{array}$$
       实现代码见 附录.3。

5.实验结果及分析

作弊可检测的秘密共享

方案一：

       基本实验参数：

s	n	t	p	$f(x)$（此处为方便演示固定，实际可随机选取）
12	8	5	19	$5\ast x^4+7\ast x^3+9\ast x^2+5\ast x+12$

       秘密分发如下：

$P_1$	$P_2$	$P_3$	$P_4$	$P_5$	$P_6$	$P{p}_7$	$P_8$
$(1,0)$	$(2,4)$	$(3,18)$	$(4,4)$	$(5,6)$	$(6,17)$	$(7,17)$	$(8,11)$

       模拟作弊者：

Cheater	$Src$	$Tar$
$P_2$	$(2,4)$	$(2,5)$
$P_8$	$(8,11)$	$(2,12)$

       作弊者检测与秘密信息恢复：

Users	Cheater	$f^{\prime }(x)$ Degree	Cheater Detection	Secret
$P_1$,$P_2$,$P_3$,$P_4$,$P_5$,$P_6$	$P_2:(2,5)$	$5>t-1$	$Yes$	$None$
$P_1$,$P_2$,$P_3$,$P_4$,$P_5$,$P_8$	$P_2:(2,5)$,$P_8:(8,12)$	$5>t-1$	$Yes$	$None$
$P_1$,$P_2$,$P_3$,$P_4$,$P_5$	$P_2:(2,5)$	$4=t-1$	$No$	$2$
$P_1$,$P_3$,$P_4$,$P_5$,$P_6$,$P_7$	$None$	$4=t-1$	$No$	$12$
$P_1$,$P_3$,$P_4$,$P_5$,$P_6$	$None$	$5>t-1$	$No$	$12$
$P_1$,$P_3$,$P_4$,$P_5$	$None$	$4=t-1$	$No$	$None$

       当参与恢复的用户数小于门限 $t$ 时，无法恢复秘密信息。当参与恢复的用户中含有作弊者且用户数大于门限 $t$ 时，可以检测出作弊者的存在。当参与恢复的用户中含有作弊者且用户数不大于门限 $t$ 时，不能检测出作弊者的存在。

方案二：

       基本实验参数：

s	n	t	p	$f(x)$（此处为方便演示固定，实际可随机选取）	$g(x)$（此处为方便演示固定，实际可随机选取）
12	8	5	19	$x^4+6\ast x^3+7\ast x^2+18\ast x+12$	$13\ast x^4+11\ast x^3+5\ast x^2+7\ast x+11$

       秘密分发如下：

$P_1$	$P_2$	$P_3$	$P_4$	$P_5$	$P_6$	$P{p}_7$	$P_8$
$(1,6,9)$	$(2,7,18)$	$(3,11,2)$	$(4,0,9)$	$(5,18,0)$	$(6,0,1)$	$(7,0,8)$	$(8,1,6)$

       模拟作弊者：

Cheater	$Src$	$Tar$
$P_2$	$(2,7,18)$	$(2,7,0)$
$P_8$	$(8,1,6)$	$(2,1,7)$

       作弊者检测与秘密信息恢复：

Users	Cheater	Cheater Detection	Secret
$P_1$,$P_2$,$P_3$,$P_4$,$P_5$,$P_6$	$P_2:(2,7,18)$	$Yes$	$None$
$P_1$,$P_2$,$P_3$,$P_4$,$P_5$,$P_8$	$P_2:(2,7,18)$,$P_8:(8,1,6)$	$Yes$	$None$
$P_1$,$P_2$,$P_3$,$P_4$,$P_5$	$P_2:(2,7,18)$	$Yes$	$None$
$P_1$,$P_3$,$P_4$,$P_5$,$P_6$	$P_3$,$P_4$,$P_5$,$P_6$	$Yes$	$None$
$P_1$,$P_3$,$P_4$,$P_5$,$P_6$,$P_7$	$None$	$No$	$12$
$P_1$,$P_3$,$P_4$,$P_5$,$P_6$	$None$	$No$	$12$
$P_1$,$P_3$,$P_4$,$P_5$	$None$	$No$	$None$

       当参与恢复的用户数小于门限 $t$ 时，无法恢复秘密信息。当参与恢复的用户中含有作弊者且作弊者数小于 $t-1$ 时，可以检测出作弊者的存在。相比方案一，可检测的下限更低，最少 $t$ 个用户就可以进行检测。

作弊可识别的秘密共享

       基本实验参数：

s	n	t	p	$F(x,y)$（此处为方便演示固定，实际可随机选取）
13	9	5	23	$-4\ast x^4\ast y^4+2\ast x^4\ast y^3+2\ast x^3\ast y^4-4\ast x^4\ast y^2-x^3\ast y^3-4\ast x^2\ast y^4-10\ast x^4\ast y-9\ast x^3\ast y^2-9\ast x^2\ast y^3-10\ast x\ast y^4-5\ast x^4+10\ast x^3\ast y+6\ast x^2\ast y^2+10\ast x\ast y^3-5\ast y^4-2\ast x^3+5\ast x^2\ast y+5\ast x\ast y^2-2\ast y^3+4\ast x^2+9\ast x\ast y+4\ast y^2+7\ast x+7\ast y-10$

       秘密分发如下：

User	Share
$P_1$	$(1,2\ast y^4+2\ast y^2-2\ast y-6)$
$P_2$	$(2,3\ast y^4+6\ast y^3-6\ast y^2+11\ast y-7)$
$P_3$	$(3,4\ast y^4-10\ast y^3-11\ast y^2-y+2)$
$P_4$	$(4,7\ast y^4-3\ast y^3-8\ast y^2-3\ast y+8)$
$P_5$	$(5,10\ast y^4+5\ast y^3+4\ast y^2+7\ast y-7)$
$P_6$	$(6,7\ast y^4-6\ast y^3-y^2-2\ast y+3)$
$P_7$	$(7,7\ast y^4-6\ast y^3-y^2-2\ast y+3)$
$P_8$	$(8,7\ast y^4-6\ast y^3-y^2-2\ast y+3)$
$P_9$	$(9,7\ast y^4-6\ast y^3-y^2-2\ast y+3)$

       模拟作弊者：

Cheater	$Src$	$Tar$
$P_2$	$(2,3\ast y^4+6\ast y^3-6\ast y^2+11\ast y-7)$	$(2,3\ast y^4+6\ast y^3-6\ast y^2+11\ast y-6)$
$P_3$	$(3,4\ast y^4-10\ast y^3-11\ast y^2-y+2)$	$(3,4\ast y^4-10\ast y^3-11\ast y^2-y+3)$

       作弊者检测识别与秘密信息恢复：

Users	Cheater	Algorithm	Cheater Detection	Cheater Recognition	Secret
$P_3$,$P_4$,$P_5$,$P_6$,$P_7$,$P_8$,$P_9$	Algorithm 1	$P_3$	$Yes$	$P_3$	$13$
$P_3$,$P_4$,$P_5$,$P_6$,$P_7$,$P_8$,$P_9$	Algorithm 2	$P_3$	$Yes$	$P_3$	$13$
$P_1$,$P_2$,$P_3$,$P_4$,$P_5$,$P_8$,$P_9$	Algorithm 1	$P_2$,$P_3$	$Yes$	$P_2$,$P_3$	$13$
$P_1$,$P_2$,$P_3$,$P_4$,$P_5$,$P_8$,$P_9$	Algorithm 2	$P_2$,$P_3$	$Yes$	$P_2$,$P_3$	$13$
$P_1$,$P_2$,$P_3$,$P_4$,$P_5$,$P_8$	Algorithm 1	$P_2$,$P_3$	$Yes$	$P_2$,$P_3$	$None$
$P_1$,$P_2$,$P_3$,$P_4$,$P_5$,$P_8$	Algorithm 2	$P_2$,$P_3$	$Yes$	$P_2$,$P_3$	$None$
$P_1$,$P_2$,$P_3$,$P_4$,$P_5$	Algorithm 1	$P_2$,$P_3$	$Yes$	$None$	$None$
$P_1$,$P_2$,$P_3$,$P_4$,$P_5$	Algorithm 2	$P_2$,$P_3$	$Yes$	$P_2$,$P_3$	$None$
$P_1$,$P_7$,$P_4$,$P_5$,$P_6$	Algorithm 1	$None$	$No$	$None$	$13$
$P_1$,$P_7$,$P_4$,$P_5$,$P_6$	Algorithm 2	$None$	$No$	$None$	$13$
$P_1$,$P_2$,$P_4$,$P_5$	Algorithm 1	$None$	$No$	$None$	$None$
$P_1$,$P_2$,$P_4$,$P_5$	Algorithm 2	$None$	$No$	$None$	$None$

       当参与恢复的用户数小于门限 $t$ 时，算法1和算法2均无法恢复秘密信息。当参与恢复的用户中含有作弊者且用户数大于门限 $t$ 时，算法1和算法2均可以检测出作弊者的存在。当参与恢复的用户中含有作弊者且作弊用户数 $k<\frac{m-t+3}{2}$ 时，算法1无法识别具体的作弊者，但算法2可以。当识别出作弊者，且去除作弊者后的参与恢复用户数大于等于门限 $t$，则可以恢复秘密信息，否则不能。

鲁棒性秘密共享

       基本实验参数：

s	n	t	p	$f(x)$（此处为方便演示固定，实际可随机选取）
12	7	5	17	$16\ast x^4+15\ast x^3+16\ast x^2+12$

       秘密分发如下：

User	Share s	Share $S=(s_i,d_{i,1},...,d_{i,t},g_{i,1},...,g_{i,i-1},g_{i,i+1},...,g_{i,n},b_{i,1},...,b_{i,i-1},b_{i,i+1},...,b_{i,n})$
$P_1$	$(1,8)$	$[8,[4,1,15,5,0],[11,0,13,12,11,3],[133,39,68,197,224,32]]$
$P_2$	$(2,10)$	$[10,[10,1,2,10,0],[0,2,8,0,10,14],[106,151,166,146,334,96]]$
$P_3$	$(3,4)$	$[4,[9,13,7,10,0],[7,9,10,2,15,13],[333,391,457,423,692,140]]$
$P_4$	$(4,3)$	$[3,[4,9,2,14,0],[14,5,4,11,8,5],[680,736,829,1003,1070,196]]$
$P_5$	$(5,13)$	$[13,[16,7,7,11,0],[5,5,11,10,0,10],[1049,1365,1543,1879,1704,356]]$
$P_6$	$(6,16)$	$[13,[16,7,7,11,0],[5,5,11,10,0,10],[1049,1365,1543,1879,1704,356]]$
$P_7$	$(7,4)$	$[4,[16,0,2,2,0],[16,5,12,14,1,3],[2589,3595,3921,5009,4194,4332]]$

       模拟作弊者：

Cheater	$Src$	$Tar$
$P_2$	$(2,10)$	$(2,11)$
$P_3$	$(3,4)$	$(3,5)$

       鲁棒性秘密信息恢复：

Users	Cheater	$Ep$	$Qp$	$Pp$	Secret
$P_1$,$P_2$,$P_3$,$P_4$,$P_5$,$P_6$,$P_7$	$P_2$	$x+15$	$16\ast x^5+3\ast x^3+2\ast x^2+12\ast x+10$	$16x^4 + 15x^3 + 16*x^2 + 12
$	$12$
$P_1$,$P_2$,$P_3$,$P_4$,$P_5$,$P_6$,$P_7$	$P_2$,$P_3$(作弊数$\ge \frac{m-t+1}{2}$)	$None$	$None$	$None$	$None$
$P_1$,$P_2$,$P_3$,$P_4$,$P_5$,$P_6$,$P_7$	$None$	$x+15$	$16\ast x^5+3\ast x^3+2\ast x^2+12\ast x+10$	$16x^4 + 15x^3 + 16*x^2 + 12
$	$12$
$P_1$,$P_2$,$P_3$,$P_4$,$P_5$	$None$	$None$	$None$	$16\ast x^4+15\ast x^3+16\ast x^2+12$	$12$
$P_1$,$P_2$,$P_3$,$P_4$	$None$	$None$	$None$	$None$	$None$

       当参与恢复的用户数小于门限 $t$ 时，无法恢复秘密信息。当参与恢复的用户数大于门限 $t$，且其中包含的作弊者数 $<\frac{m-t+1}{2}$ 时，可以恢复秘密信息，否则不能。

6.总结

       作弊可检测的秘密共享方案一中，虽然作弊者被发现的概率很高，但他们获得了秘密，而其他参与者却没有获得关于该秘密的信息。同时需要至少 $t+1$ 个用户才能检测。

       作弊可检测的秘密共享方案二中，最少只需要 $t$ 个用户就可以检测作弊者，且最多可以检测 $t-1$ 个作弊者

       作弊可识别的秘密共享方案二中，第一个算法可以通过 $m$ 个参与秘密重构的用户来识别作弊者，第二个算法可以在其余 $n-m$ 个未参与秘密重构的用户的协作下实现更强的作弊识别能力。该方案的欺诈识别仅基于二元多项式的对称性和插值多项式的线性，不包含份额中的任何冗余信息。这两种算法在识别作弊者的能力方面都是有效的。

       鲁棒性秘密共享方案中，共享碎片的大小有所改进。

引用

[1] A Shamir, How to share a secret. Commun. ACM. 22(11), 612–613 (1979).
[2] K. Kaya et al.Threshold cryptography based on asmuth-bloom secret sharing Inf. Sci. (Ny) (2007)
[3] Tompa, M., Woll, H. How to share a secret with cheaters. J. Cryptology 1, 133–138 (1989)
[4]  R.J.McEliece and D.V.Sarwate, On sharing secrets and Reed-Solomon codes,Comm.ACM, 24(1981), pp.583-584.
[5] Harn, L., Lin, C. Detection and identification of cheaters in (t, n) secret sharing scheme. Des. Codes Cryptogr. 52, 15–24 (2009).
[6] Kurosawa K., Obana S., Ogata W. (1995) t-Cheater Identifiable (k, n) Threshold Secret Sharing Schemes. In: Coppersmith D. (eds) Advances in Cryptology — CRYPT0’ 95. CRYPTO 1995. 
[7] Liu, Yanxiao; Yang, Chingnung; Wang, Yichuan; Zhu, Lei; Ji, Wenjiang (2018). Cheating identifiable secret sharing scheme using symmetric bivariate polynomial. Information Sciences, 453(), 21–29. 
[8] Roy, P. S., Adhikari, A., Xu, R., Morozov, K., & Sakurai, K. (2014). An Efficient Robust Secret Sharing Scheme with Optimal Cheater Resiliency. Lecture Notes in Computer Science, 47–58.
[9] Berlekamp, E.R., Welch, L.R.: Error correction of algebraic block codes. U.S. Patent Number 4, 633.470 (1986)
[10] Y. Liu, “Linear (k, n ) secret sharing scheme with cheating detection,” Security and Communication Networks, vol. 9, no. 13, pp. 2115–2121, 2016.

附录.1

# -------------------------------------------------------------------------
# 作弊者可检测秘密共享方案
# -------------------------------------------------------------------------
# 秘密信息划分函数
# 参数s：秘密信息
# 参数n：划分个数
# 参数t：门限
# 参数p：模数
# -------------------------------------------------------------------------
def ShareGen(s, n, t, p):
    # 随机生成多项式系数，n-1次，模p
    factor = []
    S = []
    for i in range(t - 1):
        factor.append(ZZ.random_element(0, p))
    factor.append(s)
    print("多项式系数：",factor)
    factor.reverse()
    # 定义在环Zp上的多项式
    R.<x> = Zmod(p)[]
    f = R(factor)
    print("多项式为：", f)
    # 计算n个秘密碎片
    for i in range(n):
        temp = []
        num = s
        temp.append(i+1)
        # 计算多项式的值 f(i)
        temp.append(f(i+1))
        S.append(temp)
    
    print("秘密信息划分为：", S)
    return S

# -------------------------------------------------------------------------
# 作弊者检测和秘密信息恢复函数 
# 参数S：秘密信息碎片列表
# 参数t：门限
# 参数p：模数
# -------------------------------------------------------------------------
def Detection_Reconstruct(S, t, p):
    if len(S) < t:
        print("参与恢复的碎片数量少于门限{0}，无法恢复！".format(t))
    else:
        secret = 0
        # 定义在环Zp上的多项式
        R.<x> = Zmod(p)[]
        f = R([0])
        # 拉格朗日插值法
        for i in range(len(S)):
            temp = []
            num1, num2 = 1, 1
            temp.extend(S[:i])
            temp.extend(S[i+1:])

            g1 = R([1])
            g2 = R([1])
            
            for j in range(len(temp)):
                g1 = (g1 * (x - temp[j][0]))
                g2 = (g2 * (S[i][0] - temp[j][0]))
            g = int(g2(0))
            f = (f + S[i][1] * g1 * inverse_mod(g, p))

        print("重构多项式为：", f)
        print("次数为：", R(f).degree())
        # 判断多项式次数
        if R(f).degree() == t - 1:
            secret = f(0)
            print("恢复的秘密信息为：", secret)
            return secret
        else:
            print("警告！检测到作弊者，恢复秘密失败！")
            return -1

# -------------------------------------------------------------------------
# 测试
# -------------------------------------------------------------------------
S = ShareGen(12, 8, 5, 19)
# 正常情况
s = Detection_Reconstruct(S[:5], 5, 19)
# 攻击
# 作弊者修改 [1,y+1]
S[1][1] = S[1][1] + 1
# S[2][1] = S[2][1] + 1
s = Detection_Reconstruct(S[:6], 5, 19)

附录.2

# -------------------------------------------------------------------------
# 作弊者可检测识别秘密共享方案
# -------------------------------------------------------------------------
# 秘密划分函数
# 参数s：秘密信息
# 参数n：划分个数
# 参数t：门限
# 参数p：模数
# -------------------------------------------------------------------------
def ShareGen(s, n, t, p):
    S = []
    # 定义在环Zp上的多项式
    R.<x,y> = GF(p)[]
    # 此处默认，分发中心D可自主选择（保密）
    f = 7*x + 4*x^2 + 21*x^3 + 18*x^4 + 7*y + 9*x*y + 5*x^2*y + 10*x^3*y + 13*x^4*y + 4*y^2 + 5*x*y^2 + 6*x^2*y^2 + 14*x^3*y^2 + 19*x^4*y^2 + 21*y^3 +\
    10*x*y^3 + 14*x^2*y^3 + 22*x^3*y^3 + 2*x^4*y^3 + 18*y^4 + 13*x*y^4 + 19*x^2*y^4 + 2*x^3*y^4 + 19*x^4*y^4
    f = f + s
    print("二元多项式为：", f)
    # 计算n个秘密碎片
    print("秘密信息划分为：")
    for i in range(n):
        temp = []
        num = s
        temp.append(i+1)
        # 计算多项式的值 f(i)
        temp.append(f(i+1,y))
        S.append(temp)
        print(f(i+1,y))
    
    return S

# -------------------------------------------------------------------------
# 作弊者检测识别和秘密信息恢复函数 
# 参数S：多项式碎片列表
# 参数t：门限
# 参数p：模数
# 参数v: 秘密碎片
# 参数e1: 检测碎片
# 参数e2: 检测碎片
# 参数d1: 随机整数
# 参数d2: 随机整数
# -------------------------------------------------------------------------
# 算法1
# -------------------------------------------------------------------------
def Detection_Reconstruct1(S, v, e1, e2, t, n, p, d1, d2):
    print("算法一：")
    if len(S) < t:
        print("参与恢复的碎片数量少于门限{0}，无法恢复！".format(t))
    else:
        # 秘密信息
        secret = 0
        R.<x> = Zmod(p)[]
        
        # Step 2
        # 拉格朗日插值法 v
        g0 = R([0])
        for i in range(len(v)):
            temp = []
            num1, num2 = 1, 1
            temp.extend(v[:i])
            temp.extend(v[i+1:])

            h1 = R([1])
            h2 = R([1])
            
            for j in range(len(temp)):
                h1 = (h1 * (x - temp[j][0]))
                h2 = (h2 * (v[i][0] - temp[j][0]))
            h = int(h2(0))
            g0 = (g0 + v[i][1] * h1 * inverse_mod(h, p))

        print("重构多项式g0为：", g0)
        
        # 拉格朗日插值法 e1
        g1 = R([0])
        for i in range(len(e1)):
            temp = []
            num1, num2 = 1, 1
            temp.extend(e1[:i])
            temp.extend(e1[i+1:])

            h1 = R([1])
            h2 = R([1])
            
            for j in range(len(temp)):
                h1 = (h1 * (x - temp[j][0]))
                h2 = (h2 * (e1[i][0] - temp[j][0]))
            h = int(h2(0))
            g1 = (g1 + e1[i][1] * h1 * inverse_mod(h, p))

        print("重构多项式g1为：", g1)
        
        # 拉格朗日插值法 e2
        g2 = R([0])
        for i in range(len(e2)):
            temp = []
            num1, num2 = 1, 1
            temp.extend(e2[:i])
            temp.extend(e2[i+1:])

            h1 = R([1])
            h2 = R([1])
            
            for j in range(len(temp)):
                h1 = (h1 * (x - temp[j][0]))
                h2 = (h2 * (e2[i][0] - temp[j][0]))
            h = int(h2(0))
            g2 = (g2 + e2[i][1] * h1 * inverse_mod(h, p))

        print("重构多项式g2为：", g2)
        
        # Step 3
        if g0.degree() == t-1 and g1.degree() == t-1 and g2.degree() == t-1:
            # print(g1(d2),g2(d1),g1(0),g2(0),g0(d2))
            if g1(d2) == g2(d1) and g1(0) == g0(d1) and g2(0) == g0(d2):
                secret = g0(0)
                print("未检测到作弊者！")
                print("恢复的秘密信息为：", secret)
        else:
            # Step 4
            # 票数 V
            V = []
            # 作弊者列表
            L = []
            # 诚实用户
            H = []
            for i in range(len(v)):
                V.append([v[i][0], 0])
            for i in range(len(v)):
                for j in range(i + 1, len(v)):
                    # print(S[i][0],S[j][0],S[i][1](S[i][0],S[j][0]),S[j][1](S[j][0],S[i][0]))
                    if S[i][1](S[i][0],S[j][0]) == S[j][1](S[j][0],S[i][0]):
                        V[i][1] = V[i][1] + 1
                        V[j][1] = V[j][1] + 1
            
            for i in range(len(v)):
                if V[i][1] < float((len(v) + t - 5) / 2):
                    # 作弊者
                    L.append(V[i][0])
                else:
                    # 诚实用户
                    H.append(v[i])
            
            print("存在作弊者，识别到的作弊者为：", L)
            
            # 重构秘密信息 secret
            if len(v) - len(L) >= t:
                # 拉格朗日插值法
                f = R([0])
                for i in range(len(H)):
                    temp = []
                    num1, num2 = 1, 1
                    temp.extend(H[:i])
                    temp.extend(H[i+1:])

                    g1 = R([1])
                    g2 = R([1])

                    for j in range(len(temp)):
                        g1 = (g1 * (x - temp[j][0]))
                        g2 = (g2 * (H[i][0] - temp[j][0]))
                    g = int(g2(0))
                    f = (f + H[i][1] * g1 * inverse_mod(g, p))
                secret = f(0)
                print("重构多项式为：", f)
                print("恢复的秘密信息为：", secret)
            else:
                print("诚实用户数不足，无法恢复秘密信息！")

# -------------------------------------------------------------------------
# 算法2
# -------------------------------------------------------------------------
def Detection_Reconstruct2(S_other, S, v, t, p):
    print("算法二：")
    if len(S) < t:
        print("参与恢复的碎片数量少于门限{0}，无法恢复！".format(t))
    else:
        secret = 0
        R.<x> = Zmod(p)[]
        
        # Step 1
        # 票数 V
        V = []
        # 作弊者列表
        L = []
        # 诚实用户
        H = []
        for i in range(len(S)):
            V.append([S[i][0], 0])
        for i in range(len(S)):
            for j in range(i + 1, len(S)):
                # print(S[i][1](S[i][0],j+1) , S[j][1](S[j][0],i+1))
                if S[i][1](S[i][0],S[j][0]) == S[j][1](S[j][0],S[i][0]):
                    V[i][1] = V[i][1] + 1
                    V[j][1] = V[j][1] + 1
        flag = 1
        for i in range(len(S)):
            if V[i][1] != len(S) - 1:
                flag = 0
                break
        if flag == 1:
            # Step 2
            print("不存在作弊者！")
            # 重构秘密信息 secret
            # 拉格朗日插值法
            f = R([0])
            vv = v[:t]
            for i in range(t):
                temp = []
                num1, num2 = 1, 1
                temp.extend(vv[:i])
                temp.extend(vv[i+1:])
                    
                g1 = R([1])
                g2 = R([1])
                    
                for j in range(len(temp)):
                    g1 = (g1 * (x - temp[j][0]))
                    g2 = (g2 * (vv[i][0] - temp[j][0]))
                g = int(g2(0))
                f = (f + vv[i][1] * g1 * inverse_mod(g, p))
            secret = f(0)
            print("重构多项式为：", f)
            print("恢复的秘密信息为：", secret)
        else:
            # Step 3
            # 识别作弊者
            # n - m 个用户投票
            for i in range(len(S_other)):
                for j in range(len(S)):
                    
                    if S_other[i][1](S_other[i][0],S[j][0]) == S[j][1](S[j][0],S_other[i][0]):
                        V[j][1] = V[j][1] + 1
            for i in range(len(S)):
                if V[i][1] < float((n + t - 3) / 2):
                    # 作弊者
                    L.append(V[i][0])
                else:
                    # 诚实用户
                    H.append(v[i])
            
            print("存在作弊者，识别到的作弊者为：", L)
            # 重构秘密信息 secret
            if len(v) - len(L) >= t:
                # 拉格朗日插值法
                f = R([0])
                for i in range(len(H)):
                    temp = []
                    num1, num2 = 1, 1
                    temp.extend(H[:i])
                    temp.extend(H[i+1:])

                    g1 = R([1])
                    g2 = R([1])

                    for j in range(len(temp)):
                        g1 = (g1 * (x - temp[j][0]))
                        g2 = (g2 * (H[i][0] - temp[j][0]))
                    g = int(g2(0))
                    f = (f + H[i][1] * g1 * inverse_mod(g, p))
                secret = f(0)
                print("重构多项式为：", f)
                print("恢复的秘密信息为：", secret)
                
            else:
                print("诚实用户数不足，无法恢复秘密信息！")
                
                
# -------------------------------------------------------------------------
# 测试
# -------------------------------------------------------------------------
t = 5
n = 9
p = 23
secret =13

S = ShareGen(secret, n, t, p)

# 攻击
# 伪造一个碎片 [1, f1()] 改为 [1, f1()+1]

S[2][1] = S[2][1]+1

# 秘密碎片
v = []
# 检测碎片
e1 = []
e2 = []
        
# 定义在环Zp上的多项式
R.<x,y> = GF(p)[]
# 生成两个随机数 d1,d2 >n
d1 = ZZ.random_element(n, n*n)
d2 = ZZ.random_element(n, n*n)

# 计算秘密碎片 v 检测碎片 e1,e2
for i in range(len(S)):
    f = S[i][1]
    v.append([S[i][0],f(S[i][0],0)])
    e1.append([S[i][0],f(S[i][0],d1)])
    e2.append([S[i][0],f(S[i][0],d2)])

# 参与重构的用户
m = 6
# 算法一
Detection_Reconstruct1(S[2:], v[2:], e1[2:], e2[2:], t, n, p, d1, d2)
# 算法二
# 攻击
S_other = S[:2]
S = S[2:]
Detection_Reconstruct2(S_other, S, v[2:], t, p)

附录.3

# -------------------------------------------------------------------------
# 鲁棒秘密共享方案
# -------------------------------------------------------------------------
# 秘密划分函数
# 参数s：秘密信息
# 参数n：划分个数
# 参数t：门限
# 参数p：模数
# -------------------------------------------------------------------------
import numpy as np

def ShareGen(s, n, t, p):
    # 此处默认参与者序号从1开始以此增加到n
    # 随机选取最高次数为 t-1 的多项式，模p
    factor = []
    S = []
    SS = []
    for i in range(t - 1):
        factor.append(ZZ.random_element(0, p))
    factor.append(s)
    print("多项式系数：",factor)
    factor.reverse()
    # 定义在环Zp上的多项式
    R.<x> = Zmod(p)[]
    f = R(factor)
    print("多项式为：", f)
    # 计算n个秘密碎片
    for i in range(n):
        temp = []
        num = s
        temp.append(i+1)
        # 计算多项式的值 f(i)
        temp.append(f(i+1))
        S.append(temp)
    
    print("秘密信息划分为：", S)
    
    # p<s
    g = np.zeros((n, n))
    d = np.zeros((n, t))
    b = np.zeros((n, n))
    # 随机选取 d
    for i in range(n):
        for k in range(t-1):
            d[i][k] = ZZ.random_element(0, p)
    for i in range(n):
        for j in range(n-1):
            if j >= i:
                j = j+1
            # 随机选取 g
            g[i][j] = ZZ.random_element(0, p)
            
            if p < s:
                l = s/p
                s_j = []
                # 十进制转二进制
                s_bin = bin(S[j][1])
                s_bin = s_bin[2:]
                ls = list(s_bin)
                ls.reverse()
                # 计算 s_j
                s_j = []
                for k in range(l*len(bin(p)[2:])-len(l)):
                    ls.append('0')
                ls.reverse()
                for k in range(l):
                    s_j.append(int("".join(l[k*len(bin(p)[2:]):(k+1)*len(bin(p)[2:])]),2))
                
                # 计算 b
                sum_1, sum_2 = 0, 0
                
                for k in range(l):
                    sum_1 = sum_1 + g[i][j]^k*s_j[k]
                for k in range(t-1):
                    sum_2 = sum_2 + S[i][0]^k*d[j][k]
                    
                b[i][j] = sum_1 +sum_2
            else:
                # 计算 b
                sum_1 = 0
                
                for k in range(t-1):
                    sum_1 = sum_1 + S[i][0]^k*d[j][k]
                
                b[i][j] = g[i][j]*int(S[j][1]) + int(sum_1)
        
        g_temp = list(g[i])[:i]
        g_temp.extend(list(g[i])[i+1:])
        b_temp = list(b[i])[:i]
        b_temp.extend(list(b[i])[i+1:])
        SS.append([[i+1],[S[i][1], list(d[i]), g_temp, b_temp]])
        
    print("秘密信息划分为：", SS)
    return SS

# -------------------------------------------------------------------------
# 秘密信息恢复函数 
# 参数S：多项式碎片列表
# 参数t：门限
# 参数p：模数
# 参数l：l=m/p
# -------------------------------------------------------------------------
def Reconstruct(S, t, n, l, p):
    s = [0]*len(S)
    g = np.zeros((n, n))
    d = np.zeros((n, t))
    b = np.zeros((n, n))
    b_ver = np.zeros((n, n)) 
    # 秘密碎片第一部分 s,d
    for i in range(len(S)):
        s[i] = S[i][1][0]
        # print(np.array(S[1][1]))
        d[i] = np.array(S[i][1][1])
        
    # 秘密碎片第二部分 g,b
    for i in range(len(S)):
        temp = S[i][1][2][:i]
        temp.append(0)
        temp.extend(S[i][1][2][i:])
        g[i] = np.array(temp)
        
        temp = S[i][1][3][:i]
        temp.append(0)
        temp.extend(S[i][1][3][i:])
        b[i] = np.array(temp)
    
    # 验证数组 v
    v = np.zeros((n, n))
    # 计算 b'
    for i in range(len(S)):
        for j in range(len(S)-1):
            if j >= i:
                j = j+1
            # p<m
            if l>1:
                # 计算 b'
                sum_1, sum_2 = 0, 0
                
                for k in range(l):
                    sum_1 = sum_1 + g[i][j]^k*s_j[k]
                for k in range(t-1):
                    sum_2 = sum_2 + S[i][0]^k*d[j][k]
                    
                b_ver[i][j] = int(sum_1) + int(sum_2)
            else:
                # 计算 b'
                sum_1 = 0
                
                for k in range(t-1):
                    sum_1 = sum_1 + S[i][0][0]^k*d[j][k]
                b_ver[i][j] = int(g[i][j])*int(s[j]) + int(sum_1)
    
    # 验证
    for i in range(len(S)):
        for j in range(len(S)-1):
            if j >= i:
                j = j+1
            if b_ver[i][j] == b[i][j]:
                v[i][j] = 1
    print("验证数组为：\n", v)
    
    # 计算满足条件的最大集合 I
    I = []
    for i in range(len(S)):
        sum_vi = 0
        for j in range(len(S)-1):
            if j >= i:
                j = j+1
            sum_vi = sum_vi + v[i][j]
        if sum_vi >= t:
            I.append([S[i][0][0],S[i][1][0]])
    e = (len(I)-t)//2

    if e > 0:
        print("作弊者数量最大为：", e)

        # 使用 Reed−Solomon code 的纠错算法重构秘密信息
        # Berlekamp-Welch算法
        for m in range(1, e+1):
            print("假设错误个数为：", m)
            E, Q = np.zeros((len(I),m+1)), np.zeros((len(I),m+t))
            for i in range(len(I)):
                for j in range(m+1):
                    E[i][j] = int(I[i][1]*(I[i][0]^j))
                for k in range(m+t):
                    Q[i][k] = int(I[i][0]^k)

            b_temp = [[0] * m + [1] + [0] * (m+t)]
            slv = np.append(E, (-1)*Q, axis=1)
            slv = np.append(slv,b_temp,axis=0)

            slv = matrix(Zmod(p), len(I)+1, 2*m+t+1, slv)
            b_temp = [0] * (len(I))
            b_temp.append(1)
            b_temp = matrix(Zmod(p), len(I)+1, 1, b_temp)
            try:
                X = slv.solve_right(b_temp)
            except Exception:
                print("错误个数有误，无法恢复！")
                continue
            Q,E = [],[]
            for i in range(m+1):
                E.append(X[i,0])
            for i in range(m+1,2*m+t+1):
                Q.append(X[i,0])

            R.<x> = Zmod(p)[]
            Ep = R(E)
            Qp = R(Q)
            Pp = Qp/Ep
            print("恢复的多项式：")
            print("Ep:", Ep)
            print("Qp:", Qp)
            if Qp % Ep == 0:
                print("Pp:", Pp)
                print("恢复的秘密信息为：", Pp(0))
                return Pp(0)
            else:
                print("多项式无法重构！")
                return -1
    else:
        R.<x> = Zmod(p)[]
        f = R([0])
        # 拉格朗日插值法
        if len(I) >= t:
            for i in range(len(I)):
                temp = []
                num1, num2 = 1, 1
                temp.extend(I[:i])
                temp.extend(I[i+1:])

                g1 = R([1])
                g2 = R([1])

                for j in range(len(temp)):
                    g1 = (g1 * (x - temp[j][0]))
                    g2 = (g2 * (I[i][0] - temp[j][0]))
                g = int(g2(0))
                f = (f + I[i][1] * g1 * inverse_mod(g, p))

            print("重构多项式为：", f)
            print("恢复的秘密信息为：", f(0))
            return f(0)
        else:
            print("通过验证的参与者数量少于门限t，无法恢复秘密信息s！")
            return -1
    
    
# -------------------------------------------------------------------------
# 测试
# -------------------------------------------------------------------------
s=12
n=7
t=5
p=17
S = ShareGen(s, n, t, p)
# 改变一个碎片
S[1][1][0] = (S[1][1][0]+1)%p
# S[2][1][0] = S[2][1][0]+1
Reconstruct(S, t, n, 1, p)
# 改变两个碎片
S[2][1][0] = (S[2][1][0]+1)%p
# S[2][1][0] = S[2][1][0]+1
Reconstruct(S, t, n, 1, p)

附录.4

# -------------------------------------------------------------------------
# 作弊者可检测秘密共享方案
# -------------------------------------------------------------------------
# 秘密信息划分函数
# 参数s：秘密信息
# 参数n：划分个数
# 参数t：门限
# 参数p：模数
# -------------------------------------------------------------------------
def ShareGen(s, n, t, p):
    # 随机生成多项式系数，n-1次，模p
    factor = []
    S = []
    for i in range(t - 1):
        factor.append(ZZ.random_element(0, p))
    factor.append(s)
    print("多项式系数：",factor)
    factor.reverse()
    # 定义在环Zp上的多项式
    R.<x> = Zmod(p)[]
    f = R(factor)
    # 计算多项式 g
    a0 = factor[0]
    a1 = factor[1]
    # 随机数r
    r = ZZ.random_element(1, p)
    print("随机数为：", r)
    
    b0 = p - (r*a0)%p
    b1 = p - (r*a1)%p
    factor = []
    for i in range(t - 2):
        factor.append(ZZ.random_element(0, p))
        
    factor.append(b1)
    factor.append(b0)    
    factor.reverse()
    g = R(factor)
    
    print("多项式为f：", f)
    print("多项式为g：", g)
    
    # 计算n个秘密碎片
    for i in range(n):
        temp = []
        num = s
        temp.append(i+1)
        # 计算多项式的值 f(i)
        temp.append(f(i+1))
        temp.append(g(i+1))
        S.append(temp)
        
    print("秘密信息划分为：", S)
    return S

# -------------------------------------------------------------------------
# 作弊者检测和秘密信息恢复函数 
# 参数S：秘密信息碎片列表
# 参数t：门限
# 参数p：模数
# -------------------------------------------------------------------------
def Detection_Reconstruct(S, t, p):
    if len(S) < t:
        print("参与恢复的碎片数量少于门限{0}，无法恢复！".format(t))
    else:
        secret = 0
        # 定义在环Zp上的多项式
        R.<x> = Zmod(p)[]
        f = R([0])
        g = R([0])
        # 拉格朗日插值法
        for i in range(len(S)):
            temp = []
            num1, num2 = 1, 1
            temp.extend(S[:i])
            temp.extend(S[i+1:])

            g1 = R([1])
            g2 = R([1])
            
            for j in range(len(temp)):
                g1 = (g1 * (x - temp[j][0]))
                g2 = (g2 * (S[i][0] - temp[j][0]))
            g_int = int(g2(0))
            f = (f + S[i][1] * g1 * inverse_mod(g_int, p))
        
                # 拉格朗日插值法
        for i in range(len(S)):
            temp = []
            num1, num2 = 1, 1
            temp.extend(S[:i])
            temp.extend(S[i+1:])

            g1 = R([1])
            g2 = R([1])
            
            for j in range(len(temp)):
                g1 = (g1 * (x - temp[j][0]))
                g2 = (g2 * (S[i][0] - temp[j][0]))
            g_int = int(g2(0))
            g = (g + S[i][2] * g1 * inverse_mod(g_int, p))
        
        print("重构多项式f为：", f)
        print("重构多项式g为：", g)
        
        a0 = int(str(f).split("+")[-1])
        if str(f).split("+")[-2][-2] != "x":
            a1 = 0
        else:
            if str(f).split("+")[-2].split("*")[0] == " ":
                a1 = 1
            else:
                a1 = int(str(f).split("+")[-2].split("*")[0])
        
        b0 = int(str(g).split("+")[-1])
        if str(g).split("+")[-2][-2] != "x":
            b1 = 0
        else:
            if str(g).split("+")[-2].split("*")[0] == " ":
                b1 = 1
            else:
                b1 = int(str(g).split("+")[-2].split("*")[0])
        
        for i in range(p):
            if (i*a0+b0)%p == 0 and (i*a1+b1)%p == 0:
                print("未检测到作弊者！恢复的秘密信息为：", f(0))
                return f(0)
        
        print("检测到作弊者！恢复失败！")
        return -1
            
        
# -------------------------------------------------------------------------
# 测试
# -------------------------------------------------------------------------
S = ShareGen(12, 8, 5, 19)
# 正常情况
s = Detection_Reconstruct(S[:5], 5, 19)
# 攻击
# 作弊者修改 [1,y+1]
S[1][1] = S[1][1] + 1
# S[2][1] = S[2][1] + 1
s = Detection_Reconstruct(S[:6], 5, 19)