What really matters in a public key certificate? For practitioners looking at this problem for the first time, the answer is obvious: the issuer and subject public keys. But those familiar with X.509-based public key infrastructures could counter that the distinguished names of the issuer and subject alone provide enough information to verify a certificate chain.
The process of certificate path validation from an end-entity certificate of interest to a trusted root is the algorithmic foundation of establishing trust in public key systems. In turn, checking to determine whether a certificate has been revoked is just a function of the underlying algorithm.
The proposed IETF public key infrastructure standard, PKIX Part 1 [4], specifies the algorithm for determining whether a particular certificate chain is valid but does not describe how to discover certificate chains in the first place. Moreover, the semantics of PKIX certificate revocation are also underspecified, which puts crucial issues of meaning in the hands of individual implementations. In every case, the actual process of certificate revocation is deemed the responsibility of the signer even if it is at the request of the subscriber. In theory, the certificate authority has the most to lose with continued circulation of a bad certificate.
Let
C = c0, c1, ..., cn be a chain of certificates where cn is
the end-entity certificate of interest, c0 is a self-signed trusted
root certificate, and ck is signed by the subject of ck-1 for
all
k = 1,...,n. By definition, if any certificate ci in C is
revoked then C is not a valid chain. Assume that no ci in C is
revoked, and let
be a second chain of certificates from
cn to a trusted root (
), with
distinct from ck-1. Certificates ck-1 and
have the same subject public key (the issuer of the statement in ck).
Now, because revocation in the PKIX model applies to a particular
certificate, it is possible to revoke
without
revoking ck-1. Then chain
is an invalid chain while
C is still valid. Is this consistent? It depends on the semantics of
the revocation. The certificate
is a statement by an
issuer
that binds together subject
name
and a subject public key
.
That is:
So, revoking
(e.g. adding
to a
``certificate revocation list'' (CRL) signed by
)
could mean ``UNDO'' any of the following:
Each of these cases means something different, and chain processing in the presence of revocation information acts differently in each case.
Consider the first case (a) above, where revocation of
denotes compromise of the subject public key. In this
case, the fact that
is revoked should cause all certificate paths that involve the subject public key
to no longer be valid. So, not only is
now invalid, but C itself is now invalid as:
Case (b), direct revocation of the subject name-subject public key
binding by the issuer, is a fuzzier situation. If the subject names in
the two certificates ck-1 and
are distinct (i.e.
)
then revocation of
should have no impact on acceptance of ck-1itself. That is, chain
is invalid because of the
revocation but C is still a perfectly valid chain. Notice, however,
that if the subject names in the two certificates are equal then
relying parties could reasonably choose to reject C (or at least
suspect it) if the name information
is important to their particular application.
Finally, in case (c) we have revocation of certificate
because the issuer of that certificate no longer has a relationship with the
subject public key. Revocation here speaks not to the validity of the
name-key binding but rather to a lack of contractual obligation. Revocation
of
should not in any way impact chain C as there is no
authorization statement from the issuer of
concerning the
validity of the subject public key
itself (which
would make it case (a)) or the name-key binding (case (b)).
The fact that the act of revoking a particular certificate needed to be qualified with intended semantics was recognized by the authors of the X.509 standard. In X.509 Version 2 Certificate Revocation Lists (CRLs), it is possible to include a reason code extension on each and every entry in the CRL. Reason codes are semantics modifiers and can specify situations such as:
Thus, one could conceivably decide whether a particular revocation fell into cases (a)-(c) above based on reason code, assuming one was present in the CRL and that each possible reason code could be assigned to a particular case. (This is not currently true in the PKIX specification as some reason codes have semantics orthogonal to the separation described above. For example, reason code 6, ``certificateHold,'' means that the certificate in question has been ``suspended'' pending the outcome of some process. Clearly the suspended certificate could fall into any of cases (a)-(c).)
Even if reason codes were always present (which is not required by PKIX) and defined to fall into exactly one semantic category for meaning, they only solve the problem if this information is always available to the chain-building algorithm. This is clearly not the case, as any revocation that falls into case (a) (including reason code 1, ``keyCompromise'') may impact certificate chains that do not include the particular revoked certificate. Thus, until we come up with a better mechanism for moving revocation information around, and binding that revocation information to the proper statement being undone by the revocation, use of revocation information can add significant ambiguity to the chain-building process.