Page 441 - 《软件学报》2026年第3期
P. 441

1404                                                       软件学报  2026  年第  37  卷第  3  期



                                                                                        β χ
                    如果复用策略已经生成过, 数据所有者从本地取出该复用策略的标识符                          SP DO  = {T tag ,g }, 并将其中的组件
                                                                                Tag
                                                                                          ′
                 T tag = g ·g b·ϑ·FR v   嵌入密文. 此时复用策略对应的子树被伪属性   χ 替代, 访问策略    Λ 被转换成    Λ , 具体过程可参考
                      β χ
                 第  2.4  节. 将转换访问策略   Λ  的叶子节点集合记为       X = (X −τ)∪χ τ 为复用策略的属性集合. 对      X  中包含伪属性
                                                                    ,
                                                                                             ′
                                       ′
                                                          ′
                                                                           r
                                                   ′
                                                                ′
                 和真实属性在内的节点, 计算相应的组件             E = g r·q x(0)  ∪g r·q χ(0) ,  E = g α x ·r ∪(T tag ) , 其余组件的计算过程同步骤①中一
                                                  2             3
                                 δ
                                                                                  δ
                 致. 最后得到密文:    CT = {Λ , M,E m ,FileMatch,E 0 ,E 1 ,E ,E ,E 4 ,T tag }, 数据所有者将   CT  和  {KW k } k∈K  发送给云服务器.
                                      ′
                                                          ′
                                                             ′
                                 m                        2  3                    m
                                 δ
                      (5) IndexGen(CT ,{KW k } k∈K ,MPK) → Index Invert : 索引生成算法
                                 m
                                                                                                   CT  的
                                                                                                     δ
                    云服务器根据关键词集合         {KW k } k∈K  计算各个关键词在哈希表中的位置      [L k ] k∈K = H 2 (KW k ) k∈K . 并按照接收
                                                                                                     m
                                                           δ                       H m
                 时间顺序对其生成一个唯一的标识号            FileID, 而后从  CT  中取出验证组件    FileMatch=g . 将  < FileID,FileMatch >
                                                           m
                 放到关键词对应的跳表上, 形成         FileID 有序的索引结构     Index Invert .
                      (6) TrapGen(MPK,UK,{sw s } s∈S ) → Q s : 检索陷门生成算法
                                                                                  Q s = {UK,{SW s } s∈S }  发送给云
                    数据访问者对检索关键词集合            {sw s } s∈S   计算  {SW s = H 1 (sw s )} s∈S , 形成检索陷门
                 服务器. 检索陷门中的多个关键词可以用布尔逻辑进行连接, 例如对                      3  个检索关键词求检索数据的交集:          {SW 1 &
                 SW 2 & SW 3 }, 或对两个检索关键词求检索数据的并集         {SW 2 ||SW 4 } 等.
                     (7) Search(MPK,Q s ,Index Invert ) → SR: 检索算法

                    云服务器计算      H 2 (SW s ) 得到每个检索关键词  SW s  在哈希表中的位置. 对该位置上存放的           KW k  和检索关键词
                 SW s  进行等值比较, 相等则返回相应的加密数据编号. 根据检索请求中关键词的逻辑连接方式, 对所有检索关键词
                 的数据编号集合      {FileID s } s∈S  进行交集或并集的计算, 得到检索结果    SR.
                      (8) Decrypt 1 (SR,Q s ,SP CSP ,MPK) → CT m : 外包解密算法
                                      Tag
                                                                              δ              Q s  中数据访问
                    云服务器根据检索结果         SR 中的加密数据编号       FileID 提取相应的密文    CT , 并基于检索令牌
                                                                              m
                 者的属性密钥     UK  对  CT  δ   进行外包解密. 根据  CT  δ   中是否包含  T tag , 将叶子节点的计算分成以下两种情况.
                                   m                  m
                                  T tag , 即访问策略中不包含复用策略.
                    ① 密文中不包含
                    对  访  问  策  略  中  的  叶  子  节  点     x ∈ X   执  行  DecLea f(CT ,UK, x)   解  密  算  法  :    D x = e(K 1 ,E 1 )·e(K 2 ,E 2 )/e(K 3 ,E 3 ) =
                                                              δ

                                                              m
                 e(g,g) α y ·z ′ ·b·r  ·e(g,g) c·r·q x(0) /z /e(g,g) b·z ′ ·r·α x  , 对属性相同的节点有  D x = e(g,g) c·r·q x(0) /z  .
                    ② 密文中包含     T tag , 即访问策略中包含复用策略.
                                                                                             r
                                                                   ′
                                                                                  ′
                    对普通属性叶子节点的计算同步骤①. 当按序计算到组件                   E = g r·q x(0)  ∪g r·q χ(0)   和  E = g α x ·r  ∪(T tag )  的最后一个元
                                                                  2               3
                 素时, 云服务器首先根据密文组件中的            T tag  找到对应的  SP CSP  = {BF j ,l i,j } i∈I,j∈J  并判定数据访问者是否满足复用策略.
                                                             Tag
                 该判定过程分为两步, 首先基于布隆过滤器进行初步判定, 具体过程如第                      2.4  节所示. 而后对通过布隆过滤器判定
                                                                                           z ′

                 的真子句    l i,j = g ϑ·(α 1,j +α 2, j +...+α i,j )   和  UK  基于双线性配对进行二次验证, 计算  e(K 4 ,l i,j )/e(K 1 ,E 4 ) = e(g ,g ϑ·(α 1, j +α 2, j +...+α i,j ) )/
                         ?
                                                                                          δ
                       ϑ
                                                                r
                 e(g α y ·z ′  ,g ) = 1. 若该等式成立则返回  FR ν = 0, 此时  E  中  (T tag ) = g β χ ·r  . 由解密算法  DecLea f(CT ,UK,χ)  计算得到
                                                          ′
                                                                                          m
                                                          3
                                                                                         ) r
                                        ′
                                                                                   ′
                 伪属性叶子节点的秘密值          D = e(g,g) c·r·q χ(0) /z  . 若判定失败则返回  FR ν = 1, 此时在  E  中  ( T tag = g β χ ·r ·g b·ϑ·r  ,  D χ ′ =
                                        χ
                                                                                   3
                 e(g,g) c·r·q x(0) /z /e(g,g) b·z ′ ·b·ϑ·r  , 存在不能消除的组件  e(g,g) b·z ′ ·b·ϑ·r   无法向上递归重构其父节点的秘密值.
                    对上述两种情况中包含伪属性在内满足阈值条件的叶子节点, 通过拉格朗日插值函数重构其父节点的秘密
                                                                                  κ
                 值. 假设阈值节点     n 的子节点   x 集合为  , 对访问策略中阈值节点的计算如下: 将            x 在   处的次序记为   κ = index(x κ ),
                                              n x
                                                 δ                                          D n = ⊥, 反之计
                 K n = {index(x κ ), x ∈ n x }. 执行  DecNode(CT ,UK,n)  算法, 将输出结果记为  D n . 当集合  K n  不存在时
                                                m
                         (
                       ∏      c·r·q parent(x) index(xκ ) /z  ) ∆ κ,Kn (0)  ∏  c·r·q n (κ)·∆ κ,Kn (0) /z  c·r·q n(0) /z
                 算:  D n =  e(g,g)           =  e(g,g)        =e(g,g)   . 递归计算到根节点时得到        D r =e(g,g) c·r·r ′ /z .
                       x∈n x                  x∈n x
                 最后将中间密文      CT m = {E m ,D r , M} 发送给数据访问者.
                    若数据访问者不满足密文的访问策略, 则无法恢复访问控制树的根节点秘密值, 外包解密失败. 此时, 云服务
                 器中止对外包解密算法且不向数据访问者返回该密文的任何信息.
                    (9)  Decrypt 2 (CT m ,TK) → m: 本地解密算法
                                                                                                     TK
                    数据访问者收到中间密文         CT m ={E m ,D r , M} 后用自己的解密私钥   TK =K 0 =z 计算得到对称密钥  CK =E m /(D r ) =
                 CK ·e(g,g) c·r·r ′ /(e(g,g) c·r·r ′ /z z  CK 解密得到明文数据  m = Dec CK (M).
                                    ) . 接着使用对称密钥
   436   437   438   439   440   441   442   443   444   445   446