基于代理的分布式身份管理方案

目的是使用分布式的联合计算分发去替换掉区块链中原有的类第三方可信中心的证书机制,更加去中心化。

GS-TBK

Group Signatures with Time-bound Keys.

CS-TBK 算法

Complete subtree With Time-bound Keys,该算法是用来辅助检测用户的签名是否有效,是否在有效期内。
一些基本定义
+ $ T $:整个算法的最大的时间。 + $ BT $:一个完全二叉树 + $ t $ :当前的时间。 + $ \tau $:有效时间,如果$ \tau
算法概述
首先每个叶子节点代表一个时间$ t $,可以理解为一个节点就是一个时间段。

算法输入是一个二叉树$ BT 和当前的时间 和当前的时间 和当前的时间 t ,首先定义了两个空集合 ,首先定义了两个空集合 ,首先定义了两个空集合 X,Y ,选取 ,选取 ,选取 t-1 这个叶子节点(如果 这个叶子节点(如果 这个叶子节点(如果 t 是第一个节点,那么就选取 是第一个节点,那么就选取 是第一个节点,那么就选取 t 这个节点),将对应的 这个节点),将对应的 这个节点),将对应的 Path(\eta) 存到 存到 存到 X 中,然后对于每个 中,然后对于每个 中,然后对于每个 X 中的节点,将其不属于 中的节点,将其不属于 中的节点,将其不属于 X 的右子节点存入 的右子节点存入 的右子节点存入 Y 中,如果 中,如果 中,如果 Y 为空,那么放入根节点,最后输出 为空,那么放入根节点,最后输出 为空,那么放入根节点,最后输出 Y $。

那么这个算法相当于对于当前的时间$ t 节点,会存在一个集合 节点,会存在一个集合 节点,会存在一个集合 Y ,其中包括了不含 ,其中包括了不含 ,其中包括了不含 Path(\eta) $的右子树节点。如下图,

若叶子节点8为例,那么$ X=Path(8)={1,2,4,8} , , Y={1} $(第一个节点)

若叶子节点10为例,那么$ X=Path(9)={1,2,4,9} , , Y={3,5} $

若叶子节点11为例,那么$ X=Path(10)={1,2,5,10} , , Y={3,11} $

若叶子节点12为例,那么$ X=Path(11)={1,2,5,11} , , Y={3} $

每个时间$ t 都将被分配到一个叶子节点(每个叶子节点代表一个时间),同样一个有效时间 都将被分配到一个叶子节点(每个叶子节点代表一个时间),同样一个有效时间 都将被分配到一个叶子节点(每个叶子节点代表一个时间),同样一个有效时间 \tau 也会被分配到一个叶子节点。而一个用户会被分配到一个有效期 也会被分配到一个叶子节点。而一个用户会被分配到一个有效期 也会被分配到一个叶子节点。而一个用户会被分配到一个有效期 \tau 。那么意味着,如果多个用户的 。那么意味着,如果多个用户的 。那么意味着,如果多个用户的 \tau
$是相同的话,那么他们将会同时被分配到同一个叶节点。

在GS-TBK的应用-用户撤销管理
主要是管理用户的撤销。

$ GS-TBK 中所有的时间信息都交给一颗拥有最大数量 中所有的时间信息都交给一颗拥有最大数量 中所有的时间信息都交给一颗拥有最大数量 T 叶节点的二叉树管理,有效期 叶节点的二叉树管理,有效期 叶节点的二叉树管理,有效期 \tau 和当前时间 和当前时间 和当前时间 t $都会和一个叶子节点绑定在一起。

如果$ \tau 分配到了节点 分配到了节点 分配到了节点 \eta ,那么管理员将生成包含所有 ,那么管理员将生成包含所有 ,那么管理员将生成包含所有 Path(\eta) 节点的签名,这些签名会发送给有效期是 节点的签名,这些签名会发送给有效期是 节点的签名,这些签名会发送给有效期是 \tau 的用户( B T W ,每个用户拿到的是不一样的,即便是同一个 的用户(BTW,每个用户拿到的是不一样的,即便是同一个 的用户(BTW,每个用户拿到的是不一样的,即便是同一个 \tau $下的用户,但都包含同样的节点的信息)。

我们说,当$ \tau <t ,那么代表和 ,那么代表和 ,那么代表和 \tau 绑定的所有用户都被撤销了,失效了, i . e . ,叶子节点左边的叶子节点都被撤销了,以右上图的 绑定的所有用户都被撤销了,失效了,i.e.,叶子节点左边的叶子节点都被撤销了,以右上图的 绑定的所有用户都被撤销了,失效了,i.e.,叶子节点左边的叶子节点都被撤销了,以右上图的 12 节点为例,那么 节点为例,那么 节点为例,那么 8,9,10,12 $都被撤销了。

接着管理员将生成$ CS-TBK 算法的输出节点集合(也就是集合 算法的输出节点集合(也就是集合 算法的输出节点集合(也就是集合 Y )的一系列签名信息,并广播,这些信息称为 )的一系列签名信息,并广播,这些信息称为 )的一系列签名信息,并广播,这些信息称为 ei_t ( E x p i r e I n f o r m a t i o n ) ,用于后续的用户验证。如果 (Expire Information),用于后续的用户验证。如果 (ExpireInformation),用于后续的用户验证。如果 \tau>t ,那么相关联的用户前面拿到的签名里应该持有和 ,那么相关联的用户前面拿到的签名里应该持有和 ,那么相关联的用户前面拿到的签名里应该持有和 ei_t $中至少一个相同的节点的信息。那么如何检测是否过期呢?

还是以上面的图为例,假设$ \tau = 11 $,左边的图为用户没有过期,右边的图则为过期。

  • 先看未过期的图,首先假设$ T=10 ,首先那么关联到 11 节点的用户将收到来自管理员的 ,首先那么关联到11节点的用户将收到来自管理员的 ,首先那么关联到11节点的用户将收到来自管理员的 Path(11)={1,2,5,11} 四个节点的签名。在左边图里,当前时间为 四个节点的签名。在左边图里,当前时间为 四个节点的签名。在左边图里,当前时间为 t=10 ,所以 8 和 9 节点被自然撤销了,根据 ,所以8和9节点被自然撤销了,根据 ,所以89节点被自然撤销了,根据 CS-TBK 算法, 算法, 算法, 3、5 将被选择为 将被选择为 将被选择为 Y 集合元素输出,所以 集合元素输出,所以 集合元素输出,所以 ei_t 里会包括 里会包括 里会包括 3、5 的签名信息。此时,用户自己持有节点 的签名信息。此时,用户自己持有节点 的签名信息。此时,用户自己持有节点 5 $的签名即可证明自己的签名有效,没有过期。
  • 再看右边的图,当前时间变为$ t=12 ,那么 ,那么 ,那么 ei_t 里将只包括节点 里将只包括节点 里将只包括节点 3 的签名,而节点 的签名,而节点 的签名,而节点 11 关联的用户并不持有 关联的用户并不持有 关联的用户并不持有 3 $节点的签名,故,用户已经被撤销。

GS-TBK 方案

算法组成
1. $ GKeyGen(\lambda) $:输入安全参数,输出群公钥$ gpk $和私钥$ msk $。设定一个注册表$ reg $,最大有效期为$ T $(包含在gpk中)。 2. $ Join/Issue() $:用户与管理员之间的交互算法,用于给新加入的用户分发密钥和设置有效期。 + $ Join(gpk) $:输出用户的签名密钥$ gsk_i $,有效期$ \tau_i $,用户私钥$ usk_i $。 + $ Issue(msk,reg,\tau_i) $:输出$ reg $表,表中的每个元素都会存储$ grt_i $ (revocation token) 和有效期$ \tau_i $即,$ reg[i]=(grt_i,\tau_i) $。 3. $ Revoke(gpk,msk,t,reg,RU_t) $:$ RU_t $代表将要被撤销的用户集合,$ RL_t $(revocation list),设定其为空集合,如果$ \tau_i $过期了被提前撤销了,那么将对应的$ grt_{i,t} $存储到$ RL_t $中。然后算法计算$ ei_t $。最后输出$ RL_t $和$ ei_t $。 4. $ Sign(gpk,gsk_i,usk_i,m,t,ei_t) $:$ m $代表待签名的信息,最终输出签名$ \sigma $。 5. $ Verify(gpk,t,\sigma,m,RL_t) $:输出 valid or invalid 。 6. $ Open(gpk,msk,t,reg,\sigma,m,RL_t) $:输出用户的身份。
撤销方案
前面已经简单提过一下,现在具体描述一下。撤销主要分为自然撤销和提前撤销,前面描述的主要是自然撤销的一思路。

首先时间管理还是根据一颗二叉树,每一个节点都会跟一个域中的元素绑定,方便计算。

(这里不需要理解参数具体含义,知道有这个东西就好)

自然撤销

假定$ Path(\eta)=(u_!,\dots,u_l),u_l=\eta $,集合中的每个元素都是一个节点,它与一个域中的元素绑定在一起。

  • 分发签名:前面说过,在用户分配到有效期$ \tau 之后,管理员会生成所有 之后,管理员会生成所有 之后,管理员会生成所有 Path(\eta) 节点的签名并发送给用户,这个签名就是 节点的签名并发送给用户,这个签名就是 节点的签名并发送给用户,这个签名就是 gsk_i = \left(\left{\left(A_{j}, \xi_{j}, \zeta_{j}\right), u_{i}\right}_{j \in[1, \ell]}\right) , , Path(\eta) 中有多少个节点就会有多少个 中有多少个节点就会有多少个 中有多少个节点就会有多少个 A_j ,每个 ,每个 ,每个 A_j 都存储了两个重要信息,即节点 都存储了两个重要信息,即节点 都存储了两个重要信息,即节点 u 和用户自选的 和用户自选的 和用户自选的 x (包含在 (包含在 (包含在 X $中)。
  • 分发过期信息:在到达一个当前时间$ t 的时候,管理员会执行 的时候,管理员会执行 的时候,管理员会执行 CS-TBK ,然后对结果计算签名,也就是过期信息 ,然后对结果计算签名,也就是过期信息 ,然后对结果计算签名,也就是过期信息 ei_t 。假设 。假设 。假设 CS-TBK 结果为 结果为 结果为 Y = (v_1,\dots,v_{num}) ,那么计算的 ,那么计算的 ,那么计算的 ei_t = \left{\left(B_{i, t}, \xi_{i}^{\prime}, \zeta_{i}^{\prime}\right)\right}_{i \in[1, \text { num }]} ,同样, ,同样, ,同样, Y 有多少个节点就会有多少个 有多少个节点就会有多少个 有多少个节点就会有多少个 A_j ,每个 ,每个 ,每个 A_j 都存储了两个重要信息,即节点信息 都存储了两个重要信息,即节点信息 都存储了两个重要信息,即节点信息 v 和时间 和时间 和时间 t $。
  • 验证:在前面$ CS-TBK 的描述中已经说明,如果用户没有过期,也就是 的描述中已经说明,如果用户没有过期,也就是 的描述中已经说明,如果用户没有过期,也就是 \tau>t , , \tau 在 在 t 的右边,那么此时会存在一个节点 的右边,那么此时会存在一个节点 的右边,那么此时会存在一个节点 u \in Path(\eta) \cap Y ,这个时候用户就可以通过零知识证明,证明自己的 ,这个时候用户就可以通过零知识证明,证明自己的 ,这个时候用户就可以通过零知识证明,证明自己的 gsk_i 和 和 ei_t $中存在相同节点。

提前撤销

实质是给被撤销的用户做了一个标识,后续通过验证签名来判定是否有效。

这里会涉及到一个椭圆双曲线映射,有如下图基本性质,

有三个群$ \mathbb{G}_1,\mathbb{G_2},\mathbb{G_t} ,满足 ,满足 ,满足 \mathbb{G}_1 \times \mathbb{G_2} \rightarrow \mathbb{G_T} ,映射函数为 ,映射函数为 ,映射函数为 e() , , \widetilde{g},\widehat{g} 分别取自是 分别取自是 分别取自是 \mathbb{G}_1,\mathbb{G_2} $。

提前撤销的用户将被提前存储在$ RU_t 中。然后会计算对应用户的 中。然后会计算对应用户的 中。然后会计算对应用户的 grt_{i,t} 并放入 并放入 并放入 RL_t 中,验证者通过依此检测 中,验证者通过依此检测 中,验证者通过依此检测 RL_t 中的 中的 中的 grt_{i,t} $是否满足映射关系来判定是否提前过期。具体如下,

在$ Join/Issue \ phase $ ,管理员存储了$ grt_i = \widetilde{X}_i = \widetilde{g}^{x_i=usk_i} \in \mathbb{G}_1 ,在到达时间 ,在到达时间 ,在到达时间 t 的时候,管理员会计算一个 的时候,管理员会计算一个 的时候,管理员会计算一个 \widetilde{h}_t = \widetilde{g}^{y_t} \in \mathbb{G}_1 和 和 \widehat{h}_t = \widehat{g}^{y_t}\in \mathbb{G}_2 $,此时会存在一个映射关系,即

$ e\left(\widetilde{h}{t}, \widehat{g}\right)=e\left(\widetilde{g}^{y{t}}, \widehat{g}\right)=e\left(\widetilde{g}, \widehat{g}^{y_{t}}\right)=e\left(\widetilde{g}, \widehat{h}_{t}\right) $。满足了,即可代表被撤销了。

在$ Sign \ phase ,产生的群签名 ,产生的群签名 ,产生的群签名 \sigma 会包含 会包含 会包含 \widetilde{h}t\beta,\widetilde{g}{d(x_i+\beta)} ,假设某用户被提前撤销了,那么群管理员会计算 ,假设某用户被提前撤销了,那么群管理员会计算 ,假设某用户被提前撤销了,那么群管理员会计算 grt{i,t} = grt_i{y_t}=\widetilde{h}_t{x_i} ,然后将它存到 ,然后将它存到 ,然后将它存到 RL_t 中,此时的 中,此时的 中,此时的 grt_{i,t} $会满足一个映射关系,即

$ e(grt_{i,t}\widetilde{h}{t}{\beta},\widehat{g}{d})=e(\widetilde{h}{t}{x_{i}+\beta},\widehat{g}{d})=e(\widetilde{g}{y_{t}(x_{i}+\beta)},\widehat{g}{d})=e(\widetilde{g}{d(x_i+\beta)},\widehat{g}{y_t})=e(\widetilde{g}^{d(x_i+\beta)},\widehat{h}_t) $

验证者通过检测是否满足上面等式来判定该用户的签名是否过期,满足则用户存在于撤销名单中,则签名无效。

分布式GS-TBK 思路

方案中加入了一个代理节点,用于减少通信的开销。

(以下表述中,委员会 = 管理员= Node,代理 = Proxy, 用户 = User)

Setup Phase

方案思路
这个阶段主要是信息的初始化以及连接的建立。
  • 代理 Proxy
    1. 代理节点初始化自己的信息(门限信息,通信连接信息等),生成树。
  • 委员会 Node
    1. 委员会节点初始化自己的信息(包含生成 CL 同态密钥对,通信连接信息,门限信息等等),接着所有委员会节点会将自己的同态公钥P2P发给代理服务器,然后代理服务器会对其进行排序,然后返回给委员会公钥集合以及相应的序号,便于节点建立连接
代码思路
1. Proxy 加载自己的配置完成初始化,生成树,并为叶子节点分配时间,设定有效期,开启监听,等待节点连接。 2. 所有 Nodes 加载自己的配置完成初始化,然后与 Proxy 建立连接,连接后**P2P**发送自己的PK和监听地址给Proxy。 3. Proxy 收到所有的 PK 后,对其排序,然后返回一个 NodeInfo list,包含参与的Node id,监听地址和PK,同时还将发送生成好的tree信息,广播给所有的 Nodes。 4. 所有Nodes根据收到的NodeInfo list 和对应的 Node 建立 p2p 连接,完成信道搭建。信道搭建好后将句柄和对应id号存储下来,便于消息的发送。 5. 所有Nodes发送阶段结束Flag,Proxy收到后也发送一个结束Flag。

GKeyGen Phase

方案思路
这个阶段主要需要生成公钥和四把私钥。

上面的图片是非分布式的方案原型,接下来将其拆解为分布式包含代理的版本。

主要的不同来自于四把私钥$ \gamma_A,\gamma_B,\gamma_O,\gamma_C 的生成,不是随机选取,而是通过分布式密钥生成( D K G )。最终的结果是每个委员会节点将持有四把私钥的分各自一部分碎片( 的生成,不是随机选取,而是通过分布式密钥生成( DKG )。最终的结果是每个委员会节点将持有四把私钥的分各自一部分碎片( 的生成,不是随机选取,而是通过分布式密钥生成(DKG)。最终的结果是每个委员会节点将持有四把私钥的分各自一部分碎片( (t,n) $share )。

另外需要再加一把密钥$ \gamma_C $,此密钥和前面的三把密钥生成一样的,用于后面的 Open Phase 中公开用户的身份

公共参数:$ pp = ((G_1,G_2,G_T,e,g, \hat{g}),f, \tilde g, g_2, h_0, h_1, h_2 \leftarrow \mathbb{Z}_q,H,H’)
$

联合计算参数: $ (\gamma_A, \gamma_B, \gamma_O, \gamma_C) \leftarrow DKG(pp, n, t, CL_{PK}, s) $

Phase one

  • 代理 Proxy
    1. 广播发送给委员会节点阶段开始flag信息。
    2. 计算出$ GPK 中除了 中除了 中除了 vk_A = \hat g^{\gamma_A},vk_B = \hat g{\gamma_B},g_1=f{\gamma_O} $的部分,并选择出参与节点。
    3. 然后一并广播发送给委员会节点
  • 委员会 Node
    1. 收到flag后,也P2P对代理发送一个阶段开始Flag信息。
    2. 每个委员会节点自选随机数作为私钥$ u_i ,然后计算自己的公钥 ,然后计算自己的公钥 ,然后计算自己的公钥 y_i=g^{u_i} $,并对该公钥做一个哈希承诺,
    3. 在整个委员会集体里进行广播该承诺。

Phase two

  • 委员会 Node
    1. 每个委员会节点会收集上一轮所有的广播信息,进行承诺验证
    2. 计算出整体多项式的公钥$ y=\prod y_i $
    3. 接着根据自己自选的$ a_0 = u_i 进行 F e l d m a n V s s ,生成多项式 进行 Feldman Vss,生成多项式 进行FeldmanVss,生成多项式 f_i(x)=a_o+a_1x+\dots a_{t-1}x^{t-1} $,
      1. 计算出多项式系数承诺$ c_{i_0}=g{a_0},c_{i_1}=g{a_1},\cdots,c_{i_{t-1}}=g^{a_{t-1}} $
      2. 计算出对应节点的 $ (t,n) $share $ x_{ij}=f_i(j) $。
      3. 对委员会节点的share使用对应的 CL 公钥进行可验证加密得到$ CL_{Enc}(x_{ij},pk_j) ,然后做零知识证明得到 C L D L P r o o f ,该证明目的是证明 C L 密文中的 ,然后做零知识证明得到 CLDLProof,该证明目的是证明CL 密文中的 ,然后做零知识证明得到CLDLProof,该证明目的是证明CL密文中的 x_{ij} 就是 就是 就是 g^{x{ij}} 中的 中的 中的 x_{ij} $。然后将 CL 密文和对应的 CLDLProof 发送给代理节点。
      4. P2P发给代理节点加密的 share,CLDLProof 和 多项式系数承诺。

Phase three

  • 代理 Proxy
    1. 代理节点对收到的 CLDLProof 进行验证。
    2. 代理节点首先将收集到的多项式系数承诺进行合成,$ \prod c_{i_0},\prod c_{i_1},\dots \prod c_{i_{t-1}} ,得到整体多项式的系数承诺 ,得到整体多项式的系数承诺 ,得到整体多项式的系数承诺 c_o,c_1,\dots,c_{t-1} $。
    3. 代理节点将收到的每个委员会节点的$ CL_{Enc}(x_{ij},pk_j) 合成 合成 合成 Enc(x_j)=CL_{Enc}(x_{j},pk_j) = \sum CL_{Enc}(x_{ij},pk_j) $.
    4. P2P发送给对应的委员会节点 合成的加密share 以及 合成的多项式承诺。

Phase four

  • 委员会 Node
    1. 委员会节点解密收到的 $ x_j = CL_{Dec}(Enc(x_j),sk_j) $
    2. 委员会节点收到的$ x_j 的一致性进行验证,即 的一致性进行验证,即 的一致性进行验证,即 g{x_j}=g{S+a_1j+a_2{j^2} \cdots+a_t{j^{t-1}}} =c_0c_1jc_2{j^2}\cdots c_t{j{t-1}}
      $,
    3. 将最后的$ x_j $存储下来。

以上四个阶段称为一把密钥的分布式密钥生成(DKG)

由于 **Gkeygen **有四把密钥所有,上述过程需要并行的执行四次,四次后每个节点得到私钥碎片$ \gamma_{A_i},\gamma_{B_i},\gamma_{O_i},\gamma_{C_i} $。

接下来是计算公钥 ****$ GPK $


Phase five

  • 委员会 Node

委员会节点使用零知识证明,证明$ \hat g^{\gamma_{A_i}},\hat g{\gamma_{B_i}},f{\gamma_{O_i}} 它们三个中的 它们三个中的 它们三个中的 \gamma_{A_i},\gamma_{B_i},\gamma_{O_i} 和在前面的 P h a s e o n e 中,委员会节点公开过三个 和在前面的 Phase one 中,委员会节点公开过三个 和在前面的Phaseone中,委员会节点公开过三个 g{\gamma_{A_i}},g{\gamma_{B_i}},g^{\gamma_{O_i}} $中的三个相同

1. 具体方法是 委员会节点(Prover,P)和代理节点(Verifier,V)之间1. P 发送给 V $ \hat g^{\gamma_{A_i}},\hat g^{\gamma_{B_i}},f^{\gamma_{O_i}} $2. P 从域中任意选择一个$ t\in \mathbb{Z}_p $,计算$ g^t,\hat g^t,f^t $3. P 计算挑战$ e = Hash\{g,\hat g,f,g^{\gamma_{A_i}},g^{\gamma_{B_i}},g^{\gamma_{O_i}},\hat g^{\gamma_{A_i}},\hat g^{\gamma_{B_i}},f^{\gamma_{O_i}},g^t,\hat g^t,f^t\} $4. P 计算$ \begin{aligned}

z_{\gamma_{A_i}}=t+e\gamma_{A_i}\
z_{\gamma_{B_i}}=t+e\gamma_{B_i}\
z_{\gamma_{O_i}}=t+e\gamma_{O_i}
\end{aligned} $
5. P 发送给 V,proof: $ {g^t,\hat gt,ft,e,z_{\gamma_{A_i}},z_{\gamma_{B_i}},z_{\gamma_{O_i}}} $
6. V 验证$ \begin{aligned}
g^z\stackrel{?}= g^t \cdot (g{\gamma_{A_i}})e \
\hat g ^z\stackrel{?}= \hat g^t \cdot (\hat g{\gamma_{A_i}})e
\end{aligned} , , , \begin{aligned}
g^z\stackrel{?}= g^t \cdot (g{\gamma_{B_i}})e \
\hat g ^z\stackrel{?}= \hat g^t \cdot (\hat g{\gamma_{B_i}})e
\end{aligned} , , \begin{aligned}
g^z\stackrel{?}= g^t \cdot (g{\gamma_{O_i}})e \
f ^z\stackrel{?}= f^t \cdot (f{\gamma_{O_i}})e
\end{aligned} $

P2P发送给代理 proof 和$ \hat g^{\gamma_{A_i}},\hat g{\gamma_{B_i}},f{\gamma_{O_i}} $。

  • 代理 Proxy
    1. 验证ZKP,也就是前面的 f 步骤,然后聚合计算出$ \hat g^{\gamma_{A}}=\prod \hat g^{\gamma_{A_i}},\hat g^{\gamma_{B}}=\prod \hat g{\gamma_{B_i}},f{\gamma_{O}}=\prod f^{\gamma_{O_i}} , ∗ ∗ 广播 ∗ ∗ 发送给委员会,然后自行组合出完整的 ,**广播**发送给委员会,然后自行组合出完整的 广播发送给委员会,然后自行组合出完整的 GPK $。
    2. 广播给委员会

Phase six

  • 委员会 Node
    1. 接收组合出完整的$ GPK $。

Join/Issue Phase

![](https://img-blog.csdnimg.cn/img_convert/7ba02286806f20b0b040d954a2f89911.png)

signer 对应的就是用户 User。这里需要计算出每个用户的$ gsk_i $由一组BBS签名和相关参数,然后管理员需要存储 Reg。

代码的demo实现里,达到了可以并发多个用户。

方案思路
**Phase one**
  • 用户与代理建立连接,发送一个开始flag+自身ip
  • 代理P2P发送公钥给用户

Phase two

  • 用户 User
    1. 收到公钥后,用户初始化自己的信息(CL 同态密钥对,自选的私钥$ x_i ,和计算的公钥 ,和计算的公钥 ,和计算的公钥 X_i,\tilde X_i $等等)
    2. 向代理节点提出申请,也就是P2P发送身份信息$ (pk,X_i,\tilde X) $和承诺信息
  • 代理 Proxy
    1. 验证用户的承诺,如果通过,则再将承诺和身份信息$ \tau_i,grt_i $广播转发给参与委员会
    2. 对每一个 Path 算法算出的树节点都计算出一个签名的底数$ Base = gh_{0}{\zeta_j}h_{1}{u_j}X_i $然后保存。
  • 参与委员会 Node
    1. 验证用户的承诺。
    2. 每个委员会参与节点之间开始初始化参数(选择随机数$ k_i,\xi_{j_i} , 生成 M T A 参数 ,生成 MTA 参数 ,生成MTA参数 a,b $等)
      1. 进行 MTA 两两计算,最终每个节点将得到$ ni_{share}=(\xi_{j}+\gamma_A)k $ 的一部分(三轮)。
      2. 使用用户的CL公钥对$ k_i 进行加密得到 进行加密得到 进行加密得到 C_{k_i}=CL_{Enc}(k_i,pk) $
      3. P2P发送给代理节点$ C_{k_i},pi_{share},\xi _{j_i} $

这里采用的是并行发送多个消息,避免多轮通信,后面的签名计算都是。

Phase three

  • 代理 Proxy
    1. 合出$ (\xi_j+\gamma_A)k ,计算出 ,计算出 ,计算出 A_j^{\frac 1 k}=Base^{\frac 1{(\xi_j+\gamma_A)k}} = gh_{0}{\zeta_j}h_{1}{u_j}X_i {{\frac 1{(\xi_j+\gamma_A)k}}} $,
    2. 合出$ C_k = \sum C_{k_i} $
    3. 合出$ \xi_j = \sum \xi_{j_i} , 然后 ∗ ∗ P 2 P ∗ ∗ 发送给用户 ,然后**P2P**发送给用户 ,然后P2P发送给用户 A_j^{\frac 1 k},C_k,\xi_j,\zeta_j,u_j,\tau_i $。
    4. 广播参与委员会$ A_j^{\frac 1 k} $

同样这里也不是一个而是多个,一组签名。

  • 用户 User
    1. 解密$ k = CL_{Dec}(C_{k},sk) ,此时就可以计算出自己的签名 ,此时就可以计算出自己的签名 ,此时就可以计算出自己的签名 A_j = (A_j^{\frac 1 k})^k ,然后合出自己的 ,然后合出自己的 ,然后合出自己的 gsk_i $
  • 参与委员会 Node
    1. 计算出$ A_j^{\frac {\gamma_{C_i}} k} $,然后P2P发送给代理。(一组)

Phase four

  • 代理 Proxy
    1. 聚合出$ A_j^{\frac {\gamma_C} k}= \prod A_j^{\frac {\gamma_{C_i}} k} $,然后广播参与委员会。(一组)

Phase five

  • 参与委员会 Node
    1. 计算$ A_j^{\frac {\gamma_C \cdot k_i} k}=(A_j^{\frac {\gamma_C} k})k_i $(一组)
  • 代理 Proxy
    1. 聚合出$ A_j^{\gamma_C}=\prod A_j^{\frac {\gamma_C \cdot k_i} k} $,然后广播发送给委员会。(一组)

Phase six

  • 委员会 Node
    1. 存储下来到 Reg 中
    2. P2P 发送成功收下的flag给代理

Revoke Phase

方案思路
![](https://img-blog.csdnimg.cn/img_convert/a25e1874a92ada2c03a2dad5392c5cbb.png)

此步骤和 Join/Issue Phase 类似,但由于是公开的,所以无需加密。

$ ei_t :这个是根据当前时间 :这个是根据当前时间 :这个是根据当前时间 t $计算出来的一个用于后面校验签名有效性的信息。

$ RU_t :存储的是在需要提前在 :存储的是在需要提前在 :存储的是在需要提前在 t $时刻被撤销的用户列表,需要作为输入,提前生成。

$ RL_t :存储的是 :存储的是 :存储的是 grt_i ,表示的是在 ,表示的是在 ,表示的是在 t $时刻被撤销的用户的信息,也需要提前置空。

Phase one

  • 用户 User
    1. P2P发送给代理Revoke 的开始flag()
  • 代理 Proxy
    1. 收到用户flag和节点flag(需要收到这两个信息,这是为了保证多个用户同时执行的时候,消息异步到达引发的问题)后开始选择$ y_t ,计算 ,计算 ,计算 \tilde h_t,\hat h_t $
    2. 选择当前时间$ t 和随机数 和随机数 和随机数 \zeta_i’ ,对每一个 C S T B K 算法的树节点都计算出一个 ,对每一个CSTBK算法的树节点都计算出一个 ,对每一个CSTBK算法的树节点都计算出一个 Base’ = gh_{0}{\zeta_i’}h_{1}{v_i}h_2^t $,
    3. 广播发送这两个信息给参与委员会节点。
  • 委员会 Node
    1. 每个委员会参与节点之间开始初始化参数(选择随机数$ k_i’,\xi_{i_j}’ , 生成 M T A 参数 ,生成 MTA 参数 ,生成MTA参数 a,b $等)
      1. 进行 MTA 两两计算,最终每个节点将得到$ ni_{share}=(\xi_{i}'+\gamma_B)k $ 的一部分。
      2. P2P发送给代理节点$ ni_{share},k_i’,\xi_{i_j}’ $

Phase two

  • 代理 Proxy
    1. 代理聚合出$ (\xi_i’+\gamma_B)k’ = \sum ni_{share} $, $ k’ = \sum k_i’ $, $ \xi_i’=\sum \xi_{i_j}’ $
    2. 然后计算出$ B_i = (Base’^{\frac 1 {(\xi_i’+\gamma_B)k’}})^{k’} = {gh_{0}{\zeta_i’}h_{1}{v_i}h_2t} {\frac 1 {(\xi_i’+\gamma_B)}} $
    3. 选出$ RU 并计算出 并计算出 并计算出 RL $
    4. 广播给委员会节点
  • 委员会 Node
    1. 存下$ ei_t,RL $
    2. P2P 发送成功收下的flag给代理
  • 用户User
    1. 存下$ ei_t $

Sign Phase

方案思路
![](https://img-blog.csdnimg.cn/img_convert/515714ba3ad3c5f2e593abfd5d64a9c7.png)

签名阶段就是用户拿着自己聚合出来的$ A_j 和 和 Bi $对消息进行签名计算

主要就是几个式子的计算,和原方案一样。

保存下来, 然后上链。

结束后P2P发送签名结束的 flag 给代理

Verify Phase

方案思路
![](https://img-blog.csdnimg.cn/img_convert/6a2f5f25dc22bdcd1ff8edbceb653996.png)

这里的验证也和原方案类似,校验的是密钥是否过期(自然撤销,主动撤销,密钥)

不用代理验证,仅让代理转发消息,然后验证交给管理员节点,不通过则需要启动 Open Phase 来揭示用户身份。

代码demo里,流程是代理收到,用户发送自己已经签名完成的flag,结合node发送过来的revoke flag,这两个flag,然后发送开始验证的flag给委员会节点,此时委员会节点就会去链上读取用户的上链信息。

Open Phase

方案思路
![](https://img-blog.csdnimg.cn/img_convert/414e2cdb1da044dec46caf06bff09a81.png)

这个阶段的改动比较大,主要是因为原方案里的 Open 是让委员会直接拿到的用户的签名$ A_j 的,修改的方案里是不能让其拿到,而是持有 的,修改的方案里是不能让其拿到,而是持有 的,修改的方案里是不能让其拿到,而是持有 A_j^{\frac 1 k} 和 和 A_j^{\gamma_C} $。

Phase one

  • 委员会 Node
    1. 解析 Verify Phase 的结果,然后计算$ \psi_1^{\gamma_{O_i}} $,P2P发送给代理。
  • 代理 Proxy
    1. 代理聚合$ \psi_1{\gamma_O}=\prod\psi_1{\gamma_{O_i}} ,然后可以计算出 ,然后可以计算出 ,然后可以计算出 A_j = \frac {\psi_2} {\psi_1^{\gamma_O}} $,然后广播给委员会节点

Phase two

  • 委员会 Node
    1. 计算$ A_j^{\gamma_{C_i}} $,然后P2P发送给代理
  • 代理 Proxy
    1. 代理聚合$ A_j^{\gamma_C}=\prod A_j^{\gamma_{C_i}} $,然后广播给委员会

Phase three

  • 委员会 Node
    1. 寻找比对代理发送的$ A_j^{\gamma_C} 和自己的 和自己的 和自己的 Reg $表中的信息,揭示出用户的身份信息。

Key manage Phase

方案思路
**转加法共享**

$ t $个委员会节点的 share,乘以对应的拉格朗日系数即可。

密钥恢复

$ t $个委员会节点联合进行恢复算法即可。实际上的方案是不需要恢复这个功能的,这里只是为了对生成的密钥进行验证

  • 委员会 Node

将四把密钥的信息P2P发送给代理

  • 代理 Proxy

对收到的信息进行聚合,然后运行恢复算法,再进行校验

密钥刷新

每个委员会节点将自选私钥设置为 0 ,然后重新生成多项式再次 Vss Share,最后累加到原来的$ (t,n) $share上即可 。过程类似 Keygen 的 Phase 2 ~ Phase 4

Phase one

  • 代理 Proxy
    1. 发送给节点开始flag
  • 委员会 Node
    1. 根据自己自选的$ a_0 = 0 进行 F e l d m a n V s s ,生成多项式 进行 Feldman Vss,生成多项式 进行FeldmanVss,生成多项式 f_i(x)=a_o+a_1x+\dots a_{t-1}x^{t-1} $
      1. 计算出多项式系数承诺$ c_{i_0}=g{a_0},c_{i_1}=g{a_1},\cdots,c_{i_{t-1}}=g^{a_{t-1}} $
      2. 计算出对应节点的 $ (t,n) $share $ x_{ij}=f_i(j) $。
      3. 对委员会节点的share使用对应的 CL 公钥进行可验证加密得到$ CL_{Enc}(x_{ij},pk_j) ,然后做零知识证明得到 C L D L P r o o f ,该证明目的是证明 C L 密文中的 ,然后做零知识证明得到 CLDLProof,该证明目的是证明CL 密文中的 ,然后做零知识证明得到CLDLProof,该证明目的是证明CL密文中的 x_{ij} 就是 就是 就是 g^{x{ij}} 中的 中的 中的 x_{ij} $。然后将 CL 密文和对应的 CLDLProof 发送给代理节点。
      4. P2P发给代理节点加密的 share,CLDLProof 和 多项式系数承诺。

一共四个

Phase two

  • 代理 Proxy
    1. 代理节点对收到的 CLDLProof 进行验证。
    2. 代理节点首先将收集到的多项式系数承诺进行合成,$ \prod c_{i_0},\prod c_{i_1},\dots \prod c_{i_{t-1}} ,得到整体多项式的系数承诺 ,得到整体多项式的系数承诺 ,得到整体多项式的系数承诺 c_o,c_1,\dots,c_{t-1} $。
    3. 代理节点将收到的每个委员会节点的$ CL_{Enc}(x_{ij},pk_j) 合成 合成 合成 Enc(x_j)=CL_{Enc}(x_{j},pk_j) = \sum CL_{Enc}(x_{ij},pk_j) $.
    4. P2P发送给对应的委员会节点 合成的加密share 以及 合成的多项式承诺。

Phase three

  • 委员会 Node
    1. 委员会节点解密收到的 $ x_j = CL_{Dec}(Enc(x_j),sk_j) $
    2. 委员会节点收到的$ x_j 的一致性进行验证,即 的一致性进行验证,即 的一致性进行验证,即 g{x_j}=g{S+a_1j+a_2{j^2} \cdots+a_t{j^{t-1}}} =c_0c_1jc_2{j^2}\cdots c_t{j{t-1}}
      $
    3. 将最后的$ x_j $叠加到原来的 $ xj $上即可。

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处:http://www.rhkb.cn/news/425639.html

如若内容造成侵权/违法违规/事实不符,请联系长河编程网进行投诉反馈email:809451989@qq.com,一经查实,立即删除!

相关文章

微服务_入门2

文章目录 一、Feign 一、Feign 来看我们以前利用RestTemplate发起远程调用的代码&#xff1a; 存在下面的问题&#xff1a; 代码可读性差&#xff0c;编程体验不统一参数复杂URL难以维护&#xff08;有时候访问一个页面所携带的参数是非常多的&#xff09; Feign是一个声明…

CSS——网格布局(display: grid)之上篇

CSS——网格布局&#xff08;display: grid&#xff09; 前面介绍了弹性布局&#xff0c;今天我们介绍一下网格布局。 什么是网格布局 CSS网格布局&#xff08;CSS Grid Layout&#xff09;是一种用于创建复杂网页布局的系统&#xff0c;它允许开发者以二维系统&#xff08;…

双三次插值及MATLAB实现

一、双三次插值的概念 双三次插值&#xff08;Bicubic interpolation&#xff09;&#xff0c;又叫双立方插值。在数值分析这个数学分支中&#xff0c;双三次插值是二维空间中最常用的插值方法。在这种方法中&#xff0c;函数f在点 (x0 ,y0) 的值不仅考虑其直接邻接点对其的影响…

Leetcode—1137. 第 N 个泰波那契数【简单】

2024每日刷题&#xff08;160&#xff09; Leetcode—1137. 第 N 个泰波那契数 记忆化搜索实现代码 class Solution { public:int tribonacci(int n) {int zero 0;int one 1;int two 1;if(n 0) {return zero;}if(n 1) {return one;}if(n 2) {return two;}int ans 0;fo…

MATLAB、FPGA、STM32中调用FFT计算频率、幅值及相位差

系列文章目录 文章目录 系列文章目录前言MATLABSTM32调用DSPSTM32中实现FFT关于初相位 FPGA 前言 最近在学习如何在STM32中调用FFT MATLAB 首先对FFT进行一下说明&#xff0c;我们输入N个点的数据到FFT中&#xff0c;FFT会返回N个点的数据&#xff0c;这些数据都是复数&#…

【ACM出版】第三届人工智能与智能信息处理国际学术会议(AIIIP 2024,10月25-27)

第三届人工智能与智能信息处理国际学术会议&#xff08;AIIIP 2024&#xff09; 2024 3rd International Conference on Artificial Intelligence and Intelligent Information Processing 中国-天津 | 2024年10月25-27日 | 会议官网&#xff1a;www.aiiip.net 官方信息 会议…

智能客服自动化新体验:Function Calling让问题处理更高效

Function Calling作为一项创新功能&#xff0c;正深刻改变着大模型与实际产业之间的融合方式。它不仅**为大模型增添了与外部工具和API无缝连接的能力&#xff0c;助力大模型向实际产业落地迈进&#xff1b;还极大地简化了开发者与模型间的交互流程&#xff0c;使得开发者从模型…

Leetcode—1184. 公交站间的距离【简单】

2024每日刷题&#xff08;161&#xff09; Leetcode—1184. 公交站间的距离 实现代码 class Solution { public:int distanceBetweenBusStops(vector<int>& distance, int start, int destination) {int clockwise 0;int counterclockwise 0;if(start > desti…

RabbitMQ(高阶使用)死信队列

文章内容是学习过程中的知识总结&#xff0c;如有纰漏&#xff0c;欢迎指正 文章目录 一、什么是死信队列&#xff1f; 二、死信队列使用场景 三、死信队列如何使用 四、打车超时处理 1.打车超时实现 以下是本篇文章正文内容 一、什么是死信队列&#xff1f; 先从概念解释上搞…

linux入门到实操-4 linux系统网络配置、连接测试、网络连接模式、修改静态IP、配置主机名

教程来源&#xff1a;B站视频BV1WY4y1H7d3 3天搞定Linux&#xff0c;1天搞定Shell&#xff0c;清华学神带你通关_哔哩哔哩_bilibili 整理汇总的课程内容笔记和课程资料&#xff08;包含课程同版本linux系统文件等内容&#xff09;&#xff0c;供大家学习交流下载&#xff1a;…

【C++算法】前缀和

前缀和 题目链接 前缀和https://www.nowcoder.com/practice/acead2f4c28c401889915da98ecdc6bf?tpId230&tqId2021480&ru/exam/oj&qru/ta/dynamic-programming/question-ranking&sourceUrl%2Fexam%2Foj%3Fpage%3D1%26tab%3D%25E7%25AE%2597%25E6%25B3%2595%2…

CefSharp_Vue交互(Element UI)_WinFormWeb应用---设置应用透明度(含示例代码)

一、界面预览 1.1 设置透明(整个页面透明80%示例) 限制输入值:10-100(数字太小会不好看见) 1.2 vue标题栏 //注册类与js调用 (async function(

【Linux基础】冯诺依曼体系结构操作系统的理解

目录 前言一&#xff0c;冯诺依曼体系1. 为什么有内存结构?2. 对硬件中数据流动的再理解 二&#xff0c;操作系统(Operator System)1. 概念2. 操作系统结构的层状划分3. 操作系统对硬件管理的理解4. 用户与操作系统的关系的理解5. 系统调用和库函数的关系6. 为什么要有操作系统…

eclipse使用 笔记02

创建一个项目&#xff1a; 【File-->New-->Dynamic Web Project】 进入页面&#xff1a; Project name为项目命名 Target runtime&#xff1a;选择自己所对应的版本 finish创建成功&#xff1a; 创建成功后的删除操作&#xff1a; 创建前端界面&#xff1a; 【注意&a…

RT-DETR改进策略:BackBone改进|Swin Transformer,最强主干改进RT-DETR

摘要 在深度学习与计算机视觉领域,Swin Transformer作为一种强大的视觉Transformer架构,以其卓越的特征提取能力和自注意力机制,正逐步引领着图像识别与检测技术的革新。近期,我们成功地将Swin Transformer引入并深度整合至RT-DERT(一种高效的实时目标检测与识别框架)中…

数据结构(7.3_2)——平衡二叉树

平衡二叉树&#xff0c;简称平衡树(AVL树)----树上任一结点的左子树和右子树的高度之差不超过1. 结点的平衡因子左子树高-右子树高 //平衡二叉树结点 typedef struct AVLNode {int key;//数据域int blalance;//平衡因子struct AVLNode* lchild, * rchild; }AVLNode,*AVLTree; …

【开放词汇检测】基于MMDetection的MM-Grounding-DINO实战

文章目录 摘要安装基础环境新建虚拟环境安装pytorch安装openmim、mmengine、mmcv安装 MMDetection验证安装配置OV-DINO环境 MMDetection的MM-Grounding-DINO详细介绍测试结果Zero-Shot COCO 结果与模型Zero-Shot LVIS ResultsZero-Shot ODinW&#xff08;野生环境下的目标检测&…

【网络安全】Node.js初探+同步异步进程

未经许可,不得转载。 文章目录 Node.js 基础介绍NPM 包管理安装同步与异步fs 模块示例child_process 模块Node.js 基础介绍 Node.js 是运行在服务器端的 JavaScript 环境。它基于 Chrome 的 V8 引擎,拥有高效的执行性能。Node.js 采用事件驱动的 I/O 模型,使得它在处理高并…

Java笔记 2 java概述和基础知识

第2章 Java概述与基础知识 Java 历史 Java技术体系平台 Java 重要特点 Java 虚拟机[JVM] JDK&#xff0c;JRE JDK 基本介绍 JRE 基本介绍 JDK、JRE 和JVM 的包含关系 Java 快速入门 注意细节 Java 转义字符 Java 常用的转义字符 注释(comment) Java 中的注释类型 关于文档注释 …

java多线程编程示例

程序功能 程序展示了 Java 中如何使用多线程来并行执行任务。具体功能如下&#xff1a; 程序创建了三个线程&#xff0c;每个线程执行相同的任务类 Task。 每个线程在运行时输出自身名称&#xff0c;并模拟执行五次任务&#xff0c;每次任务间隔 1 秒。 主线程在启动这三个线程…