 1/draftietfsmimecmsrsakem06.txt 20090707 22:12:20.000000000 +0200
+++ 2/draftietfsmimecmsrsakem07.txt 20090707 22:12:20.000000000 +0200
@@ 1,85 +1,86 @@
S/MIME Working Group J. Randall
Internet Draft RSA
Document: draftietfsmimecmsrsakem06.txt B.Kaliski
Category: Standards EMC Corp.
Expires: March 2009 September 2008
+ S/MIME Working Group James Randall, Randall Consulting
+ Internet Draft Burt Kaliski, EMC
+ John Brainard, RSA
+ Sean Turner, IECA
+ Expires: January 7, 2010 Category: Standards
+ July 7, 2009
Use of the RSAKEM Key Transport Algorithm in CMS


Intellectual Property
+
 By submitting this InternetDraft, each author represents that any
 applicable patent or other IPR claims of which he or she is aware
 have been or will be disclosed, and any of which he or she becomes
 aware will be disclosed, in accordance with Section 6 of BCP 79.
+ Status of this Memo
 The IETF takes no position regarding the validity or scope of any
 Intellectual Property Rights or other rights that might be claimed to
 pertain to the implementation or use of the technology described in
 this document or the extent to which any license under such rights
 might or might not be available; nor does it represent that it has
 made any independent effort to identify any such rights. Information
 on the procedures with respect to rights in RFC documents can be
 found in BCP 78 and BCP 79.
+ This InternetDraft is submitted to IETF in full conformance with the
+ provisions of BCP 78 and BCP 79. This document may contain material
+ from IETF Documents or IETF Contributions published or made publicly
+ available before November 10, 2008. The person(s) controlling the
+ copyright in some of this material may not have granted the IETF
+ Trust the right to allow modifications of such material outside the
+ IETF Standards Process. Without obtaining an adequate license from
+ the person(s) controlling the copyright in such materials, this
+ document may not be modified outside the IETF Standards Process, and
+ derivative works of it may not be created outside the IETF Standards
+ Process, except to format it for publication as an RFC or to
+ translate it into languages other than English.
 Copies of IPR disclosures made to the IETF Secretariat and any
 assurances of licenses to be made available, or the result of an
 attempt made to obtain a general license or permission for the use of
 such proprietary rights by implementers or users of this
 specification can be obtained from the IETF online IPR repository at
 http://www.ietf.org/ipr.
+ InternetDrafts are working documents of the Internet Engineering
+ Task Force (IETF), its areas, and its working groups. Note that
+ other groups may also distribute working documents as Internet
+ Drafts.
 The IETF invites any interested party to bring to its attention any
 copyrights, patents or patent applications, or other proprietary
 rights that may cover technology that may be required to implement
 this standard. Please address the information to the IETF at
 ietfipr@ietf.org.
+ InternetDrafts are draft documents valid for a maximum of six months
+ and may be updated, replaced, or obsoleted by other documents at any
+ time. It is inappropriate to use InternetDrafts as reference
+ material or to cite them other than as "work in progress."
 Copyright (C) The IETF Trust (2008).
+ The list of current InternetDrafts can be accessed at
+ http://www.ietf.org/ietf/1idabstracts.txt
 This document is subject to the rights, licenses and restrictions
 contained in BCP 78, and except as set forth therein, the authors
 retain all their rights.
+ The list of InternetDraft Shadow Directories can be accessed at
+ http://www.ietf.org/shadow.html
InternetDrafts are working documents of the Internet Engineering
Task Force (IETF), its areas, and its working groups. Note that other
groups may also distribute working documents as InternetDrafts.
 InternetDrafts are draft documents valid for a maximum of six months
 and may be updated, replaced, or obsoleted by other documents at any
 time. It is inappropriate to use InternetDrafts as reference
 material or to cite them other than as "work in progress."
 The list of current InternetDrafts can be accessed at:
 http://www.ietf.org/1idabstracts.html
 The list of InternetDraft Shadow Directories can be accessed at:
 http://www.ietf.org/shadow.html
+
+ This InternetDraft will expire on January 6, 2010.
+
+ 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/licenseinfo).
+ Please review these documents carefully, as they describe your
+ rights and restrictions with respect to this document.
Comments or suggestions for improvement may be made on the "ietf
 smime" mailing list, or directly to the author.
+ smime" mailing list, or directly to the authors.
Abstract
The RSAKEM Key Transport Algorithm is a onepass (storeandforward)
mechanism for transporting keying data to a recipient using the
recipient's RSA public key. This document specifies the conventions
for using the RSAKEM Key Transport Algorithm with the Cryptographic
Message Syntax (CMS). The ASN.1 syntax is aligned with ANS X9.44 and
ISO/IEC 180332.
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
 [STDWORDS].
+ "SHOULD", "SHOULD NOT", "RECOMMENDED", "MAY", and "OPTIONAL" in this
+ document are to be interpreted as described in RFC 2119 [STDWORDS].
1. Introduction
The RSAKEM Key Transport Algorithm is a onepass (storeandforward)
mechanism for transporting keying data to a recipient using the
recipient's RSA public key.
Most previous key transport algorithms based on the RSA publickey
cryptosystem (e.g., the popular PKCS #1 v1.5 algorithm [PKCS1]) have
the following general form:
@@ 94,48 +95,47 @@
The RSAKEM Key Transport Algorithm takes a different approach that
provides higher security assurance, by encrypting a _random_ integer
with the recipient's public key, and using a symmetric keywrapping
scheme to encrypt the keying data. It has the following form:
1. Generate a random integer z between 0 and n1.
2. Encrypt the integer z with the recipient's RSA public key:
 c = z^e mod n.
+ c = z^e mod n
3. Derive a keyencrypting key KEK from the integer z.
 4. Wrap the keying data using KEK to obtain wrapped keying data
 WK.
+ 4. Wrap the keying data using KEK to obtain wrapped keying data WK.
5. Output c and WK as the encrypted keying data.
This different approach provides higher security assurance because
 (a) the input to the underlying RSA operation is effectively a
 random integer between 0 and n1, where n is the RSA modulus, so it
 does not have any structure that could be exploited by an adversary,
 and (b) the input is independent of the keying data so the result of
 the RSA decryption operation is not directly available to an
 adversary. As a result, the algorithm enjoys a "tight" security
 proof in the random oracle model. (In other padding schemes, such
 as PKCS #1 v1.5, the input has structure and/or depends on the
 keying data, and the provable security assurances are not as
 strong.) The approach is also architecturally convenient because the
 publickey operations are separate from the symmetric operations on
 the keying data. One benefit is that the length of the keying data
 is bounded only by the symmetric keywrapping scheme, not the size
 of the RSA modulus.
+ (a) the input to the underlying RSA operation is effectively a random
+ integer between 0 and n1, where n is the RSA modulus, so it does not
+ have any structure that could be exploited by an adversary, and (b)
+ the input is independent of the keying data so the result of the RSA
+ decryption operation is not directly available to an adversary. As a
+ result, the algorithm enjoys a "tight" security proof in the random
+ oracle model. (In other padding schemes, such as PKCS #1 v1.5, the
+ input has structure and/or depends on the keying data, and the
+ provable security assurances are not as strong.) The approach is also
+ architecturally convenient because the publickey operations are
+ separate from the symmetric operations on the keying data. One
+ benefit is that the length of the keying data is bounded only by the
+ symmetric keywrapping scheme, not the size of the RSA modulus.
The RSAKEM Key Transport Algorithm in various forms is being adopted
 in several draft standards as well as in ANSX9.44 and ISO/IEC
 180332. It has also been recommended by the NESSIE project [NESSIE].
+ in several draft standards as well as in ANSX9.44 and ISO/IEC 18033
+ 2. It has also been recommended by the NESSIE project [NESSIE].
+
For completeness, a specification of the algorithm is given in
Appendix A of this document; ASN.1 syntax is given in Appendix B.
NOTE: The term KEM stands for "key encapsulation mechanism" and
refers to the first three steps of the process above. The
formalization of key transport algorithms (or more generally,
asymmetric encryption schemes) in terms of key encapsulation
mechanisms is described further in research by Victor Shoup leading
to the development of the ISO/IEC 180332 standard [SHOUP].
@@ 143,191 +143,187 @@
The RSAKEM Key Transport Algorithm MAY be employed for one or more
recipients in the CMS envelopeddata content type (Section 6 of
[CMS]), where the keying data processed by the algorithm is the CMS
contentencryption key.
The RSAKEM Key Transport Algorithm SHOULD be considered for new
CMSbased applications as a replacement for the widely implemented
RSA encryption algorithm specified originally in PKCS #1 v1.5 (see
[PKCS1] and Section 4.2.1 of [CMSALGS]), which is vulnerable to
 chosenciphertext attacks. The RSAESOAEP Key Transport Algorithm
 has also been proposed as a replacement (see [PKCS1] and [CMS
 OAEP]). RSAKEM has the advantage over RSAESOAEP of a tighter
 security proof, but the disadvantage of slightly longer encrypted
 keying data.
+ chosenciphertext attacks. The RSAESOAEP Key Transport Algorithm has
+ also been proposed as a replacement (see [PKCS1] and [CMSOAEP]).
+ RSAKEM has the advantage over RSAESOAEP of a tighter security
+ proof, but the disadvantage of slightly longer encrypted keying data.
2.1 Underlying Components
+ 2.1. Underlying Components
A CMS implementation that supports the RSAKEM Key Transport
Algorithm MUST support at least the following underlying components:
 * For the key derivation function, KDF2 or KDF3 (see [ANSX9.44]
 [IEEEP1363a]) based on SHA1 (see [FIPS1802]) (this function
 is also specified as the key derivation function in
 [ANSX9.63]).
+ o For the key derivation function, KDF2 (see [ANSX9.44]) (see
+ [IEEEP1363a]) based on SHA1 (see [FIPS1802]) (this function is
+ also specified as the key derivation function in [ANSX9.63]), and
+ KDF3 (see [IEEEP1363a]) based on SHA256 (see [FIPS1802]).
 * For the keywrapping scheme, AESWrap128, i.e., the AES Key
 Wrap with a 128bit key encrypting key (see [AESWRAP])
+ o For the keywrapping scheme, AESWrap128, i.e., the AES Key Wrap
+ with a 128bit key encrypting key (see [AESWRAP])
 An implementation SHOULD also support KDF2 and KDF3 based on SHA256
 (see [FIPS1802]). The Camillia key wrap algorithm (see [CAMILLIA])
 should be supported, and, if 3DES is supported as a content
+ An implementation SHOULD also support KDF3 based on SHA1 and KDF2
+ based on SHA256. The Camellia key wrap algorithm (see [CAMELLIA])
+ SHOULD be supported, and, if 3DES is supported as a content
encryption cipher, then the TripleDES Key Wrap (see [3DESWRAP])
SHOULD also be supported.
 It MAY support other underlying components. When AES or Camilla are
+ It MAY support other underlying components. When AES or Camellia are
used the data block size is 128 bits while the key size can be 128,
192, or 256 bits while Triple DES requires a data block size of 64
bits and a key size of 112 or 168 bits.
2.2 RecipientInfo Conventions
+ 2.2. RecipientInfo Conventions
When the RSAKEM Key Transport Algorithm is employed for a recipient,
the RecipientInfo alternative for that recipient MUST be

KeyTransRecipientInfo. The algorithmspecific fields of the
KeyTransRecipientInfo value MUST have the following values:
 * keyEncryptionAlgorithm.algorithm MUST be idacgenerichybrid
 (see Appendix B)
+ o keyEncryptionAlgorithm.algorithm MUST be idrsakem see Appendix
+ B)
 * keyEncryptionAlgorithm.parameters MUST be a value of type
 GenericHybridParameters, identifying the RSAKEM key
 encapsulation mechanism (see Appendix B)
+ o keyEncryptionAlgorithm.parameters MUST be a value of type
+ GenericHybridParameters, identifying the RSAKEM key encapsulation
+ mechanism (see Appendix B)
 * encryptedKey MUST be the encrypted keying data output by the
 algorithm, where the keying data is the contentencryption key.
 (see Appendix A)
+ o encryptedKey MUST be the encrypted keying data output by the
+ algorithm, where the keying data is the contentencryption
+ key.(see Appendix A)
2.3 Certificate Conventions
+ 2.3. Certificate Conventions
The conventions specified in this section augment RFC 3280 [PROFILE].
A recipient who employs the RSAKEM Key Transport Algorithm MAY
identify the public key in a certificate by the same
AlgorithmIdentifier as for the PKCS #1 v1.5 algorithm, i.e., using
 the rsaEncryption object identifier [PKCS1].
+ the rsaEncryption object identifier [PKCS1]. The fact that the user
+ will accept RSAKEM with this public key is not indicated by the use
+ of this identifier. This may be signed by the use of the appropriate
+ SMIME Capabilities either in a message or in the certificate.
If the recipient wishes only to employ the RSAKEM Key Transport
Algorithm with a given public key, the recipient MUST identify the
 public key in the certificate using the idacgenerichybrid object
 identifier (see Appendix B) where the associated
 GenericHybridParameters value indicates the underlying components
 with which the algorithm is to be employed. The certificate user MUST
 perform the RSAKEM Key Transport algorithm using only those
 components.
+ public key in the certificate using the idrsakem object identifier
+ (see Appendix B). The parameters are absent.
Regardless of the AlgorithmIdentifier used, the RSA public key is
 encoded in the same manner in the subject public key information.
 The RSA public key MUST be encoded using the type RSAPublicKey type:
+ encoded in the same manner in the subject public key information. The
+ RSA public key MUST be encoded using the type RSAPublicKey type:
RSAPublicKey ::= SEQUENCE {
modulus INTEGER,  n
publicExponent INTEGER  e
}
Here, the modulus is the modulus n, and publicExponent is the public
exponent e. The DER encoded RSAPublicKey is carried in the
subjectPublicKey BIT STRING within the subject public key
information.
The intended application for the key MAY be indicated in the key
usage certificate extension (see [PROFILE], Section 4.2.1.3). If the
keyUsage extension is present in a certificate that conveys an RSA
 public key with the idacgenerichybrid object identifier as
 discussed above, then the key usage extension MUST contain the
 following value:
+ public key with the idrsakem object identifier as discussed above,
+ then the key usage extension MUST contain the following value:
keyEncipherment.
dataEncipherment SHOULD NOT be present. That is, a key intended to be
employed only with the RSAKEM Key Transport Algorithm SHOULD NOT
also be employed for data encryption or for authentication such as in
signatures. Good cryptographic practice employs a given RSA key pair
in only one scheme. This practice avoids the risk that vulnerability
in one scheme may compromise the security of the other, and may be
essential to maintain provable security.
2.4 SMIMECapabilities Attribute Conventions
+ 2.4. SMIMECapabilities Attribute Conventions
 RFC 2633 [MSG], Section 2.5.2 defines the SMIMECapabilities signed
+ RFC 3851 [MSG], Section 2.5.2 defines the SMIMECapabilities signed
attribute (defined as a SEQUENCE of SMIMECapability SEQUENCEs) to be
used to specify a partial list of algorithms that the software
announcing the SMIMECapabilities can support. When constructing a
signedData object, compliant software MAY include the
SMIMECapabilities signed attribute announcing that it supports the
RSAKEM Key Transport algorithm.
The SMIMECapability SEQUENCE representing the RSAKEM Key Transport
 Algorithm MUST include the idacgenerichybrid object identifier
 (see Appendix B) in the capabilityID field and MUST include a
+ Algorithm MUST include the idrsakem object identifier (see Appendix
+ B) in the capabilityID field and MUST include a
GenericHybridParameters value in the parameters field identifying the
components with which the algorithm is to be employed.
The DER encoding of a SMIMECapability SEQUENCE is the same as the DER
encoding of an AlgorithmIdentifier. Example DER encodings for typical
sets of components are given in Appendix B.4.
3. Security Considerations
 The security of the RSAKEM Key Transport Algorithm described in
 this document can be shown to be tightly related to the difficulty
 of either solving the RSA problem or breaking the underlying
 symmetric keywrapping scheme, if the underlying key derivation
 function is modeled as a random oracle, and assuming that the
 symmetric keywrapping scheme satisfies the properties of a data
 encapsulation mechanism [SHOUP]. While in practice a randomoracle
 result does not provide an actual security proof for any particular
 key derivation function, the result does provide assurance that the
 general construction is reasonable; a key derivation function would
 need to be particularly weak to lead to an attack that is not
 possible in the random oracle model.
+ The security of the RSAKEM Key Transport Algorithm described in this
+ document can be shown to be tightly related to the difficulty of
+ either solving the RSA problem or breaking the underlying symmetric
+ keywrapping scheme, if the underlying key derivation function is
+ modeled as a random oracle, and assuming that the symmetric key
+ wrapping scheme satisfies the properties of a data encapsulation
+ mechanism [SHOUP]. While in practice a randomoracle result does not
+ provide an actual security proof for any particular key derivation
+ function, the result does provide assurance that the general
+ construction is reasonable; a key derivation function would need to
+ be particularly weak to lead to an attack that is not possible in the
+ random oracle model.
The RSA key size and the underlying components should be selected
consistent with the desired symmetric security level for an
application. Several security levels have been identified in [NIST
FIPS PUB 80057]. For brevity, the first three levels are mentioned
here:
 * 80bit security. The RSA key size SHOULD be at least 1024 bits,
 the hash function underlying the KDF SHOULD be SHA1 or above,
 and the symmetric keywrapping scheme SHOULD be AES Key Wrap,
 TripleDES Key Wrap, or Camillia Key Wrap.
+ o 80bit security. The RSA key size SHOULD be at least 1024 bits,
+ the hash function underlying the KDF SHOULD be SHA1 or above, and
+ the symmetric keywrapping scheme SHOULD be AES Key Wrap, Triple
+ DES Key Wrap, or Camellia Key Wrap.
 * 112bit security. The RSA key size SHOULD be at least 2048
 bits, the hash function underlying the KDF SHOULD be SHA224 or
 above, and the symmetric keywrapping scheme SHOULD be AES Key
 Wrap, TripleDES Key Wrap, or Camillia Key Wrap.
+ o 112bit security. The RSA key size SHOULD be at least 2048 bits,
+ the hash function underlying the KDF SHOULD be SHA224 or above,
+ and the symmetric keywrapping scheme SHOULD be AES Key Wrap,
+ TripleDES Key Wrap, or Camellia Key Wrap.
 * 128bit security. The RSA key size SHOULD be at least 3072
 bits, the hash function underlying the KDF SHOULD be SHA256 or
 above, and the symmetric keywrapping scheme SHOULD be AES Key
 Wrap or Camillia Key Wrap.
+ o 128bit security. The RSA key size SHOULD be at least 3072 bits,
+ the hash function underlying the KDF SHOULD be SHA256 or above,
+ and the symmetric keywrapping scheme SHOULD be AES Key Wrap or
+ Camellia Key Wrap.
 Note that the AES Key Wrap or Camillia Key Wrap MAY be used at all
 three of these levels; the use of AES or Camillia does not require a
+ Note that the AES Key Wrap or Camellia Key Wrap MAY be used at all
+ three of these levels; the use of AES or Camellia does not require a
128bit security level for other components.
Implementations MUST protect the RSA private key and the content
encryption key. Compromise of the RSA private key may result in the
disclosure of all messages protected with that key. Compromise of the
contentencryption key may result in disclosure of the associated
encrypted content.
Additional considerations related to key management may be found in
[NISTGUIDELINE].
The security of the algorithm also depends on the strength of the
random number generator, which SHOULD have a comparable security
 level. For further discussion on random number generation, please
 see [RANDOM].
+ level. For further discussion on random number generation, please see
+ [RANDOM].
Implementations SHOULD NOT reveal information about intermediate
values or calculations, whether by timing or other "side channels",
or otherwise an opponent may be able to determine information about
the keying data and/or the recipient's private key. Although not all
intermediate information may be useful to an opponent, it is
preferable to conceal as much information as is practical, unless
analysis specifically indicates that the information would not be
useful.
@@ 349,21 +345,21 @@
SHOULD NOT be used with other key establishment schemes, or for data
encryption, or with more than one set of underlying algorithm
components.
Parties MAY formalize the assurance that one another's
implementations are correct through implementation validation, e.g.
NIST's Cryptographic Module Validation Program (CMVP).
4. References
4.1 Normative References
+ 4.1. Normative References
[3DESWRAP] Housley, R. TripleDES and RC2 Key Wrapping. RFC
3217. December 2001.
[AESWRAP] Schaad, J. and R. Housley. Advanced Encryption
Standard (AES) Key Wrap Algorithm. RFC 3394.
September 2002.
[ANSX9.63] American National Standard X9.632002: Public Key
Cryptography for the Financial Services Industry:
@@ 360,50 +356,50 @@
[3DESWRAP] Housley, R. TripleDES and RC2 Key Wrapping. RFC
3217. December 2001.
[AESWRAP] Schaad, J. and R. Housley. Advanced Encryption
Standard (AES) Key Wrap Algorithm. RFC 3394.
September 2002.
[ANSX9.63] American National Standard X9.632002: Public Key
Cryptography for the Financial Services Industry:

Key Agreement and Key Transport Using Elliptic
Curve Cryptography.
 [CAMILLIA] Kato, A., Moriai, S., and Kanda, M.: The Camellia
 Cipher Algorithm and Its Use With IPsec. RFC 3657.
 December 2005.
+ [CAMELLIA] Kato, A., Moriai, S., and Kanda, M.: Use of the
+ Camellia Encryption Algorithm in Cryptographic
+ Message Syntax. RFC 3657. December 2005.
[CMS] Housley, R. Cryptographic Message Syntax. RFC
3852. July 2004.
[CMSALGS] Housley, R. Cryptographic Message Syntax (CMS)
Algorithms. RFC 3370. August 2002.
[FIPS1802] National Institute of Standards and Technology
(NIST). FIPS 1802: Secure Hash Standard. August
2002.
[MSG] Ramsdell, B. S/MIME Version 3 Message
Specification. RFC 3851. July 2004.
 [PROFILE] Housley, R., Polk, W., Ford, W. and D. Solo.
 Internet X.509 Public Key Infrastructure:
 Certificate and Certificate Revocation List (CRL)
 Profile. RFC 3280. April 2002.
+ [PROFILE] 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.
[STDWORDS] Bradner, S. Key Words for Use in RFCs to Indicate
Requirement Levels. RFC 2119. March 1997.
4.2 Informative References
+ 4.2. Informative References
[ANSX9.44] ASC X9F1 Working Group. American National
Standard X9.44: Public Key Cryptography for the
Financial Services Industry  Key Establishment
Using Integer Factorization Cryptography. 2007
[CMSOAEP] Housley, R. Use of the RSAESOAEP Key Transport
Algorithm in the Cryptographic Message Syntax
(CMS). RFC 3560. July 2003.
@@ 413,182 +409,145 @@
[ISOIEC180332] ISO/IEC 180332:2005 Information technology 
Security techniques  Encryption algorithms 
Part 2: Asymmetric Ciphers. ISO/IEC, 2005.
[NESSIE] NESSIE Consortium. Portfolio of Recommended
Cryptographic Primitives. February 27, 2003.
Available via http://www.cryptonessie.org/.
[NISTGUIDELINE] National Institute of Standards and Technology.
 Special Publication 80057: Recommendation for Key
 Management. Part 1: General Guideline. August 2005.

 Available via:
+ Special Publication 80057: Recommendation for
+ Key Management. Part 1: General Guideline.
+ August 2005. Available via:
http://csrc.nist.gov/publications/index.html.
[PKCS1] Jonsson, J. and B. Kaliski. PKCS #1: RSA
 Cryptography Specifications Version 2.1. RFC 3447.
 February 2003.
+ Cryptography Specifications Version 2.1. RFC
+ 3447. February 2003.
[RANDOM] Eastlake, D., S. Crocker, and J. Schiller.
 Randomness Recommendations for Security. RFC 4086.
 June 2005.
+ Randomness Recommendations for Security. RFC
+ 4086. June 2005.
[SHOUP] Shoup, V. A Proposal for an ISO Standard for
Public Key Encryption. Version 2.1, December 20,
2001. Available via http://www.shoup.net/papers/.
5. IANA Considerations

 Within the CMS, algorithms are identified by object identifiers
 (OIDs). With one exception, all of the OIDs used in this document
 were assigned in other IETF documents, in ISO/IEC standards
 documents, by the National Institute of Standards and Technology
 (NIST), and in PublicKey Cryptography Standards (PKCS) documents.
 The one exception is that the ASN.1 module's identifier (see Appendix
 B.3) is assigned in this document. No further action by the IANA is
 necessary for this document or any anticipated updates.

6. Acknowledgments

 This document is one part of a strategy to align algorithm standards
 produced by ASC X9, ISO/IEC JTC1 SC27, NIST, and the IETF. We would
 like to thank the members of the ASC X9F1 working group for their
 contributions to drafts of ANS X9.44 which led to this specification.
 Our thanks to Russ Housley as well for his guidance and
 encouragement. We also appreciate the helpful direction we've
 received from Blake Ramsdell and Jim Schaad in bringing this document
 to fruition. A special thanks to Magnus Nystrom for his assistance on
 Appendix B.

7. Authors' Addresses

 James Randall
 RSA, The Security Division of EMC
 174 Middlesex Turnpike
 Bedford, MA 01730
 USA
 email: jrandall@rsa.com

 Burt Kaliski
 EMC
 176 South Street
 Hopkinton, MA 01748
 USA
 email: kaliski_burt@emc.com

Appendix A. RSAKEM Key Transport Algorithm
+ Appendix A.
+ RSAKEM Key Transport Algorithm
The RSAKEM Key Transport Algorithm is a onepass (storeandforward)
mechanism for transporting keying data to a recipient using the
recipient's RSA public key.
With this type of algorithm, a sender encrypts the keying data using
the recipient's public key to obtain encrypted keying data. The
recipient decrypts the encrypted keying data using the recipient's
private key to recover the keying data.
A.1 Underlying Components
+ A.1. Underlying Components
The algorithm has the following underlying components:
 * KDF, a key derivation function, which derives keying data of a
+ o KDF, a key derivation function, which derives keying data of a
specified length from a shared secret value
 * Wrap, a symmetric keywrapping scheme, which encrypts keying
 data using a keyencrypting key
+ o Wrap, a symmetric keywrapping scheme, which encrypts keying Data
+ using a keyencrypting key
In the following, kekLen denotes the length in bytes of the key
encrypting key for the underlying symmetric keywrapping scheme.
In this scheme, the length of the keying data to be transported MUST
be among the lengths supported by the underlying symmetric key
 wrapping scheme. (Both the AES and Camillia Key Wraps, for instance,
+ wrapping scheme. (Both the AES and Camellia Key Wraps, for instance,
require the length of the keying data to be a multiple of 8 bytes,
and at least 16 bytes.) Usage and formatting of the keying data
(e.g., parity adjustment for TripleDES keys) is outside the scope of
this algorithm. With some key derivation functions, it is possible to
include other information besides the shared secret value in the
input to the function. Also, with some symmetric keywrapping
schemes, it is possible to associate a label with the keying data.
Such uses are outside the scope of this document, as they are not
directly supported by CMS.
A.2 Sender's Operations
+ A.2. Sender's Operations
 Let (n,e) be the recipient's RSA public key (see [PKCS1] for details)
 and let K be the keying data to be transported.
+ Let (n,e) be the recipient's RSA public key (see [PKCS1] for
+ details) and let K be the keying data to be transported.
Let nLen denote the length in bytes of the modulus n, i.e., the least
integer such that 2^{8*nLen} > n.
The sender performs the following operations:
1. Generate a random integer z between 0 and n1 (see Note), and
 convert z to a byte string Z of length nLen, most significant
 byte first:
+ convert z to a byte string Z of length nLen, most significant byte
+ first:
+
z = RandomInteger (0, n1)
Z = IntegerToString (z, nLen)
 2. Encrypt the random integer z using the recipient's public key
 (n,e) and convert the resulting integer c to a ciphertext C, a
 byte string of length nLen:
+
+ 2. Encrypt the random integer z using the recipient's public key n,e)
+ and convert the resulting integer c to a ciphertext C, a byte
+ string of length nLen:
c = z^e mod n
C = IntegerToString (c, nLen)
3. Derive a keyencrypting key KEK of length kekLen bytes from the
byte string Z using the underlying key derivation function:
KEK = KDF (Z, kekLen)
 4. Wrap the keying data K with the keyencrypting key KEK using
 the underlying keywrapping scheme to obtain wrapped keying
 data WK:
+ 4. Wrap the keying data K with the keyencrypting key KEK using the
+ underlying keywrapping scheme to obtain wrapped keying data WK:
WK = Wrap (KEK, K)
5. Concatenate the ciphertext C and the wrapped keying data WK to
obtain the encrypted keying data EK:
EK = C  WK
6. Output the encrypted keying data EK.
NOTE: The random integer z MUST be generated independently at random
for different encryption operations, whether for the same or
different recipients.
A.3 Recipient's Operations
+ A.3. Recipient's Operations
Let (n,d) be the recipient's RSA private key (see [PKCS1]; other
private key formats are allowed) and let EK be the encrypted keying
data.
Let nLen denote the length in bytes of the modulus n.
The recipient performs the following operations:
1. Separate the encrypted keying data EK into a ciphertext C of
length nLen bytes and wrapped keying data WK:
C  WK = EK
If the length of the encrypted keying data is less than nLen
bytes, output "decryption error" and stop.
 2. Convert the ciphertext C to an integer c, most significant
 byte first. Decrypt the integer c using the recipient's
 private key (n,d) to recover an integer z (see Note):
+ 2. Convert the ciphertext C to an integer c, most significant byte
+ first. Decrypt the integer c using the recipient's private key
+ (n,d) to recover an integer z (see Note):
c = StringToInteger (C)
z = c^d mod n
+
If the integer c is not between 0 and n1, output "decryption
error" and stop.
3. Convert the integer z to a byte string Z of length nLen, most
significant byte first (see Note):
Z = IntegerToString (z, nLen)
4. Derive a keyencrypting key KEK of length kekLen bytes from
the byte string Z using the underlying key derivation function
@@ 586,52 +545,53 @@
error" and stop.
3. Convert the integer z to a byte string Z of length nLen, most
significant byte first (see Note):
Z = IntegerToString (z, nLen)
4. Derive a keyencrypting key KEK of length kekLen bytes from
the byte string Z using the underlying key derivation function
(see Note):
+
KEK = KDF (Z, kekLen)
5. Unwrap the wrapped keying data WK with the keyencrypting key
KEK using the underlying keywrapping scheme to recover the
keying data K:
K = Unwrap (KEK, WK)
 If the unwrapping operation outputs an error, output
 "decryption error" and stop.
+ If the unwrapping operation outputs an error, output "decryption
+ error" and stop.
6. Output the keying data K.
NOTE: Implementations SHOULD NOT reveal information about the integer
z and the string Z, nor about the calculation of the exponentiation
in Step 2, the conversion in Step 3, or the key derivation in Step 4,
whether by timing or other "side channels". The observable behavior

of the implementation SHOULD be the same at these steps for all
ciphertexts C that are in range. (For example, IntegerToString
conversion should take the same amount of time regardless of the
actual value of the integer z.) The integer z, the string Z and other
intermediate results MUST be securely deleted when they are no longer
needed.
Appendix B. ASN.1 Syntax
+ Appendix B.
+ ASN.1 Syntax
The ASN.1 syntax for identifying the RSAKEM Key Transport Algorithm
is an extension of the syntax for the "generic hybrid cipher" in
 ISO/IEC 180332 [ISOIEC180332], and is the same as employed in
 ANS X9.44 [ANSX9.44]. The syntax for the scheme is given in Section
 B.1. The syntax for selected underlying components including those
+ ISO/IEC 180332 [ISOIEC180332], and is the same as employed in ANS
+ X9.44 [ANSX9.44]. The syntax for the scheme is given in Section B.1.
+ The syntax for selected underlying components including those
mentioned above is given in B.2.
The following object identifier prefixes are used in the definitions
below:
is180332 OID ::= { iso(1) standard(0) is18033(18033) part2(2) }
nistAlgorithm OID ::= {
jointisoitut(2) country(16) us(840) organization(1)
gov(101) csor(3) nistAlgorithm(4)
@@ 642,131 +603,130 @@
NullParms is a more descriptive synonym for NULL when an algorithm
identifier has null parameters:
NullParms ::= NULL
The material in this Appendix is based on ANS X9.44.
B.1 RSAKEM Key Transport Algorithm
 The object identifier for the RSAKEM Key Transport Algorithm is the
 same as for the "generic hybrid cipher" in ISO/IEC 180332,
 idacgenerichybrid, which is defined in the draft as:
+ The object identifier for the RSAKEM Key Transport Algorithm is id
+ rsakem, which is defined in the draft as:
 idacgenerichybrid OID ::= {
 is180332 asymmetriccipher(1) generichybrid(2)
+ idrsakem OID ::= {
+ iso(1) memberbody(2) us(840) rsadsi(113549) pkcs(1)
+ pkcs9(9) smime(16) alg(3) TBA
}
 The associated parameters for idacgenerichybrid have type
 GenericHybridParameters:
+ When idrsakem is used in an AlgorithmIdentifier, the parameters
+ MUST employ the GenericHybridParameters syntax. The parameters MUST
+ be absent when used in the subjectPublicKeyInfo field The syntax for
+ GenericHybridParameters is as follows:
GenericHybridParameters ::= {
kem KeyEncapsulationMechanism,
dem DataEncapsulationMechanism
}
The fields of type GenericHybridParameters have the following
meanings:
 * kem identifies the underlying key encapsulation mechanism. For
 the RSAKEM Key Transport Algorithm, the scheme is RSAKEM from
+ o kem identifies the underlying key encapsulation mechanism. For the
+ RSAKEM Key Transport Algorithm, the scheme is RSAKEM from
ISO/IEC 180332.
The object identifier for RSAKEM (as a key encapsulation
 mechanism) is idkemrsa, which is defined in ISO/IEC 180332
 as
+ mechanism) is idkemrsa, which is defined in ISO/IEC 180332 as
idkemrsa OID ::= {
is180332 keyencapsulationmechanism(2) rsa(4)
}
The associated parameters for idkemrsa have type
RsaKemParameters:
RsaKemParameters ::= {
keyDerivationFunction KeyDerivationFunction,
keyLength KeyLength
}
 The fields of type RsaKemParameters have the following
 meanings:
+ The fields of type RsaKemParameters have the following meanings:
* keyDerivationFunction identifies the underlying key
derivation function. For alignment with ANS X9.44, it
MUST be KDF2 or KDF3. However, other key derivation
 functions MAY be used with CMS. Please see B.2.1 for the
 syntax for KDF2 and KDF3.
+ functions MAY be used with CMS. Please see B.2.1 for
+ the syntax for KDF2 and KDF3.
KeyDerivationFunction ::=
AlgorithmIdentifier {{KDFAlgorithms}}
KDFAlgorithms ALGORITHM ::= {
kdf2  kdf3,
...  implementations may define other methods
}
* keyLength is the length in bytes of the keyencrypting
key, which depends on the underlying symmetric key
wrapping scheme.
 KeyLength ::= INTEGER (1..MAX)
 * dem identifies the underlying data encapsulation mechanism.
 For alignment with ANS X9.44, it MUST be an X9approved
 symmetric keywrapping scheme. (See Note.) However, other
 symmetric keywrapping schemes MAY be used with CMS. Please see
 B.2.2 for the syntax for the AES, TripleDES, and Camillia Key
 Wraps.
+ KeyLength ::= INTEGER (1..MAX)
+ o dem identifies the underlying data encapsulation mechanism. For
+ alignment with ANS X9.44, it MUST be an X9approved symmetric key
+ wrapping scheme. (See Note.) However, other symmetric keywrapping
+ schemes MAY be used with CMS. Please see B.2.2 for the syntax for
+ the AES, TripleDES, and Camellia Key Wraps.
DataEncapsulationMechanism ::=
AlgorithmIdentifier {{DEMAlgorithms}}
DEMAlgorithms ALGORITHM ::= {
X9SymmetricKeyWrappingSchemes,
 CamilliaKeyWrappingSchemes,
+ CamelliaKeyWrappingSchemes,
...  implementations may define other methods
}
X9SymmetricKeyWrappingSchemes ALGORITHM ::= {
aes128Wrap  aes192Wrap  aes256Wrap  tdesWrap,
...  allows for future expansion
}
 CamilliaKeyWrappingSchemes ALGORITHM ::= {
 camillia128Wrap  camillia192Wrap  camillia256Wrap
+ CamelliaKeyWrappingSchemes ALGORITHM ::= {
+ Camellia128Wrap  Camellia192Wrap  Camellia256Wrap
}
NOTE: The generic hybrid cipher in ISO/IEC 180332 can encrypt
arbitrary data, hence the term "data encapsulation mechanism". The
symmetric keywrapping schemes take the role of data encapsulation
mechanisms in the RSAKEM Key Transport Algorithm. ISO/IEC 180332
allows only three specific data encapsulation mechanisms, not
including any of these symmetric keywrapping schemes. However, the
ASN.1 syntax in that document expects that additional algorithms will
be allowed.
B.2 Selected Underlying Components
+ B.2
B.2.1 Key Derivation Functions
The object identifier for KDF2 (see [ANS X9.44]) is:
idkdfkdf2 OID ::= { x944components kdf2(1) }
The associated parameters identify the underlying hash function. For
 alignment with ANS X9.44, the hash function MUST be an ASC
 X9approved hash function. However, other hash functions MAY be used
+ alignment with ANS X9.44, the hash function MUST be an ASC X9
+ approved hash function. However, other hash functions MAY be used
with CMS.
kdf2 ALGORITHM ::= { OID idkdfkdf2 PARMS KDF2HashFunction }

 KDF2HashFunction ::= AlgorithmIdentifier {{KDF2HashFunctions}}
+ KDF2HashFunction ::= AlgorithmIdentifier {{KDF2
+ HashFunctions}}
KDF2HashFunctions ALGORITHM ::= {
X9HashFunctions,
...  implementations may define other methods
}
X9HashFunctions ALGORITHM ::= {
sha1  sha224  sha256  sha384  sha512,
...  allows for future expansion
}
@@ 838,25 +799,24 @@
}
This object identifier has a NULL parameter.
tdesWrap ALGORITHM ::=
{ OID idalgCMS3DESwrap PARMS NullParms }
NOTE: As of this writing, the AES Key Wrap and the TripleDES Key
Wrap are in the process of being approved by ASC X9.
 The object identifiers for the Camillia Key Wrap depends on the size
+ The object identifiers for the Camellia Key Wrap depend on the size
of the key encrypting key. There are three object identifiers:
idcamellia128Wrap OBJECT IDENTIFIER ::=

{ iso(1) memberbody(2) 392 200011 61 security(1)
algorithm(1) keywrapalgorithm(3)
camellia128wrap(2) }
idcamellia192Wrap OBJECT IDENTIFIER ::=
{ iso(1) memberbody(2) 392 200011 61 security(1)
algorithm(1) keywrapalgorithm(3)
camellia192wrap(3) }
idcamellia256Wrap OBJECT IDENTIFIER ::=
@@ 882,35 +842,38 @@
 EXPORTS ALL
 IMPORTS None
 Useful types and definitions
OID ::= OBJECT IDENTIFIER  alias
 Unless otherwise stated, if an object identifier has associated
  parameters (i.e., the PARMS element is specified), the parameters
  field shall be included in algorithm identifier values. The
  parameters field shall be omitted if and only if the object
  identifier does not have associated parameters (i.e., the PARMS
  element is omitted), unless otherwise stated.
+
+  parameters (i.e., the PARMS element is specified), the
+  parameters field shall be included in algorithm identifier
+  values. The parameters field shall be omitted if and only if
+  the object identifier does not have associated parameters
+  (i.e., the PARMS element is omitted), unless otherwise stated.
ALGORITHM ::= CLASS {
&id OBJECT IDENTIFIER UNIQUE,
&Type OPTIONAL
}
WITH SYNTAX { OID &id [PARMS &Type] }
+
AlgorithmIdentifier { ALGORITHM:IOSet } ::= SEQUENCE {
algorithm ALGORITHM.&id( {IOSet} ),
parameters ALGORITHM.&Type( {IOSet}{@algorithm} ) OPTIONAL
}
+
NullParms ::= NULL
 ISO/IEC 180332 arc
is180332 OID ::= { iso(1) standard(0) is18033(18033) part2(2) }
 NIST algorithm arc
nistAlgorithm OID ::= {
jointisoitut(2) country(16) us(840) organization(1)
@@ 916,84 +879,79 @@
jointisoitut(2) country(16) us(840) organization(1)
gov(101) csor(3) nistAlgorithm(4)
}
 PKCS #1 arc
pkcs1 OID ::= {
iso(1) memberbody(2) us(840) rsadsi(113549) pkcs(1) pkcs1(1)
}
  RSAKEM Key Transport Algorithm, based on Generic Hybrid Cipher
+  RSAKEM Key Transport Algorithm
 idacgenerichybrid OID ::= {
 is180332 asymmetriccipher(1) generichybrid(2)
+ idrsakem OID ::= {
+ iso(1) memberbody(2) us(840) rsadsi(113549) pkcs(1)
+ pkcs9(9) smime(16) alg(3) TBA
}
GenericHybridParameters ::= SEQUENCE {
kem KeyEncapsulationMechanism,
dem DataEncapsulationMechanism
}
KeyEncapsulationMechanism ::= AlgorithmIdentifier {{KEMAlgorithms}}

 KEMAlgorithms ALGORITHM ::= {
 ...  Don't know what you want in here
 }

idkemrsa OID ::= {
is180332 keyencapsulationmechanism(2) rsa(4)
}
RsaKemParameters ::= SEQUENCE {
keyDerivationFunction KeyDerivationFunction,
keyLength KeyLength
}
KeyDerivationFunction ::= AlgorithmIdentifier {{KDFAlgorithms}}
KDFAlgorithms ALGORITHM ::= {
kdf2  kdf3,
...  implementations may define other methods
}
KeyLength ::= INTEGER (1..MAX)
 DataEncapsulationMechanism ::= AlgorithmIdentifier {{DEMAlgorithms}}
+ DataEncapsulationMechanism ::=
+ AlgorithmIdentifier {{DEMAlgorithms}}
DEMAlgorithms ALGORITHM ::= {
X9SymmetricKeyWrappingSchemes 
 CamilliaKeyWrappingSchemes,
+ CamelliaKeyWrappingSchemes,
...  implementations may define other methods
}
X9SymmetricKeyWrappingSchemes ALGORITHM ::= {
aes128Wrap  aes192Wrap  aes256Wrap  tdesWrap,
...  allows for future expansion
}
X9SymmetricKeyWrappingScheme ::=
AlgorithmIdentifier {{ X9SymmetricKeyWrappingSchemes }}
 CamilliaKeyWrappingSchemes ALGORITHM ::= {
+ CamelliaKeyWrappingSchemes ALGORITHM ::= {
camellia128Wrap  camellia192Wrap  camellia256Wrap,
...  allows for future expansion
}
 CamilliaKeyWrappingScheme ::=

 AlgorithmIdentifier {{ CamilliaKeyWrappingSchemes }}
+ CamelliaKeyWrappingScheme ::=
+ AlgorithmIdentifier {{ CamelliaKeyWrappingSchemes }}
 Key Derivation Functions
idkdfkdf2 OID ::= { x944components kdf2(1) }

 Base arc
x944 OID ::= {
iso(1) identifiedorganization(3) tc68(133) country(16) x9(840)
x9Standards(9) x944(44)
}
x944components OID ::= { x944 components(1) }
kdf2 ALGORITHM ::= { OID idkdfkdf2 PARMS KDF2HashFunction }
@@ 998,24 +956,23 @@
kdf2 ALGORITHM ::= { OID idkdfkdf2 PARMS KDF2HashFunction }
KDF2HashFunction ::= AlgorithmIdentifier {{ KDF2HashFunctions }}
KDF2HashFunctions ALGORITHM ::= {
X9HashFunctions,
...  implementations may define other methods
}
  idkdfkdf3 OID ::= { x944components kdf3(2) }
 kdf3 ALGORITHM ::= { OID idkdfkdf2 PARMS KDF3HashFunction }

 KDF3HashFunction ::= AlgorithmIdentifier {{ KDF3HashFunctions }}
+  idkdfkdf3 OID ::= { x944components kdf3(2) } kdf3 ALGORITHM
+ ::= { OID idkdfkdf2 PARMS KDF3HashFunction } KDF3HashFunction
+ ::= AlgorithmIdentifier {{ KDF3HashFunctions }}
KDF3HashFunctions ALGORITHM ::= {
X9HashFunctions,
...  implementations may define other methods
}
 Hash Functions
X9HashFunctions ALGORITHM ::= {
sha1  sha224  sha256  sha384  sha512,
@@ 1067,50 +1024,51 @@
idcamellia256Wrap OBJECT IDENTIFIER ::=
{ iso(1) memberbody(2) 392 200011 61 security(1)
algorithm(1) keywrapalgorithm(3)
camellia256wrap(4) }
camellia128Wrap ALGORITHM ::= { OID idcamellia128Wrap }
camellia192Wrap ALGORITHM ::= { OID idcamellia192Wrap }
camellia256Wrap ALGORITHM ::= { OID idcamellia256Wrap }
END

B.4 Examples
 As an example, if the key derivation function is KDF2 based on
 SHA256 and the symmetric keywrapping scheme is the AES Key Wrap
 with a 128bit KEK, the AlgorithmIdentifier for the RSAKEM Key
 Transport Algorithm will have the following value:
+ As an example, if the key derivation function is KDF2 based onSHA256
+ and the symmetric keywrapping scheme is the AES Key Wrap with a 128
+ bit KEK, the AlgorithmIdentifier for the RSAKEM Key Transport
+ Algorithm will have the following value:
SEQUENCE {
 idacgenerichybrid,  generic cipher
+ idrsakem,  RSAKEM cipher
SEQUENCE {  GenericHybridParameters
SEQUENCE {  key encapsulation mechanism
idkemrsa,  RSAKEM
SEQUENCE {  RsaKemParameters
SEQUENCE {  key derivation function
idkdfkdf2,  KDF2
SEQUENCE {  KDF2HashFunction
idsha256  SHA256; no parameters (preferred)
},
16  KEK length in bytes
},
SEQUENCE {  data encapsulation mechanism
idaes128Wrap  AES128 Wrap; no parameters
}
}
}
 This AlgorithmIdentifier value has the following DER encoding:
 30 4f
 06 07 28 81 8c 71 02 01 02  idacgenerichybrid
+ This AlgorithmIdentifier value has the following DER encoding (??
+ indicates the algorithm number which is to be assigned):
+
+ 30 53
+ 06 0b 2a 86 48 86 f7 0d 01 09 10 03 ??  idrsakem
30 44
30 25
06 07 28 81 8c 71 02 02 04  idkemrsa
30 1a
30 16
06 07 28 81 8c 71 02 05 02  idkdfkdf2
30 0b
06 09 60 86 48 01 65 03 04 02 01  idsha256
02 10  16 bytes
30 0b
@@ 1108,69 +1066,99 @@
30 25
06 07 28 81 8c 71 02 02 04  idkemrsa
30 1a
30 16
06 07 28 81 8c 71 02 05 02  idkdfkdf2
30 0b
06 09 60 86 48 01 65 03 04 02 01  idsha256
02 10  16 bytes
30 0b
06 09 60 86 48 01 65 03 04 01 05  idaes128Wrap

The DER encodings for other typical sets of underlying components are
as follows:
 * KDF2 based on SHA384, AES Key Wrap with a 192bit KEK
+ o KDF2 based on SHA384, AES Key Wrap with a 192bit KEK
 30 4f 06 07 28 81 8c 71 02 01 02 30 44 30 25 06
 07 28 81 8c 71 02 02 04 30 1a 30 16 06 07 28 81
 8c 71 02 05 02 30 0b 06 09 60 86 48 01 65 03 04
 02 02 02 18 30 0b 06 09 60 86 48 01 65 03 04 01
 19
+ 30 46 06 0b 2a 86 48 86 f7 0d 01 09 10 03 ?? 02
+ 01 02 30 44 30 25 06 07 28 81 8c 71 02 02 04 30
+ 1a 30 16 06 07 28 81 8c 71 02 05 02 30 0b 06 09
+ 60 86 48 01 65 03 04 02 02 02 18 30 0b 06 09 60
+ 86 48 01 65 03 04 01 19
 * KDF2 based on SHA512, AES Key Wrap with a 256bit KEK
+ o KDF2 based on SHA512, AES Key Wrap with a 256bit KEK
 30 4f 06 07 28 81 8c 71 02 01 02 30 44 30 25 06
 07 28 81 8c 71 02 02 04 30 1a 30 16 06 07 28 81
 8c 71 02 05 02 30 0b 06 09 60 86 48 01 65 03 04
 02 03 02 20 30 0b 06 09 60 86 48 01 65 03 04 01
 2d
+ 30 46 06 0b 2a 86 48 86 f7 0d 01 09 10 03 ?? 02
+ 01 02 30 44 30 25 06 07 28 81 8c 71 02 02 04 30
+ 1a 30 16 06 07 28 81 8c 71 02 05 02 30 0b 06 09
+ 60 86 48 01 65 03 04 02 03 02 20 30 0b 06 09 60
+ 86 48 01 65 03 04 01 2d
 * KDF2 based on SHA1, TripleDES Key Wrap with a 128bit KEK
 (twokey tripleDES)
+ o KDF2 based on SHA1, TripleDES Key Wrap with a 128bit KEK (two
+ key tripleDES)
 30 4f 06 07 28 81 8c 71 02 01 02 30 44 30 21 06
 07 28 81 8c 71 02 02 04 30 16 30 12 06 07 28 81
 8c 71 02 05 02 30 07 06 05 2b 0e 03 02 1a 02 10
 30 0f 06 0b 2a 86 48 86 f7 0d 01 09 10 03 06 05
 00
+ 30 46 06 0b 2a 86 48 86 f7 0d 01 09 10 03 ?? 02
+ 01 02 30 44 30 21 06 07 28 81 8c 71 02 02 04 30
+ 16 30 12 06 07 28 81 8c 71 02 05 02 30 07 06 05
+ 2b 0e 03 02 1a 02 10 30 0f 06 0b 2a 86 48 86 f7
+ 0d 01 09 10 03 06 05 00
Full Copyright Statement
+ IANA Considerations
 Copyright (C) The IETF Trust (2008).
+ Within the CMS, algorithms are identified by object identifiers
+ (OIDs). With one exception, all of the OIDs used in this document
+ were assigned in other IETF documents, in ISO/IEC standards
+ documents, by the National Institute of Standards and Technology
+ (NIST), and in PublicKey Cryptography Standards (PKCS) documents.
+ The one exception is that the ASN.1 module's identifier (see Appendix
+ B.3) is assigned in this document. No further action by the IANA is
+ necessary for this document or any anticipated updates.
 This document and translations of it may be copied and furnished to
 others, and derivative works that comment on or otherwise explain it
 or assist in its implementation may be prepared, copied, published
 and distributed, in whole or in part, without restriction of any
 kind, provided that the above copyright notice and this paragraph
 are included on all such copies and derivative works. However, this
 document itself may not be modified in any way, such as by removing
 the copyright notice or references to the Internet Society or other
 Internet organizations, except as needed for the purpose of
 developing Internet standards in which case the procedures for
 copyrights defined in the Internet Standards process must be
 followed, or as required to translate it into languages other than
 English.
+ Acknowledgments
 The limited permissions granted above are perpetual and will not be
 revoked by the Internet Society or its successors or assigns.
+ This document is one part of a strategy to align algorithm standards
+ produced by ASC X9, ISO/IEC JTC1 SC27, NIST, and the IETF. We would
+ like to thank the members of the ASC X9F1 working group for their
+ contributions to drafts of ANS X9.44 which led to this specification.
Disclaimer Statement
+ Our thanks to Russ Housley as well for his guidance and
+ encouragement. We also appreciate the helpful direction we've
+ received from Blake Ramsdell and Jim Schaad in bringing this document
+ to fruition. A special thanks to Magnus Nystrom for his assistance on
+ Appendix B. Thanks also to Bob Griffin and John Linn for both
+ editorial direction and procedural guidance.
 This document and the information contained herein are provided on an
 "AS IS" basis and THE CONTRIBUTOR, THE ORGANIZATION HE/SHE REPRESENTS
 OR IS SPONSORED BY (IF ANY), THE INTERNET SOCIETY, THE IETF TRUST AND
 THE INTERNET ENGINEERING TASK FORCE DISCLAIM ALL WARRANTIES, EXPRESS
 OR IMPLIED, INCLUDING BUT NOT LIMITED TO ANY WARRANTY THAT THE USE OF
 THE INFORMATION HEREIN WILL NOT INFRINGE ANY RIGHTS OR ANY IMPLIED
 WARRANTIES OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE.
+ Author Information
+
+ James Randall
+
+ Randall Consulting
+ 55 Sandpiper Drive
+ Dover, NH 03820
+ USA
+
+ Email: jdrandall@comcast.net
+
+ Burt Kaliski
+
+ EMC
+ 176 South Street
+ Hopkinton, MA 01748
+ USA
+
+ Email: kaliski_burt@emc.com
+
+ John Brainard
+
+ RSA, The Security Division of EMC
+ 174 Middlesex Turnpike
+ Bedford, MA 01730
+ USA
+ Email: jbrainard@rsa.com
+
+ Sean Turner
+
+ IECA, Inc.
+ 3057 Nutley Street, Suite 106
+ Fairfax, VA 22031
+ USA
+
+ Email: turners@ieca.com