1 /* crypto/cms/cms_asn1.c */
3 * Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL
6 /* ====================================================================
7 * Copyright (c) 2008 The OpenSSL Project. All rights reserved.
9 * Redistribution and use in source and binary forms, with or without
10 * modification, are permitted provided that the following conditions
13 * 1. Redistributions of source code must retain the above copyright
14 * notice, this list of conditions and the following disclaimer.
16 * 2. Redistributions in binary form must reproduce the above copyright
17 * notice, this list of conditions and the following disclaimer in
18 * the documentation and/or other materials provided with the
21 * 3. All advertising materials mentioning features or use of this
22 * software must display the following acknowledgment:
23 * "This product includes software developed by the OpenSSL Project
24 * for use in the OpenSSL Toolkit. (http://www.OpenSSL.org/)"
26 * 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to
27 * endorse or promote products derived from this software without
28 * prior written permission. For written permission, please contact
29 * licensing@OpenSSL.org.
31 * 5. Products derived from this software may not be called "OpenSSL"
32 * nor may "OpenSSL" appear in their names without prior written
33 * permission of the OpenSSL Project.
35 * 6. Redistributions of any form whatsoever must retain the following
37 * "This product includes software developed by the OpenSSL Project
38 * for use in the OpenSSL Toolkit (http://www.OpenSSL.org/)"
40 * THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY
41 * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
42 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
43 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE OpenSSL PROJECT OR
44 * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
45 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
46 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
47 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
48 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
49 * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
50 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
51 * OF THE POSSIBILITY OF SUCH DAMAGE.
52 * ====================================================================
55 #include <openssl/asn1t.h>
56 #include <openssl/pem.h>
57 #include <openssl/x509v3.h>
58 #include <openssl/cms.h>
62 ASN1_SEQUENCE(CMS_IssuerAndSerialNumber
) = {
63 ASN1_SIMPLE(CMS_IssuerAndSerialNumber
, issuer
, X509_NAME
),
64 ASN1_SIMPLE(CMS_IssuerAndSerialNumber
, serialNumber
, ASN1_INTEGER
)
65 } ASN1_SEQUENCE_END(CMS_IssuerAndSerialNumber
)
67 ASN1_SEQUENCE(CMS_OtherCertificateFormat
) = {
68 ASN1_SIMPLE(CMS_OtherCertificateFormat
, otherCertFormat
, ASN1_OBJECT
),
69 ASN1_OPT(CMS_OtherCertificateFormat
, otherCert
, ASN1_ANY
)
70 } ASN1_SEQUENCE_END(CMS_OtherCertificateFormat
)
72 ASN1_CHOICE(CMS_CertificateChoices
) = {
73 ASN1_SIMPLE(CMS_CertificateChoices
, d
.certificate
, X509
),
74 ASN1_IMP(CMS_CertificateChoices
, d
.extendedCertificate
, ASN1_SEQUENCE
, 0),
75 ASN1_IMP(CMS_CertificateChoices
, d
.v1AttrCert
, ASN1_SEQUENCE
, 1),
76 ASN1_IMP(CMS_CertificateChoices
, d
.v2AttrCert
, ASN1_SEQUENCE
, 2),
77 ASN1_IMP(CMS_CertificateChoices
, d
.other
, CMS_OtherCertificateFormat
, 3)
78 } ASN1_CHOICE_END(CMS_CertificateChoices
)
80 ASN1_CHOICE(CMS_SignerIdentifier
) = {
81 ASN1_SIMPLE(CMS_SignerIdentifier
, d
.issuerAndSerialNumber
, CMS_IssuerAndSerialNumber
),
82 ASN1_IMP(CMS_SignerIdentifier
, d
.subjectKeyIdentifier
, ASN1_OCTET_STRING
, 0)
83 } ASN1_CHOICE_END(CMS_SignerIdentifier
)
85 ASN1_NDEF_SEQUENCE(CMS_EncapsulatedContentInfo
) = {
86 ASN1_SIMPLE(CMS_EncapsulatedContentInfo
, eContentType
, ASN1_OBJECT
),
87 ASN1_NDEF_EXP_OPT(CMS_EncapsulatedContentInfo
, eContent
, ASN1_OCTET_STRING_NDEF
, 0)
88 } ASN1_NDEF_SEQUENCE_END(CMS_EncapsulatedContentInfo
)
90 /* Minor tweak to operation: free up signer key, cert */
91 static int cms_si_cb(int operation
, ASN1_VALUE
**pval
, const ASN1_ITEM
*it
,
94 if (operation
== ASN1_OP_FREE_POST
) {
95 CMS_SignerInfo
*si
= (CMS_SignerInfo
*)*pval
;
96 EVP_PKEY_free(si
->pkey
);
97 X509_free(si
->signer
);
99 EVP_MD_CTX_cleanup(&si
->mctx
);
104 ASN1_SEQUENCE_cb(CMS_SignerInfo
, cms_si_cb
) = {
105 ASN1_SIMPLE(CMS_SignerInfo
, version
, LONG
),
106 ASN1_SIMPLE(CMS_SignerInfo
, sid
, CMS_SignerIdentifier
),
107 ASN1_SIMPLE(CMS_SignerInfo
, digestAlgorithm
, X509_ALGOR
),
108 ASN1_IMP_SET_OF_OPT(CMS_SignerInfo
, signedAttrs
, X509_ATTRIBUTE
, 0),
109 ASN1_SIMPLE(CMS_SignerInfo
, signatureAlgorithm
, X509_ALGOR
),
110 ASN1_SIMPLE(CMS_SignerInfo
, signature
, ASN1_OCTET_STRING
),
111 ASN1_IMP_SET_OF_OPT(CMS_SignerInfo
, unsignedAttrs
, X509_ATTRIBUTE
, 1)
112 } ASN1_SEQUENCE_END_cb(CMS_SignerInfo
, CMS_SignerInfo
)
114 ASN1_SEQUENCE(CMS_OtherRevocationInfoFormat
) = {
115 ASN1_SIMPLE(CMS_OtherRevocationInfoFormat
, otherRevInfoFormat
, ASN1_OBJECT
),
116 ASN1_OPT(CMS_OtherRevocationInfoFormat
, otherRevInfo
, ASN1_ANY
)
117 } ASN1_SEQUENCE_END(CMS_OtherRevocationInfoFormat
)
119 ASN1_CHOICE(CMS_RevocationInfoChoice
) = {
120 ASN1_SIMPLE(CMS_RevocationInfoChoice
, d
.crl
, X509_CRL
),
121 ASN1_IMP(CMS_RevocationInfoChoice
, d
.other
, CMS_OtherRevocationInfoFormat
, 1)
122 } ASN1_CHOICE_END(CMS_RevocationInfoChoice
)
124 ASN1_NDEF_SEQUENCE(CMS_SignedData
) = {
125 ASN1_SIMPLE(CMS_SignedData
, version
, LONG
),
126 ASN1_SET_OF(CMS_SignedData
, digestAlgorithms
, X509_ALGOR
),
127 ASN1_SIMPLE(CMS_SignedData
, encapContentInfo
, CMS_EncapsulatedContentInfo
),
128 ASN1_IMP_SET_OF_OPT(CMS_SignedData
, certificates
, CMS_CertificateChoices
, 0),
129 ASN1_IMP_SET_OF_OPT(CMS_SignedData
, crls
, CMS_RevocationInfoChoice
, 1),
130 ASN1_SET_OF(CMS_SignedData
, signerInfos
, CMS_SignerInfo
)
131 } ASN1_NDEF_SEQUENCE_END(CMS_SignedData
)
133 ASN1_SEQUENCE(CMS_OriginatorInfo
) = {
134 ASN1_IMP_SET_OF_OPT(CMS_OriginatorInfo
, certificates
, CMS_CertificateChoices
, 0),
135 ASN1_IMP_SET_OF_OPT(CMS_OriginatorInfo
, crls
, CMS_RevocationInfoChoice
, 1)
136 } ASN1_SEQUENCE_END(CMS_OriginatorInfo
)
138 ASN1_NDEF_SEQUENCE(CMS_EncryptedContentInfo
) = {
139 ASN1_SIMPLE(CMS_EncryptedContentInfo
, contentType
, ASN1_OBJECT
),
140 ASN1_SIMPLE(CMS_EncryptedContentInfo
, contentEncryptionAlgorithm
, X509_ALGOR
),
141 ASN1_IMP_OPT(CMS_EncryptedContentInfo
, encryptedContent
, ASN1_OCTET_STRING_NDEF
, 0)
142 } ASN1_NDEF_SEQUENCE_END(CMS_EncryptedContentInfo
)
144 ASN1_SEQUENCE(CMS_KeyTransRecipientInfo
) = {
145 ASN1_SIMPLE(CMS_KeyTransRecipientInfo
, version
, LONG
),
146 ASN1_SIMPLE(CMS_KeyTransRecipientInfo
, rid
, CMS_SignerIdentifier
),
147 ASN1_SIMPLE(CMS_KeyTransRecipientInfo
, keyEncryptionAlgorithm
, X509_ALGOR
),
148 ASN1_SIMPLE(CMS_KeyTransRecipientInfo
, encryptedKey
, ASN1_OCTET_STRING
)
149 } ASN1_SEQUENCE_END(CMS_KeyTransRecipientInfo
)
151 ASN1_SEQUENCE(CMS_OtherKeyAttribute
) = {
152 ASN1_SIMPLE(CMS_OtherKeyAttribute
, keyAttrId
, ASN1_OBJECT
),
153 ASN1_OPT(CMS_OtherKeyAttribute
, keyAttr
, ASN1_ANY
)
154 } ASN1_SEQUENCE_END(CMS_OtherKeyAttribute
)
156 ASN1_SEQUENCE(CMS_RecipientKeyIdentifier
) = {
157 ASN1_SIMPLE(CMS_RecipientKeyIdentifier
, subjectKeyIdentifier
, ASN1_OCTET_STRING
),
158 ASN1_OPT(CMS_RecipientKeyIdentifier
, date
, ASN1_GENERALIZEDTIME
),
159 ASN1_OPT(CMS_RecipientKeyIdentifier
, other
, CMS_OtherKeyAttribute
)
160 } ASN1_SEQUENCE_END(CMS_RecipientKeyIdentifier
)
162 ASN1_CHOICE(CMS_KeyAgreeRecipientIdentifier
) = {
163 ASN1_SIMPLE(CMS_KeyAgreeRecipientIdentifier
, d
.issuerAndSerialNumber
, CMS_IssuerAndSerialNumber
),
164 ASN1_IMP(CMS_KeyAgreeRecipientIdentifier
, d
.rKeyId
, CMS_RecipientKeyIdentifier
, 0)
165 } ASN1_CHOICE_END(CMS_KeyAgreeRecipientIdentifier
)
167 static int cms_rek_cb(int operation
, ASN1_VALUE
**pval
, const ASN1_ITEM
*it
,
170 CMS_RecipientEncryptedKey
*rek
= (CMS_RecipientEncryptedKey
*)*pval
;
171 if (operation
== ASN1_OP_FREE_POST
) {
172 EVP_PKEY_free(rek
->pkey
);
177 ASN1_SEQUENCE_cb(CMS_RecipientEncryptedKey
, cms_rek_cb
) = {
178 ASN1_SIMPLE(CMS_RecipientEncryptedKey
, rid
, CMS_KeyAgreeRecipientIdentifier
),
179 ASN1_SIMPLE(CMS_RecipientEncryptedKey
, encryptedKey
, ASN1_OCTET_STRING
)
180 } ASN1_SEQUENCE_END_cb(CMS_RecipientEncryptedKey
, CMS_RecipientEncryptedKey
)
182 ASN1_SEQUENCE(CMS_OriginatorPublicKey
) = {
183 ASN1_SIMPLE(CMS_OriginatorPublicKey
, algorithm
, X509_ALGOR
),
184 ASN1_SIMPLE(CMS_OriginatorPublicKey
, publicKey
, ASN1_BIT_STRING
)
185 } ASN1_SEQUENCE_END(CMS_OriginatorPublicKey
)
187 ASN1_CHOICE(CMS_OriginatorIdentifierOrKey
) = {
188 ASN1_SIMPLE(CMS_OriginatorIdentifierOrKey
, d
.issuerAndSerialNumber
, CMS_IssuerAndSerialNumber
),
189 ASN1_IMP(CMS_OriginatorIdentifierOrKey
, d
.subjectKeyIdentifier
, ASN1_OCTET_STRING
, 0),
190 ASN1_IMP(CMS_OriginatorIdentifierOrKey
, d
.originatorKey
, CMS_OriginatorPublicKey
, 1)
191 } ASN1_CHOICE_END(CMS_OriginatorIdentifierOrKey
)
193 static int cms_kari_cb(int operation
, ASN1_VALUE
**pval
, const ASN1_ITEM
*it
,
196 CMS_KeyAgreeRecipientInfo
*kari
= (CMS_KeyAgreeRecipientInfo
*)*pval
;
197 if (operation
== ASN1_OP_NEW_POST
) {
198 EVP_CIPHER_CTX_init(&kari
->ctx
);
199 EVP_CIPHER_CTX_set_flags(&kari
->ctx
, EVP_CIPHER_CTX_FLAG_WRAP_ALLOW
);
201 } else if (operation
== ASN1_OP_FREE_POST
) {
202 EVP_PKEY_CTX_free(kari
->pctx
);
203 EVP_CIPHER_CTX_cleanup(&kari
->ctx
);
208 ASN1_SEQUENCE_cb(CMS_KeyAgreeRecipientInfo
, cms_kari_cb
) = {
209 ASN1_SIMPLE(CMS_KeyAgreeRecipientInfo
, version
, LONG
),
210 ASN1_EXP(CMS_KeyAgreeRecipientInfo
, originator
, CMS_OriginatorIdentifierOrKey
, 0),
211 ASN1_EXP_OPT(CMS_KeyAgreeRecipientInfo
, ukm
, ASN1_OCTET_STRING
, 1),
212 ASN1_SIMPLE(CMS_KeyAgreeRecipientInfo
, keyEncryptionAlgorithm
, X509_ALGOR
),
213 ASN1_SEQUENCE_OF(CMS_KeyAgreeRecipientInfo
, recipientEncryptedKeys
, CMS_RecipientEncryptedKey
)
214 } ASN1_SEQUENCE_END_cb(CMS_KeyAgreeRecipientInfo
, CMS_KeyAgreeRecipientInfo
)
216 ASN1_SEQUENCE(CMS_KEKIdentifier
) = {
217 ASN1_SIMPLE(CMS_KEKIdentifier
, keyIdentifier
, ASN1_OCTET_STRING
),
218 ASN1_OPT(CMS_KEKIdentifier
, date
, ASN1_GENERALIZEDTIME
),
219 ASN1_OPT(CMS_KEKIdentifier
, other
, CMS_OtherKeyAttribute
)
220 } ASN1_SEQUENCE_END(CMS_KEKIdentifier
)
222 ASN1_SEQUENCE(CMS_KEKRecipientInfo
) = {
223 ASN1_SIMPLE(CMS_KEKRecipientInfo
, version
, LONG
),
224 ASN1_SIMPLE(CMS_KEKRecipientInfo
, kekid
, CMS_KEKIdentifier
),
225 ASN1_SIMPLE(CMS_KEKRecipientInfo
, keyEncryptionAlgorithm
, X509_ALGOR
),
226 ASN1_SIMPLE(CMS_KEKRecipientInfo
, encryptedKey
, ASN1_OCTET_STRING
)
227 } ASN1_SEQUENCE_END(CMS_KEKRecipientInfo
)
229 ASN1_SEQUENCE(CMS_PasswordRecipientInfo
) = {
230 ASN1_SIMPLE(CMS_PasswordRecipientInfo
, version
, LONG
),
231 ASN1_IMP_OPT(CMS_PasswordRecipientInfo
, keyDerivationAlgorithm
, X509_ALGOR
, 0),
232 ASN1_SIMPLE(CMS_PasswordRecipientInfo
, keyEncryptionAlgorithm
, X509_ALGOR
),
233 ASN1_SIMPLE(CMS_PasswordRecipientInfo
, encryptedKey
, ASN1_OCTET_STRING
)
234 } ASN1_SEQUENCE_END(CMS_PasswordRecipientInfo
)
236 ASN1_SEQUENCE(CMS_OtherRecipientInfo
) = {
237 ASN1_SIMPLE(CMS_OtherRecipientInfo
, oriType
, ASN1_OBJECT
),
238 ASN1_OPT(CMS_OtherRecipientInfo
, oriValue
, ASN1_ANY
)
239 } ASN1_SEQUENCE_END(CMS_OtherRecipientInfo
)
241 /* Free up RecipientInfo additional data */
242 static int cms_ri_cb(int operation
, ASN1_VALUE
**pval
, const ASN1_ITEM
*it
,
245 if (operation
== ASN1_OP_FREE_PRE
) {
246 CMS_RecipientInfo
*ri
= (CMS_RecipientInfo
*)*pval
;
247 if (ri
->type
== CMS_RECIPINFO_TRANS
) {
248 CMS_KeyTransRecipientInfo
*ktri
= ri
->d
.ktri
;
249 EVP_PKEY_free(ktri
->pkey
);
250 X509_free(ktri
->recip
);
251 EVP_PKEY_CTX_free(ktri
->pctx
);
252 } else if (ri
->type
== CMS_RECIPINFO_KEK
) {
253 CMS_KEKRecipientInfo
*kekri
= ri
->d
.kekri
;
255 OPENSSL_cleanse(kekri
->key
, kekri
->keylen
);
256 OPENSSL_free(kekri
->key
);
258 } else if (ri
->type
== CMS_RECIPINFO_PASS
) {
259 CMS_PasswordRecipientInfo
*pwri
= ri
->d
.pwri
;
261 OPENSSL_cleanse(pwri
->pass
, pwri
->passlen
);
262 OPENSSL_free(pwri
->pass
);
269 ASN1_CHOICE_cb(CMS_RecipientInfo
, cms_ri_cb
) = {
270 ASN1_SIMPLE(CMS_RecipientInfo
, d
.ktri
, CMS_KeyTransRecipientInfo
),
271 ASN1_IMP(CMS_RecipientInfo
, d
.kari
, CMS_KeyAgreeRecipientInfo
, 1),
272 ASN1_IMP(CMS_RecipientInfo
, d
.kekri
, CMS_KEKRecipientInfo
, 2),
273 ASN1_IMP(CMS_RecipientInfo
, d
.pwri
, CMS_PasswordRecipientInfo
, 3),
274 ASN1_IMP(CMS_RecipientInfo
, d
.ori
, CMS_OtherRecipientInfo
, 4)
275 } ASN1_CHOICE_END_cb(CMS_RecipientInfo
, CMS_RecipientInfo
, type
)
277 ASN1_NDEF_SEQUENCE(CMS_EnvelopedData
) = {
278 ASN1_SIMPLE(CMS_EnvelopedData
, version
, LONG
),
279 ASN1_IMP_OPT(CMS_EnvelopedData
, originatorInfo
, CMS_OriginatorInfo
, 0),
280 ASN1_SET_OF(CMS_EnvelopedData
, recipientInfos
, CMS_RecipientInfo
),
281 ASN1_SIMPLE(CMS_EnvelopedData
, encryptedContentInfo
, CMS_EncryptedContentInfo
),
282 ASN1_IMP_SET_OF_OPT(CMS_EnvelopedData
, unprotectedAttrs
, X509_ATTRIBUTE
, 1)
283 } ASN1_NDEF_SEQUENCE_END(CMS_EnvelopedData
)
285 ASN1_NDEF_SEQUENCE(CMS_DigestedData
) = {
286 ASN1_SIMPLE(CMS_DigestedData
, version
, LONG
),
287 ASN1_SIMPLE(CMS_DigestedData
, digestAlgorithm
, X509_ALGOR
),
288 ASN1_SIMPLE(CMS_DigestedData
, encapContentInfo
, CMS_EncapsulatedContentInfo
),
289 ASN1_SIMPLE(CMS_DigestedData
, digest
, ASN1_OCTET_STRING
)
290 } ASN1_NDEF_SEQUENCE_END(CMS_DigestedData
)
292 ASN1_NDEF_SEQUENCE(CMS_EncryptedData
) = {
293 ASN1_SIMPLE(CMS_EncryptedData
, version
, LONG
),
294 ASN1_SIMPLE(CMS_EncryptedData
, encryptedContentInfo
, CMS_EncryptedContentInfo
),
295 ASN1_IMP_SET_OF_OPT(CMS_EncryptedData
, unprotectedAttrs
, X509_ATTRIBUTE
, 1)
296 } ASN1_NDEF_SEQUENCE_END(CMS_EncryptedData
)
298 ASN1_NDEF_SEQUENCE(CMS_AuthenticatedData
) = {
299 ASN1_SIMPLE(CMS_AuthenticatedData
, version
, LONG
),
300 ASN1_IMP_OPT(CMS_AuthenticatedData
, originatorInfo
, CMS_OriginatorInfo
, 0),
301 ASN1_SET_OF(CMS_AuthenticatedData
, recipientInfos
, CMS_RecipientInfo
),
302 ASN1_SIMPLE(CMS_AuthenticatedData
, macAlgorithm
, X509_ALGOR
),
303 ASN1_IMP(CMS_AuthenticatedData
, digestAlgorithm
, X509_ALGOR
, 1),
304 ASN1_SIMPLE(CMS_AuthenticatedData
, encapContentInfo
, CMS_EncapsulatedContentInfo
),
305 ASN1_IMP_SET_OF_OPT(CMS_AuthenticatedData
, authAttrs
, X509_ALGOR
, 2),
306 ASN1_SIMPLE(CMS_AuthenticatedData
, mac
, ASN1_OCTET_STRING
),
307 ASN1_IMP_SET_OF_OPT(CMS_AuthenticatedData
, unauthAttrs
, X509_ALGOR
, 3)
308 } ASN1_NDEF_SEQUENCE_END(CMS_AuthenticatedData
)
310 ASN1_NDEF_SEQUENCE(CMS_CompressedData
) = {
311 ASN1_SIMPLE(CMS_CompressedData
, version
, LONG
),
312 ASN1_SIMPLE(CMS_CompressedData
, compressionAlgorithm
, X509_ALGOR
),
313 ASN1_SIMPLE(CMS_CompressedData
, encapContentInfo
, CMS_EncapsulatedContentInfo
),
314 } ASN1_NDEF_SEQUENCE_END(CMS_CompressedData
)
316 /* This is the ANY DEFINED BY table for the top level ContentInfo structure */
318 ASN1_ADB_TEMPLATE(cms_default
) = ASN1_EXP(CMS_ContentInfo
, d
.other
, ASN1_ANY
, 0);
320 ASN1_ADB(CMS_ContentInfo
) = {
321 ADB_ENTRY(NID_pkcs7_data
, ASN1_NDEF_EXP(CMS_ContentInfo
, d
.data
, ASN1_OCTET_STRING_NDEF
, 0)),
322 ADB_ENTRY(NID_pkcs7_signed
, ASN1_NDEF_EXP(CMS_ContentInfo
, d
.signedData
, CMS_SignedData
, 0)),
323 ADB_ENTRY(NID_pkcs7_enveloped
, ASN1_NDEF_EXP(CMS_ContentInfo
, d
.envelopedData
, CMS_EnvelopedData
, 0)),
324 ADB_ENTRY(NID_pkcs7_digest
, ASN1_NDEF_EXP(CMS_ContentInfo
, d
.digestedData
, CMS_DigestedData
, 0)),
325 ADB_ENTRY(NID_pkcs7_encrypted
, ASN1_NDEF_EXP(CMS_ContentInfo
, d
.encryptedData
, CMS_EncryptedData
, 0)),
326 ADB_ENTRY(NID_id_smime_ct_authData
, ASN1_NDEF_EXP(CMS_ContentInfo
, d
.authenticatedData
, CMS_AuthenticatedData
, 0)),
327 ADB_ENTRY(NID_id_smime_ct_compressedData
, ASN1_NDEF_EXP(CMS_ContentInfo
, d
.compressedData
, CMS_CompressedData
, 0)),
328 } ASN1_ADB_END(CMS_ContentInfo
, 0, contentType
, 0, &cms_default_tt
, NULL
);
330 /* CMS streaming support */
331 static int cms_cb(int operation
, ASN1_VALUE
**pval
, const ASN1_ITEM
*it
,
334 ASN1_STREAM_ARG
*sarg
= exarg
;
335 CMS_ContentInfo
*cms
= NULL
;
337 cms
= (CMS_ContentInfo
*)*pval
;
342 case ASN1_OP_STREAM_PRE
:
343 if (CMS_stream(&sarg
->boundary
, cms
) <= 0)
345 case ASN1_OP_DETACHED_PRE
:
346 sarg
->ndef_bio
= CMS_dataInit(cms
, sarg
->out
);
351 case ASN1_OP_STREAM_POST
:
352 case ASN1_OP_DETACHED_POST
:
353 if (CMS_dataFinal(cms
, sarg
->ndef_bio
) <= 0)
361 ASN1_NDEF_SEQUENCE_cb(CMS_ContentInfo
, cms_cb
) = {
362 ASN1_SIMPLE(CMS_ContentInfo
, contentType
, ASN1_OBJECT
),
363 ASN1_ADB_OBJECT(CMS_ContentInfo
)
364 } ASN1_NDEF_SEQUENCE_END_cb(CMS_ContentInfo
, CMS_ContentInfo
)
366 /* Specials for signed attributes */
369 * When signing attributes we want to reorder them to match the sorted
373 ASN1_ITEM_TEMPLATE(CMS_Attributes_Sign
) =
374 ASN1_EX_TEMPLATE_TYPE(ASN1_TFLG_SET_ORDER
, 0, CMS_ATTRIBUTES
, X509_ATTRIBUTE
)
375 ASN1_ITEM_TEMPLATE_END(CMS_Attributes_Sign
)
378 * When verifying attributes we need to use the received order. So we use
379 * SEQUENCE OF and tag it to SET OF
382 ASN1_ITEM_TEMPLATE(CMS_Attributes_Verify
) =
383 ASN1_EX_TEMPLATE_TYPE(ASN1_TFLG_SEQUENCE_OF
| ASN1_TFLG_IMPTAG
| ASN1_TFLG_UNIVERSAL
,
384 V_ASN1_SET
, CMS_ATTRIBUTES
, X509_ATTRIBUTE
)
385 ASN1_ITEM_TEMPLATE_END(CMS_Attributes_Verify
)
389 ASN1_CHOICE(CMS_ReceiptsFrom
) = {
390 ASN1_IMP(CMS_ReceiptsFrom
, d
.allOrFirstTier
, LONG
, 0),
391 ASN1_IMP_SEQUENCE_OF(CMS_ReceiptsFrom
, d
.receiptList
, GENERAL_NAMES
, 1)
392 } ASN1_CHOICE_END(CMS_ReceiptsFrom
)
394 ASN1_SEQUENCE(CMS_ReceiptRequest
) = {
395 ASN1_SIMPLE(CMS_ReceiptRequest
, signedContentIdentifier
, ASN1_OCTET_STRING
),
396 ASN1_SIMPLE(CMS_ReceiptRequest
, receiptsFrom
, CMS_ReceiptsFrom
),
397 ASN1_SEQUENCE_OF(CMS_ReceiptRequest
, receiptsTo
, GENERAL_NAMES
)
398 } ASN1_SEQUENCE_END(CMS_ReceiptRequest
)
400 ASN1_SEQUENCE(CMS_Receipt
) = {
401 ASN1_SIMPLE(CMS_Receipt
, version
, LONG
),
402 ASN1_SIMPLE(CMS_Receipt
, contentType
, ASN1_OBJECT
),
403 ASN1_SIMPLE(CMS_Receipt
, signedContentIdentifier
, ASN1_OCTET_STRING
),
404 ASN1_SIMPLE(CMS_Receipt
, originatorSignatureValue
, ASN1_OCTET_STRING
)
405 } ASN1_SEQUENCE_END(CMS_Receipt
)
408 * Utilities to encode the CMS_SharedInfo structure used during key
414 ASN1_OCTET_STRING
*entityUInfo
;
415 ASN1_OCTET_STRING
*suppPubInfo
;
418 ASN1_SEQUENCE(CMS_SharedInfo
) = {
419 ASN1_SIMPLE(CMS_SharedInfo
, keyInfo
, X509_ALGOR
),
420 ASN1_EXP_OPT(CMS_SharedInfo
, entityUInfo
, ASN1_OCTET_STRING
, 0),
421 ASN1_EXP_OPT(CMS_SharedInfo
, suppPubInfo
, ASN1_OCTET_STRING
, 2),
422 } ASN1_SEQUENCE_END(CMS_SharedInfo
)
424 int CMS_SharedInfo_encode(unsigned char **pder
, X509_ALGOR
*kekalg
,
425 ASN1_OCTET_STRING
*ukm
, int keylen
)
428 CMS_SharedInfo
*pecsi
;
434 ASN1_OCTET_STRING oklen
;
439 kl
[0] = (keylen
>> 24) & 0xff;
440 kl
[1] = (keylen
>> 16) & 0xff;
441 kl
[2] = (keylen
>> 8) & 0xff;
442 kl
[3] = keylen
& 0xff;
445 oklen
.type
= V_ASN1_OCTET_STRING
;
447 ecsi
.keyInfo
= kekalg
;
448 ecsi
.entityUInfo
= ukm
;
449 ecsi
.suppPubInfo
= &oklen
;
451 return ASN1_item_i2d(intsi
.a
, pder
, ASN1_ITEM_rptr(CMS_SharedInfo
));