Page 392 - 《软件学报》2025年第7期
P. 392

殷新春 等: 支持高效数据所有权共享的动态云存储审计方案                                                    3313


                              ∑
                 常数  w i ∈  Z p  使得   w i M i = (1,0,...,0), 然后计算

                              i∈I
                                                           e(C 0 ,K 0 )
                                              B = ∏                       w i  .
                                                   (e(C i,1 ,K 1 )e(C i,2 ,K i,2 )e(C i,3 ,K i,3 ))
                                                 i∈I
                    DO  通过计算   C/B  获取  ck, 随后  DO  通过  ck 解密  e i 获取  m i , 将所有的数据块  m i 组合成文件  F.
                    ● Share(pp, uid, sk 2 , uid',   sk )→sk 2
                                         ′
                                         2
                    (1) 当数据拥有者希望与他人共同维护某文件时, 可以将该文件的所有权共享给其他用户. 令                            DO 1 为文件原
                 拥有者, 其身份为     uid, 数据审计密钥为    sk 2 ={R uid , r uid , σ uid , h 1 , r 1 }, DO 2 为新的文件拥有者, 其身份为  uid', 数据审计
                                                                                            h . 如果验证通
                       sk = {R uid ′,r uid ′,σ uid ′,h ,r . TA  首先验证  DO 1 是否为系统中的合法用户. TA  h 1 = g H 0 (R uid ) r 1
                                         ′
                        ′
                                       ′
                 密钥为    2              1  1                                     验证
                 过, TA  执行后续步骤.
                    (2) TA  根据  H 0 (R uid )+xr 1 =H 0 (R uid' )+xr 2 来计算新的随机值  r 2 , 随后将  r 2 添加到  DO 2 的数据审计密钥中, 则
                                                     ′
                                                       ′
                                       ′
                 DO 2 新的数据审计密钥为      sk = {R uid ′,r uid ′,σ uid ′,h ,r ,r 2 }.
                                       2             1  1
                    ● Update(pp, uid, sk 2 , CT)→CT
                    (1) 为了实现文件动态修改, 本方案提供了           3  种类型的操作, 分别为增加、修改和删除.
                    (2) 增加: 令  D=(fn, {m i } i∈[f'] ) 为待增加的文件, 对于  i∈[f'], DO  使用  ck 加密数据块  m i 获得对称密文  e i , 计算密
                 文  e i 的标签  T i = (H 1 ( fn||i)u )  . DO  将增加请求  req add ={sk 2 , fn, {e i , T i } i∈[f'] }发送给  TA. TA  收到请求后, 首先验证
                                      e i σ uid
                 DO  是否拥有该修改数据的所有权, TA         验证  h 1 = g H 0 (R uid ) r 1  是否成立. 如果验证通过, TA  将  fn  以及{e i , T i } i∈[f'] 发送
                                                            h
                 给  CS, CS  将{e i , T i } i∈[f'] 添加到对应于  fn  的密文中, 则更新后的密文为  CT={(M, ρ), C, C 0 , {C j,1 , C j,2 , C j,3 } j∈[l] , {e i ,
                 T i } i∈[f+f'] , tag}.
                    (3) 删除: 令  D=(fn, {m i } i∈[f'] ) 为待删除的文件, DO  将删除请求  req del ={sk 2 , fn, [f']}发送给  TA. TA  收到请求后,
                 首先验证   DO  是否拥有该修改数据的所有权, TA          验证  h 1 = g H 0 (R uid ) r 1  是否成立. 如果验证通过, TA  将  fn  以及  [f'] 发
                                                                   h
                 送给  CS, CS  删除对应密文的    e i 和  T i , 则更新后的密文为  CT={(M, ρ), C, C 0 , {C j,1 , C j,2 , C j,3 } j∈[l] , {e i , T i } i∈[f–f'] , tag}.
                    (4) 修改: 令  D=(fn, {m i } i∈[f'] ) 为待修改的文件, 用于替换  CS  存储的旧密文, 对于  i∈[f'], DO  使用  ck 加密数据
                 块  m i 获得对称密文  e i , 计算密文  e i 的标签  T i = (H 1 ( fn||i)u )  . DO  将修改请求  req mod ={sk 2 , fn, {e i , T i } i∈[f'] }发送给
                                                             e i σ uid
                 TA. TA  收到请求后, 首先验证     DO  是否拥有该修改数据的所有权, TA          验证  h 1 = g H 0 (R uid ) r 1   是否成立. 如果验证通
                                                                                    h
                 过, TA  将  fn  以及{e i , T i } i∈[f'] 发送给  CS, CS  替换对应密文的  e i 以及  T i , 则更新后的密文为  CT={(M, ρ), C, C 0 , {C j,1 ,
                 C j,2 , C j,3 } j∈[l] , {e i , T i } i∈[f] , tag}.

                 5   方案分析

                 5.1   正确性及安全性分析
                    (1) 云存储审计的正确性
                    如果  TA、DO   是可信的, CS   是半可信的, 那么任意合法的证明都可以通过               TA  的验证. 由双线性映射      (详见
                 第  2.2  节) 的特性可知, 如果以下验证等式成立, 则本方案可以保证云存储审计的正确性.

                                                                                         
                           ∏       ∏                  ∏                 ∏                
                                                                                         
                              v i            e i σ uid v i      e i v i  σ uid     v i  e i v i  σ uid 
                   e(T,g) = e    T ,g  = e    (H 1 ( fn||i)u )  ,g  = e    (H 1 ( fn||i)u ) ,g   = e    (H 1 ( fn||i) u ),g   
                                                      
                                  
                                                                           
                              i                                                          
                            i∈I        i∈I                 i∈I                  i∈I
                                                                                                
                           ∏          ∑             ∏                      ∏                    
                                       e i v i                                                  
                                    v i    r uid +xH 0 (R uid )    v i  b e  r uid  xH 0 (R uid )    v i  b e  H 0 (R uid )
                        = e    (H 1 ( fn||i) )u i∈I  ,g   = e    (H 1 ( fn||i) )u ,g g   = e    (H 1 ( fn||i) )u ,R uid Y  .
                                                                                                     
                                                                            
                                                  
                                                                                                
                            i∈I                        i∈I                       i∈I
                    (2) 错误数据的可检测性
                    在本文方案中, 如果云服务器中存储的某个文件分为                  n  个数据块, 其中有    m  个损坏的数据块, 当挑战数据块
                 数量为   c 时, 检测到这些损坏的数据块的概率至少为             1–((n–m)/m) . 令  X  为挑战数据块中损坏数据块的数量,      P X  为
                                                                   c
                 检测到损坏数据块的概率:
   387   388   389   390   391   392   393   394   395   396   397