Traceable Anonymous Certificate
RFC 5636
| Document | Type |
RFC - Experimental
(August 2009; Errata)
Was draft-ietf-pkix-tac (pkix WG)
|
|
|---|---|---|---|
| Authors | Sanghwan Park , Yoojae Won , Jaeil Lee , Stephen Kent , Haeryong Park | ||
| Last updated | 2019-12-13 | ||
| Stream | Internet Engineering Task Force (IETF) | ||
| Formats | plain text html pdf htmlized bibtex | ||
| Reviews | |||
| Stream | WG state | (None) | |
| Document shepherd | No shepherd assigned | ||
| IESG | IESG state | RFC 5636 (Experimental) | |
| Action Holders |
(None)
|
||
| Consensus Boilerplate | Unknown | ||
| Telechat date | |||
| Responsible AD | Tim Polk | ||
| Send notices to | (None) | ||
Network Working Group S. Park
Request for Comments: 5636 H. Park
Category: Experimental Y. Won
J. Lee
KISA
S. Kent
BBN Technologies
August 2009
Traceable Anonymous Certificate
Abstract
This document defines a practical architecture and protocols for
offering privacy for a user who requests and uses an X.509
certificate containing a pseudonym, while still retaining the ability
to map such a certificate to the real user who requested it. The
architecture is compatible with IETF certificate request formats such
as PKCS10 (RFC 2986) and CMC (RFC 5272). The architecture separates
the authorities involved in issuing a certificate: one for verifying
ownership of a private key (Blind Issuer) and the other for
validating the contents of a certificate (Anonymity Issuer). The end
entity (EE) certificates issued under this model are called Traceable
Anonymous Certificates (TACs).
Status of This Memo
This memo defines an Experimental Protocol for the Internet
community. It does not specify an Internet standard of any kind.
Discussion and suggestions for improvement are requested.
Distribution of this memo is unlimited.
Copyright Notice
Copyright (c) 2009 IETF Trust and the persons identified as the
document authors. All rights reserved.
This document is subject to BCP 78 and the IETF Trust's Legal
Provisions Relating to IETF Documents in effect on the date of
publication of this document (http://trustee.ietf.org/license-info).
Please review these documents carefully, as they describe your rights
and restrictions with respect to this document.
Park, et al. Experimental [Page 1]
RFC 5636 Traceable Anonymous Certificate August 2009
Table of Contents
1. Introduction ....................................................2
1.1. Conventions Used in This Document ..........................4
2. General Overview ................................................4
3. Requirements ....................................................5
4. Traceable Anonymous Certificate Model ...........................6
5. Issuing a TAC ...................................................7
5.1. Steps in Issuing a TAC .....................................8
5.2. Mapping a TAC to a User's Real Identity ...................15
5.3. TAC Request Message Format Profile ........................17
5.3.1. PKCS10 Profile .....................................17
5.3.2. CMC Profile ........................................18
6. Security Considerations ........................................19
7. Acknowledgments ................................................21
8. References .....................................................21
8.1. Normative References ......................................21
8.2. Informative References ....................................22
Appendix A. Traceable Anonymous Certificate ASN.1 Modules .........24
Appendix B. TAC Message Exchanges over Transport Layer Security ...26
B.1. Message Exchanges between a User and the BI or the AI .....26
B.2. Message Exchanges between the BI and the AI ...............27
B.3. Message Exchanges between the Aggrieved Party and the AI
or the BI .................................................27
Appendix C. Cryptographic Message Syntax Profile for TAC Token ....28
C.1. Signed-Data Content Type ..................................28
C.1.1. encapContentInfo ...................................29
C.1.2. signerInfos ........................................29
1. Introduction
Public Key Infrastructure (PKI) provides a powerful means of
authenticating individuals, organizations, and computers (e.g., web
servers). However, when individuals use certificates to access
resources on the public Internet, there are legitimate concerns about
personal privacy, and thus there are increasing demands for privacy-
enhancing techniques on the Internet.
In a PKI, an authorized entity such as a Certification Authority (CA)
or a Registration Authority (RA) may be perceived, from a privacy
perspective, as a "big brother", even when a CA issues a certificate
containing a Subject name that is a pseudonym. This is because such
entities can always map a pseudonym in a certificate they issued to
the name of the real user to whom it was issued. This document
defines a practical architecture and protocols for offering privacy
for a user who requests and uses an X.509 certificate containing a
pseudonym, while still retaining the ability to map such a
certificate to the real user who requested it.
Park, et al. Experimental [Page 2]
RFC 5636 Traceable Anonymous Certificate August 2009
A PKI typically serves to identify the holder of a private key (to
the corresponding public key in a certificate), in a standard
fashion. The public key, identity, and related information are
signed by an entity acting as a CA as specified in X.509 [11] and as
profiled for use in the Internet [2]. During the past decade, PKIs
have been widely deployed to support various types of communications
and transactions over the Internet.
However, with regard to privacy on the Internet, a PKI is generally
not supportive of privacy, at least in part because of the following
issues:
- A certificate typically contains in the Subject field the true
identity of the user to whom it was issued. This identity is
disclosed to a relying party (e.g., a web site or the recipient of
an S/MIME message [18]) whenever the certificate holder presents
it in a security protocol that requires a user to present a
certificate. In some protocols, e.g., TLS, a user's certificate
is sent via an unencrypted channel prior to establishing a secure
communication capability.
- A certificate often is published by the CA, for example, in a
directory system that may be widely accessible.
- An anonymous (end entity) certificate [9] is one that indicates
that the holder's true identity is not represented in the subject
field. (Such a certificate might more accurately be called
"pseudonymous" since an X.509 certificate must contain an
identifier to comply with PKI format standards, and a CA must not
issue multiple certificates with the same Subject name to
different entities. However, we use the more common term
"anonymous" throughout this document to refer to such
certificates.) Issuance of anonymous certificates could enhance
user privacy.
There is however, a need to balance privacy and accountability when
issuing anonymous certificates. If a CA/RA is unable to map an
anonymous certificate to the real user to whom it was issued, the
user might abuse the anonymity afforded by the certificate because
there would be no recourse for relying parties.
A CA or RA generally would be able to map an anonymous certificate to
the user to whom it was issued, to avoid such problems. To do so,
the CA/RA would initially identify the user and maintain a database
that relates the user's true identity to the pseudonym carried in the
certificate's Subject field.
Park, et al. Experimental [Page 3]
RFC 5636 Traceable Anonymous Certificate August 2009
In a traditional PKI, there is a nominal separation of functions
between a RA and a CA, but in practice these roles are often closely
coordinated. Thus, either the RA or CA could, in principle,
unilaterally map an autonomous certificate to the real user identity.
The architecture, syntax, and protocol conventions described in this
document allow anonymous certificates to be issued and used in
existing PKIs in a way that provides a balance between privacy and a
conditional ability to map an anonymous certificate to the individual
to whom it was issued.
An anonymous certificate (Traceable Anonymous Certificate) in this
document is issued by a pair of entities that operate in a split
responsibility mode: a Blind Issuer (BI) and an Anonymity Issuer
(AI). The conditional traceability offered by this model assumes
strong separation between the RA and CA roles, and employs technical
means (threshold cryptography and "blinded" signatures), to
facilitate that separation. (A blinded signature is one in which the
value being signed is not made visible to the signer, via
cryptographic means. Additional details are provided later.)
The AI has knowledge of the certificate issued to the user, but no
knowledge of the user's real identity. The BI knows the user's real
identity, but has no knowledge of the certificate issued to that
user. Only if the AI and BI collaborate can they map the TAC issued
to a user to the real identity of that user.
1.1. Conventions Used in This Document
The key words "MUST", "MUST NOT", "REQUIRED", "SHALL", "SHALL NOT",
"SHOULD", "SHOULD NOT", "RECOMMENDED", "MAY", and "OPTIONAL" in this
document are to be interpreted as described in RFC 2119 [1].
2. General Overview
This section defines the notion of a Traceable Anonymous Certificate
(referred to as TAC or anonymous certificate in this document). It
is distinguished from a conventional pseudonymous certificate [8, 9]
in that a TAC containing a pseudonym in the Subject field will be
conditionally traceable (as defined that it is not trivial to design
a system that issues anonymous certificates, consistent with Internet
PKI standards, when additional constraints are imposed, as
illustrated by the following scenarios.
- If a CA issues an anonymous certificate without verifying a true
identity, it is untraceable, which provides inadequate recourse if
the user to whom the certificate was issued abuses the anonymity
it provides. (Even without the ability to trace an anonymous
Park, et al. Experimental [Page 4]
RFC 5636 Traceable Anonymous Certificate August 2009
certificate to the corresponding user, the certificate can always
be revoked, but this may not be a sufficient response to abuse.)
- If a CA issues an anonymous certificate but verifies the real
identity and maintains a record of that identity, the CA can link
the pseudonym in the Subject field to the real identity, hence a
potential "big brother" problem [12].
- If the CA issues a certificate with a certificate containing a
user-selected Subject name, and does not verify the user's
identity, the certificate is effectively untraceable.
- If the CA issues an anonymous certificate using a blind signature
(see below), the CA cannot verify the contents of the certificate,
making the certificate untraceable and essentially forgeable. (If
a CA signs a certificate without examining its content, even after
verifying a user's identity, certificates issued by the CA are
essentially forgeable.)
To address the issues described above, we extend the simple
separation-of-authority concept already defined in the RA/CA PKI
model. First we restate the requirements in a more precise and
concise fashion, and introduce a basic model for achieving the goals
from a more general perspective [16].
3. Requirements
This document describes a new separation-of-authority model and
protocols for certificate issuance in a way that enables issuing
Traceable Anonymous Certificates, while maintaining compatibility
with the standards used in existing PKIs. To do this, the following
requirements must be satisfied.
- The Traceable Anonymous Certificate MUST be a syntactically valid
X.509 certificate in which the Subject field contains a pseudonym.
- There must be technical means to counter a claim by a malicious
user who later denies having participated in the activities that
resulted in issuing a TAC. Specifically, when a user is
identified and requests issuance of a TAC, the mechanisms employed
MUST ensure that the user to whom the TAC is issued is the one who
requested the TAC (unless that user transfers the private key to
another party, unknown to the RA/CA).
Park, et al. Experimental [Page 5]
RFC 5636 Traceable Anonymous Certificate August 2009
- The traceability and revocation functions MUST support the linkage
between a user's true identity and the pseudonym in a certificate
issued to the user. Thus, the solution MUST enable determining a
true identity from the anonymous certificate, upon agreement among
the authorities who collaborated to issue the certificate.
4. Traceable Anonymous Certificate Model
A TAC is an end entity (EE) certificate issued by a pair of entities
that operate in a split responsibility mode: a Blind Issuer (BI) and
an Anonymity Issuer (AI). The pair appear as a single CA to the
outside world, e.g., they are represented by a single CA certificate.
The public key in the CA certificate is used to verify certificates
issued by this CA in the normal fashion, i.e., a relying party
processes a TAC just like any other EE certificates.
In this model, the BI acts as a RA. It interacts with a user to
verify the user's "real" identity, just like a normal RA. The BI
maintains a database that can be used to map a TAC to the user to
whom it was issued, but only with the cooperation of the AI.
This mapping will be initiated only if there is evidence that the
user to whom the TAC was issued has abused the anonymity provided by
the TAC.
The AI acts as a CA. It validates a certificate request submitted by
the user, using a standard certificate request format such as PKCS10.
The AI performs the functions common to a CA, including a private-key
proof-of-possession (PoP) check, a name uniqueness check among all
certificates issued by it, assignment of a serial number, etc. To
effect issuance of the TAC, the AI interacts with the BI, over a
secure channel, to jointly create the signature on the TAC, and sends
the signed TAC to the user.
The AI does this without learning the user's real identity (either
from the user or from the BI).
The result of this split functionality between the BI and the AI is
that neither can unilaterally act to reveal the real user identity.
The AI has knowledge of the certificate issued to the user, but no
knowledge of the user's real identity. The BI knows the user's real
identity, but has no knowledge of the certificate issued to that
user. Only if the AI and BI collaborate can they map the TAC issued
to a user to the real identity of that user.
This system is not perfect. For example, it assumes that the AI and
BI collaborate to reveal a user's real identity only under
appropriate circumstances. The details of the procedural security
Park, et al. Experimental [Page 6]
RFC 5636 Traceable Anonymous Certificate August 2009
means by which this assurance is achieved are outside the scope of
this document. Nonetheless, there are security benefits to adopting
this model described in this document, based on the technical
approach used to enable separation of the BI and AI functions.
For example, the BI and AI can be operated by different organizations
in geographically separate facilities, and managed by different
staff. As a result, one can have higher confidence in the anonymity
offered to a user by the system, as opposed to a monolithic CA
operating model that relies only on procedural security controls to
ensure anonymity.
5. Issuing a TAC
The follow subsections describe the procedures and the protocols
employed to issue a TAC. To begin, BI and AI collaborate to generate
a public key pair (that represents the CA as seen by relying parties)
using a threshold signature scheme. Such schemes have been defined
for RSA. The details of how this is accomplished depend on the
algorithm in question, and thus are not described here. The reader
is referred to [15] where procedures for implementing RSA threshold
signatures are described. A DSA-based threshold signature scheme
will be incorporated into a future version of TAC [14].
Note that this split signing model for certificate issuance is an
especially simple case of a threshold signature; the private key used
to sign a TAC is divided into exactly two shares, one held by the BI
and one held by the AI. Both shares must be used, serially, to
create a signature on a TAC. After the key pair for the (nominal) CA
has been generated and the private key split between the BI and the
AI, the public key is published, e.g., in a self-signed certificate
that represents the TAC CA.
Another public-key cryptographic function that is an essential part
of this system is called "blind signing". To create a blind
signature, one party encrypts a value to be signed, e.g., a hash
value of a certificate, and passes it to the signer. The signer
digitally signs the encrypted value, and returns it to the first
party. The first party inverts the encryption it applied with the
random value in the first place, to yield a signature on the
underlying data, e.g., a hash value.
This technique enables the signer to digitally sign a message,
without seeing the content of the message. This is the simplest
approach to blind signing; it requires that the public key needed to
invert the encryption not be available to the blind signer. Other
blind signing techniques avoid the need for this restriction, but are
more complex.
Park, et al. Experimental [Page 7]
RFC 5636 Traceable Anonymous Certificate August 2009
The tricky part of a cryptographic blinding function is that is must
be associative and commutative, with regard to a public-key signature
function. Let B be a blinding function, B-INV is its inverse, and S
is a public-key signature. The following relationship must hold:
B-INV( S (B (X) ) ) = B-INV( B( S (X) ) ) = S (X). RSA can be used
to blind a value with random value and to sign a blinded value
because the modular exponentiation operation used by RSA for both
signature and for encryption is associative and commutative.
The TAC issuance process described below requires an ability for the
BI, the AI, and the user to employ secure communication channels
between one another.
Use of TLS [17] is one suitable means to establish such channels,
although other options also are acceptable. To this end, this
document assumes TLS as the default secure communication channel, and
thus requires that the BI and the AI have X.509 certificates that
represent them.
These certificates are independent of the certificate that represents
the CA (formed by the BI and the AI) and may be either self-signed or
issued by other CA(s).
Appendix B provides a top-level description of the application of TLS
to these message exchanges.
5.1. Steps in Issuing a TAC
Figure 1 depicts the procedures for issuing a TAC. The lines
represent steps in the issuance process, and the numbers refer to
these steps.
1 +---------------+
+<-------->| Blind |
| 2 | Issuer (BI)|
| +---------------+
+-------+ | ^
| user |<------------>| 4 | 5
+-------+ | v
| 3 +----------------+
+--------->| |
| | Anonymity |
| | Issuer (AI) |
+<-------- | |
6 +----------------+
Figure 1. TAC Issuance Procedures
Park, et al. Experimental [Page 8]
RFC 5636 Traceable Anonymous Certificate August 2009
Step 1:
A user authenticates himself to the BI. This may be effected via
an in-person meeting or electronically. The same sorts of
procedures that RAs use for normal certificate issuance are used
here. Such procedures are not standardized, and thus they are not
described here in detail. For purposes of the TAC architecture,
we require the BI to establish a record in a database for the user
and to generate a (locally) unique identifier, called the UserKey,
that will serve as a (database) key for the record. The UserKey
value MUST NOT be generated in a fashion that permits any external
entity (including the AI) to infer a user's real identity from its
value. (For example, if the user's name is used as an input to a
one-way hash algorithm to generate the UserKey value, then
additional random data must be used as an input to prevent simple
guessing attacks.) Associated with the UserKey in this database is
an expiration time. The expiration time is used by the BI and AI
to reject session-level replay attacks in some exchanges, and to
enable the BI and AI to garbage-collect database records if a user
initiates but does not complete the certificate request process.
It is RECOMMENDED that the UserKey be a random or pseudo-random
value. Whenever the BI passes a UserKey to an external party, or
accepts the UserKey from an external party (e.g., the AI), the
value is embedded in a digitally signed CMS object called a Token,
accompanied by the timestamp noted above. The signature on a
Token is generated by the BI. (Note that the certificate used is
just a certificate suitable for use with CMS, and is NOT the
split-key certificate used to verify TAC.)
The following ASN.1 syntax represents the UserKey and an
expiration time:
UserKey ::= OCTET STRING
Timeout ::= GeneralizedTime
In the context of this specification, the GeneralizedTime value
MUST be expressed in Greenwich Mean Time (Zulu) and MUST include
seconds (YYYYMMDDHHMMSSZ).
Step 2:
BI presents to the user a data structure called a Token. The
Token must be conveyed to the user via a secure channel, e.g., in
person or via a secure communication channel. The secure channel
is required here to prevent a wiretapper from being able to
Park, et al. Experimental [Page 9]
RFC 5636 Traceable Anonymous Certificate August 2009
acquire the Token. For example, if the user establishes a one-way
authenticated TLS session to the BI in Step 1, this session could
be used to pass the Token back to the user.
The Token serves two purposes. During TAC issuance, the Token is
used to verify that a request to the AI has been submitted by a
user who is registered with the BI (and thus there is a record in
the BI's database with the real identity of the user). This is
necessary to ensure that the TAC can later be traced to the user.
If there is a request to reveal the real identity of a user, the
AI will release the Token to the entity requesting that a TAC be
traced, and that entity will pass the Token to the BI, to enable
tracing the TAC. If the BI does not perform its part of the
certificate issuance procedure (in Step 6) before the Token
expires, the BI can delete the Token from the database as a means
of garbage collection. The timeout value in a Token is selected
by the BI.
The Token is a ContentInfo with a contentType of id-kisa-tac-token
and a content that holds a SignedData of CMS SignedData object
[6], signed by the BI, where the eContent
(EncapsulatedContentInfo) is a SEQUENCE consisting of the UserKey
and Timeout, and eContentType MUST be id-data.
EncapsulatedContentInfo ::= SEQUENCE {
eContentType ContentType, -- OBJECT IDENTIFIER : id-data
eContent [0] EXPLICIT OCTET STRING OPTIONAL }
-- DER encoded with the input of 'SEQUENCE of the UserKey and
-- Timeout'
id-data OBJECT IDENTIFIER ::= { iso(1) member-body(2) us(840)
rsadsi(113549) pkcs(1) pkcs7(7) 1 }
The signature (SignatureValue of SignerInfo) is generated using
the BI's private signature key, corresponding to the public key
present in the BI's certificate. (Note that this certificate is
just a certificate suitable for use with TLS, and is NOT the
split-key certificate used to verify a TAC.) The certificate (or
certificates) MUST be present. Appendix A provides the ASN.1
syntax for the Token, as a profiled CMS ContentInfo object.
Appendix C provides the CMS SignedData object profile for wrapping
the Token.
Token ::= ContentInfo
Upon receipt of the Token, the user SHOULD verify the signature
using the BI public key and note the Timeout value to ensure that
the certificate request process is completed prior to that time.
Park, et al. Experimental [Page 10]
RFC 5636 Traceable Anonymous Certificate August 2009
Step 3:
The user prepares a certificate request in a standard format,
e.g., PKCS10 [3] or CMC [4]. The Subject field of the certificate
contains a pseudonym generated by the user. It is anticipated
that the CA (BI + AI) may provide software for users to employ in
constructing certificate requests.
If so, then this software can generate a candidate Subject name to
minimize the likelihood of a collision. If the user selects a
candidate pseudonym without such support, the likelihood of a
subject name collision probably will be greater, increasing the
likelihood that the certificate request will be rejected or that
the AI will have to generate a pseudonym for the user.
After constructing the certificate request, the user sends it,
along with the Token from Step 2, to the AI, via a secure channel.
This channel MUST be encrypted and one-way authenticated, i.e.,
the user MUST be able to verify that it is communicating with the
AI, but the AI MUST NOT be able to verify the real identity of the
user. Typical use of TLS for secure web site access satisfies
this requirement. The certificate request of PKCS10 [3] or CMC
[4] carries the Token from Step 2.
The Token is carried as an attribute in a certificate request
(CertificationRequestInfo.attributes) where the attrType MUST be
id-kisa-tac below in PKCS10 format. The Token is set to
attrValues (Certificate Request Controls) where the attrType MUST
be id-kisa-tac in CMC [4] format. The TAC request message profile
is described in the section 5.3.
Step 4:
The AI, upon receipt of the certificate request containing a
Token, verifies that the request is consistent with the processing
defined for the request format (PKCS10). If a Subject name is
present, it verifies that the proposed pseudonym is unique. The
AI also verifies the signature on the Token and, if it is valid,
checks the Timeout value to reject a replay attack based on a
"timed-out" Token.
A Token with an old Timeout value is rejected out-of-hand by the
AI. (After a Token's Timeout time is reached, the AI deletes the
Token from its cache.) Next, the AI compares the received Token
against a cache of recent (i.e., not "timed out"), validated
Tokens. The AI matches the resubmitted request to the original
request, and responds accordingly. For example, if a duplicate is
detected, the certificate request can be rejected as a replay.
Park, et al. Experimental [Page 11]
RFC 5636 Traceable Anonymous Certificate August 2009
If the Subject field contains a Subject name already issued by the
AI, the AI MUST either reject the certificate request, or
substitute a pseudonym it generates, depending on the policy of
the TAC CA. If the certificate request is acceptable, the AI
assigns a serial number and constructs a tbsCertificate (i.e., the
final form of the certificate payload, ready to be signed).
The AI then computes a hash over this data structure and blinds
the hash value. (The AI blinds the hash value using a key from a
public-key encryption pair where neither key is ever made public.
The other key from this pair is used by the AI in Step 6 to "un-
blind" the signed hash value.)
The AI sends the CMS ContentInfo object of TokenandBlindHash to
the BI, via a two-way authenticated and encrypted channel. The
two-way authentication and encryption is required to ensure that
the AI is sending these values to the BI, to allow the BI to
verify that the values were transmitted by the AI, and to prevent
a wiretapper from acquiring the Token. A TLS session in which
both parties employ certificates to authenticate one another is
the RECOMMENDED way to achieve this communication.
The TokenandBlindHash is a CMS ContentInfo with a contentType of
id-kisa-tac-tokenandblindhash and a content that holds a
SignedData of CMS SignedData object [6], signed by the AI, where
the eContent (EncapsulatedContentInfo) is a SEQUENCE consisting of
the Token and BlindedCertificateHash, and eContentType MUST be
id-data.
EncapsulatedContentInfo ::= SEQUENCE {
eContentType ContentType, -- OBJECT IDENTIFIER : id-data
eContent [0] EXPLICIT OCTET STRING OPTIONAL }
-- DER encoded with the input of 'SEQUENCE of the Token and
-- BlindedCertificateHash'
The signature (SignatureValue of SignerInfo) is generated using
the AI's private signature key, corresponding to the public key
present in the AI's certificate. (Note that this certificate is
just a certificate suitable for use with TLS, and is NOT the
split-key certificate used to issue a TAC.) The certificate (or
certificates) MUST be present.
The following ASN.1 syntax represents the Token and
BlindedCertificateHash:
Token ::= ContentInfo
BlinedCertificateHash ::= OCTET STRING
Park, et al. Experimental [Page 12]
RFC 5636 Traceable Anonymous Certificate August 2009
Token is the value of ContentInfo in the certificate request
message (CertificationRequestInfo.attributes) from Step 3.
BlindedCertificateHash is the blinded hash value for the
tbsCertificate.
Appendix A provides the ASN.1 syntax for the Token, as a profiled
CMS ContentInfo object. Appendix C provides the CMS SignedData
object profile for wrapping the Token.
TokenandBlindHash ::= ContentInfo
Step 5:
The BI receives the Token and blinded certificate hash via the
secure channel described above. First the BI verifies the
signature on the TokenandBlindHash generated by AI and then
verifies the signature on the Token to ensure that it is a
legitimate Token generated by the BI. Next, the BI checks its
database to ensure that the UserKey value from the Token is
present and that the Token has not been used to authorize issuance
of a certificate previously.
This check is performed to ensure that the BI has authenticated
the user and entered the user's real identity into the BI's
database. Each Token authorizes issuance of only one certificate,
so the check also ensures that the same Token has not been used to
authorize issuance of more than one certificate. These checks
ensure that the certificate issued by the AI to this user will be
traceable, if needed.
The BI uses its share of the threshold private signature key to
sign the blinded certificate hash and returns the CMS SignedData
back to the AI. The eContent of the SignedData is a SEQUENCE
consisting of the Token and PartiallySignedCertificateHash.
The following ASN.1 syntax represents the Token and
PartiallySignedCertificateHash:
Token ::= ContentInfo
PartiallySignedCertificateHash ::= OCTET STRING
Token is the token value of the TokenandBlindHash (where the
eContent is a SEQUENCE consisting of the Token and
PartiallySignedCertificateHash) from Step 4.
Park, et al. Experimental [Page 13]
RFC 5636 Traceable Anonymous Certificate August 2009
PartiallySignedCertificateHash is the signature value generated by
BI's share of the threshold private signature key on
BlindedCertificateHash from Step 4.
The TokenandPartiallySignedCertificateHash is a CMS ContentInfo
with a contentType of id-kisa-tac-tokenandpartially and a content
that holds a SignedData of CMS SignedData object [6], signed by
the BI, where the eContent (EncapsulatedContentInfo) is a SEQUENCE
consisting of the Token and PartiallySignedCertificateHash, and
eContentType MUST be id-data.
EncapsulatedContentInfo ::= SEQUENCE {
eContentType ContentType, -- OBJECT IDENTIFIER : id-data
eContent [0] EXPLICIT OCTET STRING OPTIONAL }
-- DER encoded with the input of 'SEQUENCE of the Token and
-- PartiallySignedCertificateHash'
The signature (SignatureValue of SignerInfo) is generated using
the BI's private signature key, corresponding to the public key
present in the BI's certificate. (Note that this certificate is
just a certificate suitable for use with TLS, and is NOT the
split-key certificate used to issue a TAC.) The certificate (or
certificates) MUST be present. Appendix A provides the ASN.1
syntax for the Token, as a profiled CMS SignedData object.
Appendix C provides the CMS SignedData object profile for wrapping
the Token.
TokenandPartiallySignedCertificateHash ::= ContentInfo
Step 6:
Upon receipt of the TokenandPartiallySignedCertificateHash, the AI
verifies the signature on the PartiallySignedCertificateHash,
generated by BI and then matches the Token against its list of
outstanding requests to the BI. The AI then "un-blinds" the
blindHashValue, using the other key from the key pair employed in
Step 4. This reveals the partially signed certificate hash. The
AI then applies its part of the split private key to complete the
signature of the certificate for the user.
It records the certificate and the Token value in its database, to
enable later tracing of the certificate to the real user identity,
if needed. The AI transmits the completed certificate to the
user, via the response message from the request protocol employed
by the user in Step 3, PKCS10.
Park, et al. Experimental [Page 14]
RFC 5636 Traceable Anonymous Certificate August 2009
The user may now employ the certificate with any PKI-enabled
application or protocol that makes use of X.509 certificates
(consistent with the key usage, and Extended Key Usage (EKU)
values in the certificate). Note that the user should be prepared
to accommodate delays in the certificate issuance process. For
example, a connection between the user and the AI might fail
sometime after the user submits a certificate request at the end
of Step 3 and before the AI returns the certificate at the end of
Step 6. If this happens, the user should resubmit the request.
The AI and BI retain sufficient state to be able to match the
resubmitted request to the original request, and respond
accordingly. If the process failed in steps 5 or 6, the AI
returns an error indication to the user.
5.2. Mapping a TAC to a User's Real Identity
If a user to whom a TAC has been issued abuses the anonymity provided
by the TAC, the TAC can be traced to the identity of that user.
Mapping a TAC to a user's real identity is a four-step process,
described below and illustrated in Figure 2.
C +---------------+
+<-------->| Blind |
| D | Issuer (BI)|
| +---------------+
+---------+ |
| Relying |<---------->|
| Party | |
+---------+ |
| A +----------------+
+<-------->| Anonymity |
B | Issuer (AI) |
+----------------+
Figure 2. Revealing a TAC User's Real Identity
Step A:
The AI verifies the assertion by an aggrieved party that a TAC
user has abused the anonymity provided by his TAC. The procedures
used by AI to verify that such abuse has occurred are outside the
scope of this document. No protocol is defined here for the
interaction between the aggrieved party and AI. The only
technical requirement is that the TAC of the offending user be
provided to the AI. If the AI determines that there is sufficient
evidence of abuse to trace the TAC to the user, the AI revokes the
TAC, by listing its serial number on the next Certificate
Revocation List (CRL) issued by the AI.
Park, et al. Experimental [Page 15]
RFC 5636 Traceable Anonymous Certificate August 2009
An AI unilaterally manages the CRL for a TAC. Because RFC 5280
implementations are not required to process indirect CRLs, we
create a second certificate for the CA, under the TAC CA. Revoked
EE certificates issued by the TAC CA are recorded on this CRL and
validated using this second CA certificate.
This CA certificate will have the cRLSign bit set in the KeyUsage
extension, but not the keyCertSign bit. The private key for this
certificate will be held by the AI, so that it can issue CRLs
unilaterally.
The Subject DN (Distinguished Name) will be the same in both CA
certificates, which reinforces the notion that the CRL issuer is
the same entity as the TAC issuer, and that this CRL is not an
indirect CRL. Because the CRL issuer does not issue any
certificates itself, there is no possible serial number conflict.
This will be the only CA certificate issued under the TAC CA
certificate (and thus it will be signed jointly by the BI and AI).
We recommend that the CRL for this CA certificate be similarly
long-lived, as it too needs to be signed by the BI and AI. Each
EE TAC certificate MUST contain a CRL Distribution Point that
points to the CRL issued by this CA, to ensure that relying
parties know to check this CRL vs. the CRL that covers only the
CRL CA. (If the AI uses the Online Certificate Status Protocol
(OCSP) [13] to convey the revocation status of TACs, an equivalent
procedure is employed.) If it is later determined that the
revocation was not warranted, a new TAC can be issued, to preserve
the anonymity of the user in future transactions.
Step B:
The AI searches its database, e.g., based on the serial number in
the TAC, to locate the Token that was passed between the AI and BI
during the issuance process (Steps 5 and 6 above). The AI passes
this Token to the aggrieved party via an encrypted and two-way
authenticated channel. Encryption is required to prevent
disclosure of the Token, and two-way authentication is required to
ensure that the aggrieved party and the AI know that they are
communicating with each other. Two-way authenticated TLS is the
RECOMMENDED means of implementing this channel, though other
approaches are allowed.
Steps C and D:
The aggrieved party transits the Token to the BI, via an encrypted
and two-way authenticated channel. The channel MUST be encrypted
to prevent disclosure of the Token, and two-way authentication is
required to ensure that the aggrieved party and the BI know that
Park, et al. Experimental [Page 16]
RFC 5636 Traceable Anonymous Certificate August 2009
they are communicating with each other. If specified by the
Certificate Policy (CP) for the TAC CA, the BI will independently
determine that there is sufficient evidence of abuse to trace the
TAC to the user, before proceeding. The BI verifies its signature
on the Token, to verify that this is a Token generated by it and
presumably released to the aggrieved party by the AI. Next, the
BI searches its database using the UserKey value extracted from
the Token. The BI retrieves the user's real identity and provides
it to the aggrieved party. (By requiring the aggrieved party to
interact with both the AI and the BI, the BI can verify that it is
dealing with an aggrieved party, not with the AI acting
unilaterally.)
5.3. TAC Request Message Format Profile
TAC request MAY use either PKCS10 or CMC. An AI MUST support PKCS10
and MAY support CMC.
5.3.1. PKCS10 Profile
This profile refines the specification in PKCS10 [3], as it relates
to TAC. A Certificate Request Message object, formatted according to
PKCS10, is passed to the AI.
This profile applies the following additional constraints to fields
that may appear in a CertificationRequestInfo:
Version
This field is mandatory and MUST have the value 0.
Subject
This field MUST be present. If the value of this field is
empty, the AI will generate a subject name that is unique in
the context of certificates issued by this issuer. If the
Subject field contains a Subject name already issued by the AI,
the AI MUST either reject the certificate request, or
substitute a pseudonym it generates, depending on the policy of
the TAC CA.
SubjectPublicKeyInfo
This field specifies the subject's public key and the algorithm
with which the key is used.
Attributes
PKCS10 [3] defines the attributes field as key-value pairs
where the key is an OID and the value's structure depends on
the key. The attribute field MUST include the id-kisa-tac
attribute, which holds the Token and is defined below. The
Park, et al. Experimental [Page 17]
RFC 5636 Traceable Anonymous Certificate August 2009
Attributes field MAY also contain X509v3 Certificate Extensions
and any PKCS9 [7] extensionRequest attributes that the
subscriber would like to have included in the certificate. The
profile for extensions in certificate requests is specified in
RFC 5280 [2].
5.3.2. CMC Profile
This profile refines the Certificate Request messages in Certificate
Management over CMS in CMC [4], as they relate to TACs.
A Certificate Request message, formatted according to CMC [4], is
passed to the AI.
With the exception of the public-key-related fields, the CA is
permitted to alter any requested field when issuing a corresponding
certificate.
This profile recommends the full PKI Request of the two types of PKI
requests (Simple or Full PKI Request), and the PKI Request SHOULD be
encapsulated in SignedData with an eContentType of id-cct-PKIData.
This profile applies the following additional constraints to fields
that may appear in a Certificate Request Template of Certificate
Request Message Format (CRMF) [5]:
Version
This field MAY be absent, or MAY specify the request of a
Version 3 Certificate. It SHOULD be omitted.
SerialNumber
As per CRMF [5], this field is assigned by the CA and MUST be
omitted in this profile.
SigningAlgorithm
As per CRMF [5], this field is assigned by the CA and MUST be
omitted in this profile.
Issuer
This field is assigned by the CA and MUST be omitted in this
profile.
Validity
This field MAY be omitted. If omitted, the AI will issue a
Certificate with Validity dates as determined by the TAC CA
policy. If specified, then the CA MAY override the requested
values with dates as determined by the TAC CA policy.
Park, et al. Experimental [Page 18]
RFC 5636 Traceable Anonymous Certificate August 2009
Subject
This field MUST be present. If the value of this field is
empty, the AI MUST generate a subject name that is unique in
the context of certificates issued by this issuer. If the
Subject field contains a Subject name already issued by the AI,
the AI MUST either reject the certificate request, or
substitute a pseudonym it generates, depending on the policy of
the TAC CA.
PublicKey
This field MUST be present.
This profile also refines constraints that may appear in a
Certificate Request controls: The Token is set to attrValues (in
CertRequest.controls) where the attrType MUST be id-kisa-tac.
See Section 5.3.1, "PKCS10 Profile", for the certification request
formats based on PKCS10.
6. Security Considerations
The anonymity provided by the architecture and protocols defined in
this document is conditional. Moreover, if the user employs the same
TAC for multiple transactions (with the same or different parties),
the transactions can be linked through the use of the same TAC.
Thus, the anonymity guarantee is "weak" even though the user's real
identity is still hidden.
To achieve stronger anonymity, a user may acquire multiple TACs,
through distinct iterations of the protocol. Since each TAC is
generated independently, it should not be possible for a relying
party to discover a link between pseudonyms unless the tracing
feature of this scheme is invoked. If the TAC has a long validity
interval, this increases the probability that the identity of a TAC
user will be discovered, e.g., as a result of linking user
transactions across multiple servers. Thus, we recommend that each
TAC CA consider carefully how long the validity for a TAC certificate
should be. In the course of issuing a TAC, the AI and the user
interact directly. Thus, the AI may have access to lower-layer
information (e.g., an IP address) that might reveal the user's
identity. A user concerned about this sort of possible identity
compromise should use appropriate measures to conceal such
information, e.g., a network anonymity service such as Tor [10].
This document makes no provisions for certificate renewal or rekey;
we recommend TAC users acquire new TACs periodically, to further
reduce the likelihood of linkage. It also may be possible to
determine the identity of a user via information carried by lower-
Park, et al. Experimental [Page 19]
RFC 5636 Traceable Anonymous Certificate August 2009
level protocols, or by other, application-specific means. For
example, the IP address of the user might be used to identify him.
For this reason, we recommend that a TAC be used primarily to access
web services with anonymity. Note that the TAC architecture
described in this document is not capable of using certificates for
use with S/MIME, because there is no provision to issue two
certificates (one for encryption and one for signatures) that contain
the same (anonymous) Subject name. An analogous problem might arise
if a user visits a site (and does not conceal his identity), the site
deposits a "cookie" into the user's browser cache, and the user later
visits a site and employs a TAC with the presumption of anonymity.
The use of a TAC is a tool to help a user preserve anonymity, but it
is not, per se, a guarantee of anonymity. We recommend that each TAC
CA issue certificates with only one lifetime, in order to avoid the
complexity that might arise otherwise. If a TAC CA offered
certificates with different lifetimes, then it would need to
communicate this information from the BI to AI in a way that does not
unduly compromise the anonymity of the user.
This architecture uses the UserKey to link a TAC to the corresponding
real user identity. The UserKey is generated in a fashion to ensure
that it cannot be examined to determine a user's real identity.
UserKey values are maintained in two distinct databases: the BI
database maps a UserKey to a real user identity, and the AI database
maps a TAC to a UserKey. The UserKey is always carried in a signed
data object, a Token. The Token is signed to allow the BI to verify
its authenticity, to prevent attacks based on guessing UserKey
values. The Token also carries a Timeout value to allow the AI and
BI to reject session-level replay attacks, and to facilitate garbage
collection of AI and BI databases.
Threshold cryptography is employed to enable strong separation of the
BI and AI functions, and to ensure that both must cooperate to issue
certificates under the aegis of a TAC CA. (The AI and BI must ensure
that the threshold cryptographic scheme they employ does not provide
an advantage to either party based on the way the key-splitting is
effected.) Blind signatures are used with threshold cryptography to
preserve the separation of functions, i.e., to prevent the BI from
learning the hash value of the TAC issued by the AI.
Message exchanges between a user and the BI or the AI, between the AI
and BI, and between an aggrieved party and the AI and BI all make use
of secure channels. These channels are encrypted to prevent
disclosure of the Token value and of the pseudonym in the TAC request
and response and in a tracing request. The channels are two-way
authenticated to allow the AI and BI to verify their respective
identities when communication with one another, and one-way
Park, et al. Experimental [Page 20]
RFC 5636 Traceable Anonymous Certificate August 2009
authenticated to allow the user to verify their identities when he
communicates with them. Two-way authentication is employed for
communication between an aggrieved party and the AI and BI, to allow
all parties to verify the identity of one another.
There is an opportunity for the AI to return the wrong UserKey to
an aggrieved party, which will result in tracing a certificate to
the wrong real user identity. This appears to be unavoidable in
any scheme of this sort, since the database maintained by the BI
is intentionally ignorant of any info relating a UserKey to a TAC.
A TAC CA MUST describe in its CP how long it will retain the data
about certificates it issued, beyond the lifetime of these
certificates. This will help a prospective TAC subject gauge the
likelihood of unauthorized use of his identity as a result of a
compromise of this retained data. It also alerts relying parties of
the timeframe (after expiration of a certificate) in which an alleged
abuse must be brought to the attention of the AI and BI, before the
data linking a certificate to the real user identity is destroyed.
7. Acknowledgments
Tim Polk (NIST), Stefan Santesson (ACC-sec.com), Jim Schaad (Soaring
Hawk), David A. Cooper (NIST), SeokLae Lee, JongHyun Baek, SoonTae
Park (KISA), Taekyoung Kwon (Sejong University), JungHee Cheon (Seoul
National University), and YongDae Kim (Minnesota University) have
significantly contributed to work on the concept of TAC and have
identified security issues. Their comments enhanced the maturity of
the document.
8. References
8.1. Normative References
[1] Bradner, S., "Key words for use in RFCs to Indicate Requirement
Levels", BCP 14, RFC 2119, March 1997.
[2] Cooper, D., Santesson, S., Farrell, S., Boeyen, S., Housley, R.,
and W. Polk, "Internet X.509 Public Key Infrastructure
Certificate and Certificate Revocation List (CRL) Profile", RFC
5280, May 2008.
[3] Nystrom, M. and B. Kaliski, "PKCS #10: Certification Request
Syntax Specification Version 1.7", RFC 2986, November 2000.
[4] Schaad, J. and M. Myers, "Certificate Management over CMS
(CMC)", RFC 5272, June 2008.
Park, et al. Experimental [Page 21]
RFC 5636 Traceable Anonymous Certificate August 2009
[5] Schaad, J., "Internet X.509 Public Key Infrastructure
Certificate Request Message Format (CRMF)", RFC 4211, September
2005.
[6] Housley, R., "Cryptographic Message Syntax (CMS)", RFC 3852,
July 2004.
[7] Nystrom, M. and B. Kaliski, "PKCS #9: Selected Object Classes
and Attribute Types Version 2.0", RFC 2985, November 2000.
8.2. Informative References
[8] S. Brands, "Rethinking public key infrastructures and digital
certificates - Building in Privacy", PhD thesis, Eindhoven
Institute of Technology, Eindhoven, The Netherlands, 1999.
[9] D. Chaum, "Blind signature system", CRYPTO '83, Plenum Press,
page 153, 1984.
[10] "Tor: anonymity online", http://www.torproject.org.
[11] X.509, "Information technology - Open Systems Interconnection -
The Directory: Public-key and attribute certificate frameworks",
ITU-T Recommendation X.509, March 2000. Also available as
ISO/IEC 9594-8, 2001.
[12] S. Rafaeli, M. Rennhard, L. Mathy, B. Plattner, and D.
Hutchison, "An Architecture for Pseudonymous e-Commerce",
AISB'01 Symposium on Information Agents for Electronic Commerce,
pp. 33-41, 2001.
[13] Myers, M., Ankney, R., Malpani, A., Galperin, S., and C. Adams,
"X.509 Internet Public Key Infrastructure Online Certificate
Status Protocol - OCSP", RFC 2560, June 1999.
[14] Philip MacKenzie and Michael K. Reiter, "Two-Party Generation of
DSA Signature", Crypto 2001.
[15] Shaohua Tang, "Simple Threshold RSA Signature Scheme Based on
Simple Secret Sharing", in "Computational Intelligence and
Security", CIS 2005, Part II, Springer, pp. 186-191, 2005.
[16] Taekyoung Kwon, Jung Hee Cheon, Yongdae Kim, Jae-Il Lee,
"Privacy Protection in PKIs: A Separation-of-Authority
Approach", in "Information Security Applications", WISA 2006,
Springer, pp. 297-311, 2007.
Park, et al. Experimental [Page 22]
RFC 5636 Traceable Anonymous Certificate August 2009
[17] Dierks, T. and E. Rescorla, "The Transport Layer Security (TLS)
Protocol Version 1.2", RFC 5246, August 2008.
[18] Ramsdell, B., Ed., "Secure/Multipurpose Internet Mail Extensions
(S/MIME) Version 3.1 Certificate Handling", RFC 3850, July 2004.
Park, et al. Experimental [Page 23]
RFC 5636 Traceable Anonymous Certificate August 2009
Appendix A. Traceable Anonymous Certificate ASN.1 Modules
DEFINITIONS IMPLICIT TAGS ::=
--
-- Copyright (c) 2009 IETF Trust and the persons identified as
-- authors of the code. All rights reserved.
--
-- Redistribution and use in source and binary forms, with or
-- without modification, are permitted provided that the following
-- conditions are met:
--
-- - Redistributions of source code must retain the above
-- copyright notice, this list of conditions and the following
-- disclaimer.
--
-- - Redistributions in binary form must reproduce the above
-- copyright notice, this list of conditions and the following
-- disclaimer in the documentation and/or other materials provided
-- with the distribution.
--
-- - Neither the name of Internet Society, IETF or IETF Trust, nor
-- the names of specific contributors, may be used to endorse or
-- promote products derived from this software without specific
-- prior written permission.
--
--
--
-- THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
-- CONTRIBUTORS 'AS IS' AND ANY EXPRESS OR IMPLIED WARRANTIES,
-- INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
-- MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
-- DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
-- BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
-- EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED
-- TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-- DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
-- ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
-- OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
-- OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
-- POSSIBILITY OF SUCH DAMAGE.
--
-- This version of the ASN.1 module is part of RFC 5636;
-- see the RFC itself for full legal notices.
--
Park, et al. Experimental [Page 24]
RFC 5636 Traceable Anonymous Certificate August 2009
BEGIN
-- EXPORTS All
-- The types and values defined in this module are exported for
-- use in the other ASN.1 modules. Other applications may use
-- them for their own purposes.
IMPORTS
-- Imports from RFC 3280 [PROFILE], Appendix A.1
AlgorithmIdentifier, Certificate, CertificateList,
CertificateSerialNumber, Name FROM PKIX1Explicit88
{ iso(1) identified-organization(3) dod(6)
internet(1) security(5) mechanisms(5) pkix(7)
mod(0) pkix1-explicit(18) }
-- Imports from CMS
ContentInfo, SignedData FROM
CryptographicMessageSyntax2004{ iso(1)
member-body(2) us(840) rsadsi(113549) pkcs(1) pkcs-9(9)
smime(16) modules(0) cms-2004(24)}
UserKey ::= OCTET STRING
Timeout ::= GeneralizedTime
BlinedCertificateHash ::= OCTET STRING
PartiallySignedCertificateHash ::= OCTET STRING
EncapsulatedContentInfo ::= SEQUENCE {
eContentType ContentType, -- OBJECT IDENTIFIER : id-data
eContent [0] EXPLICIT OCTET STRING OPTIONAL }
id-data OBJECT IDENTIFIER ::= { iso(1) member-body(2) us(840)
rsadsi(113549) pkcs(1) pkcs7(7) 1 }
Token ::= ContentInfo
TokenandBlindHash ::= ContentInfo
TokenandPartiallySignedCertificateHash ::= ContentInfo
id-KISA OBJECT IDENTIFIER ::= {iso(1) member-body(2) korea(410)
kisa(200004)}
id-npki OBJECT IDENTIFIER ::= {id-KISA 10}
Park, et al. Experimental [Page 25]
RFC 5636 Traceable Anonymous Certificate August 2009
id-attribute OBJECT IDENTIFIER ::= {id-npki 1}
id-kisa-tac OBJECT IDENTIFIER ::= {id-attribute 1}
id-kisa-tac-token OBJECT IDENTIFIER ::= { id-kisa-tac 1}
id-kisa-tac-tokenandblindbash OBJECT IDENTIFIER ::= { id-kisa-tac 2}
id-kisa-tac-tokenandpartially OBJECT IDENTIFIER ::= { id-kisa-tac 3}
END
Appendix B. TAC Message Exchanges over Transport Layer Security
TAC message exchanges between a user and the BI or the AI, between
the AI and BI, and between an aggrieved party and the AI and BI all
make use of secure channels to prevent disclosure of the Token value
and of the pseudonym in the TAC request and response and in a tracing
request. The Transport Layer Security Protocol v1.2 (TLS) [17] is a
suitable security protocol to protect these message exchanges, and
this document recommends use of TLS to protect these exchanges. The
following text describes how the handshake part of TLS should be
employed to protect each type of exchange. Note that no specific
cipher suites are specified for use here; the choice of suites is up
to the client and servers, as is commonly the case.
B.1. Message Exchanges between a User and the BI or the AI
The channels between a User and the BI or the AI are one-way
authenticated to allow the user to verify their identities when he
communicates with them.
User BI or AI
ClientHello -------->
ServerHello
Certificate
<-------- ServerHelloDone
ClientKeyExchange
[ChangeCipherSpec]
Finished -------->
[ChangeCipherSpec]
<--------- Finished
TAC Message <---------> TAC Message
Figure 3. TAC Message exchanges between a User and the BI or the AI
Park, et al. Experimental [Page 26]
RFC 5636 Traceable Anonymous Certificate August 2009
B.2. Message Exchanges between the BI and the AI
The channels between the BI and the AI are two-way authenticated to
allow the AI and BI to verify their respective identities when
communication with one another.
BI AI
ClientHello -------->
ServerHello
Certificate
CertificateRequest
<-------- ServerHelloDone
Certificate
ClientKeyExchange
CertificateVerify
[ChangeCipherSpec]
Finished -------->
[ChangeCipherSpec]
<--------- Finished
TAC Message <---------> TAC Message
Figure 4. TAC Message exchanges between BI and AI
B.3. Message Exchanges between the Aggrieved Party and the AI or the BI
The channels between a User and the BI or the AI are two-way
authenticated, to allow both parties to verify the identity of one
another.
User BI or AI
ClientHello -------->
ServerHello
Certificate
CertificateRequest
<-------- ServerHelloDone
Certificate
ClientKeyExchange
CertificateVerify
[ChangeCipherSpec]
Finished -------->
[ChangeCipherSpec]
<--------- Finished
TAC Message <---------> TAC Message
Figure 5. TAC Message Exchanges between an Aggrieved Party and
the BI or the AI
Park, et al. Experimental [Page 27]
RFC 5636 Traceable Anonymous Certificate August 2009
Appendix C. Cryptographic Message Syntax Profile for TAC Token
Using the Cryptographic Message Syntax(CMS)[6], TAC Token is a type
of signed-data object. The general format of a CMS object is:
ContentInfo ::= SEQUENCE {
contentType ContentType,
content [0] EXPLICIT ANY DEFINED BY contentType }
ContentType ::= OBJECT IDENTIFIER
As a TAC is a signed-data object, it uses the corresponding OID,
1.2.840.113549.1.1.2.
C.1. Signed-Data Content Type
According to the CMS specification, the signed-data content type
shall have ASN.1 type SignedData:
SignedData ::= SEQUENCE {
version CMSVersion,
digestAlgorithms DigestAlgorithmIdentifiers,
encapContentInfo EncapsulatedContentInfo,
certificates [0] IMPLICIT CertificateSet OPTIONAL,
crls [1] IMPLICIT RevocationInfoChoices OPTIONAL,
signerInfos SignerInfos }
DigestAlgorithmIdentifiers ::= SET OF DigestAlgorithmIdentifier
SignerInfos ::= SET OF SignerInfo
The elements of the signed-data content type are as follows:
Version
The version is the syntax version number. It MUST be 3,
corresponding to the signerInfo structure having version number
3.
digestAlgorithms
This field specifies digest Algorithms.
encapContentInfo
This element is defined in Appendix C.1.1.
Park, et al. Experimental [Page 28]
RFC 5636 Traceable Anonymous Certificate August 2009
certificates
The certificates element MUST be included and MUST contain only
the single PKI EE certificate needed to validate this CMS
Object. The CertificateSet type is defined in section 10 of
RFC3852 [6].
crls
The crls element MUST be omitted.
signerInfos
This element is defined in Appendix C.1.2.
C.1.1. encapContentInfo
encapContentInfo is the signed content, consisting of a content type
identifier and the content itself.
EncapsulatedContentInfo ::= SEQUENCE{
eContentType ContentType,
eContent [0] EXPLICIT OCTET STRING OPTIONAL }
ContentType ::= OBJECT IDENTIFIER
The elements of this signed content type are as follows:
eContentType
The ContentType for an TAC Token is id-data and has the
numerical value of 1.2.840.113549.1.7.1.
eContent
The content of a TAC Token is the DER-encoded SEQUENCE of
UserKey and Timeout.
C.1.2. signerInfos
SignerInfo is defined under CMS as:
SignerInfo ::= SEQUENCE {
version CMSVersion,
sid SignerIdentifier,
digestAlgorithm DigestAlgorithmIdentifier,
signedAttrs [0] IMPLICIT SignedAttributes OPTIONAL,
signatureAlgorithm SignatureAlgorithmIdentifier,
signature SignatureValue,
unsignedAttrs [1] IMPLICIT UnsignedAttributes OPTIONAL }
Park, et al. Experimental [Page 29]
RFC 5636 Traceable Anonymous Certificate August 2009
The contents of the SignerInfo element are as follows:
Version
The version number MUST be 3, corresponding with the choice of
SubjectKeyIdentifier for the sid.
sid
The sid is defined as:
SignerIdentifier ::= CHOICE {
issuerAndSerialNumber IssuerAndSerialNumber,
subjectKeyIdentifier [0] SubjectKeyIdentifier }
For a TAC Token, the sid MUST be a SubjectKeyIdentifier.
digestAlgorithm
This field specifies digest Algorithms.
signedAttrs
The signedAttr element MUST be omitted.
SignatureAlgorithm
This field specifies the signature Algorithm.
Signature
The signature value is defined as:
SignatureValue ::= OCTET STRING
The signature characteristics are defined by the digest and
signature algorithms.
UnsignedAttrs
unsignedAttrs MUST be omitted.
Park, et al. Experimental [Page 30]
RFC 5636 Traceable Anonymous Certificate August 2009
Authors' Addresses
SangHwan Park
Korea Internet & Security Agency
78, Garak-Dong, Songpa-Gu, Seoul, Korea
EMail: shpark@kisa.or.kr
Haeryong Park
Korea Internet & Security Agency
78, Garak-Dong, Songpa-Gu, Seoul, Korea
EMail: hrpark@kisa.or.kr
YooJae Won
Korea Internet & Security Agency
78, Garak-Dong, Songpa-Gu, Seoul, Korea
EMail: yjwon@kisa.or.kr
JaeIl Lee
Korea Internet & Security Agency
78, Garak-Dong, Songpa-Gu, Seoul, Korea
EMail: jilee@kisa.or.kr
Stephen Kent
BBN Technologies
10 Moulton Street Cambridge, MA 02138
EMail: kent@bbn.com
Park, et al. Experimental [Page 31]