On the Analysis of the Revocable-Storage Identity-Based Encryption Scheme

TL;DR

This paper critically analyzes a revocable-storage identity-based encryption scheme for cloud data sharing, identifies correctness issues, and proposes modifications to ensure security and proper functionality.

Contribution

It reveals correctness flaws in Wei et al.'s RS-IBE scheme and introduces a corrected, secure version of the scheme.

Findings

Wei et al.'s RS-IBE scheme is incorrect in its original form.

A modified scheme achieves correctness and security.

The corrected scheme is suitable for secure cloud data sharing.

Abstract

Cloud computing can provide a flexible way to effectively share data among multiple users since it can overcome the time and location constraints of computing resource usage. However, the users of cloud computing are still reluctant to share sensitive data to a cloud server since the cloud server should be treated as an untrusted entity. In order to support secure and efficient data sharing in cloud computing environment, Wei et al. recently extended the concept of identity-based encryption (IBE) to support key revocation and ciphertext update functionalities, and proposed a revocable-storage identity-based encryption (RS-IBE) scheme. In this paper, we show that the RS-IBE scheme of Wei et al. does not satisfy the correctness property of RS-IBE. In addition, we propose a method to modify the existing RS-IBE scheme to be a correct and secure scheme.

Equations

$$C_0^{\prime }\cdot e(C_1^{\prime },D_1)\cdot e(C_2^{\prime },D_2)\cdot e(C_{v_{T^{\prime }},0},D_3)$$

$$=M\cdot e(g_1,g_2{)}^s\cdot e(g^{-s},g_2^{\alpha }{F}_u(ID{)}_0^r{F}_h(T{)}^{r_1})\cdot e(F_u(ID{)}^s,g^{r_0})\cdot e(F_h(T{)}^{s_{\tilde{v}}},g^{r_1})$$

$$=M\cdot e(g^{-s},F_h(T{)}^{r_1})\cdot e(F_h(T{)}^{s_{\tilde{v}}},g^{r_1})$$

$$=M\cdot e(F_h(T),g{)}^{(s_{\tilde{v}}-s)r_1}.$$

Full text

Keywords: Cloud computing, Identity-based encryption, Revocable-storage, Ciphertext update.

1 Introduction

Cloud computing is a new paradigm of computing system that provides computing resources such as computing power or data storage according to the need of users. The advantage of cloud computing is that cloud service users can use their computing resources as a service with low cost at any time from anywhere through the Internet. Many technology companies provide various types of cloud services. The main difference between traditional server computing and cloud computing is that a cloud service provider can no longer be regarded as a trusted entity. In other words, the cloud service provider should be treated as a honest-but-curious adversary.

A typical application of cloud computing is to securely share data among a large number of users. In this system, the data confidentiality should be provided because the cloud service provider is no longer a trusted entity. In addition, if a user’s credential is expired or the user’s private key is compromised, then a proper revocation method should be provided to handle this user. Furthermore, even if a revoked user tries to access past data stored in the cloud server through collusion attacks, the security of data should be guaranteed. Therefore, a secure data sharing system in the cloud server should consider various security issues described above.

Recently, a revocable-storage identity-based encryption (RS-IBE) scheme for secure data sharing in cloud storage was proposed by Wei et al. [7]. The basic idea of this RS-IBE scheme is to modify an identity-based encryption (IBE) scheme to additionally supports the key revocation and ciphertext update functionalities. In particularly, they used the IBE scheme of Waters for the underlying IBE scheme and the tree-based key revocation scheme of Boldyreva et al. [1] for key revocation. Additionally, they modified their scheme to support efficient ciphertext update by following the idea of forward-secure cryptographic systems.

In this paper, we show that there is a serious problem in the RS-IBE scheme of Wei et al. That is, if a ciphertext generated at time $T$ is updated to another ciphertext with time $T+1$ by the ciphertext update algorithm, then this updated ciphertext with time $T+1$ cannot be decrypted by using a decryption key with time $T+1$. The reason of this decryption failure problem is that the decryption algorithm uses a random value which is different from the random value used to encrypt a message if a ciphertext is updated. A more detailed explanation of this problem is given in the later part of this work. To remedy this problem, we propose a method to modify the RS-IBE scheme of Wei et al. to be a secure scheme without the decryption failure problem.

The organization of the paper is as follows. In Section 2, we review the definition and scheme of RS-IBE proposed by Wei et al. In Section 3, we point out that there is a correctness problem in Wei et al.’s RS-IBE scheme. In Section 4, we propose a method to solve this problem by. Finally, we conclude the paper in Section 5.

2 Review of the RS-IBE Scheme

In this section, we review the definition of RS-IBE including the correctness property and describe the RS-IBE scheme of Wei et al.

2.1 Revocable-Storage Identity-Based Encryption

Definition 2.1** (Revocable-Storage Identity-Based Encryption).**

A revocable-storage identity-based encryption (RS-IBE) scheme consists of eight algorithms Setup, GenKey, UpdateKey, DeriveDK, Encrypt, UpdateCT, Decrypt, and Revoke, which are defined as follows:

Setup($1^{\lambda},N_{max},T_{max}$). The setup algorithm takes as input a security parameter $1^{\lambda}$, the maximum number of users $N_{max}$, and the total number of time periods $T_{max}$. It outputs a master key $MK$ and public parameters $PP$.

GenKey($ID,MK,PP$). The key generation algorithm takes as input an identity $ID$, the master key $MK$, and the public parameters $PP$. It outputs a private key $SK_{ID}$.

UpdateKey($T,RL,MK,ST,PP$). The key update algorithm takes as input update time $T$, a revocation list $RL$, the master key $MK$, a state $ST$, and the public parameters $PP$. It outputs a key update $KU_{T}$.

DeriveDK($SK_{ID},KU_{T},PP$). The decryption key derivation algorithm takes as input a private key $SK_{ID}$, a key update $KU_{T}$, and the public parameters $PP$. It outputs a decryption key $DK_{ID,T}$.

Encrypt($ID,T,M,PP$). The encryption algorithm takes as input an identity $ID$, time $T$, a message $M$, and the public parameters $PP$. It outputs a ciphertext $CT_{ID,T}$.

UpdateCT($CT_{ID,T},T^{\prime},PP$). The ciphertext update algorithm takes as a ciphertext $CT_{ID,T}$, update time $T^{\prime}$, and the public parameters $PP$. It outputs an updated ciphertext $CT_{ID,T^{\prime}}$.

Decrypt($CT_{ID,T^{\prime}},DK_{ID,T},PP$). The decryption algorithm takes as input a ciphertext $CT_{ID,T^{\prime}}$, a decryption key $DK_{ID,T}$, and the public parameters $PP$. It outputs an encrypted message $M$ or $\perp$.

Revoke($ID,T,RL,ST,PP$). The revocation algorithm takes as input an identity $ID$, revoked time $T$, a revocation list $RL$, and a state $ST$. It outputs an updated revocation list $RL$.

The correctness property of RS-IBE is defined as follows: For all $MK,PP$ generated by Setup, any $SK_{ID}$ generated by $\textbf{GenKey}(ID,MK,PP)$ for any $ID$, any $KU_{T}$ generated by $\textbf{UpdateKey}(T,RL,MK,ST,PP)$ for any $T,RL$, $CT_{ID,T^{\prime}}$ generated by $\textbf{Encrypt}(ID,T^{\prime},M,PP)$ for any $ID,T^{\prime},M$, if $ID$ is not revoked at time $T$ in $RL$, then it is required that $DK_{ID,T}$ can be derived by $\textbf{DeriveKey}(SK_{ID},KU_{T},PP)$ and

• •

If $T^{\prime}\leq T$, then $\textbf{Decrypt}(CT_{ID,T^{\prime}},DK_{ID,T},PP)=M$.

• •

If $T^{\prime}>T$, then $\textbf{Decrypt}(CT_{ID,T^{\prime}},DK_{ID,T},PP)=\perp$.

Additionally, it is required that the ciphertext distribution of $\textbf{UpdateCT}(CT_{ID,T},T^{\prime},PP)$ is statistically equal to that of $\textbf{Encrypt}(ID,T^{\prime},M,PP)$.

2.2 Wei et al.’s RS-IBE Construction

To provide key revocation functionality, the RS-IBE scheme of Wei et al. [7] follows the binary tree-based broadcast encryption method proposed by Boldyreva et al. [1]. Let $\mathcal{BT}$ be a binary tree for handling key revocation. A user is randomly assigned to a leaf node in this $\mathcal{BT}$. At this time, the private key $SK_{ID}$ of a user with an identity $ID$ is associated with the set of nodes defined by $\textbf{Path}(x_{ID})$ which is the set of path nodes from the root node to the leaf node $x_{ID}$, and a key update $KU_{T}$ at time $T$ is associated with the set of covering nodes defined by $\textbf{KUNodes}(\mathcal{BT},RL,T)$ which is the set of nodes that covers all non-revoked leaf nodes at time $T$. If the leaf node (or the private key) of a user $ID$ is not revoked at time $T$, then there is a common node $x$ satisfying $\tilde{x}=\textbf{Path}(x_{ID})\cap\textbf{KUNodes}(\mathcal{BT},RL,T)$. The decryption of a ciphertext at time $T$ can be possible by using the private key element and key update element corresponding to the node $\tilde{x}$. For the detailed description of $\textbf{KUNodes}(\mathcal{BT},RL,T)$, please refer the work of Boldyreva et al. [1].

To provide ciphertext update functionality, this RS-IBE scheme uses the binary tree idea of Canetti et al. [2] used to build forward-secure encryption schemes. Note that the binary tree idea for time management was widely used in other RS-ABE schemes [6, 4, 5, 3]. Let $\mathcal{ET}$ be a binary tree to handle time in a ciphertext. In this case, each time is sequentially allocated to a leaf node in $\mathcal{ET}$ from left to right. In this case, $\textbf{CTNodes}(\mathcal{ET},T)$ is defined as $\textbf{RightSibling}(\textbf{Path}(v_{T}))\setminus\textbf{Path}(\textbf{Parent}(v_{T}))\cup\{v_{T}\}$ where $\textbf{RightSibling}(S)$ is a set of $\textbf{RightChild}(\textbf{Parent}(v))$ of any node $v\in S$ [6, 4]. Note that Wei et al. wrongly defined $\textbf{CTNodes}(\mathcal{ET},T)=\{v|\textbf{Parent}(v)\in\textbf{Path}(v_{T})\text{ and }v\notin\textbf{Path}(v_{T})\}\cup\{v_{T}\}$ because this (wrongly defined) set can include the left child node of $\textbf{Path}(v_{T})$, which will allow access to the past time node. To support ciphertext update, a ciphertext is constructed to have ciphertext elements associated with $\textbf{CTNodes}(\mathcal{ET},T)$. The main property of CTNodes is that if $T<T^{\prime}$, a ciphertext with $\textbf{CTNodes}(\mathcal{ET},T)$ can be updated to a ciphertext with $\textbf{CTNodes}(\mathcal{ET},T^{\prime})$ because for any node $v^{\prime}\in\textbf{CTNodes}(\mathcal{ET},T^{\prime})$ there is a node $v^{\prime\prime}$ that matches to $\textbf{CTNodes}(\mathcal{ET},T)\cap\textbf{Path}(v^{\prime})$ and the ciphertext component for $v^{\prime\prime}$ can be delegated to be a ciphertext for $v^{\prime}$. For other properties of CTNodes, please refer the work of Sahai et al. [6].

The RS-IBE scheme of Wei et al. is described as follows:

Setup($1^{\lambda},N_{max},T_{max}$):

Let $\lambda$ be the security parameter, $N_{max}=2^{n}$ be the maximum number of users, and $T_{max}=2^{\ell}$ be the total number of time periods. It chooses a bilinear group $(p,\mathbb{G},\mathbb{G}_{T},e)$ with a prime order $p$. It selects random $g,g_{2}\in\mathbb{G}$ and $\alpha\in\mathbb{Z}_{p}^{*}$, and sets $g_{1}=g^{\alpha}$. It also chooses random $u_{0},u_{1},\ldots,u_{n},h_{0},h_{1},\ldots,h_{\ell}\in\mathbb{G}$ and defines $F_{u}(ID)=u_{0}\prod_{i=1}^{n}u_{i}^{ID[i]}$, $F_{h}(T)=h_{0}\prod_{j=1}^{\ell}h_{j}^{T[j]}$ where $ID[i]$ and $T[i]$ are the $i$th bit of $ID$ and $T$ respectively. It sets a binary tree $\mathcal{BT}$ with $N_{max}$ number of leaf nodes and sets a revocation list $RL=\emptyset$, a state $ST=\mathcal{BT}$. It outputs a master key $MK=g_{2}^{\alpha}$, and public parameters PP=\big{(}(p,\mathbb{G},\mathbb{G}_{T},e),g,g_{1},g_{2},\{u_{i}\}_{i=0}^{n},\{h_{i}\}_{i=0}^{\ell}\big{)}.

GenKey($ID,MK,ST,PP$):

It assigns $ID$ to a leaf node $x_{ID}\in\mathcal{BT}$. For each node $x\in\textbf{Path}(x_{ID})$, it performs:

1. It fetches $g_{x,0}$ from the node $x$. If $g_{x,0}$ is not defined before, then it chooses random $g_{x,0}\in\mathbb{G}$ and stores the pair $(g_{x,0},g_{x,1}=g_{2}\cdot g_{x,0}^{-1})$ in the node $x$.
2. It chooses random $r_{x,0}\in\mathbb{Z}_{p}^{*}$ and obtains SK_{ID,x}=\big{(}K_{x,0}=g_{x,0}^{\alpha}F_{u}(ID)^{r_{x,0}},K_{x,1}=g^{r_{x,0}}\big{)}. Finally, it outputs a private key SK_{ID}=\big{(}\{(x,SK_{ID,x})\}_{x\in\textbf{Path}(x_{ID})}\big{)} and an updated $ST=\mathcal{BT}$.

UpdateKey($T,RL,MK,ST,PP$):

For each node $x\in\textbf{KUNodes}(\mathcal{BT},RL,T)$, it performs:

1. It fetches $g_{x,1}$ from the node $x$. If $g_{x,1}$ is not defined, then it sets the value similar to the key generation algorithm.
2. It chooses random $r_{x,1}\in\mathbb{Z}_{p}^{*}$ and obtains KU_{T,x}=\big{(}U_{0}=g_{x,1}^{\alpha}F_{h}(T)^{r_{x,1}},U_{1}=g^{r_{x,1}}\big{)}. Finally, it outputs a key update KU_{T}=\big{(}\{(x,KU_{T,x})\}_{x\in\textbf{KUNodes}(\mathcal{BT},RL,T)}\big{)}.

DeriveDK($SK_{ID},KU_{T},PP$):

It finds a common node $x$ in both $SK_{ID}$ and $KU_{T}$. If it fails to find, then it returns $\perp$. Note that If $ID$ was not revoked during the time period $T$, then there exist a node $x\in\textbf{Path}(\mathcal{BT},x_{ID})\cap\textbf{KUNodes}(\mathcal{BT},RL,T)$. For this node $x$, it retrieves $SK_{ID,x}=(K_{x,0},K_{x,1})$ and $KU_{T,x}=(U_{x,0},U_{x,1})$ from $SK_{ID}$ and $KU_{T}$ respectively. It chooses random $r_{0},r_{1}\in\mathbb{Z}_{p}^{*}$ and outputs a decryption key DK_{ID,T}=\big{(}D_{1}=K_{x,0}\cdot U_{x,0}\cdot F_{u}(ID)^{r_{0}}\cdot F_{h}(T)^{r_{1}},D_{2}=K_{x,1}\cdot g^{r_{0}},D_{3}=U_{x,1}\cdot g^{r_{1}}\big{)}.

Encrypt($ID,T,M,PP$):

Let $\mathcal{ET}$ be a binary tree for time periods and $v_{T}$ be a leaf node associated with $T$ in $\mathcal{ET}$. It chooses random $s\in\mathbb{Z}_{p}^{*}$ and computes $C_{0}=e(g_{1},g_{2})^{s}\cdot M,C_{1}=g^{-s},C_{2}=F_{u}(ID)^{s}$. For each node $v\in\textbf{CTNodes}(\mathcal{ET},T)$, it performs: 1) It chooses random $s_{v}\in\mathbb{Z}_{p}^{*}$ and sets $s_{v}=s$ if $v=v_{T}$. 2) It calculates CT_{v}=\big{(}C_{v,0}=\big{(}h_{0}\prod_{j=1}^{|b_{v}|}h_{j}^{b_{v}[j]}\big{)}^{s_{v}},C_{v,|b_{v}|+1}=h_{|b_{v}|+1}^{s_{v}},\ldots,C_{v,\ell}=h_{\ell}^{s_{v}}\big{)}. Finally, it outputs a ciphertext CT_{ID,T}=\big{(}ID,T,C_{0},C_{1},C_{2},\{CT_{v}\}_{v\in\textbf{CTNodes}(\mathcal{ET},T)}\big{)}.

UpdateCT($CT_{ID,T},T^{\prime},PP$):

Let $v_{T},v_{T^{\prime}}$ be leaf nodes in $\mathcal{ET}$ assigned to $T,T^{\prime}$, respectively. If $T^{\prime}<T$, then it returns $\perp$ to indicate that $T^{\prime}$ is invalid. It chooses random $s^{\prime}\in\mathbb{Z}_{p}^{*}$ and computes $C^{\prime}_{0}=C_{0}\cdot e(g_{1},g_{2})^{s^{\prime}},C^{\prime}_{1}=C_{1}\cdot g^{-s^{\prime}},C^{\prime}_{2}=C_{2}\cdot F_{u}(ID)^{s^{\prime}}$. For each node $v^{\prime}\in\textbf{CTNodes}(\mathcal{ET},T^{\prime})$, it performs: 1) It find a node $v\in\textbf{CTNodes}(\mathcal{ET},T)$ such that $b_{v}$ is a prefix of $b_{v^{\prime}}$. 2) It chooses random $s_{v^{\prime}}\in\mathbb{Z}_{p}^{*}$ and sets $s_{v^{\prime}}=s^{\prime}$ if $v^{\prime}=v_{T^{\prime}}$. 3) It calculates CT_{v^{\prime}}=\big{(}C_{v^{\prime},0}=C_{v,0}\cdot\prod_{j=|b_{v}|+1}^{|b_{v^{\prime}}|}C_{v,j}\cdot\big{(}h_{0}\prod_{j=1}^{|b_{v^{\prime}}|}h_{j}^{b_{v^{\prime}}[j]}\big{)}^{s_{v^{\prime}}},C_{v^{\prime},|b_{v^{\prime}}|+1}=C_{v,|b_{v^{\prime}}|+1}\cdot h_{|b_{v^{\prime}}|+1}^{s_{v^{\prime}}},\ldots,C_{v^{\prime},|b_{v^{\prime}}|+\ell}=C_{v,\ell}\cdot h_{\ell}^{s_{v^{\prime}}}\big{)}. Finally, it outputs an updated ciphertext CT_{ID,T^{\prime}}=\big{(}ID,T^{\prime},\linebreak[0]C^{\prime}_{0},C^{\prime}_{1},C^{\prime}_{2},\{CT_{v^{\prime}}\}_{v^{\prime}\in\textbf{CTNodes}(\mathcal{ET},T^{\prime})}\big{)}.

Decrypt($CT_{ID,T},DK_{ID,T^{\prime}},PP$):

Let $DK_{ID,T^{\prime}}=(D_{1},D_{2},D_{3})$. If $T^{\prime}<T$, then it returns $\perp$. Otherwise, it updates $CT_{ID,T}$ to obtains $CT_{ID,T^{\prime}}=(ID,T^{\prime},C^{\prime}_{0},C^{\prime}_{1},C^{\prime}_{2},\{CT_{v^{\prime}}\}_{v^{\prime}\in\textbf{CTNodes}(\mathcal{ET},T^{\prime})})$ where $CT_{v^{\prime}}=(C_{v^{\prime},0},\ldots,C_{v^{\prime},\ell})$ by running $\textbf{UpdateCT}(CT_{ID,T},T^{\prime},PP)$. It outputs a message $M$ by computing $C^{\prime}_{0}\cdot e(C^{\prime}_{1},D_{1})\cdot e(C^{\prime}_{2},D_{2})\cdot e(C_{v_{T^{\prime}},0},D_{3})$ where $v_{T^{\prime}}$ is a leaf node associated with $T^{\prime}$.

Revoke($ID,T,RL,ST$):

It adds $(ID,T)$ to $RL$ and returns the updated $RL$.

Wei et al. claimed that above RS-IBE scheme is correct and secure if the $\ell$-BDHE assumption holds.

3 Analysis of the RS-IBE Scheme

In this section, we show that the above RS-IBE scheme is not correct since the decryption fails if the ciphertext time $T$ is less than the decryption key time $T^{\prime}$.

Lemma 3.1**.**

Let $\mathcal{ET}$ be a binary tree for time periods and $v_{T},v_{T^{\prime}}$ be leaf nodes associated with time $T,T^{\prime}$, respectively. If $T+1\leq T^{\prime}$, then there exists a node $\tilde{v}=\textbf{CTNodes}(\mathcal{ET},T)\cap\textbf{Path}(v_{T^{\prime}})$ but $v_{T}\neq\tilde{v}$. That is, $v_{T},\tilde{v}\in\textbf{CTNodes}(\mathcal{ET},T)$, $v$ is an ancestor node of $v_{T^{\prime}}$, and $v_{T}\neq\tilde{v}$.

Proof.

By the main property of CTNodes, we have that for any node $v^{\prime}\in\textbf{CTNodes}(\mathcal{ET},T^{\prime})$ there is a common node $v^{\prime\prime}$ such that $v^{\prime\prime}=\textbf{CTNodes}(\mathcal{ET},T)\cap\textbf{Path}(\mathcal{ET},v^{\prime})$ if $T+1\leq T^{\prime}$. Therefore, for both nodes $v_{T}$ and $v_{T^{\prime}}$ associated with time $T$ and $T^{\prime}$, there exists a node $\tilde{v}=\textbf{CTNodes}(\mathcal{ET},T)\cap\textbf{Path}(\mathcal{ET},v_{T^{\prime}}$. Now, Let’s show that the node $v_{T}$ and the node $\tilde{v}$ are different. In the given condition, $T+1\leq T^{\prime}$ is established, and each time is sequentially assigned to a leaf node in $\mathcal{ET}$. Therefore, two nodes $v_{T},v_{T^{\prime}}$ are different nodes since $T\neq T^{\prime}$ and they are assigned to leaf nodes. Since the node $\tilde{v}$ belongs to the path nodes $\textbf{Path}(\mathcal{ET},v_{T^{\prime}})$, the node $\tilde{v}$ can never be a leaf node if $\tilde{v}\neq v_{T^{\prime}}$. Therefore, $\tilde{v}\neq v_{T}$ is established, since $v_{T}\neq v_{T^{\prime}}$ and $v_{T}$ is a leaf node. ∎

Theorem 3.2**.**

Let $CT_{ID,T}$ be a ciphertext associated with time $T$ and $DK_{ID,T^{\prime}}$ be a decryption key associated with time $T^{\prime}$. If $T+1\leq T^{\prime}$, then the ciphertext $CT_{ID,T}$ cannot be decrypted by using the decryption key $DK_{ID,T^{\prime}}$ in the decryption algorithm.

Proof.

To prove this theorem, we first analyze nodes in the binary tree $\mathcal{ET}$ which are associated with the ciphertext elements used in the decryption algorithm and then analyze how the random exponents of these ciphertext elements are constructed. After that, we argue that the decryption algorithm will fail due to the random exponents of the ciphertext elements which are used for decryption.

The decryption algorithm takes an original ciphertext $CT_{ID,T}$ and a decryption key $DK_{ID,T^{\prime}}$ as input. Then, it performs the UpdateCT algorithm to derive an updated ciphertext $CT_{ID,T^{\prime}}$ since $T<T^{\prime}$ . Next, it uses the updated ciphertext element $C_{v_{T^{\prime}},0}$, which is related to a leaf node $v_{T^{\prime}}$ associated with the time $T^{\prime}$, for the decryption. Here, the UpdateCT algorithm finds the node $\tilde{v}$ which is an ancestor node of $v_{T^{\prime}}$ and belongs to the set $\textbf{CTNodes}(\mathcal{ET},T)$, and delegates the ciphertext element $C_{\tilde{v},0}$ to obtain the ciphertext element $C_{v_{T^{\prime}},0}$. From the Lemma 3.1, we have that the node $\tilde{v}$ which belongs to $\textbf{CTNodes}(\mathcal{ET},T)$ is not equal to the node $v_{T}$ if $T+1\leq T^{\prime}$.

Now, we analyze random exponents in the original ciphertext $CT_{ID,T}$ which are associated with the nodes in $\textbf{CTNodes}(\mathcal{ET},T)$. The encryption algorithm generates ciphertext elements for nodes in $\textbf{CTNodes}(\mathcal{ET},T)$. According to the encryption algorithm, for each node $v\in\textbf{CTNodes}(\mathcal{ET},T)$, if $v=v_{T}$, then the same random exponent $s$ which is used for message encryption is used to generate $C_{v,0}$. If $v\neq v_{T}$, then a new random exponent $s_{v}$ is selected to generate $C_{v,0}$. However, since $\tilde{v}\neq v_{T}$ from the previous Lemma 3.1, the random exponent $s_{\tilde{v}}$ is not equal to $s$ with high probability where $s_{\tilde{v}}$ is used for the node $\tilde{v}$.

The decryption algorithm finally calculates the following equation by using the ciphertext elements and decryption elements.

[TABLE]

Note that we ignored the re-randomization process since it does not affect our analysis. In order to correctly obtain the message contained in the ciphertext, it is required that $(s_{\tilde{v}}-s)\equiv 0\mod p$ should be satisfied. However, in the previous analysis, this relation cannot be satisfied because the ciphertext element associated with the node $\tilde{v}$ of the original ciphertext uses a new random exponent $s_{\tilde{v}}$. Thus, the decryption can be successful if $T=T^{\prime}$, but the decryption always fails except with negligible probability if $T+1\leq T^{\prime}$. ∎

4 Modification to the RS-IBE Scheme

In the previous section, we have shown that the RS-IBE scheme of Wei et al. does not satisfy the correctness, which is the minimum requirement that the cryptographic scheme must satisfy, due to the problem of random exponents in the encryption algorithm. In this section, we propose a modification to the RS-IBE scheme of Wei et al. to guarantee the correctness and the security.

A simple way to modify the RS-IBE scheme of Wei et al. [7] is to force the ciphertext elements associated with $\textbf{CTNodes}(\mathcal{ET},T)$ to use the same random exponent $s$ which is used to encrypt a message in the ciphertext component $C_{0}$. In this case, there is no problem such that the decryption algorithm fails when the ciphertext is updated since $s_{v}=s$ for all nodes $v$. However, this simple modification does not lead to a secure RS-IBE scheme. The reason is that if multiple nodes are provided with ciphertext elements $\{h_{j}^{s}\}$ associated with the same random $s$, it is possible for anyone to use these elements to modify the original ciphertext element with current time to derive another ciphertext element with past time. This makes it possible for a revoked user to modify the ciphertext with current time to obtain a ciphertext with past time to decrypt the original ciphertext. Therefore, this simple method does not work.

A secure and efficient method to modify the RS-IBE scheme is to use a cryptographic scheme that supports ciphertext update functionality. Lee et al. [4, 5, 3] introduced the concept of self-updatable encryption and proposed secure SUE schemes that efficiently handle ciphertext updates. Thus, we can modify the RS-IBE scheme of Wei et al. to use the SUE scheme for the ciphertext update components and key update components. The secure SUE scheme proposed by Lee et al. supports correct decryption although it uses different random exponents in ciphertext elements associated with $\textbf{CTNodes}(\mathcal{ET},T)$. Additionally, this modified RS-IBE scheme can reduce the number of ciphertext elements from $O(\log^{2}T_{max})$ to $O(\log T_{max})$ because of the efficiency of the SUE scheme. We also note that the existing RS-ABE scheme can be easily converted to an RS-IBE scheme by changing the attribute set of ABE to the identity of IBE.

5 Conclusion

In this paper, we pointed out that the RS-IBE scheme of Wei et al. does not provide the correctness property. The problem of the RS-IBE scheme was that when a ciphertext with time $T$ is updated to a ciphertext with time $T+1$, this updated ciphertext cannot be decrypted by using a decryption key with time $T+1$. The main reason of this problem was that the random exponent of the ciphertext element associated with a tree node corresponding to time $T+1$ was not the same as the random exponent used to encrypt a message in the ciphertext. This decryption problem cannot be solved in a simple way, so we proposed a method to modify the previous RS-IBE scheme to be a secure and efficient RS-IBE scheme using a self-updatable encryption scheme.