# Use of Elliptic Curve Cryptography (ECC) Algorithms in Cryptographic Message Syntax (CMS)

Pages: 61
Informational
Errata
Obsoletes:  3278
Part 2 of 3 – Pages 11 to 33

```4.  AuthenticatedData and AuthEnvelopedData Using ECC

This section describes how to use ECC algorithms with the CMS
AuthenticatedData format.  AuthenticatedData lacks non-repudiation,
and so in some instances is preferable to SignedData.  (For example,
the sending agent might not want the message to be authenticated when
forwarded.)

This section also describes how to use ECC algorithms with the CMS
AuthEnvelopedData format [CMS-AUTHENV].  AuthEnvelopedData supports
authentication and encryption, and in some instances is preferable to
signing and then encrypting data.

For both AuthenticatedData and AuthEnvelopedData, data origin
authentication with 1-Pass ECMQV can only be provided when there is
one and only one recipient.  When there are multiple recipients, an
attack is possible where one recipient modifies the content without
other recipients noticing [BON].  A sending agent who is concerned
with such an attack SHOULD use a separate AuthenticatedData or
AuthEnvelopedData for each recipient.

Using an algorithm with the sender static key pair allows for
knowledge of the message creator; this means that authentication can,
in some circumstances, be obtained for AuthEnvelopedData and
AuthenticatedData.  This means that 1-Pass ECMQV can be a common
algorithm for EnvelopedData, AuthenticatedData, and AuthEnvelopedData
while ECDH can only be used in EnvelopedData.

4.1.  AuthenticatedData Using 1-Pass ECMQV

This section describes how to use the 1-Pass ECMQV key agreement
algorithm with AuthenticatedData.  ECMQV is method C(1, 2, ECC MQV)
from [SP800-56A].

When using ECMQV with AuthenticatedData, the fields of
AuthenticatedData are as in [CMS], but with the following
restrictions:

- macAlgorithm MUST contain the algorithm identifier of the message
authentication code (MAC) algorithm (see Section 7.1.7), which MUST
be one of the following: hmac-SHA1, id-hmacWITHSHA224, id-
hmacWITHSHA256, id-hmacWITHSHA384, or id-hmacWITHSHA512.

- digestAlgorithm MUST contain the algorithm identifier of the hash
algorithm (see Section 7.1.1), which MUST be one of the following:
id-sha1, id-sha224, id-sha256, id-sha384, or id-sha512.
```
```   As 1-Pass ECMQV is a key agreement algorithm, the RecipientInfo kari
choice is used in the AuthenticatedData.  When using 1-Pass ECMQV,
the AuthenticatedData originatorInfo field MAY include the
certificate(s) for the EC public key(s) used in the formation of the
pairwise key.  ECC certificates are discussed in Section 5.

4.1.1.  Fields of the KeyAgreeRecipientInfo

The AuthenticatedData KeyAgreeRecipientInfo fields are used in the
same manner as the fields for the corresponding EnvelopedData
KeyAgreeRecipientInfo fields of Section 3.2.1 of this document.

4.1.2.  Actions of the Sending Agent

The sending agent uses the same actions as for EnvelopedData with
1-Pass ECMQV, as specified in Section 3.2.2 of this document.

In a single message, if there are multiple layers for a recipient,
then the ephemeral public key can be reused by the originator for
that recipient in each of the different layers.

4.1.3.  Actions of the Receiving Agent

The receiving agent uses the same actions as for EnvelopedData with
1-Pass ECMQV, as specified in Section 3.2.3 of this document.

4.2.  AuthEnvelopedData Using 1-Pass ECMQV

This section describes how to use the 1-Pass ECMQV key agreement
algorithm with AuthEnvelopedData.  ECMQV is method C(1, 2, ECC MQV)
from [SP800-56A].

When using ECMQV with AuthEnvelopedData, the fields of
AuthEnvelopedData are as in [CMS-AUTHENV].

As 1-Pass ECMQV is a key agreement algorithm, the RecipientInfo kari
choice is used.  When using 1-Pass ECMQV, the AuthEnvelopedData
originatorInfo field MAY include the certificate(s) for the EC public
key used in the formation of the pairwise key.  ECC certificates are
discussed in Section 5.

4.2.1.  Fields of the KeyAgreeRecipientInfo

The AuthEnvelopedData KeyAgreeRecipientInfo fields are used in the
same manner as the fields for the corresponding EnvelopedData
KeyAgreeRecipientInfo fields of Section 3.2.1 of this document.
```
```4.2.2.  Actions of the Sending Agent

The sending agent uses the same actions as for EnvelopedData with
1-Pass ECMQV, as specified in Section 3.2.2 of this document.

In a single message, if there are multiple layers for a recipient,
then the ephemeral public key can be reused by the originator for
that recipient in each of the different layers.

4.2.3.  Actions of the Receiving Agent

The receiving agent uses the same actions as for EnvelopedData with
1-Pass ECMQV, as specified in Section 3.2.3 of this document.

5.  Certificates Using ECC

Internet X.509 certificates [PKI] can be used in conjunction with
this specification to distribute agents' public keys.  The use of ECC
algorithms and keys within X.509 certificates is specified in
[PKI-ALG].

6.  SMIMECapabilities Attribute and ECC

A sending agent MAY announce to receiving agents that it supports one
or more of the ECC algorithms specified in this document by using the
SMIMECapabilities signed attribute [MSG] in either a signed message
or a certificate [CERTCAP].

The SMIMECapabilities attribute value indicates support for one of
the ECDSA signature algorithms in a SEQUENCE with the capabilityID
field containing the object identifier ecdsa-with-SHA1 with NULL
parameters and ecdsa-with-SHA* (where * is 224, 256, 384, or 512)
with absent parameters.  The DER encodings are:

ecdsa-with-SHA1:   30 0b 06 07 2a 86 48 ce 3d 04 01 05 00

ecdsa-with-SHA224: 30 0a 06 08 2a 86 48 ce 3d 04 03 01

ecdsa-with-SHA256: 30 0a 06 08 2a 86 48 ce 3d 04 03 02

ecdsa-with-SHA384: 30 0a 06 08 2a 86 48 ce 3d 04 03 03

ecdsa-with-SHA512: 30 0a 06 08 2a 86 48 ce 3d 04 03 04

NOTE: The SMIMECapabilities attribute indicates that parameters for
ECDSA with SHA-1 are NULL; however, the parameters are absent when
used to generate a digital signature.
```
```   The SMIMECapabilities attribute value indicates support for

a)  the standard ECDH key agreement algorithm,
b)  the cofactor ECDH key agreement algorithm, or
c)  the 1-Pass ECMQV key agreement algorithm and

is a SEQUENCE with the capabilityID field containing the object
identifier

a)  dhSinglePass-stdDH-sha*kdf-scheme,
b)  dhSinglePass-cofactorDH-sha*kdf-scheme, or
c)  mqvSinglePass-sha*kdf-scheme

respectively (where * is 1, 224, 256, 384, or 512) with the
parameters present.  The parameters indicate the supported key-
encryption algorithm with the KeyWrapAlgorithm algorithm identifier.

The DER encodings that indicate capabilities are as follows (KA is
key agreement, KDF is key derivation function, and Wrap is key wrap
algorithm):

KA=ECDH standard KDF=SHA-1 Wrap=Triple-DES

30 1c 06 09 2b 81 05 10 86 48 3f 00 02 30 0f 06 0b 2a 86 48 86
f7 0d 01 09 10 03 06 05 00

KA=ECDH standard KDF=SHA-224 Wrap=Triple-DES

30 17 06 06 2b 81 04 01 0B 00 30 0d 06 0b 2a 86 48 86 f7 0d 01
09 10 03 06

KA=ECDH standard KDF=SHA-256 Wrap=Triple-DES

30 17 06 06 2b 81 04 01 0B 01 30 0d 06 0b 2a 86 48 86 f7 0d 01
09 10 03 06

KA=ECDH standard KDF=SHA-384 Wrap=Triple-DES

30 17 06 06 2b 81 04 01 0B 02 30 0d 06 0b 2a 86 48 86 f7 0d 01
09 10 03 06

KA=ECDH standard KDF=SHA-512 Wrap=Triple-DES

30 17 06 06 2b 81 04 01 0B 03 30 0d 06 0b 2a 86 48 86 f7 0d 01
09 10 03 06
```
```      KA=ECDH standard KDF=SHA-1 Wrap=AES-128

30 18 06 09 2b 81 05 10 86 48 3f 00 02 30 0b 06 09 60 86 48 01
65 03 04 01 05

KA=ECDH standard KDF=SHA-224 Wrap=AES-128

30 15 06 06 2b 81 04 01 0B 00 30 0b 06 09 60 86 48 01 65 03 04
01 05

KA=ECDH standard KDF=SHA-256 Wrap=AES-128

30 15 06 06 2b 81 04 01 0B 01 30 0b 06 09 60 86 48 01 65 03 04
01 05

KA=ECDH standard KDF=SHA-384 Wrap=AES-128

30 15 06 06 2b 81 04 01 0B 02 30 0b 06 09 60 86 48 01 65 03 04
01 05

KA=ECDH standard KDF=SHA-512 Wrap=AES-128

30 15 06 06 2b 81 04 01 0B 03 30 0b 06 09 60 86 48 01 65 03 04
01 05

KA=ECDH standard KDF=SHA-1 Wrap=AES-192

30 18 06 09 2b 81 05 10 86 48 3f 00 02 30 0b 06 09 60 86 48 01
65 03 04 01 19

KA=ECDH standard KDF=SHA-224 Wrap=AES-192

30 15 06 06 2b 81 04 01 0B 00 30 0b 06 09 60 86 48 01 65 03 04
01 19

KA=ECDH standard KDF=SHA-256 Wrap=AES-192

30 15 06 06 2b 81 04 01 0B 01 30 0b 06 09 60 86 48 01 65 03 04
01 19

KA=ECDH standard KDF=SHA-384 Wrap=AES-192

30 15 06 06 2b 81 04 01 0B 02 30 0b 06 09 60 86 48 01 65 03 04
01 19
```
```      KA=ECDH standard KDF=SHA-512 Wrap=AES-192

30 15 06 06 2b 81 04 01 0B 03 30 0b 06 09 60 86 48 01 65 03 04
01 19

KA=ECDH standard KDF=SHA-1 Wrap=AES-256

30 18 06 09 2b 81 05 10 86 48 3f 00 02 30 0b 06 09 60 86 48 01
65 03 04 01 2D

KA=ECDH standard KDF=SHA-224 Wrap=AES-256

30 15 06 06 2b 81 04 01 0B 00 30 0b 06 09 60 86 48 01 65 03 04
01 2D

KA=ECDH standard KDF=SHA-256 Wrap=AES-256

30 15 06 06 2b 81 04 01 0B 01 30 0b 06 09 60 86 48 01 65 03 04
01 2D

KA=ECDH standard KDF=SHA-384 Wrap=AES-256

30 15 06 06 2b 81 04 01 0B 02 30 0b 06 09 60 86 48 01 65 03 04
01 2D 05 00

KA=ECDH standard KDF=SHA-512 Wrap=AES-256

30 15 06 06 2b 81 04 01 0B 03 30 0b 06 09 60 86 48 01 65 03 04
01 2D

KA=ECDH cofactor KDF=SHA-1 Wrap=Triple-DES

30 1c 06 09 2b 81 05 10 86 48 3f 00 03 30 0f 06 0b 2a 86 48 86
f7 0d 01 09 10 03 06 05 00

KA=ECDH cofactor KDF=SHA-224 Wrap=Triple-DES

30 17 06 06 2b 81 04 01 0E 00 30 0d 06 0b 2a 86 48 86 f7 0d 01
09 10 03 06

KA=ECDH cofactor KDF=SHA-256 Wrap=Triple-DES

30 17 06 06 2b 81 04 01 0E 01 30 0d 06 0b 2a 86 48 86 f7 0d 01
09 10 03 06
```
```      KA=ECDH cofactor KDF=SHA-384 Wrap=Triple-DES

30 17 06 06 2b 81 04 01 0E 02 30 0d 06 0b 2a 86 48 86 f7 0d 01
09 10 03 06

KA=ECDH cofactor KDF=SHA-512 Wrap=Triple-DES

30 17 06 06 2b 81 04 01 0E 03 30 0d 06 0b 2a 86 48 86 f7 0d 01
09 10 03 06

KA=ECDH cofactor KDF=SHA-1 Wrap=AES-128

30 18 06 09 2b 81 05 10 86 48 3f 00 03 30 0b 06 09 60 86 48 01
65 03 04 01 05

KA=ECDH cofactor KDF=SHA-224 Wrap=AES-128

30 15 06 06 2b 81 04 01 0E 00 30 0b 06 09 60 86 48 01 65 03 04
01 05

KA=ECDH cofactor KDF=SHA-256 Wrap=AES-128

30 15 06 06 2b 81 04 01 0E 01 30 0b 06 09 60 86 48 01 65 03 04
01 05

KA=ECDH cofactor KDF=SHA-384 Wrap=AES-128

30 15 06 06 2b 81 04 01 0E 02 30 0b 06 09 60 86 48 01 65 03 04
01 05

KA=ECDH cofactor KDF=SHA-512 Wrap=AES-128

30 17 06 06 2b 81 04 01 0E 03 30 0b 06 09 60 86 48 01 65 03 04
01 05

KA=ECDH cofactor KDF=SHA-1 Wrap=AES-192

30 18 06 09 2b 81 05 10 86 48 3f 00 03 30 0b 06 09 60 86 48 01
65 03 04 01 19

KA=ECDH cofactor KDF=SHA-224 Wrap=AES-192

30 15 06 06 2b 81 04 01 0E 00 30 0b 06 09 60 86 48 01 65 03 04
01 19
```
```      KA=ECDH cofactor KDF=SHA-256 Wrap=AES-192

30 15 06 06 2b 81 04 01 0E 01 30 0b 06 09 60 86 48 01 65 03 04
01 19

KA=ECDH cofactor KDF=SHA-384 Wrap=AES-192

30 15 06 06 2b 81 04 01 0E 02 30 0b 06 09 60 86 48 01 65 03 04
01 19

KA=ECDH cofactor KDF=SHA-512 Wrap=AES-192

30 15 06 06 2b 81 04 01 0E 03 30 0b 06 09 60 86 48 01 65 03 04
01 19

KA=ECDH cofactor KDF=SHA-1 Wrap=AES-256

30 15 06 09 2b 81 05 10 86 48 3f 00 03 30 0b 06 09 60 86 48 01
65 03 04 01 2D

KA=ECDH cofactor KDF=SHA-224 Wrap=AES-256

30 15 06 06 2b 81 04 01 0E 00 30 0b 06 09 60 86 48 01 65 03 04
01 2D

KA=ECDH cofactor KDF=SHA-256 Wrap=AES-256

30 15 06 06 2b 81 04 01 0E 01 30 0b 06 09 60 86 48 01 65 03 04
01 2D

KA=ECDH cofactor KDF=SHA-384 Wrap=AES-256

30 15 06 06 2b 81 04 01 0E 02 30 0b 06 09 60 86 48 01 65 03 04
01 2D

KA=ECDH cofactor KDF=SHA-512 Wrap=AES-256

30 15 06 06 2b 81 04 01 0E 03 30 0b 06 09 60 86 48 01 65 03 04
01 2D

KA=ECMQV 1-Pass KDF=SHA-1 Wrap=Triple-DES

30 1c 06 09 2b 81 05 10 86 48 3f 00 10 30 0f 06 0b 2a 86 48 86
f7 0d 01 09 10 03 06 05 00
```
```      KA=ECMQV 1-Pass KDF=SHA-224 Wrap=Triple-DES

30 17 06 06 2b 81 04 01 0F 00 30 0d 06 0b 2a 86 48 86 f7 0d 01
09 10 03 06

KA=ECMQV 1-Pass KDF=SHA-256 Wrap=Triple-DES

30 17 06 06 2b 81 04 01 0F 01 30 0d 06 0b 2a 86 48 86 f7 0d 01
09 10 03 06

KA=ECMQV 1-Pass KDF=SHA-384 Wrap=Triple-DES

30 17 06 06 2b 81 04 01 0F 02 30 0d 06 0b 2a 86 48 86 f7 0d 01
09 10 03 06

KA=ECMQV 1-Pass KDF=SHA-512 Wrap=Triple-DES

30 17 06 06 2b 81 04 01 0F 03 30 0d 06 0b 2a 86 48 86 f7 0d 01
09 10 03 06

KA=ECMQV 1-Pass KDF=SHA-1 Wrap=AES-128

30 18 06 09 2b 81 05 10 86 48 3f 00 10 30 0b 06 09 60 86 48 01
65 03 04 01 05

KA=ECMQV 1-Pass KDF=SHA-224 Wrap=AES-128

30 15 06 06 2b 81 04 01 0F 00 30 0b 06 09 60 86 48 01 65 03 04
01 05

KA=ECMQV 1-Pass KDF=SHA-256 Wrap=AES-128

30 15 06 06 2b 81 04 01 0F 01 30 0b 06 09 60 86 48 01 65 03 04
01 05

KA=ECMQV 1-Pass KDF=SHA-384 Wrap=AES-128

30 15 06 06 2b 81 04 01 0F 02 30 0b 06 09 60 86 48 01 65 03 04
01 05

KA=ECMQV 1-Pass KDF=SHA-512 Wrap=AES-128

30 15 06 06 2b 81 04 01 0F 03 30 0b 06 09 60 86 48 01 65 03 04
01 05
```
```      KA=ECMQV 1-Pass KDF=SHA-1 Wrap=AES-192

30 18 06 09 2b 81 05 10 86 48 3f 00 10 30 0b 06 09 60 86 48 01
65 03 04 01 19

KA=ECMQV 1-Pass KDF=SHA-224 Wrap=AES-192

30 15 06 06 2b 81 04 01 0F 00 30 0b 06 09 60 86 48 01 65 03 04
01 19

KA=ECMQV 1-Pass KDF=SHA-256 Wrap=AES-192

30 15 06 06 2b 81 04 01 0F 01 30 0b 06 09 60 86 48 01 65 03 04
01 19

KA=ECMQV 1-Pass KDF=SHA-384 Wrap=AES-192

30 15 06 06 2b 81 04 01 0F 02 30 0b 06 09 60 86 48 01 65 03 04
01 19

KA=ECMQV 1-Pass KDF=SHA-512 Wrap=AES-192

30 15 06 06 2b 81 04 01 0F 03 30 0b 06 09 60 86 48 01 65 03 04
01 19

KA=ECMQV 1-Pass KDF=SHA-1 Wrap=AES-256

30 18 06 09 2b 81 05 10 86 48 3f 00 10 30 0b 06 09 60 86 48 01
65 03 04 01 2D

KA=ECMQV 1-Pass KDF=SHA-224 Wrap=AES-256

30 15 06 06 2b 81 04 01 0F 00 30 0b 06 09 60 86 48 01 65 03 04
01 2D

KA=ECMQV 1-Pass KDF=SHA-256 Wrap=AES-256

30 15 06 06 2b 81 04 01 0F 01 30 0b 06 09 60 86 48 01 65 03 04
01 2D

KA=ECMQV 1-Pass KDF=SHA-384 Wrap=AES-256

30 15 06 06 2b 81 04 01 0F 02 30 0b 06 09 60 86 48 01 65 03 04
01 2D
```
```      KA=ECMQV 1-Pass KDF=SHA-512 Wrap=AES-256

30 15 06 06 2b 81 04 01 0F 03 30 0b 06 09 60 86 48 01 65 03 04
01 2D

NOTE: The S/MIME Capabilities for the supported AES content-
encryption key sizes are defined in [CMS-AES].

NOTE: The S/MIME Capabilities for the supported MAC algorithms are
defined in [CMS-ASN].

7.  ASN.1 Syntax

The ASN.1 syntax [X.680], [X.681], [X.682], [X.683] used in this
document is gathered in this section for reference purposes.

7.1.  Algorithm Identifiers

This section provides the object identifiers for the algorithms used
in this document along with any associated parameters.

7.1.1.  Digest Algorithms

Digest algorithm object identifiers are used in the SignedData
digestAlgorithms and digestAlgorithm fields and the AuthenticatedData
digestAlgorithm field.  The digest algorithms used in this document
are SHA-1, SHA-224, SHA-256, SHA-384, and SHA-512.  The object
identifiers and parameters associated with these algorithms are found
in [CMS-ALG] and [CMS-SHA2].

7.1.2.  Originator Public Key

The KeyAgreeRecipientInfo originator field uses the following object
identifier to indicate an elliptic curve public key:

id-ecPublicKey OBJECT IDENTIFIER ::= {
ansi-x9-62 keyType(2) 1 }

where

ansi-x9-62 OBJECT IDENTIFIER ::= {
iso(1) member-body(2) us(840) 10045 }

When the object identifier id-ecPublicKey is used here with an
algorithm identifier, the associated parameters MUST be either absent
or ECParameters.  Implementations MUST accept id-ecPublicKey with
absent and ECParameters parameters.  If ECParameters is present, its
```
```   value MUST match the recipient's ECParameters.  Implementations
SHOULD generate absent parameters for the id-ecPublicKey object
identifier in the KeyAgreeRecipientInfo originator field.

[CMS-ECC] indicated the parameters were NULL.  Support for this
legacy form is OPTIONAL.

7.1.3.  Signature Algorithms

Signature algorithm identifiers are used in the SignedData
signatureAlgorithm and signature fields.  The signature algorithms
used in this document are ECDSA with SHA-1, ECDSA with SHA-224, ECDSA
with SHA-256, ECDSA with SHA-384, and ECDSA with SHA-512.  The object
identifiers and parameters associated with these algorithms are found
in [PKI-ALG].

[CMS-ECC] indicated the parameters were NULL.  Support for this
legacy form is OPTIONAL.

7.1.4.  Key Agreement Algorithms

Key agreement algorithms are used in EnvelopedData,
AuthenticatedData, and AuthEnvelopedData in the KeyAgreeRecipientInfo
keyEncryptionAlgorithm field.  The following object identifiers
indicate the key agreement algorithms used in this document
[SP800-56A], [SEC1]:

dhSinglePass-stdDH-sha1kdf-scheme OBJECT IDENTIFIER ::= {
x9-63-scheme 2 }

dhSinglePass-stdDH-sha224kdf-scheme OBJECT IDENTIFIER ::= {
secg-scheme 11 0 }

dhSinglePass-stdDH-sha256kdf-scheme OBJECT IDENTIFIER ::= {
secg-scheme 11 1 }

dhSinglePass-stdDH-sha384kdf-scheme OBJECT IDENTIFIER ::= {
secg-scheme 11 2 }

dhSinglePass-stdDH-sha512kdf-scheme OBJECT IDENTIFIER ::= {
secg-scheme 11 3 }

dhSinglePass-cofactorDH-sha1kdf-scheme OBJECT IDENTIFIER ::= {
x9-63-scheme 3 }

dhSinglePass-cofactorDH-sha224kdf-scheme OBJECT IDENTIFIER ::= {
secg-scheme 14 0 }
```
```      dhSinglePass-cofactorDH-sha256kdf-scheme OBJECT IDENTIFIER ::= {
secg-scheme 14 1 }

dhSinglePass-cofactorDH-sha384kdf-scheme OBJECT IDENTIFIER ::= {
secg-scheme 14 2 }

dhSinglePass-cofactorDH-sha512kdf-scheme OBJECT IDENTIFIER ::= {
secg-scheme 14 3 }

mqvSinglePass-sha1kdf-scheme OBJECT IDENTIFIER ::= {
x9-63-scheme 16 }

mqvSinglePass-sha224kdf-scheme OBJECT IDENTIFIER ::= {
secg-scheme 15 0 }

mqvSinglePass-sha256kdf-scheme OBJECT IDENTIFIER ::= {
secg-scheme 15 1 }

mqvSinglePass-sha384kdf-scheme OBJECT IDENTIFIER ::= {
secg-scheme 15 2 }

mqvSinglePass-sha512kdf-scheme OBJECT IDENTIFIER ::= {
secg-scheme 15 3 }

where

x9-63-scheme OBJECT IDENTIFIER ::= {
iso(1) identified-organization(3) tc68(133) country(16)
x9(840) x9-63(63) schemes(0) }

and

secg-scheme OBJECT IDENTIFIER ::= {
iso(1) identified-organization(3) certicom(132) schemes(1) }

When the object identifiers are used here within an algorithm
identifier, the associated parameters field contains KeyWrapAlgorithm
to indicate the key wrap algorithm and any associated parameters.

7.1.5.  Key Wrap Algorithms

Key wrap algorithms are used as part of the parameters in the key
agreement algorithm.  The key wrap algorithms used in this document
are Triple-DES, AES-128, AES-192, and AES-256.  The object
identifiers and parameters for these algorithms are found in
[CMS-ALG] and [CMS-AES].
```
```7.1.6.  Content Encryption Algorithms

Content encryption algorithms are used in EnvelopedData and
AuthEnvelopedData in the EncryptedContentInfo
contentEncryptionAlgorithm field.  The content encryption algorithms
used with EnvelopedData in this document are 3-Key Triple DES in CBC
mode, AES-128 in CBC mode, AES-192 in CBC mode, and AES-256 in CBC
mode.  The object identifiers and parameters associated with these
algorithms are found in [CMS-ALG] and [CMS-AES].  The content
encryption algorithms used with AuthEnvelopedData in this document
are AES-128 in CCM mode, AES-192 in CCM mode, AES-256 in CCM mode,
AES-128 in GCM mode, AES-192 in GCM mode, and AES-256 in GCM mode.
The object identifiers and parameters associated with these
algorithms are found in [CMS-AESCG].

7.1.7.  Message Authentication Code Algorithms

Message authentication code algorithms are used in AuthenticatedData
in the macAlgorithm field.  The message authentication code
algorithms used in this document are HMAC with SHA-1, HMAC with
SHA-224, HMAC with SHA-256, HMAC with SHA-384, and HMAC with SHA-512.
The object identifiers and parameters associated with these
algorithms are found in [CMS-ALG] and [HMAC-SHA2].

NOTE: [HMAC-SHA2] defines the object identifiers for HMAC with
SHA-224, HMAC with SHA-256, HMAC with SHA-384, and HMAC with SHA-512,
but there is no ASN.1 module from which to import these object
identifiers.  Therefore, the object identifiers for these algorithms
are included in the ASN.1 modules defined in Appendix A.

7.1.8.  Key Derivation Algorithm

The KDF used in this document is as specified in Section 3.6.1 of
[SEC1].  The hash algorithm is identified in the key agreement
algorithm.  For example, dhSinglePass-stdDH-sha256kdf-scheme uses the
KDF from [SEC1] but uses SHA-256 instead of SHA-1.

7.2.  Other Syntax

The following additional syntax is used here.

When using ECDSA with SignedData, ECDSA signatures are encoded using
the type:

ECDSA-Sig-Value ::= SEQUENCE {
r INTEGER,
s INTEGER }
```
```   ECDSA-Sig-Value is specified in [PKI-ALG].  Within CMS, ECDSA-Sig-
Value is DER-encoded and placed within a signature field of
SignedData.

When using ECDH and ECMQV with EnvelopedData, AuthenticatedData, and
AuthEnvelopedData, ephemeral and static public keys are encoded using
the type ECPoint.  Implementations MUST support uncompressed keys,
MAY support compressed keys, and MUST NOT support hybrid keys.

ECPoint ::= OCTET STRING

When using ECMQV with EnvelopedData, AuthenticatedData, and
AuthEnvelopedData, the sending agent's ephemeral public key and
additional keying material are encoded using the type:

MQVuserKeyingMaterial ::= SEQUENCE {
ephemeralPublicKey      OriginatorPublicKey,
addedukm            [0] EXPLICIT UserKeyingMaterial OPTIONAL  }

The ECPoint syntax is used to represent the ephemeral public key and
is placed in the ephemeralPublicKey publicKey field.  The additional
user keying material is placed in the addedukm field.  Then the
MQVuserKeyingMaterial value is DER-encoded and placed within the ukm
field of EnvelopedData, AuthenticatedData, or AuthEnvelopedData.

When using ECDH or ECMQV with EnvelopedData, AuthenticatedData, or
AuthEnvelopedData, the key-encryption keys are derived by using the
type:

ECC-CMS-SharedInfo ::= SEQUENCE {
keyInfo         AlgorithmIdentifier,
entityUInfo [0] EXPLICIT OCTET STRING OPTIONAL,
suppPubInfo [2] EXPLICIT OCTET STRING  }

The fields of ECC-CMS-SharedInfo are as follows:

keyInfo contains the object identifier of the key-encryption
algorithm (used to wrap the CEK) and associated parameters.  In
this specification, 3DES wrap has NULL parameters while the AES
wraps have absent parameters.

entityUInfo optionally contains additional keying material
supplied by the sending agent.  When used with ECDH and CMS, the
entityUInfo field contains the octet string ukm.  When used with
ECMQV and CMS, the entityUInfo contains the octet string addedukm
(encoded in MQVuserKeyingMaterial).
```
```      suppPubInfo contains the length of the generated KEK, in bits,
represented as a 32-bit number, as in [CMS-DH] and [CMS-AES].
(For example, for AES-256 it would be 00 00 01 00.)

Within CMS, ECC-CMS-SharedInfo is DER-encoded and used as input to
the key derivation function, as specified in Section 3.6.1 of [SEC1].

NOTE: ECC-CMS-SharedInfo differs from the OtherInfo specified in
[CMS-DH].  Here, a counter value is not included in the keyInfo field
because the key derivation function specified in Section 3.6.1 of
[SEC1] ensures that sufficient keying data is provided.

8.  Recommended Algorithms and Elliptic Curves

It is RECOMMENDED that implementations of this specification support
SignedData and EnvelopedData.  Support for AuthenticatedData and
AuthEnvelopedData is OPTIONAL.

In order to encourage interoperability, implementations SHOULD use
the elliptic curve domain parameters specified by [PKI-ALG].

Implementations that support SignedData with ECDSA:

- MUST support ECDSA with SHA-256; and

- MAY support ECDSA with SHA-1, ECDSA with SHA-224, ECDSA with
SHA-384, and ECDSA with SHA-512; other digital signature
algorithms MAY also be supported.

When using ECDSA, to promote interoperability it is RECOMMENDED that
the P-192, P-224, and P-256 curves be used with SHA-256; the P-384
curve be used with SHA-384; and the P-521 curve be used with SHA-512.

If EnvelopedData is supported, then ephemeral-static ECDH standard
primitive MUST be supported.  Support for ephemeral-static ECDH co-
factor is OPTIONAL, and support for 1-Pass ECMQV is also OPTIONAL.

Implementations that support EnvelopedData with the ephemeral-static
ECDH standard primitive:

- MUST support the dhSinglePass-stdDH-sha256kdf-scheme key
agreement algorithm, the id-aes128-wrap key wrap algorithm, and
the id-aes128-cbc content encryption algorithm; and
```
```      - MAY support the dhSinglePass-stdDH-sha1kdf-scheme, dhSinglePass-
stdDH-sha224kdf-scheme, dhSinglePass-stdDH-sha384kdf-scheme, and
dhSinglePass-stdDH-sha512kdf-scheme key agreement algorithms;
the id-alg-CMS3DESwrap, id-aes192-wrap, and id-aes256-wrap key
wrap algorithms; and the des-ede3-cbc, id-aes192-cbc, and id-
aes256-cbc content encryption algorithms; other algorithms MAY
also be supported.

Implementations that support EnvelopedData with the ephemeral-static
ECDH cofactor primitive:

- MUST support the dhSinglePass-cofactorDH-sha256kdf-scheme key
agreement algorithm, the id-aes128-wrap key wrap algorithm, and
the id-aes128-cbc content encryption algorithm; and

- MAY support the dhSinglePass-cofactorDH-sha1kdf-scheme,
dhSinglePass-cofactorDH-sha224kdf-scheme, dhSinglePass-
cofactorDH-sha384kdf-scheme, and dhSinglePass-cofactorDH-
sha512kdf-scheme key agreement; the id-alg-CMS3DESwrap, id-
aes192-wrap, and id-aes256-wrap key wrap algorithms; and the
des-ede3-cbc, id-aes192-cbc, and id-aes256-cbc content
encryption algorithms; other algorithms MAY also be supported.

Implementations that support EnvelopedData with 1-Pass ECMQV:

- MUST support the mqvSinglePass-sha256kdf-scheme key agreement
algorithm, the id-aes128-wrap key wrap algorithm, and the id-
aes128-cbc content encryption algorithm; and

- MAY support the mqvSinglePass-sha1kdf-scheme, mqvSinglePass-
sha224kdf-scheme, mqvSinglePass-sha384kdf-scheme, and
mqvSinglePass-sha512kdf-scheme key agreement algorithms; the id-
alg-CMS3DESwrap, id-aes192-wrap, and id-aes256-wrap key wrap
algorithms; and the des-ede3-cbc, id-aes192-cbc, and id-
aes256-cbc content encryption algorithms; other algorithms MAY
also be supported.

Implementations that support AuthenticatedData with 1-Pass ECMQV:

- MUST support the mqvSinglePass-sha256kdf-scheme key agreement,
the id-aes128-wrap key wrap, the id-sha256 message digest, and
id-hmacWithSHA256 message authentication code algorithms; and

- MAY support the mqvSinglePass-sha1kdf-scheme, mqvSinglePass-
sha224kdf-scheme, mqvSinglePass-sha384kdf-scheme, mqvSinglePass-
sha512kdf-scheme key agreement algorithms; the id-alg-
CMS3DESwrap, id-aes192-wrap, and id-aes256-wrap key wrap
algorithms; the id-sha1, id-sha224, id-sha384, and id-sha512,
```
```        message digest algorithms; and the hmac-SHA1, id-hmacWithSHA224,
id-hmacWithSHA384, and id-hmacWithSHA512 message authentication
code algorithms; other algorithms MAY also be supported.

Implementations that support AuthEnvelopedData with 1-Pass ECMQV:

- MUST support the mqvSinglePass-sha256kdf-scheme key agreement,
the id-aes128-wrap key wrap, and the id-aes128-ccm
authenticated-content encryption; and

- MAY support the mqvSinglePass-sha1kdf-scheme, mqvSinglePass-
sha224kdf-scheme, mqvSinglePass-sha384kdf-scheme, and
mqvSinglePass-sha512kdf-scheme key agreement algorithms; the id-
alg-CMS3DESwrap, id-aes192-wrap, and id-aes256-wrap key wrap
algorithms; and the id-aes192-ccm, id-aes256-ccm, id-aes128-gcm,
id-aes192-gcm, and id-aes256-ccm authenticated-content
encryption algorithms; other algorithms MAY also be supported.

9.  Security Considerations

Cryptographic algorithms will be broken or weakened over time.
Implementers and users need to check that the cryptographic
algorithms listed in this document continue to provide the expected
level of security.  The IETF from time to time may issue documents
dealing with the current state of the art.

Cryptographic algorithms rely on random numbers.  See [RANDOM] for
guidance on generation of random numbers.

Receiving agents that validate signatures and sending agents that
encrypt messages need to be cautious of cryptographic processing
usage when validating signatures and encrypting messages using keys
larger than those mandated in this specification.  An attacker could
send keys and/or certificates with keys that would result in
excessive cryptographic processing, for example, keys larger than
those mandated in this specification, which could swamp the
processing element.  Agents that use such keys without first
validating the certificate to a trust anchor are advised to have some
sort of cryptographic resource management system to prevent such
attacks.

Using secret keys of an appropriate size is crucial to the security
of a Diffie-Hellman exchange.  For elliptic curve groups, the size of
the secret key must be equal to the size of n (the order of the group
generated by the point g).  Using larger secret keys provides
absolutely no additional security, and using smaller secret keys is
likely to result in dramatically less security.  (See [SP800-56A] for
```
```   This specification is based on [CMS], [CMS-AES], [CMS-AESCG],
[CMS-ALG], [CMS-AUTHENV], [CMS-DH], [CMS-SHA2], [FIPS180-3],
[FIPS186-3], and [HMAC-SHA2], and the appropriate security
considerations of those documents apply.

In addition, implementers of AuthenticatedData and AuthEnvelopedData
should be aware of the concerns expressed in [BON] when using
AuthenticatedData and AuthEnvelopedData to send messages to more than
one recipient.  Also, users of MQV should be aware of the
vulnerability described in [K].

When implementing EnvelopedData, AuthenticatedData, and
AuthEnvelopedData, there are five algorithm-related choices that need

1) What is the public key size?
2) What is the KDF?
3) What is the key wrap algorithm?
4) What is the content encryption algorithm?
5) What is the curve?

Consideration must be given to the strength of the security provided
by each of these choices.  Security algorithm strength is measured in
bits, where bits is measured in equivalence to a symmetric cipher
algorithm.  Thus, a strong symmetric cipher algorithm with a key of X
bits is said to provide X bits of security.  For other algorithms,
the key size is mapped to an equivalent symmetric cipher strength.
It is recommended that the bits of security provided by each are
roughly equivalent.  The following table provides comparable minimum
bits of security [SP800-57] for the ECDH/ECMQV key sizes, KDFs, key
wrapping algorithms, and content encryption algorithms.  It also
lists curves [PKI-ALG] for the key sizes.
```
```   Minimum  | ECDH or  | Key        | Key      | Content     | Curves
Bits of  | ECMQV    | Derivation | Wrap     | Encryption  |
Security | Key Size | Function   | Alg.     | Alg.        |
---------+----------+------------+----------+-------------+----------
80       | 160-223  | SHA-1      | 3DES     | 3DES CBC    | sect163k1
|          | SHA-224    | AES-128  | AES-128 CBC | secp163r2
|          | SHA-256    | AES-192  | AES-192 CBC | secp192r1
|          | SHA-384    | AES-256  | AES-256 CBC |
|          | SHA-512    |          |             |
---------+----------+------------+----------+-------------+---------
112      | 224-255  | SHA-1      | 3DES     | 3DES CBC    | secp224r1
|          | SHA-224    | AES-128  | AES-128 CBC | sect233k1
|          | SHA-256    | AES-192  | AES-192 CBC | sect233r1
|          | SHA-384    | AES-256  | AES-256 CBC |
|          | SHA-512    |          |             |
---------+----------+------------+----------+-------------+---------
128      | 256-383  | SHA-1      | AES-128  | AES-128 CBC | secp256r1
|          | SHA-224    | AES-192  | AES-192 CBC | sect283k1
|          | SHA-256    | AES-256  | AES-256 CBC | sect283r1
|          | SHA-384    |          |             |
|          | SHA-512    |          |             |
---------+----------+------------+----------+-------------+---------
192      | 384-511  | SHA-224    | AES-192  | AES-192 CBC | secp384r1
|          | SHA-256    | AES-256  | AES-256 CBC | sect409k1
|          | SHA-384    |          |             | sect409r1
|          | SHA-512    |          |             |
---------+----------+------------+----------+-------------+---------
256      | 512+     | SHA-256    | AES-256  | AES-256 CBC | secp521r1
|          | SHA-384    |          |             | sect571k1
|          | SHA-512    |          |             | sect571r1
---------+----------+------------+----------+-------------+---------
```
```   To promote interoperability, the following choices are RECOMMENDED:

Minimum  | ECDH or  | Key        | Key      | Content     | Curve
Bits of  | ECMQV    | Derivation | Wrap     | Encryption  |
Security | Key Size | Function   | Alg.     | Alg.        |
---------+----------+------------+----------+-------------+----------
80       | 192      | SHA-256    | 3DES     | 3DES CBC    | secp192r1
---------+----------+------------+----------+-------------+----------
112      | 224      | SHA-256    | 3DES     | 3DES CBC    | secp224r1
---------+----------+------------+----------+-------------+----------
128      | 256      | SHA-256    | AES-128  | AES-128 CBC | secp256r1
---------+----------+------------+----------+-------------+----------
192      | 384      | SHA-384    | AES-256  | AES-256 CBC | secp384r1
---------+----------+------------+----------+-------------+----------
256      | 512+     | SHA-512    | AES-256  | AES-256 CBC | secp521r1
---------+----------+------------+----------+-------------+----------

When implementing SignedData, there are three algorithm-related
choices that need to be made:

1) What is the public key size?
2) What is the hash algorithm?
3) What is the curve?

Consideration must be given to the bits of security provided by each
of these choices.  Security is measured in bits, where a strong
symmetric cipher with a key of X bits is said to provide X bits of
security.  It is recommended that the bits of security provided by
each choice are roughly equivalent.  The following table provides
comparable minimum bits of security [SP800-57] for the ECDSA key
sizes and message digest algorithms.  It also lists curves [PKI-ALG]
for the key sizes.
```
```   Minimum  | ECDSA    | Message   | Curve
Bits of  | Key Size | Digest    |
Security |          | Algorithm |
---------+----------+-----------+-----------
80       | 160-223  | SHA-1     | sect163k1
|          | SHA-224   | secp163r2
|          | SHA-256   | secp192r1
|          | SHA-384   |
|          | SHA-512   |
---------+----------+-----------+-----------
112      | 224-255  | SHA-224   | secp224r1
|          | SHA-256   | sect233k1
|          | SHA-384   | sect233r1
|          | SHA-512   |
---------+----------+-----------+-----------
128      | 256-383  | SHA-256   | secp256r1
|          | SHA-384   | sect283k1
|          | SHA-512   | sect283r1
---------+----------+-----------+-----------
192      | 384-511  | SHA-384   | secp384r1
|          | SHA-512   | sect409k1
|          |           | sect409r1
---------+----------+-----------+-----------
256      | 512+     | SHA-512   | secp521r1
|          |           | sect571k1
|          |           | sect571r1
---------+----------+-----------+-----------

To promote interoperability, the following choices are RECOMMENDED:

Minimum  | ECDSA    | Message   | Curve
Bits of  | Key Size | Digest    |
Security |          | Algorithm |
---------+----------+-----------+-----------
80       | 192      | SHA-256   | sect192r1
---------+----------+-----------+-----------
112      | 224      | SHA-256   | secp224r1
---------+----------+-----------+-----------
128      | 256      | SHA-256   | secp256r1
---------+----------+-----------+-----------
192      | 384      | SHA-384   | secp384r1
---------+----------+-----------+-----------
256      | 512+     | SHA-512   | secp521r1
---------+----------+-----------+-----------
```
```10.  IANA Considerations

This document makes extensive use of object identifiers to register
originator public key types and algorithms.  The algorithm object
identifiers are registered in the ANSI X9.62, ANSI X9.63, NIST, RSA,
and SECG arcs.  Additionally, object identifiers are used to identify
the ASN.1 modules found in Appendix A (there are two).  These are
defined by the SMIME WG Registrar in an arc delegated by RSA to the
SMIME Working Group: iso(1) member-body(2) us(840) rsadsi(113549)
pkcs(1) pkcs-9(9) smime(16) modules(0).  No action by IANA is
necessary for this document or any anticipated updates.

```

(page 33 continued on part 3)