0 引言

近年来，云计算技术^[1-2]凭借其低廉的成本、强大的计算能力和易于扩展等优点备受人们的青睐。云服务提供商通过组建一个由大量服务器构成的“云”，赋予用户前所未有的计算能力; 此外，用户还可以在云平台上轻易地实现数据的存取、共享等操作。目前，IBM、Google、Microsoft、阿里云、百度等公司都推出了它们自己的云服务平台。

但是，随着越来越多的人将隐私数据存储在第三方平台，数据安全^[3-4]也逐渐成为云计算技术发展过程中所不得不面对的问题。为了解决数据安全问题，研究者们提出了大量的数据保护方案。在这些方案中，基于属性基加密(Attribute Based Encryption, ABE)凭借其安全性和访问控制能力成为研究的热点。

2005年，Sahai等^[5]首次提出属性基加密的概念。随后，研究者们针对不同的场景，设计了大量的属性基加密方案。目前，属性基加密方案主要分为两种：密文策略ABE(Ciphertext Policy Attribute Based Encryption, CP-ABE)方案^[6]和密钥策略属性基加密(Key Policy Attribute Based Encryption, KP-ABE)方案^[7]。在CP-ABE中，用户的密钥与一个属性集合相关联，密文与一个访问树相关联。数据拥有者可以自由定义访问树，解密某个密文的唯一条件是用户的属性集合满足密文中隐藏的访问树。因此CP-ABE更加适合云环境中一对多的加密模式。

由于现实中的人际关系经常会发生变动，为了解决这个问题，研究者们提出了一些属性撤销方案^[8]。Boldyreva等^[9]提出一个支持撤销的身份基加密方案；但该方案只支持用户撤销，不支持属性撤销。为了解决属性撤销的问题，Yu等^[10]提出一个支持属性撤销的属性基加密方案，并证明该方案基于判定双线性Diffie Hellman(Decisional Bilinear Diffie-Hellman, DBDH)假设是选择明文安全的(Chosen Plaintext Secure, CPS); 但是该方案中密文和用户密钥的长度与系统中属性的个数成比例。Tysowski等^[11]提出引入“群组”的概念来执行用户撤销, 在该方案中，每个用户属于一个用户群，拥有一个与这个群相关的群密钥，通过使用重加密的方法来进行用户撤销；但是由于群中所有用户的群密钥都是相同的，该方案无法抵抗群内用户和已撤销用户发起的共谋攻击。随后Li等^[12]对文献[11]方案进行改进，弥补了无法抵抗共谋攻击的缺陷，并使用外包技术进一步降低用户的计算开销，但他们的方案并不支持属性撤销。

另一方面，目前大多数属性基加密方案只能描述属性的二元状态：0代表不满足，1代表满足^[13-15]。Liu等^[16]提出一种支持属性分类的细粒度访问控制方案，在该方案中，属性被分为动态属性和静态属性，其中静态属性代表一段时间内不会发生变动的属性，动态属性在必要时可以进行更新；但是该方案中，属性依然只有两种状态且云服务提供商和数据拥有者各自需要维护两个列表。Wang等^[17]在文献[18]研究的基础上提出一个可以表达属性任意元状态的方案，在该方案中，使用带权属性来提高属性的表达能力，同时降低访问结构的复杂度。例如在某所大学中，教师的职位分为助教、讲师、副教授、教授四种，分别赋予他们权重1、2、3和4，即用Teacher:1、Teacher:2、Teacher:3和Teacher:4来分别表示这4个职位，这样仅用Teacher一个属性就可以达到原来4个属性的效果。如果存在一个访问结构T:{教授or副教授or讲师}，其在系统中的结构可以化简为{Teacher:2}，即用满足条件的最低属性代替其他属性。

针对现存的大部分属性基加密方案仅支持二元属性表示和加解密过程计算开销大的问题，本文提出一种支持带权属性撤销的CP-ABE(CP-ABE scheme with Weighted Attribute Revocation, CPABEWAR)方案，支持属性的多元表示，同时降低访问树的复杂度和存储开销，可以灵活地对用户权限进行部分或全部撤销。此外，本文方案将部分解密过程外包给云服务提供商，在保证数据机密性的前提下降低了用户方面的计算开销。

1 相关知识 1.1 属性

设L:{λ₁, λ₂, …, λ_p}是全部属性集合，那么每一个用户密钥相联系的属性集合A是L一个不为空的子集，A⊆{λ₁, λ₂, …, λ_p}。

1.2 素数阶双线性群

令G和G_T为两个阶为素数p的循环群。令g为群G的生成元，e:G×G→G_T为双线性映射。其中双线性映射e满足如下条件：

1) 双线性性：∀u, v∈G和a, b∈Z_P，有e(u^a, v^b)=e(u, v)^ab。

2) 非退化性：e(g, g)≠1。

3) 可计算性：对∀u, v∈G，都存在有效算法去计算e(u, v)。

如果群G上的群操作和双线性映射e:G×G→G_T可以进行有效的计算，那么称G是一个双线性群。注意到映射e(·, ·)是对称的，因为e(g^a, g^b)=e(g, g)^ab=e(g^b, g^a)。

1.3 判定双线性Diffe-Heman假设

设G₁和G₂是两个群，g是G₁的生成元，e是双线性映射。{G₁, G₂, e}的DBDH假设^[19]就是：挑战者随机选择a, b, c, z∈Z_P，则不存在攻击者能在任何多项式时间内以不可忽略的优势去区分元组(A=g^a, B=g^b, C=g^c, e(g, g)^abc)和元组(A=g^a, B=g^b, C=g^c, e(g, g)^z)。

1.4 带权访问树

设T为一棵带权访问树，其根节点为R。通过定义以下符号和函数来具体表达其功能：

1) x代表树T的根节点。如果x是一个叶节点，就代表一个带权属性；如果x是一个非叶节点，则代表一个操作符(如：与门、或门、门限门)。

2) num_x代表树T中x的孩子节点的数量。

3) k_x代表节点x的门限值，其中0 < k_x < num_x。当k_x=1且x是一个非叶节点时，表示一个或门；当k_x=num_x且x是一个非叶节点时，表示一个与门。另外，如果x是一个叶子节点，其k_x=1。

4) parent(x)代表树T中x的父亲节点。

5) att(x)代表树T中与叶子节点x相关联的属性。

6) index(x)返回一个与节点x相关的唯一序号。

7) T_x代表树T中以x为根节点的子树。用T_x(S)=1表示带权属性集合S可以满足这个访问树T_x。T_x的计算按下面的方法递归进行。如果x是一个非叶节点，当且仅当至少有k_x个孩子节点返回1时，T_x(S)才返回1；如果x是一个叶子节点，当且仅当集合S中属性x的权重w_x大于或等于叶子节点的权重时，T_x(S)才返回1，即weight(w_x)≥weight(att(x))。

2 系统模型

系统包括五个实体：数据拥有者(Data Owner, DO)、系统管理员(System Manager, SM)、可信授权机构(Trusted Authority, TA)、云存储服务提供商(Cloud Service Provider, CSP)、访问用户(Data User, DU)。可信授权机构为用户提供属性授权、身份认证、密钥生成服务。可信系统管理员为用户生成证书、更新密钥，并向云存储服务提供商申请执行密文的重加密命令。云存储服务提供商被定义为忠实而好奇的，它向用户提供密文存储，密文重加密和部分解密操作。用户分为数据拥有者和访问用户两种，前者负责加密数据和上传加密后的数据给CSP，从而后者可以根据自身的权限获取相应的数据。本文方案的系统模型图如图 1所示。

本文方案由九个算法组成，描述如下：

1) SystemSetup(1^λ)→{MK, PK}：输入安全参数λ；输出系统公钥PK和主密钥MK。

2) VerSetup(PK)→{VMK₀, VPK₀, Dic₀}：输入系统公钥PK；输出版本主密钥VMK₀，版本公钥VPK₀。每当有用户属性被撤销，系统版本加1。在本文的方案中，使用下标ver表示当前版本。

3) CertGen(PK, UID, VMK_ver)→δ_ver：输入系统公钥PK，用户身份UID和版本主密钥VMK_ver。为身份为UID的用户生成证书δ_ver。

4) KeyGen(PK, MK, VPK_ver, S, UID, δ_ver)→{SK_ver, UP_ver}：输入系统公钥PK，主密钥MK，版本主密钥VMK_ver，用户属性集S，用户身份UID和与其相关的证书δ_ver；输出用户密钥SK_ver和一个元组UP_ver。其中元组UP_ver用于更新用户密钥。

5) Encrypt(PK, VPK_ver, M, T)→CT_ver：系统首先选择一个随机密钥ck使用公钥加密算法加密明文M为Eck(M)。然后输入系统公钥PK，版本主密钥VMK_ver，密钥ck，访问树T；输出密文CT_ver。

6) Revocation(PK, VMK_ver, R_UID)→{VMK_ver+1, VPK_ver+1, Re-Key_ver→er+1}：输入系统公钥PK，版本主密钥VMK_ver以及身份为UID的某用户的撤销属性列表R_UID；输出新的版本主密钥VMK_ver+1, 版本公钥VPK_ver+1，重加密密钥Re-Key_ver→ver+1，最后根据R_UID更新相应用户的UP_ver为UP_ver+1。

7) UserUpdate(SK_ver, UP_ver+1)→SK_ver+1：输入用户密钥SK_ver，元组UP_ver+1；输出新的用户密钥SK_ver+1。

8) Re-Encrypt(CT_ver, Re-Key_ver→ver+1)→CT_ver+1：输入密文CT_ver和重加密密钥Re-Key_ver→ver+1；输出新的密文CT_ver+1。

9) Decrypt(PK, CT_ver, SK_ver+1)→M：输入系统公钥PK，密文CT_ver+1和用户DU的密钥SK_ver+1，如果用户DU的属性可以满足访问树则输出明文M，否则输出⊥。

3 具体实现

选取一个阶为p的双线性群G，其生成元为g，令e:G×G→G_T代表双线性映射。选择一个哈希函数H:{0, 1}*→G将属性或身份映射为随机群元素。

3.1 SystemSetup(1^λ)→{MK, PK}

① 可信授权机构随机生成α, β∈Z_p^*。计算g^α、g^β和e(g, g)^α。

② 公布公钥PK={G, g, g^β, e(g, g)^α}，保存主密钥MK={β, g^α}。

3.2 VerSetup(PK)→{VMK₀, VPK₀, Dic₀}

① 系统管理员随机选择γ₀∈Z_p^*作为版本主密钥VMK={γ₀}，再计算g^γ₀和e(g, g)^γ₀。

② 公布版本公钥VPK={g^γ₀, e(g, g)^γ₀}。

在本方案中，0代表初始版本。每当有属性撤销时，系统密钥对将会更新到新的版本。本文使用ver来代表当前版本。

3.3 CertGen(PK, UID, VMK_ver)→δ_ver

输入系统公钥PK、用户身份UID和版本主密钥VMK_ver；输出用户UID的证书δ_ver。

① 系统管理员为系统中身份为UID的用户生成一个身份证书δ_ver。

② 系统管理员计算δ_ver=g^βγ_ver×H(UID)^γ_ver。

③ 系统管理员通过一个安全渠道将δ_ver发送给对应用户。

3.4 KeyGen(PK, MK, VPK_ver, S, UID, δ_ver)→{SK_ver, UP_ver}

密钥生成算法分为两个阶段，用户认证阶段和密钥生成阶段。

1) 用户认证：可信授权机构通过计算e(g, δ_ver)=e(g^β×H(UID), g^γ_ver)来验证用户是否是合法用户。如果验证的结果为真则进入第二阶段，否则算法输出⊥。

2) 密钥生成：经过验证后，可信授权机构为用户生成一个与属性集S相关密钥。

① 计算H(UID)^γ_ver=δ_ver/(g^γ_ver)^β。

② 随机选择r, t∈Z_p^*, D₁=(g^(α+γ_ver)×H(UID)^rγ_ver)^t/β。

③ 为每个属性j∈S，随机选择r_j∈Z_p^*，计算D_j=H(UID)^rγ_ver×H(j)^tr_j, D_j=g^tr_j。

④ 根据每个属性j∈S的权重w_j，计算D_j2=H(j)^{r_j tw_j}。

⑤ DSK_ver={D₁=(g^(α+γ_ver)×H(UID)^rγ_ver)^t/β, ∀j∈S:D_j=H(UID)^rγ_ver)×H(j)^tr_j, D_j′=g^tr_j, D_j²=H(j)^{r_j tw_j}}，因此用户的密钥为SK={t, DSK}。可信授权机构将UP_ver={UID, d₁=(g×H(UID)^r)^1/β, d₂=H(UID)^r}发送给系统管理员。

3.5 Encrypt(PK, VPK_ver, M, T)→CT_ver

在上传文件M到云存储服务提供商之前，数据拥有者需要为文件M选择一个对称密钥ck。通过对称加密算法如：RSA(Rivest-Shamir-Adleman)算法使用密钥ck来加密文件M，用Eck(M)来代表产生的加密文件。定义一个访问树T，使用外包加密的方法加密密钥ck，由于对称加密所需的计算量与运算速度要优于属性基加密，这样避免数据拥有者直接加密文件M，降低了数据拥有者的计算开销。

选择一个随机数s∈Z_p^*，加密密钥ck为密文C_ver=ck·e(g, g)^(α+r_ver)s，并将{s, C_ver}发送给云存储服务提供商。

1) 云存储服务提供商计算C₁=g^βs, C=g^s。

2) 从根节点R开始，为树T中的每个节点x按从上到下的方式随机选择一个多项式q_x。对于每一个树中的节点，设置其多项式的次数d_x为k_x-1，其中k_x是节点x的门限值。

接下来从根节点R开始，数据拥有者设置q_R(0)=s(s∈Z_p^*)，并随机选择其他d_R个多项式q_R上的点来完成对q_R的定义。对于每个非根节点x，数据拥有者设置q_x(0)=q_parent(x)(index(x))，并随机选择其他d_x个多项式q_x上的点来完成对q_x的定义。最后，每个叶节点都代表一个带权属性。

3) 在访问树T中，令Y代表叶节点的集合，数据拥有者设置w_i表示解密每个叶节点所需的最小权值。最后产生完整密文如下:

$ \begin{array}{l} CT = \left\{ {version = ver, {\kern 1pt} {\kern 1pt} {\kern 1pt} {\kern 1pt} {\kern 1pt} T, {\kern 1pt} {\kern 1pt} {\kern 1pt} {\kern 1pt} {\kern 1pt} {\kern 1pt} {C_{ver}} = ck \cdot e{{\left( {g, {\kern 1pt} {\kern 1pt} {\kern 1pt} {\kern 1pt} {\kern 1pt} g} \right)}^{\left( {\alpha + {r_{ver}}} \right)s}}, {\kern 1pt} {\kern 1pt} {\kern 1pt} {\kern 1pt} {\kern 1pt} {\kern 1pt} C = {g^s}, } \right.\\ \;\;\;\;\;\;\;\;\;{C_1} = {g^{\beta s}}, {\kern 1pt} {\kern 1pt} {\kern 1pt} {\kern 1pt} {\kern 1pt} {\kern 1pt} \forall y \in Y, {\kern 1pt} {\kern 1pt} {\kern 1pt} {\kern 1pt} {\kern 1pt} i \in \left[{1, n} \right]:{C_y} = {g^{{q_y}\left( 0 \right)}}, {C_{y'}} = \\ \;\;\;\;\;\;\;\;\;\;H{\left( {att\left( y \right)} \right)^{{q_y}\left( 0 \right) -s{w_i}}}, \forall j \in \left( {i, n} \right]:{C_{y, j}} = \\ \;\;\;\;\;\;\;\;\;\;\left. {H{{\left( {att\left( y \right)} \right)}^{{q_y}\left( 0 \right) -\left( {{w_j} -{w_i}} \right)s}}} \right\} \end{array} $

4) 云存储服务提供商保存{CT, Eck(M)}。

3.6 Revocation(PK, VMK_ver, R_UID)→{VMK_ver+1, VPK_ver+1, Re-Key_ver→er+1}

当数据拥有者希望撤销某个用户的部分或全部访问权限时，需要将系统版本密钥对更新为一个新的版本。

① 系统管理员选择一个γ_ver+1∈Z_p^*作为更新的版本主密钥VMK_ver+1={γ_ver+1}，再计算g^γ_ver+1，e(g, g)^γ_ver+1。

② 更新的版本公钥VPK_ver+1={g^γ_ver+1, e(g, g)^γ_ver+1}。

③ 系统管理员计算重加密密钥为Re-Key_ver→ver+1=g^{(r_ver+1-r_ver)/β}来执行重加密操作。

④ 对于系统中身份为UID的用户，系统管理员根据R_UID将现存的元组UP_ver更新为UP_ver+1={UID, R_UID, d₁=(g×H(UID)^r)^{(γ_ver+1-γ_ver)/β}, d₂=H(UID)^{r(γ_ver+1-γ_ver)}}，并将其发送给用户执行更新操作。

3.7 UserUpdate(SK_ver, UP_ver+1)→SK_ver+1

系统中的用户一旦获取UP_ver+1，即可自己更新自己的密钥。

① D₁=D₁×d₁^t=(g^{(α+γ_ver+1)}×H(UID)^rγ_ver+1)^t/β

② ∀j∈S:D_j=D_j×d₂^t=H(UID)^rtγ_ver+1×H(j)^tr_j

③ ∀j∈R_UID:D_j²=H(j)^{r_j tw′}，其中w′=1，表示没有访问权限。

更新后的密钥如下：

$ \begin{align} & DSK=\left\{ {{D}_{1}}={{\left( {{g}^{\left( \alpha +{{\gamma }_{ver+1}} \right)}}\times H{{\left( UID \right)}^{r{{\gamma }_{ver+1}}}} \right)}^{{t}/{\beta }\;}},\forall j\in S: \right. \\ & \ \ \ \ \ \ \ \ \ \ \ \ \left. {{D}_{j}}=H{{\left( UID \right)}^{rt{{\gamma }_{ver+1}}}}\times H{{\left( j \right)}^{t{{r}_{j}}}},{{D}_{{{j}^{2}}}}=H{{\left( j \right)}^{{{r}_{j}}t{{w}_{j}}}} \right\} \\ \end{align} $

3.8 Re-Encrypt(CT_ver, Re-Key_ver→ver+1)→CT_ver+1

系统管理员向云存储服务提供商申请执行密文重加密操作。更新后的密文就不能再被旧版本的密钥解密。

密文重加密过程如下：

$ \begin{align} & {{C}_{ver+1}}={{C}_{ver}}\cdot e\left( \operatorname{Re}-Ke{{y}_{ver\to ver+1}},{{C}_{1}} \right)= \\ & \ \ \ ck\cdot e{{\left( g,g \right)}^{\left( \alpha s+s{{\gamma }_{ver}} \right)}}e\left( {{g}^{{\left( {{\gamma }_{ver+1}}-{{\gamma }_{ver}} \right)}/{\beta }\;}},{{g}^{\beta s}} \right)= \\ & \ \ \ ck\cdot e{{\left( g,g \right)}^{\left( \alpha +{{\gamma }_{ver+1}} \right)s}} \\ \end{align} $

新的密文为：

$ \begin{array}{l} C{T_{ver + 1}} = \left\{ {version = ver + 1, {\kern 1pt} {\kern 1pt} {\kern 1pt} {\kern 1pt} {\kern 1pt} T, {\kern 1pt} {\kern 1pt} {\kern 1pt} {\kern 1pt} {\kern 1pt} {C_{ver}}, {\kern 1pt} {\kern 1pt} {\kern 1pt} {\kern 1pt} {\kern 1pt} C, {\kern 1pt} {\kern 1pt} {\kern 1pt} {\kern 1pt} {\kern 1pt} {\kern 1pt} {C_1}, \forall y \in Y, {\kern 1pt} {\kern 1pt} {\kern 1pt} {\kern 1pt} i \in } \right.\\ \;\;\;\;\;\;\;\;\;\;\;\;\;\left. {\left[{1, n} \right]:{C_y}, {\kern 1pt} {\kern 1pt} {\kern 1pt} {\kern 1pt} {C_{y'}}, {\kern 1pt} {\kern 1pt} {\kern 1pt} {\kern 1pt} {\kern 1pt} \forall j \in \left( {i, n} \right]:{C_{y, j}}} \right\} \end{array} $

3.9 Decrypt(PK, CT_ver, SK_ver+1)→M

属性基加密系统中的合法用户可以根据系统分配的属性，访问权限范围内的加密文件。在本方案中，为了降低用户的解密开销，在保证密文不泄露的前提下，将部分解密计算任务外包给云存储服务提供商。因此，解密操作总共分为两个部分：外包解密和用户解密。

1) 外包解密。

访问用户向云存储服务提供商提交部分密钥{DSK}，云存储服务提供商检查用户密钥中包含的属性是否满足数据拥有者预先定义的访问树。如果符合，则执行以下步骤：

① 云存储服务提供商输入密文与部分密钥执行一个递归的解密函数DecryptNode(CT_ver+1, DSK, x)，其中x是访问树T中的一个节点。

② 若节点x是一个叶子节点，令i=att(x)。

③ 若i∈S, 函数DecryptNode(CT_ver+1, DSK, x)定义如下:

$ \begin{array}{l} DecryptNode\left( {C{T_{ver + 1}}, {\kern 1pt} {\kern 1pt} {\kern 1pt} {\kern 1pt} {\kern 1pt} DSK, {\kern 1pt} {\kern 1pt} {\kern 1pt} {\kern 1pt} {\kern 1pt} x} \right) = \frac{{e({D_i}, {\kern 1pt} {\kern 1pt} {\kern 1pt} {\kern 1pt} {\kern 1pt} {C_x})}}{{e\left( {{C_{x'}}, {\kern 1pt} {\kern 1pt} {\kern 1pt} {\kern 1pt} {\kern 1pt} {D_{i'}}} \right) \cdot e\left( {C, {\kern 1pt} {\kern 1pt} {\kern 1pt} {\kern 1pt} {\kern 1pt} {D_{{j^2}}}} \right)}}\\ = e{\left( {H\left( {UID} \right), {\kern 1pt} {\kern 1pt} {\kern 1pt} {\kern 1pt} {\kern 1pt} g} \right)^{rt{\gamma _{ver + 1}}{q_x}\left( 0 \right)}} = {F_x} \end{array} $

若i∉S，定义函数DecryptNode(CT_ver+1, DSK, x)=⊥，若x是非叶子节点，那么对于x的每个孩子节点z，调用DecryptNode(CT_ver+1, DSK, z)并用F_z来代表结果。令S_x代表一个大小为k_x的孩子节点z的集合且F_z≠⊥。若不存在这样的集合，表示这个节点不能被满足，函数输出⊥；否则云存储服务供应商计算：

$ \begin{align} & {{F}_{x}}=\prod\limits_{z\in {{S}_{x}}}{{{F}_{z}}^{{{\Delta }_{i,S_{x}^{'}}}\left( 0 \right)}=} \\ & \ \ \ \prod\limits_{z\in {{S}_{x}}}{{{\left( e{{\left( H\left( UID \right),g \right)}^{rt{{\gamma }_{ver+1}}{{q}_{z}}\left( 0 \right)}} \right)}^{{{\Delta }_{i,S_{x}^{'}}}\left( 0 \right)}}}= \\ & \ \ \ \ \prod\limits_{z\in {{S}_{x}}}{{{\left( e{{\left( H\left( UID \right),g \right)}^{rt{{\gamma }_{ver+1}}{{q}_{parent\left( x \right)}}\left( index\left( z \right) \right)}} \right)}^{{{\Delta }_{i,S_{x}^{'}}}\left( 0 \right)}}}= \\ & \ \ \ \ \ \prod\limits_{z\in {{S}_{x}}}{e{{\left( H\left( UID \right),g \right)}^{rt{{\gamma }_{ver+1}}{{q}_{x}}\left( i \right)}}^{{{\Delta }_{i,S_{x}^{'}}}\left( 0 \right)}}= \\ & \ \ \ \ e{{\left( H\left( UID \right),g \right)}^{rt{{\gamma }_{ver+1}}{{q}_{x}}\left( 0 \right)}} \\ \end{align} $

其中i=index(z), S′_x={index(z):z∈S_x}。

④ 如果访问用户的属性能满足访问树T，则函数DecryptNode(CT_ver+1, DSK, x)执行的最终结果为：

$ \begin{array}{l} {F_R} = DecryptNode\left( {C{T_{ver + 1}}, {\kern 1pt} {\kern 1pt} {\kern 1pt} {\kern 1pt} {\kern 1pt} DSK, {\kern 1pt} {\kern 1pt} {\kern 1pt} {\kern 1pt} {\kern 1pt} R} \right) = \\ {\kern 1pt} {\kern 1pt} {\kern 1pt} {\kern 1pt} {\kern 1pt} {\kern 1pt} {\kern 1pt} {\kern 1pt} {\kern 1pt} {\kern 1pt} {\kern 1pt} {\kern 1pt} \;\;\;e{\left( {H\left( {UID} \right), {\kern 1pt} {\kern 1pt} {\kern 1pt} {\kern 1pt} {\kern 1pt} g} \right)^{rt{\gamma _{ver{\rm{ + }}1}}{q_R}\left( 0 \right)}} = \\ {\kern 1pt} {\kern 1pt} {\kern 1pt} {\kern 1pt} {\kern 1pt} {\kern 1pt} {\kern 1pt} {\kern 1pt} {\kern 1pt} {\kern 1pt} {\kern 1pt} {\kern 1pt} {\kern 1pt} \;\;\;e{\left( {H\left( {UID} \right), {\kern 1pt} {\kern 1pt} {\kern 1pt} {\kern 1pt} {\kern 1pt} g} \right)^{rt{\gamma _{ver{\rm{ + }}1}}s}} \end{array} $

⑤ 然后云存储服务提供商计算：

$ \begin{align} & B=e\left( {{C}_{1}},{{D}_{1}} \right) \\ & = \ \ e\left( {{g}^{s\beta }},{{\left( {{g}^{\left( \alpha +{{\gamma }_{ver+1}} \right)}}\times H{{\left( UID \right)}^{r{{\gamma }_{ver\text{+}1}}}} \right)}^{{t}/{\beta }\;}} \right)= \\ & \ \ e{{\left( g,{{g}^{\left( \alpha +{{\gamma }_{ver\text{+}1}} \right)}}\times H{{\left( UID \right)}^{r{{\gamma }_{ver\text{+}1}}}} \right)}^{st}}= \\ & \ \ e{{\left( g,g \right)}^{\left( \alpha +{{\gamma }_{ver\text{+}1}} \right)st}}\cdot e{{\left( g,H\left( UID \right) \right)}^{r{{\gamma }_{ver\text{+}1}}st}} \\ \end{align} $

最终，云存储服务提供商将{Eck(M), C_ver+1, F_R, B}发送给访问用户。

2) 用户解密。

一旦接收到{Eck(M), C_ver+1, F_R, B}，访问用户计算：

$F_{R}^{'}={{F}_{R}}^{{1}/{t}\;}=e{{\left( H\left( UID \right),g \right)}^{r{{\gamma }_{ver+1}}s}}$

${{B}^{'}}={{B}^{{1}/{t}\;}}=e{{\left( g,g \right)}^{\left( \alpha +{{\gamma }_{ver+1}} \right)s}}\cdot e{{\left( g,H\left( UID \right) \right)}^{r{{\gamma }_{ver+1}}s}}$

然后访问用户通过以下计算恢复对称加密密钥ck：

$ \begin{align} & \frac{{{C}_{ver+1}}\cdot F_{R}^{'}}{{{B}^{'}}}= \\ & \frac{ck\cdot e{{\left( g,g \right)}^{\left( \alpha +{{\gamma }_{ver+1}} \right)s}}\cdot e{{\left( H\left( UID \right),g \right)}^{r{{\gamma }_{ver+1}}s}}}{e{{\left( g,g \right)}^{\left( \alpha +{{\gamma }_{ver+1}} \right)s}}\cdot e{{\left( g,H\left( UID \right) \right)}^{r{{\gamma }_{ver+1}}s}}}=ck \\ \end{align}$

通过对称密钥ck和对称解密算法(如：RSA算法)即可恢复明文M。

4 安全性分析 4.1 安全模型

本文所提出的CPABEWAR在选择明文攻击下的安全模型可以通过以下攻击游戏来定义。

初始化  敌手A选择要挑战的访问树T^*，版本号ver^*和属性撤销列表R^*发送给挑战者B。

系统建立  挑战者B运行SystemSetup(1^λ)生成主密钥MK，公钥PK。随机选择γ₀∈Z_p^*，生成版本主密钥VMK₀和版本公钥VPK₀。然后挑战者B执行Revocation(PK, VMK_ver, R^*)算法生成属性撤销后的版本主密钥VMK_ver和版本公钥VPK_ver和重加密密钥Re-Key_ver-1→ver, ver∈[1, ver^*]。最后挑战者B将公钥MK、版本公钥{VPK_ver}_{0≤ver≤ver^*}和{UP_ver+1}_{0≤ver≤ver^*-1}发送给敌手A，自己保存主密钥MK、版本主密钥{VMK_ver}_{0≤ver≤ver^*}和重加密密钥{Re-Key_ver→ver+1}_{0≤ver≤ver^*-1}。

密钥查询阶段1  敌手A选择一个身份为UID的用户和一个属性集S，其中属性集S不能满足访问树T^*。

1) 挑战者B通过计算g^βγ_ver×H(UID)^γ_ver为身份为UID用户生成证书δ_ver，并将证书δ_ver提交给敌手A。

2) 挑战者B根据〈PK, MK, VPK_ver, S, UID, δ_ver〉生成与属性集S相关的密钥SK_ver。挑战者B将密钥SK_ver提交给敌手A。

3) 敌手根据收到的{UP_ver+1}_{0≤ver≤ver^*-1}和SK_ver生成最新版本的密钥SK_ver^*。

挑战  查询阶段结束之后，敌手提交2个等长的明文M₀和M₁给挑战者B。挑战者B随机选择b∈{0, 1}并计算挑战密文CT_b=Encrypt(PK, VPK_ver^*, M_b, T)。挑战者将密文CT_b返回给敌手A。

密钥查询阶段2  重复阶段1的查询。

猜测  敌手A输出对b的猜测b′∈{0, 1}。如果b′=b，则敌手A获胜，其获胜的优势为Adv_A=|Pr[b′=b]-1/2|。

定义1  如果没有概率多项式时间的敌手能够以不可忽略的优势赢得游戏，则称支持带权属性撤销的CP-ABE方案是选择明文安全的。

4.2 安全性证明

本文方案的安全性基于判定双线性Diffie-Hellman假设。

定理1  假设DBDH假设成立，即不存在敌手A可以在多项式时间内以不可忽略的优势ε破解本文所提出的CPABEWAR，那么本方案就足够安全以抵抗CPA。

证明  如果存在一个敌手能在多项式时间内以不可忽略的优势ε破解CPABEWAR，则可以构造一个挑战者B以最大ε/2的优势解决DBDH问题。即输入五元组〈g, g^α₁, g^α₂, g^s, Z=e(g, g)^θ〉，挑战者B决定等式Z=e(g, g)^α₁α₂s是否成立。

模拟过程如下：

挑战者B随机选取α₁, α₂∈Z_p^*，g是素数阶群G的生成元，e:G×G→G_T是双线性映射。

1) 初始化。敌手A发送要挑战的访问树T^*和系统版本号ver^*给挑战者B。

2) 系统建立。

① 挑战者B随机选择x, β∈Z_p^*，计算e(g, g)^α, g^α, g^β，其中α=α₁α₂+x。生成系统公钥PK={G, g, g^β, e(g, g)^α}和相应的主密钥MK={β, g^α}。

② 挑战者B随机选择γ₀, γ₁, …, γ_ver^*-1∈Z_p^*并计算{g^γ_ver}_{0≤ver < ver^*}∪{g^γ_ver*}, {e(g, g)^γ_ver}_{0≤ver < ver^*}∪{e(g, g)^γ_ver*}。生成版本公钥VPK={g^γ_ver, e(g, g)^γ_ver}_{0≤ver < ver^*}∪{g^γ_ver*, e(g, g)^γ_ver*}和相应的版本主密钥VMK={γ_ver}_{0≤ver < ver*}∪{γ_ver^*}。挑战者B将系统公钥PK和版本公钥VPK发送给敌手A。

3) 查询1。敌手A选择属性集S和用户身份UID，向挑战者B申请相应密钥。其中属性集S不能满足访问树T^*。

① 证书查询。输入参数{UID, VPK, ver}，挑战者B根据敌手A提交的UID和版本公钥VPK_ver^*生成一个唯一的证书δ_ver=g^βγ_ver×H(UID)^γ_ver并返回给敌手A。

② 密钥查询。输入参数{UID, VPK, ver}，挑战者B随机选择r, t∈Z_p^*，并为每个属性j∈S随机选择r_j∈Z_p^*，计算密钥如下：

$ \begin{align} & \ \ \ \ DS{{K}_{ver}}=\left\{ {{D}_{1}}={{\left( {{g}^{\left( \alpha +{{\gamma }_{ver}} \right)}}\times H{{\left( UID \right)}^{r{{\gamma }_{ver}}}} \right)}^{{t}/{\beta }\;}},\forall j\in S:{{D}_{j}}= \right. \\ & \left. H{{(UID)}^{rt{{\gamma }_{ver}}}}\times H{{\left( j \right)}^{t{{r}_{j}}}},D_{j}^{'}={{g}^{t{{r}_{j}}}},{{D}_{{{j}^{2}}}}=H{{\left( j \right)}^{{{r}_{j}}t{{w}_{j}}}} \right\} \\ \end{align} $

挑战者将密钥SK_ver={t, DSK_ver }发送给敌手A。

③ 密钥更新查询。输入参数{UID, DSK_ver, ver^*}，如果敌手A得到的密钥版本号ver < ver^*，敌手A向挑战者B申请执行更新密钥操作。挑战者B根据VMK执行算法Revocation(PK, VMK)得到UP_ver+1={UID, d₁=(g×H(UID)^r)^{(γ_ver+1-γ_ver)/β}, d₂=H(UID)^{r(γ_ver+1-γ_ver)}}，并将UP_ver+1返回给敌手A。敌手A通过执行算法UserUpdate(DSK_ver, UP_ver+1)获取新的密钥DSK_ver+1。

④ 重加密查询。输入参数{C_ver, ver^*}，如果密文版本号ver < ver^*, 挑战者B首先计算重加密密钥Re-Key_ver→er+1=g^{(γ_ver+1-γ_ver)/β}。根据Re-Key_ver→er+1获取重加密密文C_ver+1。最后挑战者将重加密密文C_ver+1返回给敌手A。

4) 挑战阶段。敌手A向挑战者B提交两段长度相同的明文M₀和M₁。挑战者B随机选择一个b={0, 1}并执行以下操作：

① 随机选择s∈Z_p^*，计算密文：

$ \begin{align} & {{C}_{ver}}={{M}_{b}}\cdot e{{\left( g,g \right)}^{\left( \alpha +{{\gamma }_{ver}} \right)s}}= \\ & \ \ \ \ \ \ \ {{M}_{b}}\cdot e{{\left( g,g \right)}^{s\cdot {{\alpha }_{1}}{{\alpha }_{2}}}}\cdot e{{\left( g,g \right)}^{s{{\gamma }_{ver}}}} \\ & {{C}_{1}}={{g}^{\beta s}} \\ & C={{g}^{s}} \\ \end{align} $

② 从访问树T的根节点R开始，为树T中的每个节点x按从上到下的方式随机选择一个多项式q_x。对于每一个树中的节点，设置其多项式的次数d_x为k_x-1，其中k_x是节点x的门限值。

接下来从根节点R开始，数据拥有者设置q_R(0)=s(s∈Z_p^*)，并随机选择其他d_R个多项式q_R上的点来完成对q_R的定义。对于每个非根节点x，数据拥有者设置q_x(0)=q_parent(x)(index(x))，并随机选择其他d_x个多项式q_x上的点来完成对q_x的定义。最后，每个叶节点都代表一个带权属性。

③ 在访问树T中，令Y代表叶节点的集合，数据拥有者设置w_i表示解密每个叶节点所需的最小权值。最后产生完整密文如下：

$ \begin{array}{l} CT = \left\{ {version = ve{r^*}, T, {C_{ver}} = ck \cdot e{{\left( {g, g} \right)}^{\left( {\alpha + {\gamma _{ve{r^*}}}} \right)s}}, C = } \right.\\ \;\;\;\;\;\;\;\;\;{g^s}, {C_1} = {g^{\beta s}}, \forall y \in Y, i \in \left[{1, n} \right]:{C_y} = {g^{{q_y}\left( 0 \right)}}, {{C'}_y} = \\ \;\;\;\;\;\;\;\;\;H{\left( {att\left( y \right)} \right)^{{q_y}\left( 0 \right) -s{w_j}}}, \forall j \in \left( {i, n} \right]:{C_{y, j}} = \\ \;\;\;\;\;\;\;\;\;\left. {H{{\left( {att\left( y \right)} \right)}^{{q_y}\left( 0 \right) -\left( {{w_j} -{w_i}} \right)s}}} \right\} \end{array} $

挑战者B将密文CT返回给敌手A。

5) 查询2。同查询1，敌手A继续向挑战者B提问。

6) 猜测阶段。敌手A输出猜测b′={0, 1}。如果b′=b，则挑战者B输出1，表示挑战成功，Z=e(g, g)^{s·α₁α₂}；否则输出0，表示Z=e(g, g)^θ。当Z=e(g, g)^{s·α₁α₂}时，敌手获得有效的密文，其获胜优势为Pr[b′=b|Z=e(g, g)^{s·α₁α₂}]=1/2+ε。当Z=e(g, g)^θ时，敌手获取的密文是随机生成的，不能获取任何明文信息，Pr[b′≠b|Z=e(g, g)^θ]=1/2。因此，游戏中，敌手A获胜的优势为:

$\begin{array}{l} \frac{1}{2}\Pr \left[{b' = b|Z = e{{\left( {g, g} \right)}^{s \cdot {\alpha _1}{\alpha _2}}}} \right] + \\ \;\;\;\frac{1}{2}\Pr \left[{b' \ne b|Z = e{{\left( {g, g} \right)}^\theta }} \right] - \frac{1}{2} = \frac{\varepsilon }{2} \end{array} $

根据DBDH假设，不存在敌手在多项式时间内以不可忽略的优势解决DBDH问题，因此本方案是不可区分选择明文攻击(INDistinguishability under Chosen Plaintext Attack, IND-CPA)安全的。

5 方案对比

下面将本文的方案与文献[12]方案和文献[17]方案从系统功能、存储开销和计算效率三个方面进行比较，具体比较情况如表 1~3所示。

由表 1可知，本文方案不仅支持用户撤销和用户部分属性撤销，还实现了属性状态的多元表示，增强了系统的灵活性的同时，简化了访问树的复杂性。考虑到系统用户的计算能力可能并不强大，本文方案在保证数据机密性的前提下将部分计算过程外包给计算资源丰富的云存储服务供应商，从而减轻系统用户的计算开销。

在表 2中：n_u代表系统中用户的总数；|g|、|g_T|和|p|分别代表G、G_T和Z_p^*中元素的大小；|S|和|Y|分别表示密钥与访问树中所包含的属性个数；n用于表示属性的最大权值。

从表 2的结果可以看出，文献[12]方案、文献[17]方案和本文提出的方案在主密钥和公钥这两项中所占用的空间基本相同。文献[12]提出方案中密文长度虽然最小，但其只支持用户撤销并不支持属性撤销，在灵活性上有所缺乏。与文献[17]方案相比，由于n远小于|Y|，因此本文提出的方案仅略微增加了密文长度，却实现了其他两个方案所不具备的属性撤销，提高方案的实用性。此外，由于密文主要存储在CSP中，因此密文长度的少量增加并不影响系统的整体效率。另一方面，本文所提出方案的密钥长度和撤销操作所涉及的其他元素的大小与同样支持撤销的文献[12]所提出的方案相似，但却通过使用带权属性简化了访问树的结构，提高属性的表达能力，让本文方案弥补了当前属性基加密对系统属性和访问树表达能力不足的缺陷。

表 3中：G_i(i=0, T)表示群G_i的指数或乘法运算；C_e表示双线性配对操作；S表示满足访问树所需最少的内部节点个数；|A_C|、|A_u|分别表示密文中包含的属性和用户拥有的属性；ω_i、ω_i1分别表示属性i的最大权重和密文中属性i的权重。从表 3中可以看出，在加密阶段，本文方案的计算效率要优于文献[12]的方案。而与文献[17]的方案相比，虽然本文方案计算量增加了|A_C|G₀，但是考虑到本文方案实现了文献[17]方案所不具备的用户撤销机制，因此完全可以接受。而在解密阶段，本文方案与文献[12]、文献[17]方案基本相同。由于本文方案可将部分计算过程外包给CSP执行，因此用户方面所需承担的计算量将会更小，从而进一步提升效率。

6 结语

针对目前属性基加密方案中属性撤销缺乏灵活性、用户计算量大的问题，本文提出一种支持带权属性撤销的密文策略属性基加密方案，并证明该方案在DBDH假设下是CPA安全的。通过引入带权属性的概念，我们提高了系统中属性表达的灵活性，降低了访问树的复杂性，实现用户属性的部分或全部撤销。此外，在保证安全的前提下通过将解密阶段部分外包给云存储服务提供商来降低用户方面的计算开销。经过与文献[12]方案和文献[17]方案的分析对比，本文方案以存储开销少量增加为代价，提高了系统效率和访问控制的灵活性，解决了属性基加密方案中的属性撤销问题，适合计算资源有限的云用户。因此，进一步优化密文和密钥长度是下一步工作中需要考虑的重点。