Implicit certificate

In cryptography, implicit certificates are a variant of public key certificate, such that a public key can be reconstructed from any implicit certificate, and is said then to be implicitly verified, in the sense that the only party who can know the associated private key is the party identified in the implicit certificate. This does not rule out the possibility that nobody knows the private key, but this possibility is not considered a major problem.

By comparison, traditional public-key certificates include a copy of the public key and the digital signature of the certification authority. Upon verification of the digital signature, the public key is explicitly verified, in the sense that the party identified in the certificate knows the associated private key and is the only party who can know the private key. Unlike an implicit certificate, there is no possibility that nobody knows the private key. For the purposes of this article, such certificates will be called explicit certificates.

Elliptic Curve Qu-Vanstone (ECQV) are one kind of implicit certificates. This article will use ECQV as a concrete example to illustrate implicit certificates.

The cryptographic portion of an ECQV implicit certificate is the size of an elliptic curve point, making it considerably smaller than a comparable explicit certificate. Smaller certificates are useful in highly constrained environments, such as Radio-frequency Identification RFID tags, where not a lot of memory or bandwidth is available.

Digital certificates are considered the best-known method of establishing identity in network communications. A certificate provides a binding between identity information and a public key; a key pair can subsequently be used for key exchange to set up secured communications and for digital signatures, to authenticate users or transactions for example.

Conventional explicit certificates are made up of three parts: identification data, a public key and a digital signature which binds the public key to the user’s identification data (ID). The digital certificate is created by a trusted third party and its signature can be independently verified by anyone in the network. The public key, ID and digital signature are distinct data elements which make the up the physical size of the certificate. Conventional certificates can get very large. For example, a standard X.509 certificate is on the order of 1KB in size (~8000 bits).

Implicit certificates carry the same data (ID, public key and digital signature) but the data elements are super imposed into a string the size of the public key. For example using an elliptic curve system at 160 bits would give us implicit certificates of size 160 bits.

With implicit certificates there is no explicit validation of the Certificate Authority's (CA’s) signature on a certificate. Instead, a user computes a public key from the implicit certificate and simply uses it in the intended ECC operation, e.g. key agreement protocols such as ECDH and ECMQV, or signing such as ECDSA. The operation will fail if the certificate is invalid. Thus ECQV is regarded as an implicit validation scheme. Computing the public key is very fast, much faster than a public key operation.

Generating implicit certificates

Initially the elliptic curve parameters must be agreed upon. We define $G \,$ as a generating point of order $n \,$ . The Certificate Authority (CA) will have private key $c \,$ and public key $Q_{CA} = cG \,$ . Alice will be the user who requests the implicit certificate from the CA.

Alice generates a random integer $\alpha \,$ and computes $\alpha\,G \,$ and sends that to the CA. The CA does all the rest.
CA Select a random integer $k \,$ from $[1, n-1] \,$ and computes $kG \,$ .
CA computes $\gamma = \alpha \,G + kG \,$ (this is the public key reconstruction data)
CA computes $Cert= \textrm{Encode} ( \gamma , \textrm{ID}_A ) \,$ is Alice's identifying information and $Encode \,$ is an encoding function
CA computes $e = \textrm{H}( Cert )$ , where $\textrm{H} \,$ is a cryptographic hash function, such as SHA
CA computes $s = ek + c \pmod{n} \,$ where $s \,$ is private key reconstruction data
CA sends $(s, Cert) \,$ to Alice

Alice’s private key is $a = e\alpha + s \pmod{n} \,$

Alice’s public key is $Q_A = e\gamma + Q_{CA} \,$

Computing the public-key from the implicit certificate

Computing Alice's public key $Q_A \,$ can be computed by any third party provided they know $\gamma \,$ , $\textrm{ID}_A \,$ and $Q_{CA} \,$ .

Note that the size of the implicit certificate $\gamma \,$ is the same size as Alice's public key $Q_{A} \,$ .

Security

A security proof for ECQV has been published by Brown et al.^[1]

References

↑ Brown, Daniel R. L.; Gallant, Robert P.; Vanstone, Scott A. (2001). "Provably Secure Implicit Certificate Schemes". Financial Cryptography 2001. Lecture Notes in Computer Science (Springer Berlin Heidelberg) 2339 (1): 156–165. doi:10.1007/3-540-46088-8_15. Retrieved 27 December 2015.

Hankerson, D.; Vanstone, S.; Menezes, A. (2004). Guide to Elliptic Curve Cryptography. Springer Professional Computing. New York: Springer. doi:10.1007/b97644. ISBN 0-387-95273-X.
Certicom Research, Standards for efficient cryptography, SEC 4: Elliptic Curve Cryptography, Draft document, November 11, 2006.
certicom.com, Explaining Implicit Certificates, Code and Cipher Vol. 2, no. 2
Leon Pintsov and Scott Vanstone, Postal Revenue Collection in the Digital Age, Financial Cryptography 2000, Lecture Notes in Computer Science 1962, pp. 105–120, Springer, February 2000.

External links

Standards for Efficient Cryptography Group
Blackberry Crypto API supports ECQV
Blackberry's Certicom Corp. uses ECQV for Zigbee Smart Energy

Public-key cryptography

Algorithms

Integer Factorization	Benaloh Blum–Goldwasser Cayley–Purser Damgård–Jurik GMR Goldwasser–Micali Paillier Rabin RSA Okamoto–Uchiyama Schmidt–Samoa

Discrete logarithm	Cramer–Shoup DH DSA ECDH ECDSA EdDSA EKE ElGamal signature scheme MQV Schnorr SPEKE SRP STS

Others	AE CEILIDH EPOC HFE IES Lamport McEliece Merkle–Hellman Naccache–Stern Naccache–Stern knapsack cryptosystem NTRUEncrypt NTRUSign Three-pass protocol XTR

Theory

Standardization

Topics

Cryptography

History of cryptography Cryptanalysis Outline of cryptography

Symmetric-key algorithm Block cipher Stream cipher Public-key cryptography Cryptographic hash function Message authentication code Random numbers Steganography

Portal

This article is issued from Wikipedia - version of the Monday, December 28, 2015. The text is available under the Creative Commons Attribution/Share Alike but additional terms may apply for the media files.