Mathematical Problems in Engineering
Volume 2014 (2014), Article ID 728591, 16 pages
http://dx.doi.org/10.1155/2014/728591

Research Article

Secure Certificateless Signature with Revocation in the Standard Model

Tung-Tso Tsai, Sen-Shan Huang, and Yuh-Min Tseng

Department of Mathematics, National Changhua University of Education, Chang-Hua City 500, Taiwan

Received 6 May 2014; Revised 3 September 2014; Accepted 3 October 2014; Published 19 November 2014

Academic Editor: Kwok-Wo Wong

Copyright © 2014 Tung-Tso Tsai et al. This is an open access article distributed under the Creative Commons Attribution License, which permits unrestricted use, distribution, and reproduction in any medium, provided the original work is properly cited.

Abstract.

Certificateless public key cryptography is very attractive in solving the key escrow problem which is inherent in identity- (ID-) based public key cryptography. In the past, a large number of certificateless cryptographic schemes and protocols were presented, but a secure certificateless signature in the standard model (without random oracles) is still not accessible until now. To the best of our knowledge, all the previously proposed certificateless signature schemes were insecure under a considerably strong security model in the sense that they suffered from outsiders’ key replacement attacks or the attacks from the key generation center (KGC). In this paper, we propose a certificateless signature scheme without random oracles. Moreover, our scheme is secure under the strong security model and provides a public revocation mechanism, called revocable certificateless signature (RCLS). Under the standard computational Diffie-Hellman assumption, we formally demonstrate that our scheme possesses existential unforgeability against adaptive chosen-message attacks.

1. Introduction

In 2001, Boneh and Franklin [1], led by Shamir’s idea [2], realized a practical construction of an identity- (ID-) based public key system (ID-PKS) by using bilinear pairings, such as Weil, Tate, and Ate pairings. Subsequently, the study of ID-based cryptographic mechanisms using bilinear pairings has received a great attention from researchers. A large number of literatures, such as [3–7], have been presented. An ID-based public key system consists of two roles, namely, a trusted private key generator (PKG) and users. A user’s identity information, such as social security number, e-mail address, and IP address, is viewed as her/his public key and the corresponding private key is computed and issued secretly by the trusted PKG. Evidently, the PKG owns all the users’ private keys so that it can decrypt ciphertexts or sign messages on behalf of any user as it wishes. Hence, an ID-based public key system always inherits an imperfection—the key escrow problem.

To overcome the key escrow problem in ID-based public key systems, Gentry [8] introduced the concept of certificate-based public key system, which contains two roles, namely, a key generation center (KGC) and users. Here, we roughly describe Gentry’s system. A user first generates the public key and then sends it to the KGC. The KGC generates a certificate for the user’s public key and then sends it to the user. The certificate also acts as a decryption or signing key of the user.

In 2003, Al-Riyami and Paterson [9] proposed a new paradigm for public key cryptography by combining the traditional public key system (PKS) with ID-PKS, termed certificateless public key system. As a result, certificates are no longer needed, but the two roles, namely, a KGC and users, remain in their certificateless public key system. A user’s private key consists of two components: a partial private key and a secret key. They are generated by the KGC and the user, independently. In this case, the KGC does not have access to the user’s full private key due to the lack of the secret key generated by the user. Hence, this certificateless design resolves the key escrow problem in ID-based public key systems. Subsequently, a numer of certificateless cryptographic schemes and protocols have been studied [10–22].

Al-Riyami and Paterson [9] presented a security model for certificateless public key cryptography. It consists of two types of adversaries, namely, outsiders (Type I adversary) and the KGC (Type II adversary). They also presented a concrete certificateless signature (CLS) scheme but did not offer security notion for this kind of scheme. Two years later, Huang et al. [11] first provided formal security notion for CLS schemes and pointed out that Al-Riyami and Paterson’s scheme above suffers from key replacement attacks from outsiders in the sense that, by replacing a user’s public key, an outsider can forge valid signatures without the knowledge of the user’s partial private key. In 2004, Yum and Lee [23] gave a generic construction of CLS schemes by combining an ID-based signature scheme with a signature scheme based on traditional public key systems. In 2006, Hu et al. [12] presented a considerably strong security model for CLS schemes and pointed out a security drawback in Yum and Lee’s construction. Since then, Hu et al.’s security model is considered promising and is generally adopted to formalize the security of CLS schemes.

To improve the efficiency of CLS schemes, several constructions of CLS were built and discussed such as [24–27]. In addition, for providing relatively short signature, Huang et al. [14] proposed a certificateless short signature scheme, which was shown to suffer from key replacement attacks by Shim [28]. Recently, Chen et al. [29] wrote a survey article on CLS schemes, in which they also presented a secure certificateless short signature scheme.

The security of all the CLS schemes mentioned above was based on the random oracle model [30]. Although these schemes offer better performance, they could be insecure when random oracles are instantiated with some particular hash functions such as SHA-1. In order to compensate this situation, a secure CLS scheme in the standard model (without random oracles) must be constructed. Based on the ID-based signature scheme presented by Paterson and Schuldt [31], Liu et al. [16] proposed the first CLS scheme in the standard model. However, Xiong et al. [17] pointed out that Liu et al.’s scheme is insecure against KGC attacks. To withstand the KGC attacks, two CLS schemes [18, 21] were independently proposed but later shown to be insecure [32, 33]. To our best knowledge, a secure CLS in the standard model (without random oracles) is still not accessible. All the previously proposed CLS schemes in the standard model were insecure under Hu et al.’s strong security model in [12] in the sense that they suffered from key replacement attacks from outsiders (Type I adversary) or attacks from the key generation center (Type II adversary).

A public key system should provide an efficient revocation mechanism to revoke misbehaving/compromised users. In traditional public key systems, users are able to know the revoked public keys by querying the certificate revocation list (CRL) [34] which contains all the revoked public keys. Evidently, the CRL approach is no longer suited for the certificateless public key system due to the lack of the usage of certificates. So, revoking misbehaving/compromised users in certificateless public key system has received attention from cryptographic researchers. Recently, Tsai and Tseng [22] and Shen et al. [35], independently, used the revocation technique presented by Tseng and Tsai [36] to propose a revocable certificateless public-key encryption (RCL-PKE) scheme. However, there was little work in constructing a revocable CLS scheme without random oracles.

Our Construction. In this paper, we will propose a CLS scheme with revocation in the standard model, called revocable certificateless signature (RCLS). This scheme includes two merits.

(1)Under the standard computational Diffie-Hellman assumption, our scheme is secure under Hu et al.’s strong security model. We will formally demonstrate that our scheme possesses existential unforgeability against adaptive chosen-message attacks under the standard computational Diffie-Hellman assumption.(2)Our CLS scheme provides a public revocation mechanism to revoke misbehaving/compromised users.

The rest of the paper is organized as follows. We give some preliminaries in Section 2. In Section 3, we review the framework and security notion for RCLS schemes. A concrete RCLS scheme in the standard model is proposed in Section 4. We analyze the security of the proposed scheme in Section 5. In Section 6, we present discussions and comparisons between some existing schemes and ours. Finally, a concluding remark is drawn in Section 7.

2. Preliminaries

In this section, we will review some fundamentals required in this sequel, namely, the concept of bilinear pairings and the related assumption.

2.1. Bilinear Pairings

In the sequel, and denote two multiplicative cyclic groups of large prime order . A map is called an admissible bilinear map if it satisfies the following properties.

(1)The map is bilinear: given and , we have .(2)The map is nondegenerate: there exist such that .(3)The map is efficiently computable.

We refer the reader to previous literature, such as [1, 9], for a more comprehensive description of groups, maps, and other parameters.

2.2. Related Mathematical Assumption

Here, we introduce the computational Diffie-Hellman (CDH) problem and define its corresponding security assumption (CDH assumption) on which our scheme is based.

Definition 1. Let be a generator of . Given with unknown randomly chosen from , the CDH problem is to compute . The associated CDH assumption states that there exists no probabilistic polynomial-time adversary that can solve the CDH problem with nonnegligible probability. The successful probability (advantage) of the adversary is presented as

where the probability is over the random choice consumed by the adversary .

3. Framework and Security Notion of Revocable Certificateless Signature

In this section, we will define the framework and security notion for our RCLS scheme. In 2003, Al-Riyami and Paterson [9] presented a concrete certificateless signature (CLS) scheme, but did not give formal security notion for such schemes. Later, Yum and Lee [23] and Huang et al. [11] defined formal security notion for CLS schemes. Furthermore, Hu et al. [12] enhanced the definitions in [11, 23] to permit stronger queries. Since then, Hu et al.’s security model is generally adopted to formalize the security of CLS schemes. By modifying Hu et al.’s framework and security notion for CLS schemes [12], we present a framework of our RCLS scheme by adding time key update algorithm. Under this new framework, a user’s partial private key consists of two components, namely, an initial secret key (fixed since being issued) and a time update key (altered every period of time). As a result, the issue on time update key queries must be addressed in the security notion for CLS schemes.

Definition 2. A revocable certificateless signature (RCLS) is specified by six algorithms, namely, the system setup, the initial key extract, the time key update, the user key generation, the signing, and the verification.

(i)System setup: this algorithm takes security parameter and the total number of periods as input and returns a system secret key, a time secret key, and the public parameters . We assume that are publicly and authentically available in all the following algorithms.(ii)Initial key extract: this algorithm takes the system secret key and a user’s identity as input and returns the user’s initial secret key to the user via a secure channel.(iii)Time key update: this algorithm takes the time secret key, a user’s identity , and a period as input and returns the user’s time update key to the user via a public channel.(iv)User key generation: this algorithm takes the public parameters and as input and outputs the secret key and public key .(v)Signing: this algorithm takes a user’s initial secret key , the user’s time update key , the user’s secret key , and a message as input and returns a signature .(vi)Verification: taking a signature , a message , a user identity , a period , and the user’s public key as input; the algorithm outputs either “accept” or “reject.”

Remark 3. The system setup, the initial key extract, and the time key update algorithms are run by the KGC, while the user key generation algorithm is run by the user.
There are three types of adversaries in our security notion for RCLS schemes. In the following, we will employ a security game to model security notion for RCLS schemes. The security game describes the interaction between a challenger and an adversary. Before introducing the security game, we first describe capabilities of Type I, Type II, and Type III adversaries, respectively.

(i)Type I adversary (outsider): an adversary of this type does not have access to the system secret key and time secret key, but she/he can replace the public key of any entity with another of her/his own choice.(ii)Type II adversary (KGC): an adversary of this type is the KGC who knows the system secret key and time secret key. The KGC can produce the initial secret key and time update key of arbitrary identity, but it is forbidden to replace the public key of any identity at any time.(iii)Type III adversary (revoked user): an adversary of this type used to be a member of the system before being revoked by the system. A revoked user still owns the initial secret key although the system stops issuing the current time update key for her/him.

Definition 4. A RCLS scheme is existential unforgeable against chosen message attack if there is no probabilistic polynomial-time (PPT) adversary which has non-negligible advantage in the following security game.

(i)Setup. A challenger takes a security parameter and runs the system setup algorithm. The challenger gives the public parameters to the adversary . Meanwhile, if is of Type II adversary, gives the system secret key and time secret key to . Otherwise, the challenger keeps them for itself.(ii)Phase 1. The adversary may issue the public key retrieve, public key replace, initial key extract, time key update, secret key extract, and signing queries as follows.

(a)Public key retrieve query ( ). When issues this query with an identity , the challenger returns the corresponding public key to .(b)Public key replace query ( ). In such a query, the adversary replaces the public key of the identity with . The challenger records the replacement.(c)Initial key extract query ( ). When issues this query with an identity , the challenger runs the initial key extract algorithm to return the initial secret key .(d)Time key update query ( ). When issues this query with an identity in a period , the challenger runs the time key update algorithm to return the time update key .(e)Secret key extract query ( ). When issues this query with an identity , the challenger returns the secret key . Here, the query is forbidden if the identity has already appeared in the public key replace query.(f)Signing query ( ). When issues this query with , the challenger uses the initial secret key , the time update key , and the secret key to run the signing algorithm to obtain a signature on the message . The challenger then returns to no matter whether the identity appears in the public key replace query or not.

 Note that a Type I adversary can issue all types of queries except the initial key extract query on ; a Type II adversary can issue all types of queries except the queries on public key replace and the secret key extract query on ; a Type III adversary (revoked user) is allowed to issue all types of queries except the time update key query on .(iii)Forgery. The adversary outputs . We say that the adversary wins this game if the following conditions are satisfied.

(1)The response of the algorithm on is “accept.”(2) has never been submitted during the signing query process.

Remark 5. Since a Type II adversary owns the system secret key and the time secret key, it is able to generate any initial secret key and time update key. Hence, a Type II adversary does not need to issue the queries on initial secret key and time update key.

4. Concrete Revocable Certificateless Signature Scheme

In this section, we describe a concrete revocable certificateless signature scheme that consists of six algorithms.

(i)System setup: the KGC takes a security parameter as input and returns , where is an admissible bilinear map and and are two cyclic groups of sufficiently large prime order . Then, the KGC sets five collision-resistant hash functions , , , , and , where , , , , and are fixed. Furthermore, the KGC randomly chooses five values , , , , and five vectors , , , , , where , , , , for , , , , and . A generator of and two values are picked. The KGC computes and randomly chooses to set the system secret key as and the time secret key as . Then, the public parameters are presented as , .(ii)Initial key extract: given a user’s identity , the KGC computes a bit string . The KGC then chooses a random value and uses the system secret key to compute the user’s initial secret key . The KGC transmits to the user via a secure channel.(iii)Time update key: given a user’s identity and a period , the KGC computes a bit string . The KGC then chooses a random value and uses the time secret key to compute the user’s time update key . The KGC transmits to the user via a public channel.(iv)User key generation: given a user’s identity , this algorithm selects two secret values and computes the user’s public key . Then, the algorithm first computes two bit strings and . Finally, the algorithm uses the selected two secret values to compute the user’s secret key .(v)Signing: given a message , a signer computes a bit string . The signer chooses a random value and computes . The signer uses her/his initial secret key , time update key , and secret key to compute a signature on the message as follows:

(vi)Verification: given a period , a signature on a message for a signer with an identity and the signer’s public key , a verifier first computes five bit strings , , , , and . Finally, the verifier checks the following equation:

5. Security Analysis

In this section, we establish three theorems to demonstrate that, under the CDH assumption, the proposed RCLS scheme offers existential unforgeability against adaptive chosen-message attacks for Type I, Type II, and Type III adversaries, respectively.

Theorem 6. Under the CDH assumption, the proposed RCLS scheme is secure against Type I adversary (outsider). Concretely, if there is a Type I adversary that has an advantage against the proposed scheme within a running time , then we can construct an algorithm to solve the CDH problem with an advantage

within a running time + , in which , and are the numbers of queries on initial key extract, time key update, and signing, respectively, is the sum of the numbers of queries on public key replace and secret key extract, and and denote the executing time of a multiplication and an exponentiation in , respectively.

Proof. Assume that a Type I adversary can forge a valid signature for the proposed RCLS scheme. We will construct an algorithm that solves the CDH problem as follows. Without loss of generality, we assume that there exists a tuple , as mentioned in Section 2, and the algorithm is given , where and are unknown to . In order to compute , the algorithm simulates a challenger in the following game.

(i)Setup. A challenger (algorithm) first sets five collision-resistant hash functions , , , , and , where , , , , and are fixed. Note that the employed collision-resistant hash functions are not viewed as random oracles in our security proofs. The challenger then sets , , and and chooses three integers , , and at random, where , , and . We assume that , , and for the given values of , , , , and . The challenger randomly selects the integers , , , , , , and . Now, the challenger constructs a set of public parameters as follows. The challenger chooses a value as the time secret key. The challenger sets and . Furthermore, computes and a vector , where for ; and a vector , where for ; and a vector , where for ; and a vector , where for ; and a vector , where for . Now, the challenger has constructed a set of public parameters as , . Before performing and between the adversary and the challenger , we define seven functions , , , , , , and by

 Here, as before, for an identity , for an identity in a period , and for a public key , and for a message . Finally, for the cumbersome notations defined above, we conclude with five relations to which will be referred frequently in the sequel; namely,

(ii) Queries. The challenger maintains a list of tuples of the form . Initially the list is empty. The adversary may make a number of queries in an adaptive manner as follows.

(a)Public key retrieve query ( ): upon receiving a query for the public key of an identity , the challenger responds to the query as follows.

(1)If appears in the list , the challenger responds with the corresponding .(2)If does not appear in the list , the challenger selects two secret values , sets the public key , and then computes , , and the secret key . The challenger adds the tuple in the list and returns as the query output.

(b)Public key replace query ( ): upon receiving a query to replace the public key of an identity , the challenger accesses the tuple in the list . If appears in the list , the challenger replaces with . If does not appear in the list , the challenger adds the tuple in the list .(c)Initial key extract query ( ): upon receiving a query for the initial secret key of an identity , the challenger first sets , and then computes and . If , the challenger aborts. Otherwise, the challenger chooses a random value and responds with the initial secret key generated by

 Here, is indeed a valid initial secret key since, by the first equality in (6),

 where .(d)Time key update query ( ): upon receiving a query for the time update key of an identity in a period , the challenger first sets and then computes . The challenger chooses a random and uses the time secret key to compute the time update key as follows:

(e)Secret key extract query ( ): upon receiving a query for the secret key of an identity , the challenger accesses the tuple in the list . If appears in the list , the challenger responds with . If does not appear in the list , the challenger runs user key generation algorithm to add the tuple in the list and responds with .(f)Signing query ( ): consider a query for a message , an identity , a period , and a public key . The challenger first sets , , , , and . then computes , , , , , , and . If , the challenger reports failure and terminates. Otherwise, the challenger considers the following two cases. Case  1: assume that the identity has previously appeared in the public key replace query. If , the challenger can compute the initial secret key as in the initial key extract query. In addition, the challenger computes the time update key as in the time key update query. The challenger then chooses a random value and responds whit the signature

 Note that is indeed a valid signature since and, by the equalities in (6),

 where . On the other hand, if , the challenger first computes the time update key as in the time key update query. Then, the challenge chooses two random values and responds with the signature

 Note that is also a valid signature since, by (6),

 where . Case  2: assume that the identity has not previously appeared in the public key replace query. The challenger computes the time update key as in the time key update query. If , the challenger can compute the initial secret key as in the initial key extract query and accesses the list to obtain the corresponding secret key . The challenger chooses a random value and then responds with the signature

 If , then chooses two random values and responds with the signature

(iii)Forgery. Assume that the adversary generates a valid signature for on in , where , , and are the target identity, period, and message, respectively. The challenger first accesses to the list to obtain . The challenger then computes , , , , , , , , , , , and . If , , or , the challenger aborts. Otherwise, that is, when , the challenger , by using (6), computes as follows:

 Thus, the challenger resolves the computational Diffie-Hellman (CDH) problem.

Next, we proceed to the probability analysis for the simulation above. Note that if the simulation aborts, then the CDH problem will be unable to be computed by the challenger. In Forge phase, the adversary can generate a signature if the challenger can correctly response the adversary’s queries in Phase 1 and do not abort in the security game. If the signature is valid, the challenger can use it to solve the CDH problem. Thus, the probability of the challenger not aborting in the security game is equal to the probability of solving the CDH problem. Hence, we list the events that the challenger does not abort during the simulation process.

(1)In the phase of initial key extract query: if , the challenger can correctly answer queries without aborting.(2)In the phase of signing query: if , the challenger can correctly respond queries without aborting.(3)In the phase of forgery: if , the challenger can perform the simulation without aborting.

Let be the number of identities appearing in either initial key extract queries or signing queries not involving the challenge identity. In addition, let be the number of identities with the period appearing in the time key update queries and let be the number of messages in the signing queries involving the challenge identity. Clearly, we will have , and . To simplify the analysis, we define the events mod for the query , mod , mod for the query , mod , and mod . From the above analysis, the probability of the challenger not aborting is

Note that, if mod , there will be a unique choice of with such that . Since are chosen randomly, we obtain that

By similar arguments, we have

We also have that

and, similarly,

Hence, we can obtain that

We have set , , and in the setup at the beginning of the proof, and so the resulting probability of the challenger not aborting is

Since the adversary that has an advantage against the proposed certificateless signature scheme, the challenger has an advantage

to solve the CDH problem.
For the queries, we observe that there are multiplications and exponentiations in the initial key extract queries. There are multiplications and exponentiations in the time update key queries. There are multiplications and exponentiations in both the public key retrieve and the secret key extract queries. Moreover, there are multiplications and O(1) exponentiations in the signing queries. So we have + , where and denote the executing time of a multiplication in and an exponentiation in , respectively.

Theorem 7. Under the CDH assumption, the proposed RCLS scheme is secure against Type II adversary. Concretely, if there is a Type II adversary (KGC) that has an advantage against the proposed scheme within a running time , then we can construct an algorithm to solve the CDH problem with an advantage

within a running time + , in which and are the numbers of queries on secret key extract and signing, respectively, and and denote the executing time of a multiplication and an exponentiation in , respectively.

Proof. We assume that a Type II adversary can forge a valid signature for the proposed RCLS scheme. We will construct an algorithm that solves the CDH problem as follows. Without loss of generality, we assume that there exists a tuple , as mentioned in Section 2, and the algorithm is given , where and are unknown to . In order to compute , the algorithm simulates a challenger in the following game.

(i)Setup. A challenger (algorithm) first sets five collision-resistant hash functions , , , , and , where , , , , and are fixed. Note that the employed collision-resistant hash functions are not viewed as random oracles in our security proofs. The challenger then sets and chooses an integer at random, where . We assume that for the given values of and . The challenger randomly selects the integers: , , , , , and . Now, the challenger constructs a set of public parameters as follows. The challenger chooses two values . The challenger sets and . Furthermore, computes and sends the system secret key and time secret key to the adversary . Also, computes and a vector , where for ; and a vector , where for ; and a vector , where for ; and a vector , where for ; and a vector , where for . Now, the challenger has constructed a set of public parameters as , . Before performing and between the adversary and the challenger , we define six functions , , , , , and by

 Here, as before, for an identity , for an identity in a period , and for a public key , and for a message . Finally, for the cumbersome notations defined above, we conclude with four relations to which will be referred frequently in the sequel; namely,

(ii)Queries. The challenger maintains a list of tuples of the form . Initially the list is empty. First, without loss of generality, the challenger picks a target identity , selects a secret value , and sets the public key . Then, the challenger adds the tuple in the list . The adversary may make a number of queries in an adaptive manner as follows.

(a)Public key retrieve query ( ): upon receiving a query for the public key of an identity , the challenger responds to the query as follows.

(1)If appears in the list , the challenger responds with the corresponding .(2)If does not appear in the list , the challenger selects two secret values , sets the public key , and then computes , and the secret key . The challenger adds the tuple in the list and returns as the query output.

(b)Secret key extract query ( ): consider such a query along with an identity . If , the challenger aborts. If and appears in the list , the challenger accesses the tuple in the list and responds with . If and does not appear in the list , the challenger runs the user key generation algorithm to add the tuple in the list and then responds with so obtained.(c)Signing query ( ): consider a query for a message , an identity , a period , and a public key . The challenger first sets , , , , and . then computes , , , , , and . If , the challenger reports failure and terminates. Otherwise, the challenger considers the following two cases. Case  1: if , the challenger runs the initial key extract and time key update algorithms to obtain the initial secret key and the time update key . The challenger chooses a random value and then responds with the signature

 Note that is indeed a valid signature since and, by the equalities in (27),

 where . Case  2: if , the challenger runs the initial key extract and time key update algorithms to obtain the initial secret key and the time update key . Then, accesses to the list to obtain the secret key . The challenger chooses a random value and then responds with the signature

(iii)Forgery. Assume that the adversary generates a valid signature for on in , where , , and are the target identity, period, and message, respectively. If , the challenger reports failure and terminates. If , the challenger first accesses to the list to obtain . The challenger then computes , , , , , , , , , , and . If , the challenger aborts. Otherwise, that is, when , the challenger , by using (27), computes as follows:

where and have been chosen in the setup at the beginning of the proof. Finally, by computing , we obtain the value . Thus, the challenger resolves the computational Diffie-Hellman (CDH) problem.
Next, we proceed to the probability analysis for the simulation above. For convenience, we list the events that the challenger does not abort during the simulation process.

(1)In the phase of signing query: if , the challenger can correctly respond to queries without aborting.(2)In the phase of forgery: if and , the challenger can perform the simulation without aborting.

Let be the number of messages in the signing queries involving the challenge identity. Clearly, we will have . To simplify the analysis, we define the events for the th query , , . From the analysis above, the probability of the challenger not aborting is

The analysis of probability above is similar to Theorem 6. Here, we can obtain that

Since we have set , the resulting probability of the challenger not aborting is

by noting that .
Since the adversary has an advantage against the proposed certificateless signature scheme, the challenger has an advantage

to solve the CDH problem.
For the queries, we observe that there are multiplications and exponentiations in secret key extract queries. Moreover, there are multiplications and exponentiations in the signing queries. So we have + , where and denote the executing time of a multiplication and an exponentiation in , respectively.

Theorem 8. Under the CDH assumption, the proposed RCLS scheme is secure against Type III adversary (revoked user). Concretely, if there is a revoked user that has an advantage against the proposed scheme within a running time , then we can construct an algorithm to solve the CDH problem with an advantage

within a running time + , in which , , and are the numbers of queries on initial key extract, time key update, and signing, respectively, is the sum of the numbers of queries on public key replace and secret key extract, and and denote the executing time of a multiplication and an exponentiation in , respectively.

Proof. Assume that a revoked user can forge a valid signature for the proposed RCLS scheme. We will construct an algorithm that solves the CDH problem as follows. Without loss of generality, we assume that there exists a tuple , as mentioned in Section 2, and the algorithm is given , where and are unknown to . In order to compute , the algorithm simulates a challenger in the following game.

(i)Setup. A challenger (algorithm) first sets five collision-resistant hash functions , , , , and , where , , , , and are fixed. Note that the employed collision-resistant hash functions are not viewed as random oracles in our security proofs. The challenger then sets , and , and chooses three integers , , and at random, where , , and . We assume that , , and for the given values of , , , , , and . The challenger randomly selects the integers: , , , , , , and . Now, the challenger constructs a set of public parameters as follows. The challenger chooses a value as the system secret key. The challenger sets and . Furthermore, computes and a vector , where for ; and a vector , where for ; and a vector , where for ; and a vector , where for ; and a vector , where for . Now, the challenger has constructed a set of public parameters as , . Before performing and between the adversary and the challenger , we define seven functions , , , , , , and by

 Here, as before, for an identity , for an identity in a period , and for a public key , and for a message . Finally, for the cumbersome notations defined above, we conclude with four relations to which will be referred frequently in the sequel; namely,

(ii) Queries. The challenger maintains a list of tuples of the form . Initially the list is empty. The adversary may make a number of queries in an adaptive manner as follows.

(a) Public key retrieve query ( ): to respond to the queries, the challenger responds to the queries as in Theorem 6.(b) Public key replace query ( ): to respond to the queries, the challenger responds to the queries as in Theorem 6.(c) Initial key extract query ( ): upon receiving a query for the initial secret key of an identity , the challenger first sets and then computes . The challenger chooses a random and uses the system secret key to compute the initial secet key as follows:

(d) Time key update query ( ): upon receiving a query for the time update key of an identity in a period , the challenger first sets , and then computes and . If , the challenger aborts. Otherwise, the challenger chooses a random value and responds with the time update key generated by

 Here, is indeed a valid time update key since, by the first equality in (38),

 where .(e) Secret key extract query ( ): to respond to the queries, the challenger responds to the queries as in Theorem 6.(f) Signing query ( ): consider a query for a message , an identity , a period , and a public key . The challenger first sets , , , , and . then computes , , , , , , and . If , the challenger reports failure and terminates. Otherwise, the challenger considers the following two cases. Case  1: assume that the identity has previously appeared in the public key replace query. If , the challenger can compute the time update key as in the time key update query. In addition, the challenger computes the initial secret key as in the initial key extract query. The challenger then chooses a random value and responds with the signature

 Note that is indeed a valid signature since and, by the equalities in (38),

 where . On the other hand, if , the challenger first computes the initial secret key as in the initial key extract query. Then, the challenge chooses two random values and responds with the signature

 Note that is also a valid signature since, by (38),

 where . Case  2: assume that the identity has not previously appeared in the public key replace query. The challenger computes the initial secret key as in the initial key extract query. If , the challenger can compute the time update key as in the initial key extract query and accesses the list to obtain the corresponding secret key . The challenger chooses a random value and then responds with the signature

 If , then chooses two random values and responds with the signature

(iii)Forgery. Assume that the adversary generates a valid signature for on in , where , , and are the target identity, period, and message, respectively. The challenger first accesses the list to obtain . The challenger then computes , , , , , , , , , , , and . If , , or , the challenger aborts. Otherwise, that is, when , the challenger , by using (38), computes as follows:

 Thus, the challenger resolves the computational Diffie-Hellman (CDH) problem.

The analysis is similar to Theorem 6. The probability of the challenger not aborting is
. Then, the successful probability (advantage) of the challenger who can solve the CDH problem is at least . The executing time is + + , where and denote the executing time of a multiplication in and an exponentiation in , respectively.

6. Discussions and Comparisons

Here, we compare our RCLS scheme with the previously proposed CLS schemes in the standard model [16–18, 21]. Table 1 presents the comparisons between those schemes and ours in terms of computational cost and security property.

Table 1: Comparisons between our scheme and the previously proposed schemes.

Liu et al.’s scheme [16]
Xiong et al.’s scheme [17]
Yuan et al.’s scheme [18]
Yu et al.’s scheme [21]
Our scheme

Computational cost for signature
6
6
9
7
2

Computational cost for verification
6
3
6
5
7

Against Type I adversary
Yes
No
No
No
Yes

Against Type II adversary
No
Yes
Yes
No
Yes

Revocation mechanism
No
No
No
No
Yes

Against Type III adversary
—
—
—
—
Yes

Security assumption
NGBDH
Many-DH
NGBDH
Many-DH
AC-DH
2-Many-DH
NGBDH
Many-DH
CDH

In the signature procedure, our scheme requires only operations and the other schemes require at least operations, where is the time for executing an exponentiation operation in . In the verification procedure, our scheme requires operations, where denotes the time for executing a pairing operation . Our scheme requires more pairing operations than the others but it provides the security against both Type I and Type II adversaries. As for the security analysis, as mentioned in Section 1, all the existing CLS schemes in the standard model suffer from outsiders’ key replacement attacks (Type I adversary) or KGC attacks (Type II adversary). We emphasize that our scheme provides a full security against both Type I and Type II adversaries.

In addition, our scheme provides a public revocation mechanism, while the existing CLS schemes did not. As for security assumptions, our scheme is based on the standard CDH assumption, while the others are based on nonstandard assumptions, such as the non-pairing-based generalized bilinear Diffie-Hellman (NGBDH), many Diffie-Hellman (Many-DH), augmented computational Diffie-Hellman (AC-DH), and 2-many Difffie-Hellman (2-Many-DH) assumptions.

Furthermore, to reduce the KGC’s computational cost, one may adopt the technique in [37] by employing a delegated revocation authority (DRA) to generate users’ time update keys. In Figure 1, we illustrate how the DRA assists the KGC in revoking misbehaving/compromised users. First, the KGC generates the public parameters params, the system secret key and the time secret key . Secondly, the KGC transmits the time secret key to the DRA by using a secure channel, and then the DRA can use it to generate users’ time update keys and send them to users via a public channel. Finally, in order to revoke some misbehaving/compromised users, it only stops issuing the current time update keys to those users.

Figure 1: The generation of a user’s full signing key.

7. Conclusions

In this article, we proposed the first secure revocable certificateless signature scheme in the standard model under an extended model of Hu et al.’s. We formally demonstrated that our scheme possesses existential unforgeability against adaptive chosen-message attacks from Type I, Type II, and Type III adversaries under the standard computational Diffie-Hellman assumption. Moreover, Table 1 indicates that our scheme owns better security than the others under consideration. Finally, an interesting and nontrivial issue, namely, constructing a strongly unforgeable certificateless signature scheme, is worth studying. We leave it as future work.

Conflict of Interests

The authors declare that there is no conflict of interests regarding the publication of this paper.

Acknowledgments

The authors would like to thank anonymous referees for their valuable comments and constructive suggestions. This research was partially supported by the Ministry of Science and Technology, Taiwan, under contract no. MOST103-2221-E-018-022-MY2.

References

D. Boneh and M. Franklin, “Identity-based encryption from the Weil pairing,” in Proceedings of the 21st Annual International Cryptology Conference (Crypto '01), pp. 213–229, Santa Barbara, Calif, USA, August 2001.

A. Shamir, “Identity-based cryptosystems and signature schemes,” in Advances in Cryptology: Proceedings of CRYPTO '84, vol. 196 of Lecture Notes in Computer Science, pp. 47–53, Springer, Berlin, Germany, 1985.

J. C. Cha and J. H. Cheon, “An identity-based signature from gap Diffie-Hellman groups,” in Public Key Cryptography—PKC 2003, vol. 2567 of Lecture Notes in Computer Science, pp. 18–30, 2003.

B. Waters, “Efficient identity-based encryption without random oracles,” in Proceedings of the 24th Annual International Conference on the Theory and Applications of Cryptographic Techniques (Eurocrypt '05), pp. 1–33, Aarhus, Denmark, May 2005.

Y.-M. Tseng, T.-Y. Wu, and J.-D. Wu, “An efficient and provably secure id-based signature scheme with batch verifications,” International Journal of Innovative Computing, Information and Control, vol. 5, no. 11, pp. 3911–3922, 2009.

Y. Ren, D. Gu, S. Wang, and X. Zhang, “New fuzzy identity-based encryption in the standard model,” Informatica, vol. 21, no. 3, pp. 393–407, 2010.

J. Li, X. Chen, C. Jia, and W. Lou, “Identity-based encryption with outsourced revocation in cloud computing,” IEEE Transactions on Computers, 2013.

C. Gentry, “Certificate-based encryption and the certificate revocation problem,” in Advances in Cryptology—EUROCRYPT '03, vol. 2656 of Lecture Notes in Computer Science, pp. 272–293, 2003.

S. S. Al-Riyami and K. G. Paterson, “Certificateless public key cryptography,” in Advances in Cryptology—ASIACRYPT 2003, vol. 2894 of Lecture Notes in Computer Science, pp. 452–473, Springer, Berlin, Germany, 2003.

S. S. Al-Riyami and K. G. Paterson, “CBE from CL-PKE: a generic construction and efficient schemes,” in Proceedings of the 8th International Workshop on Theory and Practice in Public Key Cryptography (PKC '05), pp. 398–415, Les Diablerets, Switzerland, January 2005.

X. Huang, W. Susilo, Y. Mu, and F. Zhang, “On the security of certificateless signature schemes from Asiacrypt 2003,” in Proceedings of the Cryptology and Network Security (CANS '05), pp. 13–25, 2005.

B. Hu, D. Wong, Z. Zhang, and X. Deng, “Key replacement attack against a generic construction of certificateless signature,” in Information Security and Privacy, vol. 4058 of Lecture Notes in Computer Science, pp. 235–246, Springer, Berlin, Germany, 2006.

B. Libert and J. J. Quisquater, “On constructing certificateless cryptosystems from identity based encryption,” in Public Key Cryptography—PKC '06, vol. 3958 of Lecture Notes in Computer Science, pp. 474–490, 2006.

X. Huang, Y. Mu, W. Susilo, D. S. Wong, and W. Wu, “Certificateless signature revisited,” in Proceedings of the 12th Australasian Conference (ACISP '07), pp. 308–322, Townsville, Australia, July 2007.

Y. H. Hwang, J. K. Liu, and S. S. Chow, “Certificateless public key encryption secure against malicious KGC attacks in the standard model,” Journal of Universal Computer Science, vol. 14, no. 3, pp. 463–480, 2008.

J. K. Liu, M. H. Au, and W. Susilo, “Self-generated-certificate public key cryptography and certificateless signature/encryption scheme in the standard model,” in Proceedings of the 2nd ACM Symposium on Information, Computer and Communications Security (ASIACCS '07), pp. 273–283, March 2007.

H. Xiong, Z. Qin, and F. Li, “An improved certificateless signature scheme secure in the standard model,” Fundamenta Informaticae, vol. 88, no. 1-2, pp. 193–206, 2008.

Y. Yuan, D. Li, L. Tian, and H. Zhu, “Certificateless signature scheme without random oracles,” in Proceedings of the Advances in Information Security and Assurance (ISA '09), pp. 31–40, 2009.

D. Fiore, R. Gennaro, and N. P. Smart, “Constructing certificateless encryption and ID-based encryption from ID-based key agreement,” in Pairing-Based Cryptography—Pairing '10, vol. 6487 of Lecture Notes in Computer Science, pp. 167–186, 2010.

G. Yang and C. H. Tan, “Strongly secure certificateless key exchange without pairing,” in Proceedings of the 6th International Symposium on Information, Computer and Communications Security (ASIACCS '11), pp. 71–79, March 2011.

Y. Yu, Y. Mu, G. Wang, Q. Xia, and B. Yang, “Improved certificateless signature scheme provably secure in the standard model,” IET Information Security, vol. 6, no. 2, pp. 102–110, 2012.

T.-T. Tsai and Y.-M. Tseng, “Revocable certificateless public key encryption,” IEEE Systems Journal, 2013.

D. Yum and P. Lee, “Generic construction of certificateless encryption,” in Proceedings of the International Conference on Computational Science and Its Applications (ICCSA '04 ), pp. 802–811, 2004.

M. C. Gorantla and A. Saxena, “An efficient certificateless signature scheme,” in Proceedings of the International Conference (CIS '05), pp. 110–116, Xi’an, China, December 2005.

X. Cao, K. G. Paterson, and W. Kou, “An attack on a certificateless signature scheme,” Tech. Rep. 2006/367, Cryptology ePrint Archive, 2006, http://eprint.iacr.org/2006/367.

J. Zhang and J. Mao, “Security analysis of two signature schemes and their improved schemes,” in Proceedings of the International Conference on Computational Science and Its Applications (ICCSA '07), pp. 589–602, 2007.

L. Zhang and F. Zhang, “A new provably secure certificateless signature scheme,” in Proceedings of the IEEE International Conference on Communications (ICC '08), pp. 1685–1689, May 2008.

K.-A. Shim, “Breaking the short certificateless signature scheme,” Information Sciences, vol. 179, no. 3, pp. 303–306, 2009.

Y. C. Chen, R. Tso, W. Susilo, X. Huang, and G. Horng, “Certificateless signatures: structural extensions of security models and new provably secure schemes,” Tech. Rep. 2013/193, Cryptology ePrint Archive, 2013, http://eprint.iacr.org/2013/193.

M. Bellare and P. Rogaway, “Random oracles are practical: a paradigm for designing efficient protocols,” in Proceedings of the 1st ACM Conference on Computer and Communications Security (CCS '93), pp. 62–73, November 1993.

K. G. Paterson and J. C. N. Schuldt, “Efficient identity-based signatures secure in the standard model,” in Information Security and Privacy, vol. 4058 of Lecture Notes in Computer Science, pp. 207–222, Springer, Berlin, Germany, 2006.

Q. Xia, C. Xu, and Y. Yu, “Key replacement attack on two certificateless signature schemes without random oracles,” Key Engineering Materials, vol. 439-440, pp. 1606–1611, 2010.

L. Cheng, Q. Wen, Z. P. Jin, and H. Zhang, “On the security of a certificateless signature scheme in the standard model,” Cryptology ePrint Archive Report 2013/153, 2013, https://eprint.iacr.org/2013/153.

R. Housley, W. Polk, W. Ford, and D. Solo, “Internet X.509 public key infrastructure certificate and certificate revocation list (CRL) profile,” RFC 3280, IETF, 2002.

L. Shen, F. Zhang, and Y. Sun, “Efficient revocable certificateless encryption secure in the standard model,” The Computer Journal, vol. 57, no. 4, pp. 592–601, 2014.

Y.-M. Tseng and T.-T. Tsai, “Efficient revocable ID-based encryption with a public channel,” Computer Journal, vol. 55, no. 4, pp. 475–486, 2012.

T.-T. Tsai, Y.-M. Tseng, and T.-Y. Wu, “RHIBE: constructing revocable hierarchical ID-based encryption from HIBE,” Informatica, vol. 25, no. 2, pp. 299–326, 2014.