0 概述

病历是医务人员对病人患病经过和治疗情况所作的文字记录，是医生诊断和治疗疾病的依据。随着医院现代化建设的发展和计算机信息技术的普及，电子病历（Electronic Medical Record，EMR）逐步取代纸质病历，在病人信息的收集、储存、分析、传递和利用中得到广泛应用，解决了纸质病历易丢失、易损坏等问题。对于疾病的研究^[1]，医生或医疗机构需对大量相同或类似的EMR进行系统分析对比以找出准确的病因和更好的医疗办法^[2-4]。随着大量EMR的生成，不仅占用医院本地服务器资源，而且难以进行数据共享和计算^[5-7]，因此越来越多的医院选择存储空间大、计算效率高和响应速度快的云服务器进行存储^[8-10]。但是，如果云服务器受到攻击或缺乏监控，数据可能会被窃取、泄露或篡改，而且云服务器可能存在未经授权访问等安全问题，所以云服务器不能被用户完全信任，而去中心化分布式存储的区块链技术^[11-13]为EMR提供了安全不可修改的记录，然而很多EMR文件数据由于具有高度保密性和敏感性，因此不能直接存储在区块链中，以太坊^[14]是一个具备图灵完备性的开源区块链平台，为实现EMR在区块链上的存储提供了技术支持^[15]。

在文件上传存储前必须将数据文件进行加密，以保证数据的安全性和隐私性，但在搜索大量数据时，数据使用者需要将全部数据文件下载并解密，然后进行数据搜索，因此该方法的搜索效率极低。文献[16]提出在密文上实现关键字搜索的可搜索加密（Searchable Encryption，SE）方案，该方案的搜索效率较高并保证了服务器执行搜索操作时的隐私性和保密性，但在存放加密数据时对不同文档通常使用不同的密钥，用户持有的密钥会随文档数量的增多而增加，因此用户必须生成大量的陷门进行搜索，导致工作效率低下。文献[17]提出一种可搜索的聚合密钥加密方案，解决了用户持有大量不同密钥时的复杂困难搜索问题，但在用户得到数据后一般需要在相关文档集上进行验证，当用户完成对大量文档集的搜索后也会拥有大量的可验证令牌，因此文献[18]提出一种可验证的可搜索聚合密钥加密方案，该方案实现了对通过密钥聚合得到数据的简单快速验证。本文提出一种面向区块链电子病历的基于密钥聚合的密文检索方案。该方案利用密钥聚合技术，当数据用户请求多个文件数据时，仅需生成一个聚合陷门即可进行数据检索，同时通过智能合约技术确保用户进行数据验证，从而得到正确完整的文件。

1 基础知识 1.1 双线性映射和困难性假设

定义1  令$ {G}_{1} $和$ {G}_{2} $为两个阶为素数$ p $的乘法循环群，定义一个双线性映射$ e:{G}_{1}\times {G}_{1}\to {G}_{2} $满足如下性质：

1）双线性：对任意的$ u, v\in {G}_{1} $，存在$ a, b\in {\mathbb{Z}}_{p}^{\mathrm{*}} $，使得$ e({u}^{a}, {v}^{b})=e{(u, v)}^{ab} $。

2）非退化性：存在$ u, v\in {G}_{1} $，使得$ e(u, v)\ne 1 $。

3）可计算性：对任意的$ u, v\in {G}_{1} $，存在有效算法计算$ e(u, v) $。

定义2  基于l阶的双线性Diffie-Hellman指数假设（l-BDHE）问题给定包含（$ 2l+1 $）个元素的向量$ \left(h, g, {g}^{\alpha }, {g}^{{\alpha }^{2}}, \cdots , {g}^{{\alpha }^{l}}, {g}^{{\alpha }^{l+2}}, \cdots , {g}^{{\alpha }^{2l}}\right)\in {\left({G}^{\mathrm{*}}\right)}^{2l+1} $作为输入，输出为$ e{\left(g, h\right)}^{{\alpha }^{l+1}}\in {G}_{1} $。在本文中为便于描述，使用$ {g}_{i} $表示$ {g}_{i}={g}^{{\alpha }^{i}}\in G $。

1.2 同态向量哈希函数

定义3  设$ G $是一个阶为$ p $的循环群，随机选取公共参数$ {g}_{1}, {g}_{2}, \cdots , {g}_{d}\in G $，则向量$ \boldsymbol{v}=({v}_{1}, {v}_{2}, \cdots , {v}_{d})\in $ $ {\mathbb{Z}}_{p}^{} $的哈希函数为：

$ H\left(\boldsymbol{v}\right)\stackrel{\mathrm{d}\mathrm{e}\mathrm{f}}{̿}\prod\limits_{j=1}^{d}{g}_{j}^{{v}_{j}} $

向量哈希函数满足以下性质：

1）同态性：对任意2个向量$ {\boldsymbol{m}}_{1} $、$ {\boldsymbol{m}}_{2} $和2个实数$ {l}_{1} $、$ {l}_{2} $，满足$H({l_1}{\mathit{\boldsymbol{m}}_1} + {l_2}{\mathit{\boldsymbol{m}}_2}) = H{({\mathit{\boldsymbol{m}}_1})^{{l_1}}}H{({\mathit{\boldsymbol{m}}_2})^{{l_2}}}$。

2）免碰撞性：不存在一个多项式时间的攻击者伪造一个向量$ {\boldsymbol{m}}_{3} $，同时满足$ {\boldsymbol{m}}_{3}\ne {l}_{1}{\boldsymbol{m}}_{1}+{l}_{2}{\boldsymbol{m}}_{2} $且$H\left( {{\mathit{\boldsymbol{m}}_3}} \right) = H{({\mathit{\boldsymbol{m}}_1})^{{l_1}}}H{({\mathit{\boldsymbol{m}}_2})^{{l_2}}}$。

定理1  同态向量哈希函数在离散对数问题是困难问题假设下是安全的^[19]。

1.3 密钥聚合的密文检索方案

为防止数据在上传过程中的信息泄露，通常采用加密云存储^[20]，具体方法为：在数据上传至云端前数据拥有者将所有文件加密，加密数据只能被解密密钥拥有者进行搜索和解密。假如文件拥有者希望通过云服务器安全共享敏感文件，同时拥有者希望向部分用户授权，使得用户可以在拥有者提供的子集中搜索文件。针对该关键字搜索问题，文献[21-22]提出可搜索加密技术，保证了服务器执行搜索时的隐私性和保密性。

如图 1所示，在传统密文检索方案中，Alice对其不同的文档集$ {\left\{{d}_{i}\right\}}_{i=1}^{n} $使用不同的密钥加密并上传至云服务器，当Bob想获取部分文档$ S\left(\left|S\right|=m\right) $的搜索时，Alice需要将密钥$ {\left\{{k}_{i}\right\}}_{i=1}^{m} $通过安全信道发送给Bob进行授权。为搜索$ S $中的目标文档，Bob需要生成包含关键字$ w $的大量陷门$ {\left\{\mathrm{T}{\mathrm{r}}_{i}\right\}}_{i=1}^{m} $并提交给云服务器获得文件进行结果验证。当$ m $足够大时，对于Bob而言，密钥的分配和存储以及陷门的生成会变得非常困难，这违背了使用云服务器存储和计算的初衷。本文使用改进的聚合密钥检索方案，将大量计算和存储转移至云服务器且不会造成信息泄露。如图 2所示，在聚合密钥的密文检索方案中，Alice和Bob只需发送一个聚合密钥$ {k}_{\mathrm{a}\mathrm{g}\mathrm{g}} $和一个聚合陷门$ \mathrm{T}\mathrm{r} $，利用密钥聚合技术将大量文件进行聚合并发送给用户，用户通过生成聚合陷门得到请求数据从而提高搜索效率。

1.4 区块链中的智能合约技术

智能合约由密码学家尼克·萨博于1995年提出^[23]，是一套以数字形式定义的承诺，承诺控制着数字资产并包含了合约参与者约定的权利和义务。智能合约的工作理论迟迟没有实现，一个重要原因是因为缺乏能够支持可编程合约的数字系统和技术，区块链技术的出现解决了该问题。区块链系统中的每个节点用户可以通过发布一笔交易创建智能合约^[24]，并利用编程方式将智能合约设置为自己的所有权转移规则、交易方式和状态转换函数。本文利用以太坊区块链中的智能合约技术，并使用$ \mathrm{S}\mathrm{o}\mathrm{l}\mathrm{i}\mathrm{d}\mathrm{i}\mathrm{t}\mathrm{y} $语言编写智能合约，第三方数据用户将结果提供给完成部署的智能合约以验证医疗云服务器返回的检索结果是否正确和完整，函数将正确的检索结果返回给用户，通过智能合约技术确保用户获得的文件数据未被云服务器恶意篡改或丢失信息。

2 算法形式化定义和系统模型 2.1 算法形式化定义

算法形式化定义如下：

1）系统建立$ \mathrm{S}\mathrm{e}\mathrm{t}\mathrm{U}\mathrm{p}\left({1}^{\lambda }\right)\to \mathrm{p}\mathrm{a}\mathrm{r}\mathrm{a}\mathrm{m}\mathrm{s} $：输入安全参数$ \lambda $和公开的双线性映射$ B=\left(p, {G}_{1}, {G}_{2}, e\left(\cdot , \cdot \right)\right) $，医疗云服务器运行该算法输出系统参数$ \mathrm{p}\mathrm{a}\mathrm{r}\mathrm{a}\mathrm{m}\mathrm{s}=\left(B, {P}_{\mathrm{p}\mathrm{u}\mathrm{b}}, H\right) $。

2）密钥生成$ \mathrm{K}\mathrm{e}\mathrm{y}\mathrm{G}\mathrm{e}\mathrm{n}\left(\gamma \right)\to （\mathrm{p}\mathrm{k}, \mathrm{m}\mathrm{s}\mathrm{k}） $：输入随机数$ \gamma \in {\mathbb{Z}}_{p}^{\mathrm{*}} $，医生执行该算法输出密钥对、公钥$ \mathrm{p}\mathrm{k} $和主密钥$ \mathrm{m}\mathrm{s}\mathrm{k} $。

3）数据加密$ \mathrm{E}\mathrm{n}\mathrm{c}\mathrm{r}\mathrm{y}\mathrm{p}\mathrm{t}({D}_{\mathrm{m}}, w, I, H)\to ({C}_{\mathrm{m}}, {C}_{\mathrm{w}}, {∆}_{i}, A, {h}_{i}) $：输入电子病历文件$ {D}_{\mathrm{m}} $、关键字$ w $和文件索引$ {I}_{\mathrm{m}} $，医生执行该算法输出加密文件$ {C}_{\mathrm{m}} $、关键字密文$ {C}_{\mathrm{w}} $和辅助值$ {∆}_{i} $并上传至云服务器，同时输出文件地址$ {A}_{i} $。医生对每一个$ {C}_{{\mathrm{m}}_{i}}\in {C}_{\mathrm{m}} $计算$ {h}_{i}=H（{C}_{{\mathrm{m}}_{i}}） $，并将每一个$ {C}_{{\mathrm{m}}_{i}}\in {C}_{\mathrm{m}} $对应的文件地址$ {A}_{i} $与$ {h}_{i} $共同构建为新交易，同时将交易广播至联盟链。

4）聚合密钥提取$ \mathrm{E}\mathrm{x}\mathrm{t}\mathrm{r}\mathrm{a}\mathrm{c}\mathrm{t}\left(\mathrm{m}\mathrm{s}\mathrm{k}, S\right)\to {k}_{\mathrm{a}\mathrm{g}\mathrm{g}} $：输入主密钥$ \mathrm{m}\mathrm{s}\mathrm{k} $和集合$ S $，通过医院授权后医生执行该算法输出聚合密钥$ {k}_{\mathrm{a}\mathrm{g}\mathrm{g}} $。

5）陷门生成$ \mathrm{T}\mathrm{r}\mathrm{a}\mathrm{p}\mathrm{d}\mathrm{o}\mathrm{o}\mathrm{r}（{k}_{\mathrm{a}\mathrm{g}\mathrm{g}}, {w}_{i}）\to \mathrm{T}\mathrm{r} $：输入聚合密钥$ {k}_{\mathrm{a}\mathrm{g}\mathrm{g}} $和待搜索关键字$ {w}_{i} $，数据用户执行该算法输出聚合陷门$ \mathrm{T}\mathrm{r} $。

6）搜索验证$ \mathrm{T}\mathrm{e}\mathrm{s}\mathrm{t}（\mathrm{T}\mathrm{r}, {∆}_{i}, S）\to （{A}_{i}, {C}_{{\mathrm{m}}_{i}}） $：输入陷门$ \mathrm{T}\mathrm{r} $、辅助值$ {∆}_{i} $和集合$ S $，医疗云服务器执行该算法进行搜索，当验证结果为正确时则输出密文文件$ {C}_{{\mathrm{m}}_{i}} $和对应的文件地址$ {A}_{i} $，否则检索失败。

7）数据验证$ \mathrm{V}\mathrm{e}\mathrm{r}\mathrm{i}\mathrm{f}\mathrm{y}({A}_{i}^{\text{'}}, {h}_{i}^{\text{'}})\to \delta $：输入文件地址$ {A}_{i}^{\text{'}} $和$ {h}_{i}^{\text{'}} $，联盟链通过智能合约执行该算法进行验证，若输出结果为$ \delta $则代表验证结果为正确，否则返回错误结果。

2.2 系统模型

本文电子病历系统模型如图 3所示，该系统主要包括患者、数据拥有者、数据用户、医疗云服务器和联盟链5个实体：

1）患者：患者在医院就医时需要用个人身份证/医保卡进行医院注册，当患者在医院注册后，医生会根据对患者的诊断创建其个人的电子病历，本文中当患者在医院就医并创建了电子病历，即默认患者将个人的电子病历授权给了医院和医生。

2）数据拥有者：数据拥有者指的是医院和医生。医生在得到患者的授权后负责生成电子病历，在电子病历中提取并生成一系列关键字，将电子病历和关键字进行加密并计算加密文件的哈希值，并将加密文件和加密的关键字共同上传至医疗云服务器，然后将医疗云服务器返回的文件地址和密文的哈希值构建为新交易广播至联盟链。

3）数据用户：数据用户指的是医疗机构和政府等权威机构，且包括医院和医生在内的联盟链中的成员。数据用户向医院进行数据请求，当医院授权给医生后，医生生成相关文件的聚合密钥，数据用户将生成的聚合陷门发送给医疗云服务器得到数据文件，获取数据后计算密文的哈希值并发送给联盟链，同时通过智能合约验证数据是否完整正确。

4）医疗云服务器：医疗云服务器主要负责存储医生上传的加密文件和加密关键字，并将存储的数据文件地址返回给数据拥有者。当数据用户上传聚合陷门时，医疗云服务器会进行搜索验证，只有当结果为正确时才会将数据文件和文件地址一起返回给数据用户，否则检索失败。

5）联盟链：联盟链节点负责将医生上传的对应密文哈希值和文件地址构建的新交易进行验证并打包放入区块中，当用户发送密文哈希值和相应的文件地址时，联盟链通过已部署好的智能合约验证用户得到的数据正确性和完整性，当数据正确时触发智能合约返回正确验证结果，否则返回错误验证。

2.3 方案设计目标 2.3.1 功能性需求

本文方案需满足以下3个功能性需求：

1）紧凑性，确保聚合密钥的大小独立于分享的文件数量。对于一组密钥$ \left\{{k}_{i}\right\}\left(i\in S\right) $，将其密钥聚合$ \mathrm{E}\mathrm{x}\mathrm{t}\mathrm{r}\mathrm{a}\mathrm{c}\mathrm{t}\left(\mathrm{m}\mathrm{s}\mathrm{k}, S\right)\to {k}_{\mathrm{a}\mathrm{g}\mathrm{g}} $，在设计方案时需要在后续步骤不失效的情况下将密钥集聚合为单个密钥。

2）可搜索性，使用户提供的任何关键字在可搜索加密文档上生成所需的陷门，即在减少密钥数量的同时保留搜索功能。对于每一个包含关键字$ w $的文档集，要求其如果得到陷门$ \mathrm{T}\mathrm{r}\mathrm{a}\mathrm{p}\mathrm{d}\mathrm{o}\mathrm{o}\mathrm{r}（{k}_{\mathrm{a}\mathrm{g}\mathrm{g}}, {w}_{i}）\to \mathrm{T}\mathrm{r} $，则应计算出$ \mathrm{T}\mathrm{e}\mathrm{s}\mathrm{t}（\mathrm{T}\mathrm{r}, {∆}_{i}, S）\to （{A}_{i}, {C}_{{\mathrm{m}}_{i}}） $，并且通过验证$ \mathrm{V}\mathrm{e}\mathrm{r}\mathrm{i}\mathrm{f}\mathrm{y}（{A}_{i}^{\text{'}}, {h}_{i}^{\text{'}}）\to \delta $。

3）安全授权，通过聚合密钥将关键字的搜索权委托给数据用户。为确保任何拥有委托聚合密钥的用户都可以执行关键字搜索，要求陷门生成算法的输入是不能公开的，即这些输入不应该依赖任何用户的私人信息。

2.3.2 安全性需求

任何可搜索的聚合密钥加密方案应满足以下两个安全性需求：

1）聚合密钥安全性，攻击者无法搜索没有数据拥有者授权的任意关键字，即攻击者不能对已知聚合密钥但无关的文档进行关键字搜索，也不能根据已知密钥为其他文档集生成新的聚合加密密钥。

2）陷门和关键字安全性，攻击者无法从陷门中确定检索中使用的关键字，只能通过观察获得关键字信息，即用户可能会要求不受信任的云服务器搜索敏感词，但不会将该敏感词透露给云服务器。

3 基于密钥聚合的密文检索方案

基于密钥聚合的密文检索流程具体如下：

1）系统建立：医疗云服务器输入安全参数$ \lambda $和公开的双线性映射$ B=\left(p, {G}_{1}, {G}_{2}, e(\cdot , \cdot )\right) $，定义一个双线性映射$ e:{G}_{1}\times {G}_{1}\to {G}_{2} $和抗碰撞的哈希函数$ H:{\left\{\mathrm{0, 1}\right\}}^{\mathrm{*}}\to {G}_{1} $，且循环群$ {G}_{1} $的阶为$ p $（$ {2}^{\lambda }\le p\le {2}^{\lambda +1} $），随机选取生成元$ g\in {G}_{1} $和$ \alpha \in {\mathbb{Z}}_{p}^{\mathrm{*}} $，计算$ {g}_{i}={g}^{{\alpha }^{i}}\in {G}_{1}\left(i=\right. $ $ \left.\{\mathrm{1, 2}, \cdots , n, n+2, \cdots , 2n\}\right) $。假设n为医疗云服务器可存储的最大电子病历数，医疗云服务器输出系统参数$ \mathrm{p}\mathrm{a}\mathrm{r}\mathrm{a}\mathrm{m}\mathrm{s}=（B, {P}_{\mathrm{p}\mathrm{u}\mathrm{b}}, H） $，其中$ {P}_{\mathrm{p}\mathrm{u}\mathrm{b}}=\left({g}_{1}, {g}_{2}, \cdots , {g}_{n}, {g}_{n+2}, \cdots , {g}_{2n}\right)\in $ $ {G}_{1}^{2n+1} $。

2）密钥生成：医生使用该算法生成密钥对，并随机选择$ \gamma \in {\mathbb{Z}}_{p}^{\mathrm{*}} $，输出$ \mathrm{p}\mathrm{k}=\boldsymbol{\nu }={g}^{\gamma } $、$ \mathrm{m}\mathrm{s}\mathrm{k}=\gamma $。

3）数据加密：医生使用该算法加密数据，将每个患者的电子病历$ {D}_{\mathrm{m}}=\left\{{D}_{{\mathrm{m}}_{1}}, {D}_{{\mathrm{m}}_{2}}, \cdots , {D}_{{\mathrm{m}}_{n}}\right\} $加密为$ {C}_{\mathrm{m}}=\left\{{C}_{{\mathrm{m}}_{1}}, {C}_{{\mathrm{m}}_{2}}, \cdots , {C}_{{\mathrm{m}}_{n}}\right\} $，并将电子病历中出现的所有症状提取生成一系列关键字$ w=\left\{{w}_{1}, {w}_{2}, \cdots , {w}_{n}\right\} $。为生成关键字密文，该算法需输入文件索引$ {I}_{\mathrm{m}}\in $ $ \left\{\mathrm{1, 2}, \cdots , n\right\} $，医生需要进行以下操作：

（1）对每一个文件随机选取$ t\in {\mathbb{Z}}_{p}^{\mathrm{*}} $作为文件的可搜索加密密钥$ {k}_{i} $，对文档集合$ S $中任意文档的密钥$ {k}_{i} $生成公共辅助值$ {∆}_{i}=({c}_{1}, {c}_{2}, \mu ) $并且存储在医疗云服务器中，具体计算为$ {c}_{1}={g}^{t} $、$ {c}_{2}=（\boldsymbol{\nu }\cdot {g}_{i}{）}^{t} $、$ \mu =e{\left(\prod\limits_{j\in S}{g}_{n+1-j}, \prod\limits_{i=1}^{n}{g}_{i}\right)}^{t} $。

（2）对每一个关键字$ {w}_{i} $输出所有关键字密文$ {C}_{\mathrm{w}}=\prod\limits_{i=1}^{n}{C}_{{\mathrm{w}}_{i}}=\prod\limits_{i=1}^{n}e{\left(g, {g}_{i}^{{w}_{i}}\right)}^{t}/\mu $，并将$ {C}_{\mathrm{m}} $和$ {C}_{\mathrm{w}} $上传至医疗云服务器，医疗云服务器向医生返回每个文件在服务器中的存储地址$ A=\left\{{A}_{1}, {A}_{2}, \cdots , {A}_{n}\right\} $。

（3）对每一个加密的密文文件$ {C}_{{\mathrm{m}}_{i}}\in {C}_{\mathrm{m}} $计算$ {h}_{i}=H（{C}_{{\mathrm{m}}_{i}}）(1\le i\le n) $，将计算后的$ \mathrm{H}\mathrm{a}\mathrm{s}\mathrm{h} $值$ {h}_{i}=H\left({C}_{{\mathrm{m}}_{i}}\right) $与其对应的文件地址$ {A}_{i} $一起构成新交易并广播至联盟链等待节点验证，当超过2/3的节点验证确认消息后，联盟链接受新交易并生成如图 4所示的新区块，否则拒绝新块加入联盟链。区块由块头和块体组成，块头包括前块哈希、时间戳、块大小和块标识，块体中则存放交易单数据，交易单数据包括密文哈希、文件地址和医生签名，其中医生签名有助于追踪建立电子病历的医生，时间戳显示块的生成时间。

4）聚合密钥提取：医生使用该算法生成一个可搜索聚合加密密钥$ {k}_{\mathrm{a}\mathrm{g}\mathrm{g}} $。当数据用户向医生请求相关电子病历时，医生需要先向医院进行申请，在医院对医生授权后，对于任何包含关键字索引的文档子集$ S\subseteq \left\{\mathrm{1, 2}, \cdots , n\right\} $，医生需要输入主密钥$ \mathrm{m}\mathrm{s}\mathrm{k} $并输出聚合密钥$ {k}_{\mathrm{a}\mathrm{g}\mathrm{g}}=\prod\limits_{j\in S}{g}_{n+1-j}^{\gamma } $，为将电子病历中关键字搜索权委托给数据用户，需要将聚合密钥$ {k}_{\mathrm{a}\mathrm{g}\mathrm{g}} $和集合$ S $同时发送给数据用户。

5）陷门生成：数据用户使用该算法生成可搜索的关键字陷门。当数据用户得到聚合密钥$ {k}_{\mathrm{a}\mathrm{g}\mathrm{g}} $后，对于聚合密钥$ {k}_{\mathrm{a}\mathrm{g}\mathrm{g}} $所有相关的文档，该算法将会对搜索关键字$ {w}_{i}=\left\{{w}_{1}, {w}_{2}, \cdots , {w}_{n}\right\} $仅生成一个聚合陷门$ \mathrm{T}\mathrm{r} $且计算公式为$ \mathrm{T}\mathrm{r}={k}_{\mathrm{a}\mathrm{g}\mathrm{g}}\cdot {g}_{i}^{{w}_{i}} $。数据用户在生成陷门后，将陷门$ \mathrm{T}\mathrm{r} $以及集合$ S $发送至医疗云服务器进行搜索验证算法，只有通过搜索验证，用户才可以获得数据。

6）搜索验证：云服务器使用该算法执行关键字搜索。根据该算法输入陷门$ \mathrm{T}\mathrm{r} $与可搜索加密密钥$ {k}_{i} $的辅助值$ {∆}_{i}=\left({c}_{1}, {c}_{2}, \mu \right) $，云服务器进行计算验证，当结果正确时向用户返回加密的密文文件$ {C}_{{\mathrm{m}}_{i}} $和相对应的文件地址$ {A}_{i} $，若验证结果错误则检索失败，其中$ {P}_{S}=\prod\limits_{j\in S}{g}_{n+1-j} $，计算公式为$ {C}_{\mathrm{w}}\stackrel{？}{̿}\frac{e\left(\mathrm{T}\mathrm{r}, {c}_{1}\right)}{e\left({P}_{S}, \prod\limits_{i=1}^{n}{c}_{2}\right)} $，正确性验证过程为：

$ {C}_{\mathrm{w}}=\frac{\prod\limits_{i=1}^{n}e{\left(g, {{g}_{i}}^{{w}_{i}}\right)}^{t}}{e{\left(\prod\limits_{j\in S}{g}_{n+1-j}, \prod\limits_{i=1}^{n}{g}_{i}\right)}^{t}}=\frac{e\left(\prod\limits_{i=1}^{n}{g}_{i}^{{w}_{i}}, {g}^{t}\right)}{e{\left(\prod\limits_{j\in S}{g}_{n+1-j}, \prod\limits_{i=1}^{n}{g}_{i}\right)}^{t}} $

$ \begin{array}{l}\frac{e\left(\mathrm{T}\mathrm{r}, {c}_{1}\right)}{e\left({P}_{S}, \prod\limits_{i=1}^{n}{c}_{2}\right)}=\frac{e\left({k}_{\mathrm{a}\mathrm{g}\mathrm{g}}, {g}^{t}\right)\cdot e\left(\prod\limits_{i=1}^{n}{g}_{i}^{{w}_{i}}, {g}^{t}\right)}{e\left(\prod\limits_{j\in S}{g}_{n+1-j}, \prod\limits_{i=1}^{n}{\left(v\cdot {g}_{i}\right)}^{t}\right)}=\\ \frac{e\left(\prod\limits_{j\in S}{g}_{n+1-j}^{\gamma }, {g}^{t}\right)\cdot e\left(\prod\limits_{i=1}^{n}{g}_{i}^{{w}_{i}}, {g}^{t}\right)}{e\left(\prod\limits_{j\in S}{g}_{n+1-j}, {\left(\prod\limits_{i=1}^{n}{g}_{i}\cdot {g}^{\gamma }\right)}^{t}\right)}=\\ \frac{e{\left(\prod\limits_{j\in S}{g}_{n+1-j}, {g}^{\gamma }\right)}^{t}\cdot e\left(\prod\limits_{i=1}^{n}{g}_{i}^{{w}_{i}}, {g}^{t}\right)}{e{\left(\prod\limits_{j\in S}{g}_{n+1-j}, {g}^{\gamma }\right)}^{t}\cdot e{\left(\prod\limits_{j\in S}{g}_{n+1-j}, \prod\limits_{i=1}^{n}{g}_{i}\right)}^{t}}=\\ \frac{e\left(\prod\limits_{i=1}^{n}{g}_{i}^{{w}_{i}}, {g}^{t}\right)}{e{\left(\prod\limits_{j\in S}{g}_{n+1-j}, \prod\limits_{i=1}^{n}{g}_{i}\right)}^{t}}={C}_{\mathrm{w}}\end{array} $

7）数据验证：将服务器部署的智能合约相关变量和函数接口采用$ \mathrm{S}\mathrm{o}\mathrm{l}\mathrm{i}\mathrm{d}\mathrm{i}\mathrm{t}\mathrm{y} $语言编写，智能合约提供一个函数接口进行数据验证并保证数据用户得到的文件未被云服务器篡改。当数据用户得到云服务器返回的数据文件$ {C}_{{\mathrm{m}}_{i}}^{\text{'}} $和相应的文件地址$ {A}_{i}^{\text{'}} $，数据用户通过公共参数计算$ {h}_{i}^{\text{'}}=H\left({C}_{{\mathrm{m}}_{i}}^{\text{'}}\right) $并将$ {A}_{i}^{\text{'}} $和$ H\left({C}_{{\mathrm{m}}_{i}}^{\text{'}}\right) $发送给联盟链，联盟链节点通过地址找到包含此交易的相应区块，并使用智能合约算法进行验证，数据验证阶段的智能合约算法具体流程如算法1所示，当$ H\left({C}_{{\mathrm{m}}_{i}}^{\text{'}}\right)=H\left({C}_{{\mathrm{m}}_{i}}\right) $和$ {A}_{i}^{\text{'}}={A}_{i} $时，返回正确验证结果$ \delta $，否则返回错误结果。

算法1  验证阶段的智能合约算法

输入  $ H\left({C}_{{\mathrm{m}}_{i}}^{\text{'}}\right)\mathrm{、}{A}_{i}^{\text{'}} $

输出  $ \delta 或\mathrm{f}\mathrm{a}\mathrm{l}\mathrm{s}\mathrm{e} $

1.$ \mathrm{i}\mathrm{f}\;\mathrm{ }\mathrm{m}\mathrm{s}\mathrm{g}.\mathrm{s}\mathrm{e}\mathrm{n}\mathrm{d}\mathrm{e}\mathrm{r}\mathrm{\;}\mathrm{i}\mathrm{s}\mathrm{\;}\mathrm{n}\mathrm{o}\mathrm{t}\mathrm{\;}\mathrm{u}\mathrm{s}\mathrm{e}\mathrm{r}\mathrm{\;}\mathrm{t}\mathrm{h}\mathrm{e}\mathrm{n} $

2.$ \mathrm{t}\mathrm{h}\mathrm{r}\mathrm{o}\mathrm{w}; $

3.$ \mathrm{e}\mathrm{l}\mathrm{s}\mathrm{e} $

4.if H（$ {\mathrm{C}}_{{\mathrm{m}}_{\mathrm{i}}}^{\text{'}} $）=（$ {\mathrm{C}}_{{\mathrm{m}}_{\mathrm{i}}}^{} $） & & $ {\mathrm{A}}_{\mathrm{i}}^{\text{'}}={\mathrm{A}}_{\mathrm{i}}\mathrm{t}\mathrm{h}\mathrm{e}\mathrm{n} $

5.$ \mathrm{r}\mathrm{e}\mathrm{t}\mathrm{u}\mathrm{r}\mathrm{n}\mathrm{ }\mathrm{\delta }; $

6.$ \mathrm{e}\mathrm{l}\mathrm{s}\mathrm{e}\mathrm{ }\mathrm{i}\mathrm{f}\mathrm{ }\mathrm{H}\left({\mathrm{C}}_{{\mathrm{m}}_{\mathrm{i}}}^{\text{'}}\right)\ne \mathrm{H}\left({\mathrm{C}}_{{\mathrm{m}}_{\mathrm{i}}}\right)\&\&{\mathrm{A}}_{i}^{\text{'}}\ne {\mathrm{A}}_{\mathrm{i}}\mathrm{t}\mathrm{h}\mathrm{e}\mathrm{n} $

7.$ \mathrm{r}\mathrm{e}\mathrm{t}\mathrm{u}\mathrm{r}\mathrm{n}\mathrm{ }\mathrm{f}\mathrm{a}\mathrm{l}\mathrm{s}\mathrm{e}; $

8.$ \mathrm{e}\mathrm{n}\mathrm{d} $

4 安全性分析

为满足本文方案的安全需求，假设医疗云服务器仅根据本文方案提供合法的服务，授权用户可以尝试访问权限范围内或权限范围外的数据。此外，涉及医疗云服务器的通信通道被认为是不安全的。基于以上考虑，本节将在聚合密钥以及陷门和关键字安全性方面进行具体分析。

4.1 聚合密钥安全性分析

本文要求任何拥有聚合密钥的用户都可以对集合$ S $中的文档进行关键字搜索，但不能对集合$ S $之外的文档进行关键字搜索。用户也不能从已知的集合$ S $中生成新的集合$ S\text{'} $并生成其他的可搜索聚合加密密钥。每个拥有聚合密钥的数据用户都可以成功地执行关键字检索。数据用户将得到的聚合密钥生成一个聚合陷门$ \mathrm{T}\mathrm{r} $，然后执行搜索验证算法进行关键字检索，通过下式可以验证检索算法的正确性：

$ \begin{array}{l}\frac{e\left(\mathrm{T}\mathrm{r}, {c}_{1}\right)}{e\left({P}_{S}, \prod\limits_{i=1}^{n}{c}_{2}\right)}\mathrm{ }=\frac{e{\left(\prod\limits_{j\in S}{g}_{n+1-j}, {g}^{\gamma }\right)}^{t}\cdot e\left(\prod\limits_{i=1}^{n}{g}_{i}^{{w}_{i}}, {g}^{t}\right)}{e{\left(\prod\limits_{j\in S}{g}_{n+1-j}, {g}^{\gamma }\right)}^{t}\cdot e{\left(\prod\limits_{j\in S}{g}_{n+1-j}, \prod\limits_{i=1}^{n}{g}_{i}\right)}^{t}}\mathrm{ }=\\ \frac{e\left(\prod\limits_{i=1}^{n}{g}_{i}^{{w}_{i}}, {g}^{t}\right)}{e{\left(\prod\limits_{j\in S}{g}_{n+1-j}, \prod\limits_{i=1}^{n}{g}_{i}\right)}^{t}}\mathrm{ }={C}_{\mathrm{w}}\end{array} $

由此可知，拥有聚合密钥的数据用户可以成功地执行关键字检索。攻击者无法对任何不在聚合密钥范围内的文档执行关键字检索，即使服务器与恶意授权用户串通，也无法对任何不在聚合密钥范围内的文档执行关键字检索。攻击者$ A $可能为云服务器或恶意授权用户，此类攻击者可能试图对不在其聚合密钥范围内的文档执行关键字搜索。从$ \frac{e\left(\mathrm{T}\mathrm{r}, {c}_{1}\right)}{e\left({P}_{S}, \prod\limits_{i=1}^{n}{c}_{2}\right)} $中可以看出，如果$ {P}_{S} $是由错误的文档集$ j\in S\text{'} $生成，则$ e\left({k}_{\mathrm{a}\mathrm{g}\mathrm{g}}, {g}^{t}\right) $与$ e\left({P}_{S}, {g}^{t}\right) $在等式中无法消除，因此必须在聚合密钥相同的文档集合$ S $上进行计算。基于上述情况，攻击者可能使用目标集合$ S\text{'} $作为输入，但会因为文档索引$ {I}_{m}\notin S $，在搜索验证算法中返回错误结果。

攻击者无法通过已知的聚合密钥为任何新文档集合生成新的聚合密钥。假设一个拥有文档集合$ S\text{'} $的聚合密钥$ {k}_{\mathrm{a}\mathrm{g}\mathrm{g}} $的攻击者$ A $想要尝试为一组新的集合$ S\text{'} $生成新的聚合密钥。$ A $需要已知任意文档$ j\in S\text{'} $的$ {g}_{n+1-j}^{\gamma } $值，即使$ A $已知聚合密钥$ {k}_{\mathrm{a}\mathrm{g}\mathrm{g}}=\prod\limits_{j\in S}{g}_{n+1-j}^{\gamma } $的值，由于每个乘数的值由数据拥有者的主密钥$ \gamma $生成，因此$ A $无法从获得的$ {k}_{\mathrm{a}\mathrm{g}\mathrm{g}} $值中获取其中每个加密的乘数，因此攻击者$ A $无法从已知的聚合密钥中为任何新的文档集合生成新的聚合密钥。

4.2 陷门和关键字安全性分析

假设攻击者$ A $可能会获得相关信息来发起攻击，例如当云服务器获取到存储的关键字密文、可搜索加密密钥$ {k}_{i} $的辅助值$ {∆}_{i} $和提交的陷门$ \mathrm{T}\mathrm{r} $等时，对于恶意的授权用户假设拥有聚合密钥以及可在文档集合$ S $中执行关键字搜索的权力，然而即使云服务器能获取到这些信息，本文方案仍具备查询隐私安全性。

4.2.1 陷门安全性

假设攻击者$ A $在获得提交的陷门$ \mathrm{T}\mathrm{r}={k}_{\mathrm{a}\mathrm{g}\mathrm{g}}\cdot \prod\limits_{i=1}^{n}{{g}_{i}^{{w}_{i}}}^{} $后，只有取得聚合密钥$ {k}_{\mathrm{a}\mathrm{g}\mathrm{g}} $才能在搜索时获得关键字，在此情况下由于攻击者$ A $已知系统参数$ \mathrm{p}\mathrm{a}\mathrm{r}\mathrm{a}\mathrm{m}\mathrm{s}=\left(B, {P}_{\mathrm{p}\mathrm{u}\mathrm{b}}, H\right) $、$ {P}_{\mathrm{p}\mathrm{u}\mathrm{b}}=\left({g}_{1}, {g}_{2}, \cdot \cdot \cdot , {g}_{n}, {g}_{n+2}，\cdot \cdot \cdot , {g}_{2n}\right)\in {G}_{1}^{2n+1} $以及文档集合$ S $，为计算$ {k}_{\mathrm{a}\mathrm{g}\mathrm{g}} $，攻击者$ A $需先计算每一个文档$ j\in S $的$ {g}_{n+1-j}^{\gamma } $，其中$ \gamma $为数据拥有者的主密钥且为保密值，而$ A $计算得到$ \gamma $的概率可以忽略不计，因此攻击者$ A $无法发起攻击，可见本文方案具备陷门安全性。

4.2.2 关键字安全性

假设云服务器和攻击者$ A $试图在存储的数据中学习且假设已知$ {P}_{\mathrm{p}\mathrm{u}\mathrm{b}}=\left({g}_{1}, {g}_{2}, \cdot \cdot \cdot , {g}_{n}, {g}_{n+2}, \cdot \cdot \cdot , {g}_{2n}\right)\in {G}_{1}^{2n+1} $、$ {c}_{1}={g}^{t} $、$ {c}_{2}={\left(\nu \cdot {g}_{\mathrm{i}}\right)}^{t} $、$ \mu =e{\left(\prod\limits_{j\in S}{g}_{n+1-j}, \prod\limits_{i=1}^{n}{g}_{i}\right)}^{t} $以及$ {c}_{\mathrm{w}}=\frac{\prod\limits_{i=1}^{n}e{\left(g, {g}_{i}^{{w}_{i}}\right)}^{t}}{e{\left(\prod\limits_{j\in S}{g}_{n+1-j}, \prod\limits_{i=1}^{n}{g}_{i}\right)}^{t}} $，$ A $可能尝试发起以下攻击：

1）从已知的$ {c}_{1} $和$ {c}_{2} $中检索$ t $的值，但在离散对数问题中$ A $不能计算得到$ t $的值。

2）已知$ \mu =e{\left(\prod\limits_{j\in S}{g}_{n+1-j}, \prod\limits_{i=1}^{n}{g}_{i}\right)}^{t} $和$ {c}_{\mathrm{w}} $，由于用户可能搜索多关键字，因此假设$ 1\le i\le n $，攻击者$ A $无法从已知的值中计算出聚合中每个乘数的具体值。因此，经过以上分析可知，攻击者$ A $无法从存储的信息中确定文档中的关键字。

5 性能分析

将本文方案与文献[17-18, 23]方案在区块链应用、安全搜索、密钥聚合和可验证性方面进行对比，如表 1所示，其中，“√”表示具备该功能特性，“×”表示不具备该功能特性，文献[17-18, 23]方案的应用环境均为云服务器，而本文方案是云服务器和区块链的结合。可以看出，文献[17, 23]方案不具备可验证功能，而本文方案通过应用区块链智能合约技术可验证医疗云服务器是否恶意修改信息或丢失数据，保证了用户获取文件的正确性和完整性，相比其他方案在区块链应用、安全搜索、密钥聚合和可验证性方面更具优势。

表 2为本文方案与文献[17-18]方案的运算时间对比结果，其中，$ {T}_{\mathrm{p}} $表示双线性映射配对运算时间，$ {T}_{\mathrm{e}} $表示指数运算时间，$ {T}_{\mathrm{m}} $表示乘法运算时间，$ {T}_{\mathrm{h}} $表示哈希函数运算时间。已知常用的密码操作时间排序为$ {T}_{\mathrm{p}}>{T}_{\mathrm{e}}>{T}_{\mathrm{m}}>{T}_{\mathrm{h}} $且双线性映射配对$ {T}_{\mathrm{p}} $的运算时间远大于其他密码操作的时间。结合数据加密阶段和数据搜索阶段的运算时间可以看出，本文方案的整体运算时间最少。

为更准确地评估密文检索方案的实际性能，本文基于2.60 GHz CPU、8 GB内存的联想笔记本和Linux虚拟机，并在真实数据集和由C语言编写的PBC库上进行模拟实验。在实验中，将最大文件值$ n $设置为500，关键字个数设置为1、10、20、30、40和50，实验取50次运行结果的平均值。为体现本文方案的性能优势，将本文方案和文献[17]方案数据加密和数据搜索阶段的时间开销进行对比，如图 5、图 6所示。可以看出，因为本文方案利用多关键字加密算法，所以在数据加密阶段的时间开销随着关键字的增加而增长，且在关键字个数大于10时，本文方案的数据加密开销低于文献[17]方案。在数据搜索阶段，本文方案和文献[17]方案的时间开销随着关键字个数的增加成正相关变化，且时间开销低于文献[17]方案，可见本文方案的搜索效率更高，系统性能更优。

6 结束语

本文提出一种面向区块链电子病历的基于密钥聚合的密文检索方案。该方案基于云服务器和联盟链进行构建，将医院医生和医疗机构、政府等权威机构在内的联盟成员分别定义为数据拥有者和数据用户，使数据加密上传至医疗云服务器，并将数据密文哈希值打包至联盟链，同时使用密钥聚合技术对多个文件生成一个聚合陷门进行安全检索，并利用联盟链的智能合约技术实现数据验证，防止医疗云服务器的恶意攻击行为。通过理论分析与数值模拟实验验证了该方案的安全性与高效性。