Page 400 - 《软件学报》2026年第2期
P. 400

李鲍 等: 基于  TEE  安全高效的细粒度统计分析与可验证数据聚合方案                                            879


                 双线性映射.
                    定义  2 (DBDH  假设问题). 设  G 和  G T  是均为  p 阶的循环群,  g 为群  G  的生成元. 设映射  e : G×G → G T . 对于任
                                                                                 b
                                                                              a
                                                                                   c
                                                    a  b  c         |Pr[A(g, p,e,g ,g ,g ,h t ) = b]−1/2| 可以忽略. 其
                 意概率多项式时间内的敌手          A, 给定   (g, p,e,g ,g ,g ), 敌手的优势
                                       ϖ
                 中,  h 0 = e(g,g) 、 h 1 = e(g,g) 、  a,b,c,ϖ ∈ Z p  和  t ∈ {0,1}.
                           abc
                    定义  3 (计算性  Diffie-Hellman  问题). 设  G  是一个阶为大素数  p  的循环群, 设  g  为循环群   G  的生成元. 给定
                    α  β  3                 αβ
                 (g,g ,g ) ∈ G , 其中  α,β ∈ Z p , 计算  g ∈ G.
                    定义   4 (计算性  Diffie-Hellman  假设). 设任何概率多项式时间算法         T  成功求解群    G  上的计算性    Diffie-
                 Hellman  问题的优势为:

                                                      [                        ]
                                                              β
                                                                  αβ
                                                            α
                                         ADV CDH (T ) = Pr T (q,g,g ,g ) = g |g ∈ G,α,β ∈ Z p .
                    计算性   Diffie-Hellman  假设定义为: 对于任何概率多项式时间算法  ,
                                                                       T ADV CDH (T ) 是可忽略的.
                  2.1   哈希函数
                    哈希函数是将任意长度的输入映射到一个固定长度的输出上                      [40] . 一般表示形式为   H : {0,1} → {0,1} , 其中  α
                                                                                                 α
                                                                                           ∗
                 代表输出内容的长度. 通常来讲, 哈希函数具有下列性质                [41] .
                    (1) 确定性: 对于同一输入     m, 哈希函数的输出      H(m) 总是相同的.
                                                H(m), 多项式内无法有效逆向计算出         m  值.
                    (2) 单向性: 对于一个哈希输出结果
                    (3) 抗碰撞性: 对于一个哈希函数的结果           H(m), 不存在任何有效算法可以在多项式时间内找到一个                   n, 满足
                 H(n) = H(m)  且  n , m.
                  2.2   新型  BGN  同态加密算法
                    BGN  同态加密算法     [17]  属于全同态加密技术中的一种, 其特征在于可以进行多次加法同态和一次乘法同态加
                 密, 文献  [42] 将  BGN [17]  密码体制扩展到双消息加密的新型      BGN  同态加密算法, 具体的细节如下.
                                 λ
                    Step 1.  KeyGen(1 ) → (pk, sk). 此算法输入安全参数  λ, 输出为公钥  pk 和私钥  sk = {Sk 1 ,Sk 2 }. 首先, 选择  4 个长度
                 均为  λ 的大素数   p 、 p 、  p  和   p , 设置  N = p p p p . 选取   ˜ G 1  和   ˜ G 2  两个阶为  N  循环群,   g 1  是   ˜ G 1  循环群的生成元.
                                                      ′
                                                       ′
                                          ′
                                                    ′
                                                         ′
                                  ′
                               ′
                                      ′
                               0  1   2   3         0  1  2  3
                                                              p ′ p ′  p ′ p ′  p ′ p ′
                                                                             ′
                                                                                                       ′
                                                           ′
                                                                   ′
                 e : ˜ G 1 × ˜ G 1 → ˜ G 2  为循环群   ˜ G 1  和   ˜ G 2  的双线性映射. 设置  u = g  1 2  、 u = g  0 2   和  u = g  0 1  . 公钥   pk = {N, ˜ G 1 , ˜ G 2 ,e,g 1 ,u ,
                                                           1  1    2   1     3  1                      1
                  ′  ′          ′  ′  ′    ′  ′  ′    ′        ′  ′                 ′       p p  阶循环子群
                                                                                            ′
                                                                                              ′
                 u ,u }, 私钥  Sk 1 = p p p  和  Sk 2 = p p p . 其中,   u  是   ˜ G 1  的  p p  阶循环子群的生成元,   u  是   ˜ G 1  的
                  2  3          1  2  3    0  2  3    1        0  3                 2       1  3
                 的生成元,   u  是   ˜ G 1  的  p p  阶循环子群的生成元.
                                    ′
                          ′
                                  ′
                                    3
                          3
                                  2
                                                                           2
                                 2
                                                                                                   ′
                    Step 2.   Enc(m, m , pk,r) → C. 此算法输入明文消息空间   m ∈ [1,T 1 ] 和   m ∈ [1,T 2 ], 其中  T 1 < p p T 2 < p p , 公
                                                                                             ′
                                                                                                     ′
                                                                                           ′
                                                                                              ,
                                                                                           0  3    1  3
                                                       ′ m 2
                 钥  pk 以及随机数  r ∈ Z N , 输出则为密文  C = (u ) (u ) (u ) ∈ ˜ G 1 .
                                                           ′ r
                                                    ′ m
                                                    1  2   3
                                                                   ′ m 2
                                                                       ′ r
                    Step 3.   Dec(C, sk) → {m,m }.  此算法输入为密文  C = (u ) (u ) (u ) ∈ ˜ G 1 、私钥  Sk 1 = p p p  和  S k 2 = p p p ,
                                                               ′ m
                                         2
                                                                                                     ′
                                                                                                       ′
                                                                                         ′
                                                                                        ′
                                                                                           ′
                                                                                                    ′
                                                                                                     2
                                                                                           3
                                                                       3
                                                                   2
                                                                                                       3
                                                                                                    0
                                                                                        1
                                                               1
                                                                                         2
                                                                          2 3 ) , 接下来利用文献
                               2                Sk 1  ′ m  ′ m 2  ′ r p ′  2 3 = ((u ) 1 p ′ p ′ m  [17] 中提及的
                                                                        ′ p ′
                 输出为明文     {m, m }. 具体解密过程为    C  = ((u ) (u ) (u ) ) 1 p ′ p ′  1
                                                          2
                                                              3
                                                      1
                                                   2  2
                 Pollard  的  lambda 解密方法, 通过计算以  g (p ′ ) (p ′ ) p 3   为底  C Sk 1  的离散对数便可获得明文消息  m. 同理, 再计算  C Sk 2  =
                                                  1
                                                     2
                                                 1
                               2 3 = ((u ) 0 p ′ p ′ m 2
                       ′ m 2
                 ((u ) (u ) (u ) ) 0 p ′ p ′  ′ p ′  2 3 )   便可获得明文消息  m .
                                                           2
                           ′ r p ′
                   ′ m
                   1   2   3        2
                  3   基于  TEE  安全高效的细粒度统计分析与可验证数据聚合方案
                    为了实现医疗密文数据的安全聚合与统计分析, 本节首先设计并提出                        ODMT-BGN  算法, 然后详细介绍基于
                 TEE  安全高效的细粒度统计分析与可验证数据聚合方案的系统模型、威胁模型和方案详细描述.
                  3.1   ODMT-BGN  算法
                    新型  BGN  同态加密算法存在消息空间利用率过低的问题, 因此, 本节引入膨胀因子概念, 膨胀因子为密文长
                 度与明文长度的比值.
                    由第  2.2  节  Step 1  中  KeyGen     ˜ G 1  的阶   ′  ′  ′  ′          ′  ′  m < p p , 通过公
                                                                                            2
                                                                                                ′
                                                                                                 ′
                                                            N = p p p p , 其中要求消息
                                           算法, 可知群
                                                                0  1  2  3        m < p p  且    1  3
                                                                                      0
                                                                                        3
                                          ⌊ √   ⌋
                 式  (1) 可推导出  m  必定满足  m ⩽  p p . 由第  2.2  节的  Step 2  可知密文  C = (u ) (u ) (u ) ∈ ˜ G 1 , 故而得到一个关
                                                                                 ′ m 2
                                                                                     ′ r
                                                                             ′ m
                                             ′
                                               ′
                                             1  3                            1   2   3
   395   396   397   398   399   400   401   402   403   404   405