Line data Source code
1 : /* crypto/cms/cms_asn1.c */
2 : /*
3 : * Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL
4 : * project.
5 : */
6 : /* ====================================================================
7 : * Copyright (c) 2008 The OpenSSL Project. All rights reserved.
8 : *
9 : * Redistribution and use in source and binary forms, with or without
10 : * modification, are permitted provided that the following conditions
11 : * are met:
12 : *
13 : * 1. Redistributions of source code must retain the above copyright
14 : * notice, this list of conditions and the following disclaimer.
15 : *
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
19 : * distribution.
20 : *
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/)"
25 : *
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.
30 : *
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.
34 : *
35 : * 6. Redistributions of any form whatsoever must retain the following
36 : * acknowledgment:
37 : * "This product includes software developed by the OpenSSL Project
38 : * for use in the OpenSSL Toolkit (http://www.OpenSSL.org/)"
39 : *
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 : * ====================================================================
53 : */
54 :
55 : #include <openssl/asn1t.h>
56 : #include <openssl/pem.h>
57 : #include <openssl/x509v3.h>
58 : #include "cms.h"
59 : #include "cms_lcl.h"
60 :
61 :
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)
66 :
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)
71 :
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)
79 :
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)
84 :
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)
89 :
90 : /* Minor tweak to operation: free up signer key, cert */
91 0 : static int cms_si_cb(int operation, ASN1_VALUE **pval, const ASN1_ITEM *it,
92 : void *exarg)
93 : {
94 0 : if (operation == ASN1_OP_FREE_POST) {
95 0 : CMS_SignerInfo *si = (CMS_SignerInfo *)*pval;
96 0 : if (si->pkey)
97 0 : EVP_PKEY_free(si->pkey);
98 0 : if (si->signer)
99 0 : X509_free(si->signer);
100 0 : if (si->pctx)
101 0 : EVP_MD_CTX_cleanup(&si->mctx);
102 : }
103 0 : return 1;
104 : }
105 :
106 : ASN1_SEQUENCE_cb(CMS_SignerInfo, cms_si_cb) = {
107 : ASN1_SIMPLE(CMS_SignerInfo, version, LONG),
108 : ASN1_SIMPLE(CMS_SignerInfo, sid, CMS_SignerIdentifier),
109 : ASN1_SIMPLE(CMS_SignerInfo, digestAlgorithm, X509_ALGOR),
110 : ASN1_IMP_SET_OF_OPT(CMS_SignerInfo, signedAttrs, X509_ATTRIBUTE, 0),
111 : ASN1_SIMPLE(CMS_SignerInfo, signatureAlgorithm, X509_ALGOR),
112 : ASN1_SIMPLE(CMS_SignerInfo, signature, ASN1_OCTET_STRING),
113 : ASN1_IMP_SET_OF_OPT(CMS_SignerInfo, unsignedAttrs, X509_ATTRIBUTE, 1)
114 : } ASN1_SEQUENCE_END_cb(CMS_SignerInfo, CMS_SignerInfo)
115 :
116 : ASN1_SEQUENCE(CMS_OtherRevocationInfoFormat) = {
117 : ASN1_SIMPLE(CMS_OtherRevocationInfoFormat, otherRevInfoFormat, ASN1_OBJECT),
118 : ASN1_OPT(CMS_OtherRevocationInfoFormat, otherRevInfo, ASN1_ANY)
119 : } ASN1_SEQUENCE_END(CMS_OtherRevocationInfoFormat)
120 :
121 : ASN1_CHOICE(CMS_RevocationInfoChoice) = {
122 : ASN1_SIMPLE(CMS_RevocationInfoChoice, d.crl, X509_CRL),
123 : ASN1_IMP(CMS_RevocationInfoChoice, d.other, CMS_OtherRevocationInfoFormat, 1)
124 : } ASN1_CHOICE_END(CMS_RevocationInfoChoice)
125 :
126 : ASN1_NDEF_SEQUENCE(CMS_SignedData) = {
127 : ASN1_SIMPLE(CMS_SignedData, version, LONG),
128 : ASN1_SET_OF(CMS_SignedData, digestAlgorithms, X509_ALGOR),
129 : ASN1_SIMPLE(CMS_SignedData, encapContentInfo, CMS_EncapsulatedContentInfo),
130 : ASN1_IMP_SET_OF_OPT(CMS_SignedData, certificates, CMS_CertificateChoices, 0),
131 : ASN1_IMP_SET_OF_OPT(CMS_SignedData, crls, CMS_RevocationInfoChoice, 1),
132 : ASN1_SET_OF(CMS_SignedData, signerInfos, CMS_SignerInfo)
133 : } ASN1_NDEF_SEQUENCE_END(CMS_SignedData)
134 :
135 : ASN1_SEQUENCE(CMS_OriginatorInfo) = {
136 : ASN1_IMP_SET_OF_OPT(CMS_OriginatorInfo, certificates, CMS_CertificateChoices, 0),
137 : ASN1_IMP_SET_OF_OPT(CMS_OriginatorInfo, crls, CMS_RevocationInfoChoice, 1)
138 : } ASN1_SEQUENCE_END(CMS_OriginatorInfo)
139 :
140 : ASN1_NDEF_SEQUENCE(CMS_EncryptedContentInfo) = {
141 : ASN1_SIMPLE(CMS_EncryptedContentInfo, contentType, ASN1_OBJECT),
142 : ASN1_SIMPLE(CMS_EncryptedContentInfo, contentEncryptionAlgorithm, X509_ALGOR),
143 : ASN1_IMP_OPT(CMS_EncryptedContentInfo, encryptedContent, ASN1_OCTET_STRING_NDEF, 0)
144 : } ASN1_NDEF_SEQUENCE_END(CMS_EncryptedContentInfo)
145 :
146 : ASN1_SEQUENCE(CMS_KeyTransRecipientInfo) = {
147 : ASN1_SIMPLE(CMS_KeyTransRecipientInfo, version, LONG),
148 : ASN1_SIMPLE(CMS_KeyTransRecipientInfo, rid, CMS_SignerIdentifier),
149 : ASN1_SIMPLE(CMS_KeyTransRecipientInfo, keyEncryptionAlgorithm, X509_ALGOR),
150 : ASN1_SIMPLE(CMS_KeyTransRecipientInfo, encryptedKey, ASN1_OCTET_STRING)
151 : } ASN1_SEQUENCE_END(CMS_KeyTransRecipientInfo)
152 :
153 : ASN1_SEQUENCE(CMS_OtherKeyAttribute) = {
154 : ASN1_SIMPLE(CMS_OtherKeyAttribute, keyAttrId, ASN1_OBJECT),
155 : ASN1_OPT(CMS_OtherKeyAttribute, keyAttr, ASN1_ANY)
156 : } ASN1_SEQUENCE_END(CMS_OtherKeyAttribute)
157 :
158 : ASN1_SEQUENCE(CMS_RecipientKeyIdentifier) = {
159 : ASN1_SIMPLE(CMS_RecipientKeyIdentifier, subjectKeyIdentifier, ASN1_OCTET_STRING),
160 : ASN1_OPT(CMS_RecipientKeyIdentifier, date, ASN1_GENERALIZEDTIME),
161 : ASN1_OPT(CMS_RecipientKeyIdentifier, other, CMS_OtherKeyAttribute)
162 : } ASN1_SEQUENCE_END(CMS_RecipientKeyIdentifier)
163 :
164 : ASN1_CHOICE(CMS_KeyAgreeRecipientIdentifier) = {
165 : ASN1_SIMPLE(CMS_KeyAgreeRecipientIdentifier, d.issuerAndSerialNumber, CMS_IssuerAndSerialNumber),
166 : ASN1_IMP(CMS_KeyAgreeRecipientIdentifier, d.rKeyId, CMS_RecipientKeyIdentifier, 0)
167 : } ASN1_CHOICE_END(CMS_KeyAgreeRecipientIdentifier)
168 :
169 0 : static int cms_rek_cb(int operation, ASN1_VALUE **pval, const ASN1_ITEM *it,
170 : void *exarg)
171 : {
172 0 : CMS_RecipientEncryptedKey *rek = (CMS_RecipientEncryptedKey *)*pval;
173 0 : if (operation == ASN1_OP_FREE_POST) {
174 0 : if (rek->pkey)
175 0 : EVP_PKEY_free(rek->pkey);
176 : }
177 0 : return 1;
178 : }
179 :
180 : ASN1_SEQUENCE_cb(CMS_RecipientEncryptedKey, cms_rek_cb) = {
181 : ASN1_SIMPLE(CMS_RecipientEncryptedKey, rid, CMS_KeyAgreeRecipientIdentifier),
182 : ASN1_SIMPLE(CMS_RecipientEncryptedKey, encryptedKey, ASN1_OCTET_STRING)
183 : } ASN1_SEQUENCE_END_cb(CMS_RecipientEncryptedKey, CMS_RecipientEncryptedKey)
184 :
185 : ASN1_SEQUENCE(CMS_OriginatorPublicKey) = {
186 : ASN1_SIMPLE(CMS_OriginatorPublicKey, algorithm, X509_ALGOR),
187 : ASN1_SIMPLE(CMS_OriginatorPublicKey, publicKey, ASN1_BIT_STRING)
188 : } ASN1_SEQUENCE_END(CMS_OriginatorPublicKey)
189 :
190 : ASN1_CHOICE(CMS_OriginatorIdentifierOrKey) = {
191 : ASN1_SIMPLE(CMS_OriginatorIdentifierOrKey, d.issuerAndSerialNumber, CMS_IssuerAndSerialNumber),
192 : ASN1_IMP(CMS_OriginatorIdentifierOrKey, d.subjectKeyIdentifier, ASN1_OCTET_STRING, 0),
193 : ASN1_IMP(CMS_OriginatorIdentifierOrKey, d.originatorKey, CMS_OriginatorPublicKey, 1)
194 : } ASN1_CHOICE_END(CMS_OriginatorIdentifierOrKey)
195 :
196 0 : static int cms_kari_cb(int operation, ASN1_VALUE **pval, const ASN1_ITEM *it,
197 : void *exarg)
198 : {
199 0 : CMS_KeyAgreeRecipientInfo *kari = (CMS_KeyAgreeRecipientInfo *)*pval;
200 0 : if (operation == ASN1_OP_NEW_POST) {
201 0 : EVP_CIPHER_CTX_init(&kari->ctx);
202 0 : EVP_CIPHER_CTX_set_flags(&kari->ctx, EVP_CIPHER_CTX_FLAG_WRAP_ALLOW);
203 0 : kari->pctx = NULL;
204 0 : } else if (operation == ASN1_OP_FREE_POST) {
205 0 : if (kari->pctx)
206 0 : EVP_PKEY_CTX_free(kari->pctx);
207 0 : EVP_CIPHER_CTX_cleanup(&kari->ctx);
208 : }
209 0 : return 1;
210 : }
211 :
212 : ASN1_SEQUENCE_cb(CMS_KeyAgreeRecipientInfo, cms_kari_cb) = {
213 : ASN1_SIMPLE(CMS_KeyAgreeRecipientInfo, version, LONG),
214 : ASN1_EXP(CMS_KeyAgreeRecipientInfo, originator, CMS_OriginatorIdentifierOrKey, 0),
215 : ASN1_EXP_OPT(CMS_KeyAgreeRecipientInfo, ukm, ASN1_OCTET_STRING, 1),
216 : ASN1_SIMPLE(CMS_KeyAgreeRecipientInfo, keyEncryptionAlgorithm, X509_ALGOR),
217 : ASN1_SEQUENCE_OF(CMS_KeyAgreeRecipientInfo, recipientEncryptedKeys, CMS_RecipientEncryptedKey)
218 : } ASN1_SEQUENCE_END_cb(CMS_KeyAgreeRecipientInfo, CMS_KeyAgreeRecipientInfo)
219 :
220 : ASN1_SEQUENCE(CMS_KEKIdentifier) = {
221 : ASN1_SIMPLE(CMS_KEKIdentifier, keyIdentifier, ASN1_OCTET_STRING),
222 : ASN1_OPT(CMS_KEKIdentifier, date, ASN1_GENERALIZEDTIME),
223 : ASN1_OPT(CMS_KEKIdentifier, other, CMS_OtherKeyAttribute)
224 : } ASN1_SEQUENCE_END(CMS_KEKIdentifier)
225 :
226 : ASN1_SEQUENCE(CMS_KEKRecipientInfo) = {
227 : ASN1_SIMPLE(CMS_KEKRecipientInfo, version, LONG),
228 : ASN1_SIMPLE(CMS_KEKRecipientInfo, kekid, CMS_KEKIdentifier),
229 : ASN1_SIMPLE(CMS_KEKRecipientInfo, keyEncryptionAlgorithm, X509_ALGOR),
230 : ASN1_SIMPLE(CMS_KEKRecipientInfo, encryptedKey, ASN1_OCTET_STRING)
231 : } ASN1_SEQUENCE_END(CMS_KEKRecipientInfo)
232 :
233 : ASN1_SEQUENCE(CMS_PasswordRecipientInfo) = {
234 : ASN1_SIMPLE(CMS_PasswordRecipientInfo, version, LONG),
235 : ASN1_IMP_OPT(CMS_PasswordRecipientInfo, keyDerivationAlgorithm, X509_ALGOR, 0),
236 : ASN1_SIMPLE(CMS_PasswordRecipientInfo, keyEncryptionAlgorithm, X509_ALGOR),
237 : ASN1_SIMPLE(CMS_PasswordRecipientInfo, encryptedKey, ASN1_OCTET_STRING)
238 : } ASN1_SEQUENCE_END(CMS_PasswordRecipientInfo)
239 :
240 : ASN1_SEQUENCE(CMS_OtherRecipientInfo) = {
241 : ASN1_SIMPLE(CMS_OtherRecipientInfo, oriType, ASN1_OBJECT),
242 : ASN1_OPT(CMS_OtherRecipientInfo, oriValue, ASN1_ANY)
243 : } ASN1_SEQUENCE_END(CMS_OtherRecipientInfo)
244 :
245 : /* Free up RecipientInfo additional data */
246 0 : static int cms_ri_cb(int operation, ASN1_VALUE **pval, const ASN1_ITEM *it,
247 : void *exarg)
248 : {
249 0 : if (operation == ASN1_OP_FREE_PRE) {
250 0 : CMS_RecipientInfo *ri = (CMS_RecipientInfo *)*pval;
251 0 : if (ri->type == CMS_RECIPINFO_TRANS) {
252 0 : CMS_KeyTransRecipientInfo *ktri = ri->d.ktri;
253 0 : if (ktri->pkey)
254 0 : EVP_PKEY_free(ktri->pkey);
255 0 : if (ktri->recip)
256 0 : X509_free(ktri->recip);
257 0 : if (ktri->pctx)
258 0 : EVP_PKEY_CTX_free(ktri->pctx);
259 0 : } else if (ri->type == CMS_RECIPINFO_KEK) {
260 0 : CMS_KEKRecipientInfo *kekri = ri->d.kekri;
261 0 : if (kekri->key) {
262 0 : OPENSSL_cleanse(kekri->key, kekri->keylen);
263 0 : OPENSSL_free(kekri->key);
264 : }
265 0 : } else if (ri->type == CMS_RECIPINFO_PASS) {
266 0 : CMS_PasswordRecipientInfo *pwri = ri->d.pwri;
267 0 : if (pwri->pass) {
268 0 : OPENSSL_cleanse(pwri->pass, pwri->passlen);
269 0 : OPENSSL_free(pwri->pass);
270 : }
271 : }
272 : }
273 0 : return 1;
274 : }
275 :
276 : ASN1_CHOICE_cb(CMS_RecipientInfo, cms_ri_cb) = {
277 : ASN1_SIMPLE(CMS_RecipientInfo, d.ktri, CMS_KeyTransRecipientInfo),
278 : ASN1_IMP(CMS_RecipientInfo, d.kari, CMS_KeyAgreeRecipientInfo, 1),
279 : ASN1_IMP(CMS_RecipientInfo, d.kekri, CMS_KEKRecipientInfo, 2),
280 : ASN1_IMP(CMS_RecipientInfo, d.pwri, CMS_PasswordRecipientInfo, 3),
281 : ASN1_IMP(CMS_RecipientInfo, d.ori, CMS_OtherRecipientInfo, 4)
282 : } ASN1_CHOICE_END_cb(CMS_RecipientInfo, CMS_RecipientInfo, type)
283 :
284 : ASN1_NDEF_SEQUENCE(CMS_EnvelopedData) = {
285 : ASN1_SIMPLE(CMS_EnvelopedData, version, LONG),
286 : ASN1_IMP_OPT(CMS_EnvelopedData, originatorInfo, CMS_OriginatorInfo, 0),
287 : ASN1_SET_OF(CMS_EnvelopedData, recipientInfos, CMS_RecipientInfo),
288 : ASN1_SIMPLE(CMS_EnvelopedData, encryptedContentInfo, CMS_EncryptedContentInfo),
289 : ASN1_IMP_SET_OF_OPT(CMS_EnvelopedData, unprotectedAttrs, X509_ATTRIBUTE, 1)
290 : } ASN1_NDEF_SEQUENCE_END(CMS_EnvelopedData)
291 :
292 : ASN1_NDEF_SEQUENCE(CMS_DigestedData) = {
293 : ASN1_SIMPLE(CMS_DigestedData, version, LONG),
294 : ASN1_SIMPLE(CMS_DigestedData, digestAlgorithm, X509_ALGOR),
295 : ASN1_SIMPLE(CMS_DigestedData, encapContentInfo, CMS_EncapsulatedContentInfo),
296 : ASN1_SIMPLE(CMS_DigestedData, digest, ASN1_OCTET_STRING)
297 : } ASN1_NDEF_SEQUENCE_END(CMS_DigestedData)
298 :
299 : ASN1_NDEF_SEQUENCE(CMS_EncryptedData) = {
300 : ASN1_SIMPLE(CMS_EncryptedData, version, LONG),
301 : ASN1_SIMPLE(CMS_EncryptedData, encryptedContentInfo, CMS_EncryptedContentInfo),
302 : ASN1_IMP_SET_OF_OPT(CMS_EncryptedData, unprotectedAttrs, X509_ATTRIBUTE, 1)
303 : } ASN1_NDEF_SEQUENCE_END(CMS_EncryptedData)
304 :
305 : ASN1_NDEF_SEQUENCE(CMS_AuthenticatedData) = {
306 : ASN1_SIMPLE(CMS_AuthenticatedData, version, LONG),
307 : ASN1_IMP_OPT(CMS_AuthenticatedData, originatorInfo, CMS_OriginatorInfo, 0),
308 : ASN1_SET_OF(CMS_AuthenticatedData, recipientInfos, CMS_RecipientInfo),
309 : ASN1_SIMPLE(CMS_AuthenticatedData, macAlgorithm, X509_ALGOR),
310 : ASN1_IMP(CMS_AuthenticatedData, digestAlgorithm, X509_ALGOR, 1),
311 : ASN1_SIMPLE(CMS_AuthenticatedData, encapContentInfo, CMS_EncapsulatedContentInfo),
312 : ASN1_IMP_SET_OF_OPT(CMS_AuthenticatedData, authAttrs, X509_ALGOR, 2),
313 : ASN1_SIMPLE(CMS_AuthenticatedData, mac, ASN1_OCTET_STRING),
314 : ASN1_IMP_SET_OF_OPT(CMS_AuthenticatedData, unauthAttrs, X509_ALGOR, 3)
315 : } ASN1_NDEF_SEQUENCE_END(CMS_AuthenticatedData)
316 :
317 : ASN1_NDEF_SEQUENCE(CMS_CompressedData) = {
318 : ASN1_SIMPLE(CMS_CompressedData, version, LONG),
319 : ASN1_SIMPLE(CMS_CompressedData, compressionAlgorithm, X509_ALGOR),
320 : ASN1_SIMPLE(CMS_CompressedData, encapContentInfo, CMS_EncapsulatedContentInfo),
321 : } ASN1_NDEF_SEQUENCE_END(CMS_CompressedData)
322 :
323 : /* This is the ANY DEFINED BY table for the top level ContentInfo structure */
324 :
325 : ASN1_ADB_TEMPLATE(cms_default) = ASN1_EXP(CMS_ContentInfo, d.other, ASN1_ANY, 0);
326 :
327 : ASN1_ADB(CMS_ContentInfo) = {
328 : ADB_ENTRY(NID_pkcs7_data, ASN1_NDEF_EXP(CMS_ContentInfo, d.data, ASN1_OCTET_STRING_NDEF, 0)),
329 : ADB_ENTRY(NID_pkcs7_signed, ASN1_NDEF_EXP(CMS_ContentInfo, d.signedData, CMS_SignedData, 0)),
330 : ADB_ENTRY(NID_pkcs7_enveloped, ASN1_NDEF_EXP(CMS_ContentInfo, d.envelopedData, CMS_EnvelopedData, 0)),
331 : ADB_ENTRY(NID_pkcs7_digest, ASN1_NDEF_EXP(CMS_ContentInfo, d.digestedData, CMS_DigestedData, 0)),
332 : ADB_ENTRY(NID_pkcs7_encrypted, ASN1_NDEF_EXP(CMS_ContentInfo, d.encryptedData, CMS_EncryptedData, 0)),
333 : ADB_ENTRY(NID_id_smime_ct_authData, ASN1_NDEF_EXP(CMS_ContentInfo, d.authenticatedData, CMS_AuthenticatedData, 0)),
334 : ADB_ENTRY(NID_id_smime_ct_compressedData, ASN1_NDEF_EXP(CMS_ContentInfo, d.compressedData, CMS_CompressedData, 0)),
335 : } ASN1_ADB_END(CMS_ContentInfo, 0, contentType, 0, &cms_default_tt, NULL);
336 :
337 : /* CMS streaming support */
338 0 : static int cms_cb(int operation, ASN1_VALUE **pval, const ASN1_ITEM *it,
339 : void *exarg)
340 : {
341 : ASN1_STREAM_ARG *sarg = exarg;
342 : CMS_ContentInfo *cms = NULL;
343 0 : if (pval)
344 0 : cms = (CMS_ContentInfo *)*pval;
345 : else
346 : return 1;
347 0 : switch (operation) {
348 :
349 : case ASN1_OP_STREAM_PRE:
350 0 : if (CMS_stream(&sarg->boundary, cms) <= 0)
351 : return 0;
352 : case ASN1_OP_DETACHED_PRE:
353 0 : sarg->ndef_bio = CMS_dataInit(cms, sarg->out);
354 0 : if (!sarg->ndef_bio)
355 : return 0;
356 : break;
357 :
358 : case ASN1_OP_STREAM_POST:
359 : case ASN1_OP_DETACHED_POST:
360 0 : if (CMS_dataFinal(cms, sarg->ndef_bio) <= 0)
361 : return 0;
362 : break;
363 :
364 : }
365 : return 1;
366 : }
367 :
368 : ASN1_NDEF_SEQUENCE_cb(CMS_ContentInfo, cms_cb) = {
369 : ASN1_SIMPLE(CMS_ContentInfo, contentType, ASN1_OBJECT),
370 : ASN1_ADB_OBJECT(CMS_ContentInfo)
371 : } ASN1_NDEF_SEQUENCE_END_cb(CMS_ContentInfo, CMS_ContentInfo)
372 :
373 : /* Specials for signed attributes */
374 :
375 : /*
376 : * When signing attributes we want to reorder them to match the sorted
377 : * encoding.
378 : */
379 :
380 : ASN1_ITEM_TEMPLATE(CMS_Attributes_Sign) =
381 : ASN1_EX_TEMPLATE_TYPE(ASN1_TFLG_SET_ORDER, 0, CMS_ATTRIBUTES, X509_ATTRIBUTE)
382 : ASN1_ITEM_TEMPLATE_END(CMS_Attributes_Sign)
383 :
384 : /*
385 : * When verifying attributes we need to use the received order. So we use
386 : * SEQUENCE OF and tag it to SET OF
387 : */
388 :
389 : ASN1_ITEM_TEMPLATE(CMS_Attributes_Verify) =
390 : ASN1_EX_TEMPLATE_TYPE(ASN1_TFLG_SEQUENCE_OF | ASN1_TFLG_IMPTAG | ASN1_TFLG_UNIVERSAL,
391 : V_ASN1_SET, CMS_ATTRIBUTES, X509_ATTRIBUTE)
392 : ASN1_ITEM_TEMPLATE_END(CMS_Attributes_Verify)
393 :
394 :
395 :
396 : ASN1_CHOICE(CMS_ReceiptsFrom) = {
397 : ASN1_IMP(CMS_ReceiptsFrom, d.allOrFirstTier, LONG, 0),
398 : ASN1_IMP_SEQUENCE_OF(CMS_ReceiptsFrom, d.receiptList, GENERAL_NAMES, 1)
399 : } ASN1_CHOICE_END(CMS_ReceiptsFrom)
400 :
401 : ASN1_SEQUENCE(CMS_ReceiptRequest) = {
402 : ASN1_SIMPLE(CMS_ReceiptRequest, signedContentIdentifier, ASN1_OCTET_STRING),
403 : ASN1_SIMPLE(CMS_ReceiptRequest, receiptsFrom, CMS_ReceiptsFrom),
404 : ASN1_SEQUENCE_OF(CMS_ReceiptRequest, receiptsTo, GENERAL_NAMES)
405 : } ASN1_SEQUENCE_END(CMS_ReceiptRequest)
406 :
407 : ASN1_SEQUENCE(CMS_Receipt) = {
408 : ASN1_SIMPLE(CMS_Receipt, version, LONG),
409 : ASN1_SIMPLE(CMS_Receipt, contentType, ASN1_OBJECT),
410 : ASN1_SIMPLE(CMS_Receipt, signedContentIdentifier, ASN1_OCTET_STRING),
411 : ASN1_SIMPLE(CMS_Receipt, originatorSignatureValue, ASN1_OCTET_STRING)
412 : } ASN1_SEQUENCE_END(CMS_Receipt)
413 :
414 : /*
415 : * Utilities to encode the CMS_SharedInfo structure used during key
416 : * derivation.
417 : */
418 :
419 : typedef struct {
420 : X509_ALGOR *keyInfo;
421 : ASN1_OCTET_STRING *entityUInfo;
422 : ASN1_OCTET_STRING *suppPubInfo;
423 : } CMS_SharedInfo;
424 :
425 : ASN1_SEQUENCE(CMS_SharedInfo) = {
426 : ASN1_SIMPLE(CMS_SharedInfo, keyInfo, X509_ALGOR),
427 : ASN1_EXP_OPT(CMS_SharedInfo, entityUInfo, ASN1_OCTET_STRING, 0),
428 : ASN1_EXP_OPT(CMS_SharedInfo, suppPubInfo, ASN1_OCTET_STRING, 2),
429 : } ASN1_SEQUENCE_END(CMS_SharedInfo)
430 :
431 0 : int CMS_SharedInfo_encode(unsigned char **pder, X509_ALGOR *kekalg,
432 : ASN1_OCTET_STRING *ukm, int keylen)
433 : {
434 : union {
435 : CMS_SharedInfo *pecsi;
436 : ASN1_VALUE *a;
437 : } intsi = {
438 : NULL
439 : };
440 :
441 : ASN1_OCTET_STRING oklen;
442 : unsigned char kl[4];
443 : CMS_SharedInfo ecsi;
444 :
445 0 : keylen <<= 3;
446 0 : kl[0] = (keylen >> 24) & 0xff;
447 0 : kl[1] = (keylen >> 16) & 0xff;
448 0 : kl[2] = (keylen >> 8) & 0xff;
449 0 : kl[3] = keylen & 0xff;
450 0 : oklen.length = 4;
451 0 : oklen.data = kl;
452 0 : oklen.type = V_ASN1_OCTET_STRING;
453 0 : oklen.flags = 0;
454 0 : ecsi.keyInfo = kekalg;
455 0 : ecsi.entityUInfo = ukm;
456 0 : ecsi.suppPubInfo = &oklen;
457 : intsi.pecsi = &ecsi;
458 0 : return ASN1_item_i2d(intsi.a, pder, ASN1_ITEM_rptr(CMS_SharedInfo));
459 : }
|
