CERTIFICATION OF DL/EC KEYS
LPK
arazi@ee.bgu.ac.il
ABSTRACT
It is shown that the explicit certification of public keys in customary DL/EC (DiscreteLog/ EllipticCurve) applications, ranging from digital signatures of the DSA type to keyagreements of the DH type, can be abolished.
This facilitates highly efficient implementations in terms of the total number of exponentiations needed to be executed, the ability of having parallel processing, and communication overhead.
At the fundamental level it is shown how to integrate the processing of the public key of the trusted third party (needed, by definition, in establishing the validity of static public values submitted by a user) and the dynamic processing associated with the actual cryptographic process. This reduces, by a factor of at least 2, the processing time when compared to standard signature and keyagreement techniques, while further reducing communication overhead.
It is then shown how the performance of the introduced keyagreement techniques is further enhanced, by utilizing a principle termed "you are OK if I am OK". Here, the processing of the public key of Alice’s trusted third party is not performed by Bob after he receives the values submitted by Alice, as customarily done. Instead, Bob refers to the said public key prior to his communication with Alice (utilizing the realistic observation under which Bob is supposed to know in any case the public key of Alice’s trusted third party regardless of his communication with Alice). Here, if Bob is assured that his secret and public values are valid then he is subsequently assured that the public values submitted by Alice are valid as well.
Notations and terminology DL/EC (DiscreteLog/EllipticCurve) cryptographic applications relate to operations over a finite group of points in which the discrete log problem applies. A grouppoint is denoted in bold. s_{*}P is a grouppoint obtained by multiplying the grouppoint P by the scalar s. This scalar is considered an exponent. When operating over a group of integers modulo an agreed q, the notation s_{*}P means P^{s} mod q, and s_{*}P + t_{*}Q means P^{s}_{*}Q^{t} mod q.
G  the generating grouppoint, joint to all users that use the services of a system controlled by a certain trusted third party. Exponents are calculated modulo the order of G.
LogP  the scalar k such that P = k_{*}G.
d  the secret key of the trusted third party.
(For simpler explanations, it is assumed that Alice and Bob use the services of the same trusted third party. Extensions to the general case, where these parties use the services of different trusted third parties, naturally follow.)
R = d_{*}G  the public key of the trusted third party.
xA, xB  the secret key of Alice, Bob.
YA = xA_{*}G, YB = xB_{*}G  the public key of Alice, Bob.
PUA, PUB  the public value of Alice, Bob. (In the implementations presented in this document, the users submit the said public value, and not the public key YA, YB.)
ITA, ITB – a representative of the identification details or the attributes of Alice, Bob.
H(v,W) – a transformation, known to all, that converts a scalar v and a grouppoint W into a scalar. (H is not necessarily a hash. Features of H are discussed later.)
1. Background
1.1. DL/EC signature techniques
As a representative of DL/EC signature techniques, where Alice signs the message m, we describe the DSA [1].
Let xA denote Alice's secret key. Let G be a generating grouppoint known to all users. Let YA denote Alice's public key, where YA = xA_{*}G.
Signature: Alice selects a onetime key pair k and V = k_{*}G, represents V by an integer p and calculates q = k^{1}_{*}(m + xA_{*}p) (where integer calculations are performed modulo the order of G). The signature on m is the pair {p,q}.
Alice then submits m, p, q, YA.
Signature verification: The verifier, Bob, calculates t = q^{1}, v = m_{*}t and w = p_{*}t. He then calculates P = v_{*}G + w_{*}Yi, represents P by an integer r (in the same way that p represents V). The signature is determined to be valid if r = p.
The certification principle
Let ITA denote Alice's identification details or claimed attributes. When Alice submits to Bob her public key YA, Bob must be given an assurance that YA is associated with ITA. Here, Alice also submits to Bob a certificate CRA, which is the signature of a trusted third party on the association between YA and ITA.
A complete DSA process therefore involves two signature verifications conducted by Bob. The first involves certificate verification. Here, the signed message is a value which combines ITA and YA. The signature is CRA, generated by the trusted third party, whose private key is d. The public key used in the certificate verification is the value R = d_{*}G, published by the trusted third party. The second signature verification involves the actual process of verifying the authenticity of the dynamic message m.
Signature generation involves one exponentiation operation of the form b_{*}A. Signature verification involves an operation of the form b_{*}A + d_{*}C, performed twice (including certificate verification). The latter operation can amount to less than two individual exponentiations when using some 'speedup' methods [2].
1.2. DL/EC keyagreement techniques
DL/EC keyagreements are based on the DH (DiffieHellman) method [3] or its variants. Here, Alice and Bob exchange some public values, and by using values received from their counterpart and their own secret keys they end up with a value, common to the two of them, and which only they are supposed to know. This common value then acts as their generated session key.
A basic DH keyagreement takes the following steps:

Alice sends to Bob the values YA, ITA and CRA, defined before. Symmetrically, Bob sends to Alice: YB, ITB and CRB.

Alice and Bob establish the validity of YB, YA, based on the certificate CRB and CRA they respectively received and by referring to the public key of the trusted third party.

Alice and Bob respectively generate the session key KAB = xA_{*}YB and KBA = xB_{*}YA.
The mathematical operations performed by each user amount to one operation of the form b_{*}A + d_{*}C (for certificate verification) and one more exponentiation (for session key generation).
The above technique concerns a fixedkeyagreement, wherein Alice and Bob always end up with the same session key whenever they wish to generate such a key.
An ephemeral DH keyagreement, wherein Alice and Bob generate a different session key whenever they communicate, based on a different random value each of them generates in each communication session, takes the following possible steps:

Alice generates a random pvA, calculates the ephemeral value EVA = pvA_{*}G and uses xA in order to generate a signature SA on EVA. She then sends to Bob: YA, ITA, CRA, EVA and SA.
Symmetrically, Bob sends to Alice: YB, ITB, CRB, EVB and SB.

Alice and Bob establish the validity of YB, YA, based, respectively, on the certificate CRB and CRA and by referring to the public key of the trusted third party.

Alice and Bob establish the validity of the received ephemeral values EVB and EVA, based on the signatures SB and SA and by referring to the public keys YB and YA (whose validity was established in the preceding step).

Alice and Bob respectively generate KAB = pvA_{*}EVB and KBA = pvB_{*}EVA.
The mathematical operations performed by each user, when implementing the above procedure, amount to two operations of the form b_{*}A + d_{*}C (one for certificate verification and one for signature verification) and three more exponentiations (for ephemeral value generation, for signature generation and for key generation).
A further ephemeral keyagreement method, is the MQV [4]. The following is one variation of this method:

Alice generates a random pvA, calculates EVA = pvA_{*}G and sends to Bob: YA, ITA, CRA and EVA. Symmetrically, Bob sends to Alice: YB, ITB, CRB and EVB.

Alice and Bob establish the validity of YB, YA.

Alice and Bob respectively generate KAB = (pvA+T(EVA)_{*}xA)_{*}(EVB + T(EVB)_{*}YB) and KBA = (pvB+T(EVB)_{*}xB)_{*}(EVA + T(EVA)_{*}YA), where T is a transformation that converts the grouppoint EVA and EVB into a scalar.
The mathematical operations performed by each user, when implementing the above, amount to one operation of the form b_{*}A + d_{*}C and three more exponentiations.
2. Description of the cryptographic technique
The various aspects of the presented techniques, described next, do not include security considerations. These are treated in detail in Part 4 of this document. For simpler explanations, we treat the case where Alice and Bob use the services of the same trusted third party. Extensions to the general case simply follow. Here, whenever a user makes a reference to the public key of a trusted third party, this reference is being made to the key of the trusted third party of his counterpart.
2.1. Generating user's secret and public values
The grouppoints G and R, and the scalar d, have already been defined as the generating grouppoint, the public key of the trusted third party, and the secret key of that party, where R = d_{*}G. We further use a transformation H(v,W), known to all, that converts a scalar v and a grouppoint W into a scalar.
While Alice’s public key, in the presented technique, is still YA = xA_{*}G, for a secret key xA, the public reference value submitted by Alice is a grouppoint PUA.
The secret key xA and the public value PUA of Alice are generated as follows:

Alice generates a random hA and submits VA = hA_{*}G and ITA to the trusted third party;

The trusted third party generates a random kA, he then calculates kA_{*}G,
PUA = VA + kA_{*}G and pA = H(ITA,PUA)_{*}kA + d;

The trusted third party issues the values pA and PUA to Alice;

Alice generates her secret key xA = pA + H(ITA,PUA)_{*}hA.
That is: xA = H(ITA,PUA)_{*}(kA+hA) + d.
It is noted that YA = xA_{*}G = H(ITA,PUA)_{*}PUA + R. It is further noted that the trusted third party does not know the value of Alice’s secret key xA, while no party knows logPUA. (logPUA = hA + kA, where Alice and the trusted third party each knows only one addend.)
Alice can establish the validity of the values pA and PUA issued to her by checking whether pA_{*}G = H(ITA,PUA)_{*}(PUA  VA) + R.
2.2. DSA procedure without a separate submission of a public key and a certificate
In the presented technique, Alice signs a message m in the standard lines of the DSA. That is: Alice generates a onetime key pair k and V = k_{*}G, represents V by an integer p and calculates q = k^{1}_{*}(m + xA_{*}p). The signature on m is the pair {p,q}.
Alice then submits m, p, q, her ITA and the public value PUA. (Unlike a customary DSA, she does not submit her public key YA = xA_{*}G and she does not submit a certificate.)
Following the lines of the DSA, the verifier calculates t = q^{1}, v = m_{*}t and w = p_{*}t, and then u = H(ITA,PUA)_{*}w and P = v_{*}G + u_{*}PUA + w_{*}R. The value P is then represented by r (in the same way the signer represented V by p) and it is checked whether r = p.
Note that P = v_{*}G + u_{*}PUA + w_{*}R = v_{*}G + w_{*}(H(ITA,PUA)_{*}PUA + R) = v_{*}G + w_{*}YA, which is the expression used in the DSA.
It is observed that the single equality r=p establishes the validity of the message m as well as the validity of the public key YA (which was implicitly calculated by Bob).
The presented signature verification technique, including the implicit certificate verification, is executed by one operation of the form b_{*}A + d_{*}C + f_{*}E which is equivalent to a single ElGamal signature verification.
2.3. A modified DH fixedkeyagreement
A DH fixedkeyagreement concerns the basic implementation in which specific users always generate the same joint session key based on fixed exchanged values.
We present the following DH fixedkeyagreement technique.
After exchanging ITA and ITB, and the public values PUA and PUB, Alice and Bob respectively generate the session key KAB = xA_{*}(H(ITB,PUB)_{*}PUB + R) and
KBA = xB_{*}(H(ITA,PUA)_{*}PUA + R).
A keyconfirmation now follows. That is, the two users verify that they share an identical key by encrypting and decrypting a randomly selected value.
(The two keys equal, having the value xA_{*}xB_{*}G. This equality, in itself, does not prove yet that only the valid owners of PUA and PUB arrive at the value xA_{*}xB_{*}G. As shown later, the keyconfirmation closes the certification loop.)
The presented technique is executed by two exponentiations (or by one operation of the form b_{*}A + d_{*}C, by first calculating xA_{*}H(ITB,PUB) modulo the order of G).
2.4. A modified DH ephemeralkeyagreement
A DH ephemeralkeyagreement, as treated in Section 1.2, concerns an implementation in which two specific users generate a different session key whenever they communicate, based on an ephemeral value generated by each party.
We present the following DH ephemeralkeyagreement technique.
Alice generates a random pvA, calculates the ephemeral value EVA = pvA_{*}G and submits ITA, PUA and EVA to Bob.
Bob performs the symmetric operations.
Alice and Bob respectively generate the ephemeral session key
KAB = pvA_{*}(H(ITB,PUB)_{*}PUB + R) + (xA+pvA)_{*}EVB
KBA = pvB_{*}(H(ITA,PUA)_{*}PUA + R) + (xB+pvB)_{*}EVA
A keyconfirmation now follows.
(The two keys equal the value pvA_{*}xB_{*}G + xA_{*}pvB_{*}G + pvA_{*}pvB_{*}G. It is noted that the keys still equal if (xA+pvA)_{*}EVB and (xB+pvB)_{*}EVA are respectively replaced by xA_{*}EVB and xB_{*}EVA. The reasoning behind the presented choice follows in Part 4.)
KAB can be expressed as pvA_{*}R + [pvA_{*}H(ITB,PUB)]_{*}PUB + (xA+pvA)_{*}EVB. That is, KAB is calculated as an operation of the form b_{*}A + d_{*}C + f_{*}E. Furthermore, the grouppoint PA = pvA_{*}R can be calculated by Alice offline, together with EVA. (i.e., the random pvA and then EVA and PA can be generated prior to the communication with Bob.)
When Alice receives the values PUB and EVB, she can calculate [pvA_{*}H(ITB,PUB)]_{*}PUB + (xA+pvA)_{*}EVB and add PA to the result. This way, the complete process is executed by two offline exponentiations (the generation of EVA and PA) and one online operation of the form b_{*}A + d_{*}C, instead of the operation b_{*}A + d_{*}C + f_{*}E.
2.5. A modified MQV keyagreement
The static public keys used in an MQV keyagreement are submitted with a certificate. Since the certificate is a fixed value, it cannot provide in an implied way or any other way the dynamic certification needed for verifying the authenticity of the ephemeral value submitted by a user. This dynamic certification is essentially achieved by a keyconfirmation. We show next how the MQV version of Section 1.2 can be modified such that the keyconfirmation implicitly provides for certification of the static public keys YA and YB, on top of the implied certification of the ephemeral values EVA and EVB.
Alice calculates the scalar values pA = pvA + T(EVA)_{*}xA, qA = pA_{*}T(EVB)_{ } and rA = qA_{*}H(ITB,PUB). Bob calculates, symmetrically, the values pB, qB and rB. The session key is then KAB = pA_{*}EVB_{ }+ rA_{*}PUB + qA_{*}R and KBA = pB_{*}EVB_{ }+ rB_{*}PUB + qB_{*}R. The calculation of the session key is followed by a keyconfirmation.
A complete MQV keyagreement process is therefore performed here by one operation of the form b_{*}A + d_{*}C + f_{*}E.
To realize why KAB = KBA note that
KAB = (pvA + T(EVA)_{*}xA)_{*}(EVB + T(EVB)_{*}H(ITB,PUB)_{*}PUB + T(EVB)_{*}R) =
= (pvA + T(EVA)_{*}xA)_{*}(EVB_{ }+ T(EVB)_{*}(H(ITB,PUB)_{*}PUB + R)) =
(pvA +T(EVA)_{*}xA)_{*}(EVB + T(EVB)_{*}YB) = KBA
2.6. A further modification: the 'you are OK if I am OK' principle
Further modifying the DH fixedkeyagreement of Section 2.3.
The fixed session key generated by Alice and Bob according to the technique presented in Section 2.3 is, respectively,
KAB = xA_{*}(H(ITB,PUB)_{*}PUB + R) and KBA = xB_{*}(H(ITA,PUA)_{*}PUA + R).
These can be rewritten as
KAB = [xA_{*}H(ITB,PUB)]_{*}PUB + xA_{*}R and KBA = [xB_{*}H(ITA,PUA)]_{*}PUA + xB_{*}R.
Note that xA_{*}R is a fixed grouppoint which can be precalculated and stored by Alice. After receiving ITB and PUB Alice can calculate [xA_{*}H(ITB,PUB)]_{*}PUB and add the precalculated xA_{*}R to the result. Similar operations apply to Bob. The presented technique then facilitates the execution of a fixedkey agreement, including a mutual authentication of the participants, by a single exponentiation.
Further modifying the DH ephemeralkeyagreement of Section 2.4.
The ephemeral session key generated by Alice and Bob according to the technique presented in Section 2.4 is, respectively,
KAB = pvA_{*}(H(ITB,PUB)_{*}PUB + R) + (xA+pvA)_{*}EVB and
KBA = pvB_{*}(H(ITA,PUA)_{*}PUA + R) + (xB+pvB)_{*}EVA
These values can be rewritten as:
KAB = [pvA_{*}H(ITB,PUB)]_{*}PUB + (xA+pvA)_{*}(EVB + R)  xA_{*}R and
KBA = [pvB_{*}H(ITA,PUA)]_{*}PUA + (xB+pvB)_{*}(EVA + R)  xB_{*}R
As indicated before, the fixed grouppoint xA_{*}R can be precalculated and stored by Alice. When Alice receives ITB and PUB she can calculate [pvA_{*}H(ITB,PUB)]_{*}PUB + (xA+pvA)_{*}(EVB + R) and subtract the precalculated xA_{*}R from the result. Similar operations are performed by Bob. The presented technique can then be executed by one operation of the form b_{*}A + d_{*}C, which is preceded by the calculation of EVA = pvA_{*}G.
To further clarify the observations made next, let us assume that the value EVB + R, which appears in the expression of KAB, was calculated by Bob and not by Alice. That is, Bob transmits the value VB = EVB + R to Alice, instead of transmitting EVB. Alice then calculates KAB = [pvA_{*}H(ITB,PUB)]_{*}PUB + (xA+pvA)_{*}VB  xA_{*}R. Noting this expression, it is observed that the reference to the public key R of the trusted third party was effected prior to the communication of Alice with Bob. The same applies to the expression KAB = [xA_{*}H(ITB,PUB)]_{*}PUB + xA_{*}R specified above for the fixedkeyagreement.
After a successful keyconfirmation, Alice, who knows that her own personal keys xA and PUA are valid (i.e., they were provided to her by a recognized trusted third party), is assured that Bob has also used valid personal keys. This introduces a principle termed as 'you are OK if I am OK', where Alice can effect a keyagreement process with another party just by knowing that her own personal keys are valid, and without referring during the keyagreement process to the public key of a trusted third party.
The details discussed above concern the case where both parties use the services of the same trusted third party, and therefore refer to the same public key R. If Alice and Bob use the services of different trusted third parties, the saving in computational complexity based on the 'you are OK if I am OK' principle is still achieved if a participant knows in advance the public key of the trusted third party of his counterpart. Realistically, this is the case in most practical circumstances, as Bob must know the public key of Alice’s trusted third party regardless of his communication with Alice, and vice versa.
3. Claimed attributes and advantages of the technique
3.1. Savings in computational efforts
The savings in the computational efforts introduced by the presented techniques, when compared to customary DL/EC techniques, are summarized next in detail. These concern an overall saving in exponentiation operations, as well as parallelism which further expedites the process, where the traditional serial two operations associated with verifying a certificate and verifying the validity of a submitted dynamic value are combined into a single operation. The indicated figures were substantiated in the preceding sections.
The very significant advantages of the presented techniques, over customary techniques, are clear for the case where b_{*}A + d_{*}C or b_{*}A + d_{*}C + f_{*}E are executed by individual exponentiations as well as the case where speedup methods are used.
Verifying a signature of the DSA type
Customary implementation: Two operations of the form b_{*}A + d_{*}C, one for certificate verification and one for actual signature verification.
Presented technique: One operation of the form b_{*}A + d_{*}C + f_{*}E.
DH fixedkeyagreement
Customary implementation: One operation of the form b_{*}A + d_{*}C for certificate verification, and one exponentiation for sessionkey generation.
Presented technique: A single exponentiation (or two exponentiations when not using the “You are OK if I am OK’ principle).
DH ephemeralkeyagreement
Customary implementation: Three exponentiations (generating an ephemeral value, signing this value, and generating the sessionkey); two operations of the form b_{*}A + d_{*}C (verifying the certificate and the signature).
Presented technique: One exponentiation (generating the ephemeral value) and one operation of the form b_{*}A + d_{*}C (or one operation of the form b_{*}A + d_{*}C + f_{*}E when not using the “You are OK if I am OK’ principle).
MQV keyagreement
Customary implementation: One exponentiation (generating the ephemeral value); two operations of the form b_{*}A + d_{*}C (for certificate verification and sessionkey generation).
Presented technique: One exponentiation and one operation of the form b_{*}A + d_{*}C + f_{*}E.
3.2. Cutting down communication overhead
The presented techniques facilitate the replacement of separately submitted public key (which is a grouppoint), and a certificate (which is a DSA signature, consisting of a pair of scalars), by a single submitted value (a grouppoint), whose size is that of the public key. This significantly cuts down communication overhead.
3.3. Enhancing implementation efficiency and cutting down management overhead
Abolishing an explicit certification in keyagreement schemes saves a need to include a signature verification procedure in the execution package, enhancing implementation efficiency.
Furthermore, abolishing the need for generating, storing and submitting an explicit certificate significantly cuts down management overhead.
4. Security assessment and considerations
4.1. On the possibility of forging the user's keys defined in Section 2.1
1. Extracting the secret key of the trusted third party:
The secret key of the trusted third party is d, while R = d_{*}G is known. Users know multiple values of the form H(ITA,(hA+kA)_{*}G)_{*}kA + d, for known ITA, hA and (hA+kA)_{*}G. The trusted third party prevents the extraction of d by associating each user with a different, randomly generated, kA. It is further noted that the system secret d is revealed if H(ITA,(hA+kA)_{*}G)_{*}kA equals any fixed or known value (modulo the order of the generating grouppoint G). The trusted third party, who has control over H(ITA,(hA+kA)_{*}G)_{*}kA by choosing the random kA, should take care of this threat.
2. Preventing a “first party attack”:
A “first party attack” concerns the case where a user repudiates the validity of a cryptographic scenario in which he participated, claiming that he had “weak” secret keys which were mathematically discovered. The presented key issuing process inherently prevents such an attack, as the the trusted third party has control over the randomness of the user's secret key (while the trusted third party still does not know this key).
3. Generating values ITA, xA and PUA having a valid interdependence:
The validity of the presented technique depends on the inability of any party to generate values xA, ITA and PUA such that the interdependence xA_{*}G = H(ITA,PUA)_{*}PUA + R holds. That is, no party beside Alice (as defined in Section 2.1) should be able to submit values that stand for ITA and PUA such that he knows log[H(ITA,PUA)_{*}PUA + R].
It is first observed that a forger cannot know logPUA while he manufactured himself PUA, xA and ITA, where xA_{*}G = H(ITA,PUA)_{*}PUA + R, since he would then be able to recover logR, thereby being able to perform a general log operation.
There are three possible approaches in trying to falsify xA, ITA and PUA, while not knowing logPUA, such that xA_{*}G = H(ITA,PUA)_{*}PUA + R:
1. Select a PUA (whose log is not known) and a scalar xA, and then recover a scalar v such that R = xA_{*}G  v_{*}PUA. This attempt would fail as it would involve a log operation, regardless of the fact that v should also equal H(ITA,PUA).
2. Select a PUA, calculate H(ITA,PUA) and then recover a scalar xA such that xA_{*}G = H(ITA,PUA)_{*}PUA + R. This, again, would fail as it involves a log operation.
3. Select values v and xA and then determine the value_{ }PUA = v^{1}_{*}(xA_{*}G  R). Even if it is possible to recover a PUA such that v acts as H(ITA,PUA), PUA has to simultaneously satisfy two independent constraints, which appears to be impossible to achieve.
Trying to force (ITA,PUA)_{*}PUA = 0 (regardless of of whether this is possible or not), will also not help, since the forger then has to produce an xA such that xA_{*}G = R. That is, he has to perform a log operation.
It is therefore claimed that a user who illegally tries to present himself as Alice cannot generate values xA, ITA and PUA such that xA_{*}G = H(ITA,PUA)_{*}PUA + R.
A trial to generate valid values ITf, xf and PUf out of given valid values ITA, xA and PUA is not different from the above failed trials for generating ITA, xA and PUA from scratch.
It should further be demanded that the sum of two valid keys will not yield a valid key. This demand is satisfied if the transformation H is nonlinear.
4. Falsifying the role of the trusted third party:
As described in Section 2.1, Alice verifies the validity of the values pA and PUA, issued to her, by checking whether pA_{*}G = h(ITA,PUA)_{*}(PUAhA_{*}G) + R, where R is the public key of the trusted third party. Falsifying the role of the trusted third party involves here an ability to produce values pA and PUA such that pA = log[h(ITA,PUA)_{*}(PUAhA_{*}G) + R]. This cannot be done in view of the above considerations.
4.2. Summarizing the required features of H
The transformation H(ITA,PUA) can be a simple exor operation between ITA and any onetoone scalar representative of PUA. (When operating over an elliptic curve, this representative can be the x coordinate of PUA.)
It should be noted that a user can here make changes in both ITA and PUA, while keeping H(ITA,PUA) unchanged. That is, it is not demanded that H should be collisionfree. This is based on the observation that the change enforced into PUA (in order that H(ITA,PUA) remains unchanged for invalid ITA) would necessitate a corresponding change in the secret key xA = H(ITA,PUA)_{*}logPUA + d. The forger, who changed ITA, is then unable to come up with a correct new xA due to the new logPUA.
It is possible to use, in any case, the hash transformation which serves in general certification applications (where the certificate is the signature of the trusted party on a value H(ITA,PUA) which strongly combines the user’s identification details or attributes and his public key) while utilizing the significant advantages of the techniques presented in Part 3.
4.3. On the security of the modified DSA technique of Section 2.2
The difference between the certificateless DSA technique of Section 2.2 and a standard DSA lies in the fact that the public key YA of the signer is implicitly generated by the verifier, rather than being received with a certificate.
The operation P = v_{*}G + w_{*}YA, performed in the standard DSA procedure, is replaced with P = v_{*}G + w_{*}(H(ITA,PUA)_{*}PUA + R), which is technically executed by the parallel operation P = v_{*}G + [w_{*}H(ITA,PUA)]_{*}PUA + w_{*}R.
A forger does not know log[H(ITA,PUA)_{*}PUA + R] in view of preceding considerations. Also, he cannot submit ITA (pretending to be Alice) and his own forged public value PUf such that he knows log[H(ITA,PUf)_{*}PUf + R]. Therefore, the existence of the single equality r = p, which assures the verifier that the signer knows xA = logYA in the lines of the DSA, provides for two purposes. It establishes the validity of the signed message, based on the fundamental principle of the DSA, and it further establishes the signer’s valid ownership of the public key YA.
The main observation made above is summarized as follows: Alice’s ability to sign a message is based on her knowledge of the log of the public key she submits to Bob. In the presented technique, Alice’s public key is calculated by Bob, whereas Alice can know the log of that public key only if she is the valid owner of that key. That is, her knowledge of the log of the said public key is not only a necessary condition for Alice’s ability to sign the message, but it further guarantees her valid ownership of the key itself, whereas Alice’s knowledge of the said log is established by Bob by a single check.
4.4. On the security of the presented keyagreement techniques
The session key generated by the fixedkey technique of Section 2.3 is
KAB = xA_{*}(H(ITB,PUB)_{*}PUB + R) ; KBA = xB_{*}(H(ITA,PUA)_{*}PUA + R)
The session key generated by the ephemeralkey generation technique of Section 2.4 is
KAB = pvA_{*}(H(ITB,PUB)_{*}PUB + R) + (xA+pvA)_{*}EVB;
KBA = pvB_{*}(H(ITA,PUA)_{*}PUA + R) + (xB+pvB)_{*}EVA
The security of the technique depends again on the inability of a forger to know log[H(ITA,PUA)_{*}PUA + R] or log[H(ITB,PUB)_{*}PUB + R] or to falsify values in a way that enables him to know any of the said logs.
Only the valid Alice and Bob, who use their secret keys xA and xB, would then end up with the same session key, a fact which is established by the keyconfirmation.
Similar considerations apply to the modified MQV technique of Section 2.5.
The keyconfirmation concerns a single check made by each participant, enabling him to implicitly verify that his counterpart knows the log of the public key YA or YB, whereas the calculation of the public key is implied in the process. Like the case with the DSA, treated in the preceding Section, Alice’s knowledge of the log of the said public key, established by Bob by a single check, is not only a necessary condition for a successful DH keyagreement, but it further guarantees Alice’s valid ownership of her claimed public key.
Forward secrecy (concerning the ephemeralkey generation technique of Section 2.4)
Forward secrecy concerns the prevention of the possibility that the disclosure of any static secret value reveals session keys previously generated by two communicating parties. The said static value can either be the secret key of the trusted third party or users’ secret key or a secret value common to two or more specific communicating users.
It was shown that the generated ephemeral session key is KAB = KBA = pvA_{*}xB_{*}G + xA_{*}pvB_{*}G + pvA_{*}pvB_{*}G, where xA_{*}G, xB_{*}G, pvA_{*}G and pvB_{*}G are publicly known. A disclosure at any stage of xA and xB would not reveal the value of a previously generated KAB or KBA due to the addend pvA_{*}pvB_{*}G. This explains why it is preferred to use the expression KAB = pvA_{*}(H(ITB,PUB)_{*}PUB+R) + (xA+pvA)_{*}EVB rather than the expression KAB = pvA_{*}(H(ITB,PUB)_{*}PUB+R) + xA_{*}EVB which can also yield a valid key generation.
There are no static values common to two specific communicating users, whose disclosure reveals the value of previously generated session keys, as all the addends in the expression pvA_{*}(H(ITB,PUB)_{*}PUB + R) + (xA+pvA)_{*}EVB = pvA_{*}H(ITB,PUj)_{*}PUB + pvA_{*}R + xA_{*}pvB_{*}G + pvA_{*}pvB_{*}G are ephemeral. That is, a key does not consist of a static part, which is fixed to two specific communicating users, where this static part encrypts an ephemeral value, and where the later leakage of this static part would reveal the value of generated session keys.
5. Known limitations and disadvantages
In the proposed technique, the keys of the trusted third party and users’ keys are of the same size. This can be considered a disadvantage when compared to implementations in which explicit independent certification of users’ static keys is performed, and where the keys of the trusted third party can be made larger than users’ keys.
However, the described apparent disadvantage of the proposed technique is common to all systems offering implied key certification, including identitybased systems.
6. Intellectual property issues
A patent application on the proposed technique has been filed. A letter of assurance of “reasonable and nondiscriminatory” patent licensing will be provided if this technique is accepted as part of p1363a.
References
[1] Approval of Federal Information Processing Standards Publication 186, Digital Signature Standard (DSS), "Federal Register, v. 58, n. 96, 19 May 1994, pp. 2620826211.
[2] A. J. Menezes, P. C. van Oorschot and S. A. Vanstone, “Handbook of Applied Cryptography”, Chapter 14, pp. 617618, CRC Press, 1996.
[3] W. Diffie and M. Hellman, “New directions in cryptography”, IEEE Trans. on Information Theory, IT22, 1976, pp. 644654.
[4] Law, A. Menezes, M. Qu, J. Solinas and S. Vanstone, "An efficient protocol for authenticated key agreement”, Technical report CORR 9805, Dept. of C&O, University of Waterloo, Canada, March 1998.
