Page 318 - 《软件学报》2025年第9期
P. 318

韩将 等: 面向跨信任域互联网场景的拜占庭容错访问控制架构                                                   4229


                 安全性进行证明.

                 4.2.1    广播阶段吞吐量提升: k-RBC
                    在  PRBC (provable reliable broadcast) 中, 发起广播的节点仅通过一个  PRBC  实例完成交易信息的广播, 这使
                 得对于信道的利用率过低, 从而限制了每一轮可完成共识的交易吞吐量, 并带来了额外的广播延迟. 为了提高信道
                 利用率, 本文提出多可靠广播         (reliable broadcast, RBC) 实例的  k-RBC, 即发起广播的节点广播信息时, 将消息分割
                   k  个等长或近乎等长的消息分片, 通过   个      k  RBC  实例进行消息广播. 这里需要注意的一点是, 这里的优化后的
                 成
                 广播算法是     k-RBC  而非  k-PRBC, 这是由于共识阶段验证的优化, 导致           PRBC  中的门限签名算法冗余, 从而从
                                                                         2
                 PRBC  简化为  RBC, 使得每一次广播都少一次门限签名算法, 具有                O(n )  的时间复杂度的降低      (这里假设使用
                 ECDSA  数字签名算法构建门限签名算法).
                    k-RBC  的具体算法如算法      1  所示.

                 算法 1. 节点  P l  上的  k-RBC  算法.
                 1. if   P l == P sender  且收到输入交易  v then
                 2.  将输出交易    v 等分为   k 份, 为   {v i } k
                 3.   for  v i ← {v i } k  do
                 4.    将交易    v i  分成   n 个分片   {s j } n
                         ′
                 5.     {s } = ErasureCoding({s j }) ▷    利用纠删码对发送数据进行压缩
                          j
                 6.     h = MerkleTree({s }).GetRootHash()
                                     ′
                                     j
                 7.    for  s j ← {s j } n  do
                 8.       b j = MerkleTree(s ).GetTreeBranch() ▷    利用  Merkle 树验证交易信息是否被篡改
                                       ′
                                       j
                                     (      )
                                                        ′
                                          ′
                 9.     发送消息     VAL h,b j , s ,i := {VAL,h,b j , s ,i} 给节点  P j
                                          j             j
                                                            ′
                                              ′
                 10. upon 收到来自   P sender  的  VAL(h,b j , s ,i) := {VAL,h,b j , s ,i} 消息  do
                                              j             j
                                       ′              ′
                 11.  多播消息   ECHO(h,b j , s ,i) := {ECHO,h,b j , s ,i}
                                                      j
                                       j
                 12. upon  收到来自   P j  的  ECHO(h,b j , s ,i) := {ECHO,h,b j , s ,i} 消息  do
                                                             ′
                                             ′
                                              j
                                                             j
                 13.  if  CheckValidMerkleBranch(b j ,h, s ) then
                                               ′
                                               j
                 14.   保存消息
                 15.  else
                 16.   丢弃消息
                               n− f  个不同节点的有效     ECHO  消息 do
                 17. upon 收到来自
                 18.  从中采样   n−2 f  个  ECHO  消息中的  s ′′
                                                  j
                              ′           ′′                   h , h , 则中止
                                                                  ′
                 19.  重新计算   h = MerkleTree({s }).GetRootHash(), 若出现
                                           j
                 20.  if 还未发送消息   READY(h,i) := {READY,h,i} then
                 21.   多播消息    READY(h,i)
                 22. upon 收到   f +1 个有效的  READY(h,i) 消息 do
                 23.  if 还未发送消息   READY(h,i) := {READY,h,i} then
                 24.   多播消息    READY(h,i)
                 25. upon 收到   2 f +1 个有效的  READY(h,i) 消息 do
                         n−2 f  个
                 26.  等待        ECHO  ECHO 消息后, 恢复   v i
                 27.  if  V  中不存在   then
                                v i
                 28.    V.add(v i )
                 29.   if  |V| == k then
   313   314   315   316   317   318   319   320   321   322   323