1 /* $OpenBSD: cms_asn1.c,v 1.19 2022/01/14 08:16:13 tb Exp $ */
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 <openssl/cms.h>
59 #include "cms_lcl.h"
60
61
62 static const ASN1_TEMPLATE CMS_IssuerAndSerialNumber_seq_tt[] = {
63 {
64 .flags = 0,
65 .tag = 0,
66 .offset = offsetof(CMS_IssuerAndSerialNumber, issuer),
67 .field_name = "issuer",
68 .item = &X509_NAME_it,
69 },
70 {
71 .flags = 0,
72 .tag = 0,
73 .offset = offsetof(CMS_IssuerAndSerialNumber, serialNumber),
74 .field_name = "serialNumber",
75 .item = &ASN1_INTEGER_it,
76 },
77 };
78
79 const ASN1_ITEM CMS_IssuerAndSerialNumber_it = {
80 .itype = ASN1_ITYPE_SEQUENCE,
81 .utype = V_ASN1_SEQUENCE,
82 .templates = CMS_IssuerAndSerialNumber_seq_tt,
83 .tcount = sizeof(CMS_IssuerAndSerialNumber_seq_tt) / sizeof(ASN1_TEMPLATE),
84 .funcs = NULL,
85 .size = sizeof(CMS_IssuerAndSerialNumber),
86 .sname = "CMS_IssuerAndSerialNumber",
87 };
88
89 static const ASN1_TEMPLATE CMS_OtherCertificateFormat_seq_tt[] = {
90 {
91 .flags = 0,
92 .tag = 0,
93 .offset = offsetof(CMS_OtherCertificateFormat, otherCertFormat),
94 .field_name = "otherCertFormat",
95 .item = &ASN1_OBJECT_it,
96 },
97 {
98 .flags = ASN1_TFLG_OPTIONAL,
99 .tag = 0,
100 .offset = offsetof(CMS_OtherCertificateFormat, otherCert),
101 .field_name = "otherCert",
102 .item = &ASN1_ANY_it,
103 },
104 };
105
106 static const ASN1_ITEM CMS_OtherCertificateFormat_it = {
107 .itype = ASN1_ITYPE_SEQUENCE,
108 .utype = V_ASN1_SEQUENCE,
109 .templates = CMS_OtherCertificateFormat_seq_tt,
110 .tcount = sizeof(CMS_OtherCertificateFormat_seq_tt) / sizeof(ASN1_TEMPLATE),
111 .funcs = NULL,
112 .size = sizeof(CMS_OtherCertificateFormat),
113 .sname = "CMS_OtherCertificateFormat",
114 };
115
116 static const ASN1_TEMPLATE CMS_CertificateChoices_ch_tt[] = {
117 {
118 .flags = 0,
119 .tag = 0,
120 .offset = offsetof(CMS_CertificateChoices, d.certificate),
121 .field_name = "d.certificate",
122 .item = &X509_it,
123 },
124 {
125 .flags = ASN1_TFLG_IMPLICIT,
126 .tag = 0,
127 .offset = offsetof(CMS_CertificateChoices, d.extendedCertificate),
128 .field_name = "d.extendedCertificate",
129 .item = &ASN1_SEQUENCE_it,
130 },
131 {
132 .flags = ASN1_TFLG_IMPLICIT,
133 .tag = 1,
134 .offset = offsetof(CMS_CertificateChoices, d.v1AttrCert),
135 .field_name = "d.v1AttrCert",
136 .item = &ASN1_SEQUENCE_it,
137 },
138 {
139 .flags = ASN1_TFLG_IMPLICIT,
140 .tag = 2,
141 .offset = offsetof(CMS_CertificateChoices, d.v2AttrCert),
142 .field_name = "d.v2AttrCert",
143 .item = &ASN1_SEQUENCE_it,
144 },
145 {
146 .flags = ASN1_TFLG_IMPLICIT,
147 .tag = 3,
148 .offset = offsetof(CMS_CertificateChoices, d.other),
149 .field_name = "d.other",
150 .item = &CMS_OtherCertificateFormat_it,
151 },
152 };
153
154 const ASN1_ITEM CMS_CertificateChoices_it = {
155 .itype = ASN1_ITYPE_CHOICE,
156 .utype = offsetof(CMS_CertificateChoices, type),
157 .templates = CMS_CertificateChoices_ch_tt,
158 .tcount = sizeof(CMS_CertificateChoices_ch_tt) / sizeof(ASN1_TEMPLATE),
159 .funcs = NULL,
160 .size = sizeof(CMS_CertificateChoices),
161 .sname = "CMS_CertificateChoices",
162 };
163
164 static const ASN1_TEMPLATE CMS_SignerIdentifier_ch_tt[] = {
165 {
166 .flags = 0,
167 .tag = 0,
168 .offset = offsetof(CMS_SignerIdentifier, d.issuerAndSerialNumber),
169 .field_name = "d.issuerAndSerialNumber",
170 .item = &CMS_IssuerAndSerialNumber_it,
171 },
172 {
173 .flags = ASN1_TFLG_IMPLICIT,
174 .tag = 0,
175 .offset = offsetof(CMS_SignerIdentifier, d.subjectKeyIdentifier),
176 .field_name = "d.subjectKeyIdentifier",
177 .item = &ASN1_OCTET_STRING_it,
178 },
179 };
180
181 static const ASN1_ITEM CMS_SignerIdentifier_it = {
182 .itype = ASN1_ITYPE_CHOICE,
183 .utype = offsetof(CMS_SignerIdentifier, type),
184 .templates = CMS_SignerIdentifier_ch_tt,
185 .tcount = sizeof(CMS_SignerIdentifier_ch_tt) / sizeof(ASN1_TEMPLATE),
186 .funcs = NULL,
187 .size = sizeof(CMS_SignerIdentifier),
188 .sname = "CMS_SignerIdentifier",
189 };
190
191 static const ASN1_TEMPLATE CMS_EncapsulatedContentInfo_seq_tt[] = {
192 {
193 .flags = 0,
194 .tag = 0,
195 .offset = offsetof(CMS_EncapsulatedContentInfo, eContentType),
196 .field_name = "eContentType",
197 .item = &ASN1_OBJECT_it,
198 },
199 {
200 .flags = ASN1_TFLG_EXPLICIT | ASN1_TFLG_OPTIONAL | ASN1_TFLG_NDEF,
201 .tag = 0,
202 .offset = offsetof(CMS_EncapsulatedContentInfo, eContent),
203 .field_name = "eContent",
204 .item = &ASN1_OCTET_STRING_NDEF_it,
205 },
206 };
207
208 static const ASN1_ITEM CMS_EncapsulatedContentInfo_it = {
209 .itype = ASN1_ITYPE_NDEF_SEQUENCE,
210 .utype = V_ASN1_SEQUENCE,
211 .templates = CMS_EncapsulatedContentInfo_seq_tt,
212 .tcount = sizeof(CMS_EncapsulatedContentInfo_seq_tt) / sizeof(ASN1_TEMPLATE),
213 .funcs = NULL,
214 .size = sizeof(CMS_EncapsulatedContentInfo),
215 .sname = "CMS_EncapsulatedContentInfo",
216 };
217
218 /* Minor tweak to operation: free up signer key, cert */
219 static int
cms_si_cb(int operation,ASN1_VALUE ** pval,const ASN1_ITEM * it,void * exarg)220 cms_si_cb(int operation, ASN1_VALUE **pval, const ASN1_ITEM *it, void *exarg)
221 {
222 if (operation == ASN1_OP_FREE_POST) {
223 CMS_SignerInfo *si = (CMS_SignerInfo *)*pval;
224 EVP_PKEY_free(si->pkey);
225 X509_free(si->signer);
226 EVP_MD_CTX_free(si->mctx);
227 }
228 return 1;
229 }
230
231 static const ASN1_AUX CMS_SignerInfo_aux = {
232 .app_data = NULL,
233 .flags = 0,
234 .ref_offset = 0,
235 .ref_lock = 0,
236 .asn1_cb = cms_si_cb,
237 .enc_offset = 0,
238 };
239 static const ASN1_TEMPLATE CMS_SignerInfo_seq_tt[] = {
240 {
241 .flags = 0,
242 .tag = 0,
243 .offset = offsetof(CMS_SignerInfo, version),
244 .field_name = "version",
245 .item = &LONG_it,
246 },
247 {
248 .flags = 0,
249 .tag = 0,
250 .offset = offsetof(CMS_SignerInfo, sid),
251 .field_name = "sid",
252 .item = &CMS_SignerIdentifier_it,
253 },
254 {
255 .flags = 0,
256 .tag = 0,
257 .offset = offsetof(CMS_SignerInfo, digestAlgorithm),
258 .field_name = "digestAlgorithm",
259 .item = &X509_ALGOR_it,
260 },
261 {
262 .flags = ASN1_TFLG_IMPLICIT | ASN1_TFLG_SET_OF | ASN1_TFLG_OPTIONAL,
263 .tag = 0,
264 .offset = offsetof(CMS_SignerInfo, signedAttrs),
265 .field_name = "signedAttrs",
266 .item = &X509_ATTRIBUTE_it,
267 },
268 {
269 .flags = 0,
270 .tag = 0,
271 .offset = offsetof(CMS_SignerInfo, signatureAlgorithm),
272 .field_name = "signatureAlgorithm",
273 .item = &X509_ALGOR_it,
274 },
275 {
276 .flags = 0,
277 .tag = 0,
278 .offset = offsetof(CMS_SignerInfo, signature),
279 .field_name = "signature",
280 .item = &ASN1_OCTET_STRING_it,
281 },
282 {
283 .flags = ASN1_TFLG_IMPLICIT | ASN1_TFLG_SET_OF | ASN1_TFLG_OPTIONAL,
284 .tag = 1,
285 .offset = offsetof(CMS_SignerInfo, unsignedAttrs),
286 .field_name = "unsignedAttrs",
287 .item = &X509_ATTRIBUTE_it,
288 },
289 };
290
291 const ASN1_ITEM CMS_SignerInfo_it = {
292 .itype = ASN1_ITYPE_SEQUENCE,
293 .utype = V_ASN1_SEQUENCE,
294 .templates = CMS_SignerInfo_seq_tt,
295 .tcount = sizeof(CMS_SignerInfo_seq_tt) / sizeof(ASN1_TEMPLATE),
296 .funcs = &CMS_SignerInfo_aux,
297 .size = sizeof(CMS_SignerInfo),
298 .sname = "CMS_SignerInfo",
299 };
300
301 static const ASN1_TEMPLATE CMS_OtherRevocationInfoFormat_seq_tt[] = {
302 {
303 .flags = 0,
304 .tag = 0,
305 .offset = offsetof(CMS_OtherRevocationInfoFormat, otherRevInfoFormat),
306 .field_name = "otherRevInfoFormat",
307 .item = &ASN1_OBJECT_it,
308 },
309 {
310 .flags = ASN1_TFLG_OPTIONAL,
311 .tag = 0,
312 .offset = offsetof(CMS_OtherRevocationInfoFormat, otherRevInfo),
313 .field_name = "otherRevInfo",
314 .item = &ASN1_ANY_it,
315 },
316 };
317
318 static const ASN1_ITEM CMS_OtherRevocationInfoFormat_it = {
319 .itype = ASN1_ITYPE_SEQUENCE,
320 .utype = V_ASN1_SEQUENCE,
321 .templates = CMS_OtherRevocationInfoFormat_seq_tt,
322 .tcount = sizeof(CMS_OtherRevocationInfoFormat_seq_tt) / sizeof(ASN1_TEMPLATE),
323 .funcs = NULL,
324 .size = sizeof(CMS_OtherRevocationInfoFormat),
325 .sname = "CMS_OtherRevocationInfoFormat",
326 };
327
328 static const ASN1_TEMPLATE CMS_RevocationInfoChoice_ch_tt[] = {
329 {
330 .flags = 0,
331 .tag = 0,
332 .offset = offsetof(CMS_RevocationInfoChoice, d.crl),
333 .field_name = "d.crl",
334 .item = &X509_CRL_it,
335 },
336 {
337 .flags = ASN1_TFLG_IMPLICIT,
338 .tag = 1,
339 .offset = offsetof(CMS_RevocationInfoChoice, d.other),
340 .field_name = "d.other",
341 .item = &CMS_OtherRevocationInfoFormat_it,
342 },
343 };
344
345 const ASN1_ITEM CMS_RevocationInfoChoice_it = {
346 .itype = ASN1_ITYPE_CHOICE,
347 .utype = offsetof(CMS_RevocationInfoChoice, type),
348 .templates = CMS_RevocationInfoChoice_ch_tt,
349 .tcount = sizeof(CMS_RevocationInfoChoice_ch_tt) / sizeof(ASN1_TEMPLATE),
350 .funcs = NULL,
351 .size = sizeof(CMS_RevocationInfoChoice),
352 .sname = "CMS_RevocationInfoChoice",
353 };
354
355 static const ASN1_TEMPLATE CMS_SignedData_seq_tt[] = {
356 {
357 .flags = 0,
358 .tag = 0,
359 .offset = offsetof(CMS_SignedData, version),
360 .field_name = "version",
361 .item = &LONG_it,
362 },
363 {
364 .flags = ASN1_TFLG_SET_OF,
365 .tag = 0,
366 .offset = offsetof(CMS_SignedData, digestAlgorithms),
367 .field_name = "digestAlgorithms",
368 .item = &X509_ALGOR_it,
369 },
370 {
371 .flags = 0,
372 .tag = 0,
373 .offset = offsetof(CMS_SignedData, encapContentInfo),
374 .field_name = "encapContentInfo",
375 .item = &CMS_EncapsulatedContentInfo_it,
376 },
377 {
378 .flags = ASN1_TFLG_IMPLICIT | ASN1_TFLG_SET_OF | ASN1_TFLG_OPTIONAL,
379 .tag = 0,
380 .offset = offsetof(CMS_SignedData, certificates),
381 .field_name = "certificates",
382 .item = &CMS_CertificateChoices_it,
383 },
384 {
385 .flags = ASN1_TFLG_IMPLICIT | ASN1_TFLG_SET_OF | ASN1_TFLG_OPTIONAL,
386 .tag = 1,
387 .offset = offsetof(CMS_SignedData, crls),
388 .field_name = "crls",
389 .item = &CMS_RevocationInfoChoice_it,
390 },
391 {
392 .flags = ASN1_TFLG_SET_OF,
393 .tag = 0,
394 .offset = offsetof(CMS_SignedData, signerInfos),
395 .field_name = "signerInfos",
396 .item = &CMS_SignerInfo_it,
397 },
398 };
399
400 const ASN1_ITEM CMS_SignedData_it = {
401 .itype = ASN1_ITYPE_NDEF_SEQUENCE,
402 .utype = V_ASN1_SEQUENCE,
403 .templates = CMS_SignedData_seq_tt,
404 .tcount = sizeof(CMS_SignedData_seq_tt) / sizeof(ASN1_TEMPLATE),
405 .funcs = NULL,
406 .size = sizeof(CMS_SignedData),
407 .sname = "CMS_SignedData",
408 };
409
410 static const ASN1_TEMPLATE CMS_OriginatorInfo_seq_tt[] = {
411 {
412 .flags = ASN1_TFLG_IMPLICIT | ASN1_TFLG_SET_OF | ASN1_TFLG_OPTIONAL,
413 .tag = 0,
414 .offset = offsetof(CMS_OriginatorInfo, certificates),
415 .field_name = "certificates",
416 .item = &CMS_CertificateChoices_it,
417 },
418 {
419 .flags = ASN1_TFLG_IMPLICIT | ASN1_TFLG_SET_OF | ASN1_TFLG_OPTIONAL,
420 .tag = 1,
421 .offset = offsetof(CMS_OriginatorInfo, crls),
422 .field_name = "crls",
423 .item = &CMS_RevocationInfoChoice_it,
424 },
425 };
426
427 static const ASN1_ITEM CMS_OriginatorInfo_it = {
428 .itype = ASN1_ITYPE_SEQUENCE,
429 .utype = V_ASN1_SEQUENCE,
430 .templates = CMS_OriginatorInfo_seq_tt,
431 .tcount = sizeof(CMS_OriginatorInfo_seq_tt) / sizeof(ASN1_TEMPLATE),
432 .funcs = NULL,
433 .size = sizeof(CMS_OriginatorInfo),
434 .sname = "CMS_OriginatorInfo",
435 };
436
437 static const ASN1_TEMPLATE CMS_EncryptedContentInfo_seq_tt[] = {
438 {
439 .flags = 0,
440 .tag = 0,
441 .offset = offsetof(CMS_EncryptedContentInfo, contentType),
442 .field_name = "contentType",
443 .item = &ASN1_OBJECT_it,
444 },
445 {
446 .flags = 0,
447 .tag = 0,
448 .offset = offsetof(CMS_EncryptedContentInfo, contentEncryptionAlgorithm),
449 .field_name = "contentEncryptionAlgorithm",
450 .item = &X509_ALGOR_it,
451 },
452 {
453 .flags = ASN1_TFLG_IMPLICIT | ASN1_TFLG_OPTIONAL,
454 .tag = 0,
455 .offset = offsetof(CMS_EncryptedContentInfo, encryptedContent),
456 .field_name = "encryptedContent",
457 .item = &ASN1_OCTET_STRING_NDEF_it,
458 },
459 };
460
461 static const ASN1_ITEM CMS_EncryptedContentInfo_it = {
462 .itype = ASN1_ITYPE_NDEF_SEQUENCE,
463 .utype = V_ASN1_SEQUENCE,
464 .templates = CMS_EncryptedContentInfo_seq_tt,
465 .tcount = sizeof(CMS_EncryptedContentInfo_seq_tt) / sizeof(ASN1_TEMPLATE),
466 .funcs = NULL,
467 .size = sizeof(CMS_EncryptedContentInfo),
468 .sname = "CMS_EncryptedContentInfo",
469 };
470
471 static const ASN1_TEMPLATE CMS_KeyTransRecipientInfo_seq_tt[] = {
472 {
473 .flags = 0,
474 .tag = 0,
475 .offset = offsetof(CMS_KeyTransRecipientInfo, version),
476 .field_name = "version",
477 .item = &LONG_it,
478 },
479 {
480 .flags = 0,
481 .tag = 0,
482 .offset = offsetof(CMS_KeyTransRecipientInfo, rid),
483 .field_name = "rid",
484 .item = &CMS_SignerIdentifier_it,
485 },
486 {
487 .flags = 0,
488 .tag = 0,
489 .offset = offsetof(CMS_KeyTransRecipientInfo, keyEncryptionAlgorithm),
490 .field_name = "keyEncryptionAlgorithm",
491 .item = &X509_ALGOR_it,
492 },
493 {
494 .flags = 0,
495 .tag = 0,
496 .offset = offsetof(CMS_KeyTransRecipientInfo, encryptedKey),
497 .field_name = "encryptedKey",
498 .item = &ASN1_OCTET_STRING_it,
499 },
500 };
501
502 const ASN1_ITEM CMS_KeyTransRecipientInfo_it = {
503 .itype = ASN1_ITYPE_SEQUENCE,
504 .utype = V_ASN1_SEQUENCE,
505 .templates = CMS_KeyTransRecipientInfo_seq_tt,
506 .tcount = sizeof(CMS_KeyTransRecipientInfo_seq_tt) / sizeof(ASN1_TEMPLATE),
507 .funcs = NULL,
508 .size = sizeof(CMS_KeyTransRecipientInfo),
509 .sname = "CMS_KeyTransRecipientInfo",
510 };
511
512 static const ASN1_TEMPLATE CMS_OtherKeyAttribute_seq_tt[] = {
513 {
514 .flags = 0,
515 .tag = 0,
516 .offset = offsetof(CMS_OtherKeyAttribute, keyAttrId),
517 .field_name = "keyAttrId",
518 .item = &ASN1_OBJECT_it,
519 },
520 {
521 .flags = ASN1_TFLG_OPTIONAL,
522 .tag = 0,
523 .offset = offsetof(CMS_OtherKeyAttribute, keyAttr),
524 .field_name = "keyAttr",
525 .item = &ASN1_ANY_it,
526 },
527 };
528
529 const ASN1_ITEM CMS_OtherKeyAttribute_it = {
530 .itype = ASN1_ITYPE_SEQUENCE,
531 .utype = V_ASN1_SEQUENCE,
532 .templates = CMS_OtherKeyAttribute_seq_tt,
533 .tcount = sizeof(CMS_OtherKeyAttribute_seq_tt) / sizeof(ASN1_TEMPLATE),
534 .funcs = NULL,
535 .size = sizeof(CMS_OtherKeyAttribute),
536 .sname = "CMS_OtherKeyAttribute",
537 };
538
539 static const ASN1_TEMPLATE CMS_RecipientKeyIdentifier_seq_tt[] = {
540 {
541 .flags = 0,
542 .tag = 0,
543 .offset = offsetof(CMS_RecipientKeyIdentifier, subjectKeyIdentifier),
544 .field_name = "subjectKeyIdentifier",
545 .item = &ASN1_OCTET_STRING_it,
546 },
547 {
548 .flags = ASN1_TFLG_OPTIONAL,
549 .tag = 0,
550 .offset = offsetof(CMS_RecipientKeyIdentifier, date),
551 .field_name = "date",
552 .item = &ASN1_GENERALIZEDTIME_it,
553 },
554 {
555 .flags = ASN1_TFLG_OPTIONAL,
556 .tag = 0,
557 .offset = offsetof(CMS_RecipientKeyIdentifier, other),
558 .field_name = "other",
559 .item = &CMS_OtherKeyAttribute_it,
560 },
561 };
562
563 const ASN1_ITEM CMS_RecipientKeyIdentifier_it = {
564 .itype = ASN1_ITYPE_SEQUENCE,
565 .utype = V_ASN1_SEQUENCE,
566 .templates = CMS_RecipientKeyIdentifier_seq_tt,
567 .tcount = sizeof(CMS_RecipientKeyIdentifier_seq_tt) / sizeof(ASN1_TEMPLATE),
568 .funcs = NULL,
569 .size = sizeof(CMS_RecipientKeyIdentifier),
570 .sname = "CMS_RecipientKeyIdentifier",
571 };
572
573 static const ASN1_TEMPLATE CMS_KeyAgreeRecipientIdentifier_ch_tt[] = {
574 {
575 .flags = 0,
576 .tag = 0,
577 .offset = offsetof(CMS_KeyAgreeRecipientIdentifier, d.issuerAndSerialNumber),
578 .field_name = "d.issuerAndSerialNumber",
579 .item = &CMS_IssuerAndSerialNumber_it,
580 },
581 {
582 .flags = ASN1_TFLG_IMPLICIT,
583 .tag = 0,
584 .offset = offsetof(CMS_KeyAgreeRecipientIdentifier, d.rKeyId),
585 .field_name = "d.rKeyId",
586 .item = &CMS_RecipientKeyIdentifier_it,
587 },
588 };
589
590 static const ASN1_ITEM CMS_KeyAgreeRecipientIdentifier_it = {
591 .itype = ASN1_ITYPE_CHOICE,
592 .utype = offsetof(CMS_KeyAgreeRecipientIdentifier, type),
593 .templates = CMS_KeyAgreeRecipientIdentifier_ch_tt,
594 .tcount = sizeof(CMS_KeyAgreeRecipientIdentifier_ch_tt) / sizeof(ASN1_TEMPLATE),
595 .funcs = NULL,
596 .size = sizeof(CMS_KeyAgreeRecipientIdentifier),
597 .sname = "CMS_KeyAgreeRecipientIdentifier",
598 };
599
600 static int
cms_rek_cb(int operation,ASN1_VALUE ** pval,const ASN1_ITEM * it,void * exarg)601 cms_rek_cb(int operation, ASN1_VALUE **pval, const ASN1_ITEM *it, void *exarg)
602 {
603 CMS_RecipientEncryptedKey *rek = (CMS_RecipientEncryptedKey *)*pval;
604 if (operation == ASN1_OP_FREE_POST) {
605 EVP_PKEY_free(rek->pkey);
606 }
607 return 1;
608 }
609
610 static const ASN1_AUX CMS_RecipientEncryptedKey_aux = {
611 .app_data = NULL,
612 .flags = 0,
613 .ref_offset = 0,
614 .ref_lock = 0,
615 .asn1_cb = cms_rek_cb,
616 .enc_offset = 0,
617 };
618 static const ASN1_TEMPLATE CMS_RecipientEncryptedKey_seq_tt[] = {
619 {
620 .flags = 0,
621 .tag = 0,
622 .offset = offsetof(CMS_RecipientEncryptedKey, rid),
623 .field_name = "rid",
624 .item = &CMS_KeyAgreeRecipientIdentifier_it,
625 },
626 {
627 .flags = 0,
628 .tag = 0,
629 .offset = offsetof(CMS_RecipientEncryptedKey, encryptedKey),
630 .field_name = "encryptedKey",
631 .item = &ASN1_OCTET_STRING_it,
632 },
633 };
634
635 const ASN1_ITEM CMS_RecipientEncryptedKey_it = {
636 .itype = ASN1_ITYPE_SEQUENCE,
637 .utype = V_ASN1_SEQUENCE,
638 .templates = CMS_RecipientEncryptedKey_seq_tt,
639 .tcount = sizeof(CMS_RecipientEncryptedKey_seq_tt) / sizeof(ASN1_TEMPLATE),
640 .funcs = &CMS_RecipientEncryptedKey_aux,
641 .size = sizeof(CMS_RecipientEncryptedKey),
642 .sname = "CMS_RecipientEncryptedKey",
643 };
644
645 static const ASN1_TEMPLATE CMS_OriginatorPublicKey_seq_tt[] = {
646 {
647 .flags = 0,
648 .tag = 0,
649 .offset = offsetof(CMS_OriginatorPublicKey, algorithm),
650 .field_name = "algorithm",
651 .item = &X509_ALGOR_it,
652 },
653 {
654 .flags = 0,
655 .tag = 0,
656 .offset = offsetof(CMS_OriginatorPublicKey, publicKey),
657 .field_name = "publicKey",
658 .item = &ASN1_BIT_STRING_it,
659 },
660 };
661
662 const ASN1_ITEM CMS_OriginatorPublicKey_it = {
663 .itype = ASN1_ITYPE_SEQUENCE,
664 .utype = V_ASN1_SEQUENCE,
665 .templates = CMS_OriginatorPublicKey_seq_tt,
666 .tcount = sizeof(CMS_OriginatorPublicKey_seq_tt) / sizeof(ASN1_TEMPLATE),
667 .funcs = NULL,
668 .size = sizeof(CMS_OriginatorPublicKey),
669 .sname = "CMS_OriginatorPublicKey",
670 };
671
672 static const ASN1_TEMPLATE CMS_OriginatorIdentifierOrKey_ch_tt[] = {
673 {
674 .flags = 0,
675 .tag = 0,
676 .offset = offsetof(CMS_OriginatorIdentifierOrKey, d.issuerAndSerialNumber),
677 .field_name = "d.issuerAndSerialNumber",
678 .item = &CMS_IssuerAndSerialNumber_it,
679 },
680 {
681 .flags = ASN1_TFLG_IMPLICIT,
682 .tag = 0,
683 .offset = offsetof(CMS_OriginatorIdentifierOrKey, d.subjectKeyIdentifier),
684 .field_name = "d.subjectKeyIdentifier",
685 .item = &ASN1_OCTET_STRING_it,
686 },
687 {
688 .flags = ASN1_TFLG_IMPLICIT,
689 .tag = 1,
690 .offset = offsetof(CMS_OriginatorIdentifierOrKey, d.originatorKey),
691 .field_name = "d.originatorKey",
692 .item = &CMS_OriginatorPublicKey_it,
693 },
694 };
695
696 static const ASN1_ITEM CMS_OriginatorIdentifierOrKey_it = {
697 .itype = ASN1_ITYPE_CHOICE,
698 .utype = offsetof(CMS_OriginatorIdentifierOrKey, type),
699 .templates = CMS_OriginatorIdentifierOrKey_ch_tt,
700 .tcount = sizeof(CMS_OriginatorIdentifierOrKey_ch_tt) / sizeof(ASN1_TEMPLATE),
701 .funcs = NULL,
702 .size = sizeof(CMS_OriginatorIdentifierOrKey),
703 .sname = "CMS_OriginatorIdentifierOrKey",
704 };
705
706 static int
cms_kari_cb(int operation,ASN1_VALUE ** pval,const ASN1_ITEM * it,void * exarg)707 cms_kari_cb(int operation, ASN1_VALUE **pval, const ASN1_ITEM *it, void *exarg)
708 {
709 CMS_KeyAgreeRecipientInfo *kari = (CMS_KeyAgreeRecipientInfo *)*pval;
710 if (operation == ASN1_OP_NEW_POST) {
711 kari->ctx = EVP_CIPHER_CTX_new();
712 if (kari->ctx == NULL)
713 return 0;
714 EVP_CIPHER_CTX_set_flags(kari->ctx, EVP_CIPHER_CTX_FLAG_WRAP_ALLOW);
715 kari->pctx = NULL;
716 } else if (operation == ASN1_OP_FREE_POST) {
717 EVP_PKEY_CTX_free(kari->pctx);
718 EVP_CIPHER_CTX_free(kari->ctx);
719 }
720 return 1;
721 }
722
723 static const ASN1_AUX CMS_KeyAgreeRecipientInfo_aux = {
724 .app_data = NULL,
725 .flags = 0,
726 .ref_offset = 0,
727 .ref_lock = 0,
728 .asn1_cb = cms_kari_cb,
729 .enc_offset = 0,
730 };
731 static const ASN1_TEMPLATE CMS_KeyAgreeRecipientInfo_seq_tt[] = {
732 {
733 .flags = 0,
734 .tag = 0,
735 .offset = offsetof(CMS_KeyAgreeRecipientInfo, version),
736 .field_name = "version",
737 .item = &LONG_it,
738 },
739 {
740 .flags = ASN1_TFLG_EXPLICIT,
741 .tag = 0,
742 .offset = offsetof(CMS_KeyAgreeRecipientInfo, originator),
743 .field_name = "originator",
744 .item = &CMS_OriginatorIdentifierOrKey_it,
745 },
746 {
747 .flags = ASN1_TFLG_EXPLICIT | ASN1_TFLG_OPTIONAL,
748 .tag = 1,
749 .offset = offsetof(CMS_KeyAgreeRecipientInfo, ukm),
750 .field_name = "ukm",
751 .item = &ASN1_OCTET_STRING_it,
752 },
753 {
754 .flags = 0,
755 .tag = 0,
756 .offset = offsetof(CMS_KeyAgreeRecipientInfo, keyEncryptionAlgorithm),
757 .field_name = "keyEncryptionAlgorithm",
758 .item = &X509_ALGOR_it,
759 },
760 {
761 .flags = ASN1_TFLG_SEQUENCE_OF,
762 .tag = 0,
763 .offset = offsetof(CMS_KeyAgreeRecipientInfo, recipientEncryptedKeys),
764 .field_name = "recipientEncryptedKeys",
765 .item = &CMS_RecipientEncryptedKey_it,
766 },
767 };
768
769 const ASN1_ITEM CMS_KeyAgreeRecipientInfo_it = {
770 .itype = ASN1_ITYPE_SEQUENCE,
771 .utype = V_ASN1_SEQUENCE,
772 .templates = CMS_KeyAgreeRecipientInfo_seq_tt,
773 .tcount = sizeof(CMS_KeyAgreeRecipientInfo_seq_tt) / sizeof(ASN1_TEMPLATE),
774 .funcs = &CMS_KeyAgreeRecipientInfo_aux,
775 .size = sizeof(CMS_KeyAgreeRecipientInfo),
776 .sname = "CMS_KeyAgreeRecipientInfo",
777 };
778
779 static const ASN1_TEMPLATE CMS_KEKIdentifier_seq_tt[] = {
780 {
781 .flags = 0,
782 .tag = 0,
783 .offset = offsetof(CMS_KEKIdentifier, keyIdentifier),
784 .field_name = "keyIdentifier",
785 .item = &ASN1_OCTET_STRING_it,
786 },
787 {
788 .flags = ASN1_TFLG_OPTIONAL,
789 .tag = 0,
790 .offset = offsetof(CMS_KEKIdentifier, date),
791 .field_name = "date",
792 .item = &ASN1_GENERALIZEDTIME_it,
793 },
794 {
795 .flags = ASN1_TFLG_OPTIONAL,
796 .tag = 0,
797 .offset = offsetof(CMS_KEKIdentifier, other),
798 .field_name = "other",
799 .item = &CMS_OtherKeyAttribute_it,
800 },
801 };
802
803 static const ASN1_ITEM CMS_KEKIdentifier_it = {
804 .itype = ASN1_ITYPE_SEQUENCE,
805 .utype = V_ASN1_SEQUENCE,
806 .templates = CMS_KEKIdentifier_seq_tt,
807 .tcount = sizeof(CMS_KEKIdentifier_seq_tt) / sizeof(ASN1_TEMPLATE),
808 .funcs = NULL,
809 .size = sizeof(CMS_KEKIdentifier),
810 .sname = "CMS_KEKIdentifier",
811 };
812
813 static const ASN1_TEMPLATE CMS_KEKRecipientInfo_seq_tt[] = {
814 {
815 .flags = 0,
816 .tag = 0,
817 .offset = offsetof(CMS_KEKRecipientInfo, version),
818 .field_name = "version",
819 .item = &LONG_it,
820 },
821 {
822 .flags = 0,
823 .tag = 0,
824 .offset = offsetof(CMS_KEKRecipientInfo, kekid),
825 .field_name = "kekid",
826 .item = &CMS_KEKIdentifier_it,
827 },
828 {
829 .flags = 0,
830 .tag = 0,
831 .offset = offsetof(CMS_KEKRecipientInfo, keyEncryptionAlgorithm),
832 .field_name = "keyEncryptionAlgorithm",
833 .item = &X509_ALGOR_it,
834 },
835 {
836 .flags = 0,
837 .tag = 0,
838 .offset = offsetof(CMS_KEKRecipientInfo, encryptedKey),
839 .field_name = "encryptedKey",
840 .item = &ASN1_OCTET_STRING_it,
841 },
842 };
843
844 const ASN1_ITEM CMS_KEKRecipientInfo_it = {
845 .itype = ASN1_ITYPE_SEQUENCE,
846 .utype = V_ASN1_SEQUENCE,
847 .templates = CMS_KEKRecipientInfo_seq_tt,
848 .tcount = sizeof(CMS_KEKRecipientInfo_seq_tt) / sizeof(ASN1_TEMPLATE),
849 .funcs = NULL,
850 .size = sizeof(CMS_KEKRecipientInfo),
851 .sname = "CMS_KEKRecipientInfo",
852 };
853
854 static const ASN1_TEMPLATE CMS_PasswordRecipientInfo_seq_tt[] = {
855 {
856 .flags = 0,
857 .tag = 0,
858 .offset = offsetof(CMS_PasswordRecipientInfo, version),
859 .field_name = "version",
860 .item = &LONG_it,
861 },
862 {
863 .flags = ASN1_TFLG_IMPLICIT | ASN1_TFLG_OPTIONAL,
864 .tag = 0,
865 .offset = offsetof(CMS_PasswordRecipientInfo, keyDerivationAlgorithm),
866 .field_name = "keyDerivationAlgorithm",
867 .item = &X509_ALGOR_it,
868 },
869 {
870 .flags = 0,
871 .tag = 0,
872 .offset = offsetof(CMS_PasswordRecipientInfo, keyEncryptionAlgorithm),
873 .field_name = "keyEncryptionAlgorithm",
874 .item = &X509_ALGOR_it,
875 },
876 {
877 .flags = 0,
878 .tag = 0,
879 .offset = offsetof(CMS_PasswordRecipientInfo, encryptedKey),
880 .field_name = "encryptedKey",
881 .item = &ASN1_OCTET_STRING_it,
882 },
883 };
884
885 const ASN1_ITEM CMS_PasswordRecipientInfo_it = {
886 .itype = ASN1_ITYPE_SEQUENCE,
887 .utype = V_ASN1_SEQUENCE,
888 .templates = CMS_PasswordRecipientInfo_seq_tt,
889 .tcount = sizeof(CMS_PasswordRecipientInfo_seq_tt) / sizeof(ASN1_TEMPLATE),
890 .funcs = NULL,
891 .size = sizeof(CMS_PasswordRecipientInfo),
892 .sname = "CMS_PasswordRecipientInfo",
893 };
894
895 static const ASN1_TEMPLATE CMS_OtherRecipientInfo_seq_tt[] = {
896 {
897 .flags = 0,
898 .tag = 0,
899 .offset = offsetof(CMS_OtherRecipientInfo, oriType),
900 .field_name = "oriType",
901 .item = &ASN1_OBJECT_it,
902 },
903 {
904 .flags = ASN1_TFLG_OPTIONAL,
905 .tag = 0,
906 .offset = offsetof(CMS_OtherRecipientInfo, oriValue),
907 .field_name = "oriValue",
908 .item = &ASN1_ANY_it,
909 },
910 };
911
912 static const ASN1_ITEM CMS_OtherRecipientInfo_it = {
913 .itype = ASN1_ITYPE_SEQUENCE,
914 .utype = V_ASN1_SEQUENCE,
915 .templates = CMS_OtherRecipientInfo_seq_tt,
916 .tcount = sizeof(CMS_OtherRecipientInfo_seq_tt) / sizeof(ASN1_TEMPLATE),
917 .funcs = NULL,
918 .size = sizeof(CMS_OtherRecipientInfo),
919 .sname = "CMS_OtherRecipientInfo",
920 };
921
922 /* Free up RecipientInfo additional data */
923 static int
cms_ri_cb(int operation,ASN1_VALUE ** pval,const ASN1_ITEM * it,void * exarg)924 cms_ri_cb(int operation, ASN1_VALUE **pval, const ASN1_ITEM *it, void *exarg)
925 {
926 if (operation == ASN1_OP_FREE_PRE) {
927 CMS_RecipientInfo *ri = (CMS_RecipientInfo *)*pval;
928 if (ri->type == CMS_RECIPINFO_TRANS) {
929 CMS_KeyTransRecipientInfo *ktri = ri->d.ktri;
930 EVP_PKEY_free(ktri->pkey);
931 X509_free(ktri->recip);
932 EVP_PKEY_CTX_free(ktri->pctx);
933 } else if (ri->type == CMS_RECIPINFO_KEK) {
934 CMS_KEKRecipientInfo *kekri = ri->d.kekri;
935 freezero(kekri->key, kekri->keylen);
936 } else if (ri->type == CMS_RECIPINFO_PASS) {
937 CMS_PasswordRecipientInfo *pwri = ri->d.pwri;
938 freezero(pwri->pass, pwri->passlen);
939 }
940 }
941 return 1;
942 }
943
944 static const ASN1_AUX CMS_RecipientInfo_aux = {
945 .app_data = NULL,
946 .flags = 0,
947 .ref_offset = 0,
948 .ref_lock = 0,
949 .asn1_cb = cms_ri_cb,
950 .enc_offset = 0,
951 };
952 static const ASN1_TEMPLATE CMS_RecipientInfo_ch_tt[] = {
953 {
954 .flags = 0,
955 .tag = 0,
956 .offset = offsetof(CMS_RecipientInfo, d.ktri),
957 .field_name = "d.ktri",
958 .item = &CMS_KeyTransRecipientInfo_it,
959 },
960 {
961 .flags = ASN1_TFLG_IMPLICIT,
962 .tag = 1,
963 .offset = offsetof(CMS_RecipientInfo, d.kari),
964 .field_name = "d.kari",
965 .item = &CMS_KeyAgreeRecipientInfo_it,
966 },
967 {
968 .flags = ASN1_TFLG_IMPLICIT,
969 .tag = 2,
970 .offset = offsetof(CMS_RecipientInfo, d.kekri),
971 .field_name = "d.kekri",
972 .item = &CMS_KEKRecipientInfo_it,
973 },
974 {
975 .flags = ASN1_TFLG_IMPLICIT,
976 .tag = 3,
977 .offset = offsetof(CMS_RecipientInfo, d.pwri),
978 .field_name = "d.pwri",
979 .item = &CMS_PasswordRecipientInfo_it,
980 },
981 {
982 .flags = ASN1_TFLG_IMPLICIT,
983 .tag = 4,
984 .offset = offsetof(CMS_RecipientInfo, d.ori),
985 .field_name = "d.ori",
986 .item = &CMS_OtherRecipientInfo_it,
987 },
988 };
989
990 const ASN1_ITEM CMS_RecipientInfo_it = {
991 .itype = ASN1_ITYPE_CHOICE,
992 .utype = offsetof(CMS_RecipientInfo, type),
993 .templates = CMS_RecipientInfo_ch_tt,
994 .tcount = sizeof(CMS_RecipientInfo_ch_tt) / sizeof(ASN1_TEMPLATE),
995 .funcs = &CMS_RecipientInfo_aux,
996 .size = sizeof(CMS_RecipientInfo),
997 .sname = "CMS_RecipientInfo",
998 };
999
1000 static const ASN1_TEMPLATE CMS_EnvelopedData_seq_tt[] = {
1001 {
1002 .flags = 0,
1003 .tag = 0,
1004 .offset = offsetof(CMS_EnvelopedData, version),
1005 .field_name = "version",
1006 .item = &LONG_it,
1007 },
1008 {
1009 .flags = ASN1_TFLG_IMPLICIT | ASN1_TFLG_OPTIONAL,
1010 .tag = 0,
1011 .offset = offsetof(CMS_EnvelopedData, originatorInfo),
1012 .field_name = "originatorInfo",
1013 .item = &CMS_OriginatorInfo_it,
1014 },
1015 {
1016 .flags = ASN1_TFLG_SET_OF,
1017 .tag = 0,
1018 .offset = offsetof(CMS_EnvelopedData, recipientInfos),
1019 .field_name = "recipientInfos",
1020 .item = &CMS_RecipientInfo_it,
1021 },
1022 {
1023 .flags = 0,
1024 .tag = 0,
1025 .offset = offsetof(CMS_EnvelopedData, encryptedContentInfo),
1026 .field_name = "encryptedContentInfo",
1027 .item = &CMS_EncryptedContentInfo_it,
1028 },
1029 {
1030 .flags = ASN1_TFLG_IMPLICIT | ASN1_TFLG_SET_OF | ASN1_TFLG_OPTIONAL,
1031 .tag = 1,
1032 .offset = offsetof(CMS_EnvelopedData, unprotectedAttrs),
1033 .field_name = "unprotectedAttrs",
1034 .item = &X509_ATTRIBUTE_it,
1035 },
1036 };
1037
1038 const ASN1_ITEM CMS_EnvelopedData_it = {
1039 .itype = ASN1_ITYPE_NDEF_SEQUENCE,
1040 .utype = V_ASN1_SEQUENCE,
1041 .templates = CMS_EnvelopedData_seq_tt,
1042 .tcount = sizeof(CMS_EnvelopedData_seq_tt) / sizeof(ASN1_TEMPLATE),
1043 .funcs = NULL,
1044 .size = sizeof(CMS_EnvelopedData),
1045 .sname = "CMS_EnvelopedData",
1046 };
1047
1048 static const ASN1_TEMPLATE CMS_DigestedData_seq_tt[] = {
1049 {
1050 .flags = 0,
1051 .tag = 0,
1052 .offset = offsetof(CMS_DigestedData, version),
1053 .field_name = "version",
1054 .item = &LONG_it,
1055 },
1056 {
1057 .flags = 0,
1058 .tag = 0,
1059 .offset = offsetof(CMS_DigestedData, digestAlgorithm),
1060 .field_name = "digestAlgorithm",
1061 .item = &X509_ALGOR_it,
1062 },
1063 {
1064 .flags = 0,
1065 .tag = 0,
1066 .offset = offsetof(CMS_DigestedData, encapContentInfo),
1067 .field_name = "encapContentInfo",
1068 .item = &CMS_EncapsulatedContentInfo_it,
1069 },
1070 {
1071 .flags = 0,
1072 .tag = 0,
1073 .offset = offsetof(CMS_DigestedData, digest),
1074 .field_name = "digest",
1075 .item = &ASN1_OCTET_STRING_it,
1076 },
1077 };
1078
1079 const ASN1_ITEM CMS_DigestedData_it = {
1080 .itype = ASN1_ITYPE_NDEF_SEQUENCE,
1081 .utype = V_ASN1_SEQUENCE,
1082 .templates = CMS_DigestedData_seq_tt,
1083 .tcount = sizeof(CMS_DigestedData_seq_tt) / sizeof(ASN1_TEMPLATE),
1084 .funcs = NULL,
1085 .size = sizeof(CMS_DigestedData),
1086 .sname = "CMS_DigestedData",
1087 };
1088
1089 static const ASN1_TEMPLATE CMS_EncryptedData_seq_tt[] = {
1090 {
1091 .flags = 0,
1092 .tag = 0,
1093 .offset = offsetof(CMS_EncryptedData, version),
1094 .field_name = "version",
1095 .item = &LONG_it,
1096 },
1097 {
1098 .flags = 0,
1099 .tag = 0,
1100 .offset = offsetof(CMS_EncryptedData, encryptedContentInfo),
1101 .field_name = "encryptedContentInfo",
1102 .item = &CMS_EncryptedContentInfo_it,
1103 },
1104 {
1105 .flags = ASN1_TFLG_IMPLICIT | ASN1_TFLG_SET_OF | ASN1_TFLG_OPTIONAL,
1106 .tag = 1,
1107 .offset = offsetof(CMS_EncryptedData, unprotectedAttrs),
1108 .field_name = "unprotectedAttrs",
1109 .item = &X509_ATTRIBUTE_it,
1110 },
1111 };
1112
1113 const ASN1_ITEM CMS_EncryptedData_it = {
1114 .itype = ASN1_ITYPE_NDEF_SEQUENCE,
1115 .utype = V_ASN1_SEQUENCE,
1116 .templates = CMS_EncryptedData_seq_tt,
1117 .tcount = sizeof(CMS_EncryptedData_seq_tt) / sizeof(ASN1_TEMPLATE),
1118 .funcs = NULL,
1119 .size = sizeof(CMS_EncryptedData),
1120 .sname = "CMS_EncryptedData",
1121 };
1122
1123 static const ASN1_TEMPLATE CMS_AuthenticatedData_seq_tt[] = {
1124 {
1125 .flags = 0,
1126 .tag = 0,
1127 .offset = offsetof(CMS_AuthenticatedData, version),
1128 .field_name = "version",
1129 .item = &LONG_it,
1130 },
1131 {
1132 .flags = ASN1_TFLG_IMPLICIT | ASN1_TFLG_OPTIONAL,
1133 .tag = 0,
1134 .offset = offsetof(CMS_AuthenticatedData, originatorInfo),
1135 .field_name = "originatorInfo",
1136 .item = &CMS_OriginatorInfo_it,
1137 },
1138 {
1139 .flags = ASN1_TFLG_SET_OF,
1140 .tag = 0,
1141 .offset = offsetof(CMS_AuthenticatedData, recipientInfos),
1142 .field_name = "recipientInfos",
1143 .item = &CMS_RecipientInfo_it,
1144 },
1145 {
1146 .flags = 0,
1147 .tag = 0,
1148 .offset = offsetof(CMS_AuthenticatedData, macAlgorithm),
1149 .field_name = "macAlgorithm",
1150 .item = &X509_ALGOR_it,
1151 },
1152 {
1153 .flags = ASN1_TFLG_IMPLICIT,
1154 .tag = 1,
1155 .offset = offsetof(CMS_AuthenticatedData, digestAlgorithm),
1156 .field_name = "digestAlgorithm",
1157 .item = &X509_ALGOR_it,
1158 },
1159 {
1160 .flags = 0,
1161 .tag = 0,
1162 .offset = offsetof(CMS_AuthenticatedData, encapContentInfo),
1163 .field_name = "encapContentInfo",
1164 .item = &CMS_EncapsulatedContentInfo_it,
1165 },
1166 {
1167 .flags = ASN1_TFLG_IMPLICIT | ASN1_TFLG_SET_OF | ASN1_TFLG_OPTIONAL,
1168 .tag = 2,
1169 .offset = offsetof(CMS_AuthenticatedData, authAttrs),
1170 .field_name = "authAttrs",
1171 .item = &X509_ALGOR_it,
1172 },
1173 {
1174 .flags = 0,
1175 .tag = 0,
1176 .offset = offsetof(CMS_AuthenticatedData, mac),
1177 .field_name = "mac",
1178 .item = &ASN1_OCTET_STRING_it,
1179 },
1180 {
1181 .flags = ASN1_TFLG_IMPLICIT | ASN1_TFLG_SET_OF | ASN1_TFLG_OPTIONAL,
1182 .tag = 3,
1183 .offset = offsetof(CMS_AuthenticatedData, unauthAttrs),
1184 .field_name = "unauthAttrs",
1185 .item = &X509_ALGOR_it,
1186 },
1187 };
1188
1189 static const ASN1_ITEM CMS_AuthenticatedData_it = {
1190 .itype = ASN1_ITYPE_NDEF_SEQUENCE,
1191 .utype = V_ASN1_SEQUENCE,
1192 .templates = CMS_AuthenticatedData_seq_tt,
1193 .tcount = sizeof(CMS_AuthenticatedData_seq_tt) / sizeof(ASN1_TEMPLATE),
1194 .funcs = NULL,
1195 .size = sizeof(CMS_AuthenticatedData),
1196 .sname = "CMS_AuthenticatedData",
1197 };
1198
1199 static const ASN1_TEMPLATE CMS_CompressedData_seq_tt[] = {
1200 {
1201 .flags = 0,
1202 .tag = 0,
1203 .offset = offsetof(CMS_CompressedData, version),
1204 .field_name = "version",
1205 .item = &LONG_it,
1206 },
1207 {
1208 .flags = 0,
1209 .tag = 0,
1210 .offset = offsetof(CMS_CompressedData, compressionAlgorithm),
1211 .field_name = "compressionAlgorithm",
1212 .item = &X509_ALGOR_it,
1213 },
1214 {
1215 .flags = 0,
1216 .tag = 0,
1217 .offset = offsetof(CMS_CompressedData, encapContentInfo),
1218 .field_name = "encapContentInfo",
1219 .item = &CMS_EncapsulatedContentInfo_it,
1220 },
1221 };
1222
1223 const ASN1_ITEM CMS_CompressedData_it = {
1224 .itype = ASN1_ITYPE_NDEF_SEQUENCE,
1225 .utype = V_ASN1_SEQUENCE,
1226 .templates = CMS_CompressedData_seq_tt,
1227 .tcount = sizeof(CMS_CompressedData_seq_tt) / sizeof(ASN1_TEMPLATE),
1228 .funcs = NULL,
1229 .size = sizeof(CMS_CompressedData),
1230 .sname = "CMS_CompressedData",
1231 };
1232
1233 /* This is the ANY DEFINED BY table for the top level ContentInfo structure */
1234
1235 static const ASN1_TEMPLATE cms_default_tt = {
1236 .flags = ASN1_TFLG_EXPLICIT,
1237 .tag = 0,
1238 .offset = offsetof(CMS_ContentInfo, d.other),
1239 .field_name = "d.other",
1240 .item = &ASN1_ANY_it,
1241 };
1242
1243 static const ASN1_ADB_TABLE CMS_ContentInfo_adbtbl[] = {
1244 {
1245 .value = NID_pkcs7_data,
1246 .tt = {
1247 .flags = ASN1_TFLG_EXPLICIT | ASN1_TFLG_NDEF,
1248 .tag = 0,
1249 .offset = offsetof(CMS_ContentInfo, d.data),
1250 .field_name = "d.data",
1251 .item = &ASN1_OCTET_STRING_NDEF_it,
1252 },
1253
1254 },
1255 {
1256 .value = NID_pkcs7_signed,
1257 .tt = {
1258 .flags = ASN1_TFLG_EXPLICIT | ASN1_TFLG_NDEF,
1259 .tag = 0,
1260 .offset = offsetof(CMS_ContentInfo, d.signedData),
1261 .field_name = "d.signedData",
1262 .item = &CMS_SignedData_it,
1263 },
1264
1265 },
1266 {
1267 .value = NID_pkcs7_enveloped,
1268 .tt = {
1269 .flags = ASN1_TFLG_EXPLICIT | ASN1_TFLG_NDEF,
1270 .tag = 0,
1271 .offset = offsetof(CMS_ContentInfo, d.envelopedData),
1272 .field_name = "d.envelopedData",
1273 .item = &CMS_EnvelopedData_it,
1274 },
1275
1276 },
1277 {
1278 .value = NID_pkcs7_digest,
1279 .tt = {
1280 .flags = ASN1_TFLG_EXPLICIT | ASN1_TFLG_NDEF,
1281 .tag = 0,
1282 .offset = offsetof(CMS_ContentInfo, d.digestedData),
1283 .field_name = "d.digestedData",
1284 .item = &CMS_DigestedData_it,
1285 },
1286
1287 },
1288 {
1289 .value = NID_pkcs7_encrypted,
1290 .tt = {
1291 .flags = ASN1_TFLG_EXPLICIT | ASN1_TFLG_NDEF,
1292 .tag = 0,
1293 .offset = offsetof(CMS_ContentInfo, d.encryptedData),
1294 .field_name = "d.encryptedData",
1295 .item = &CMS_EncryptedData_it,
1296 },
1297
1298 },
1299 {
1300 .value = NID_id_smime_ct_authData,
1301 .tt = {
1302 .flags = ASN1_TFLG_EXPLICIT | ASN1_TFLG_NDEF,
1303 .tag = 0,
1304 .offset = offsetof(CMS_ContentInfo, d.authenticatedData),
1305 .field_name = "d.authenticatedData",
1306 .item = &CMS_AuthenticatedData_it,
1307 },
1308
1309 },
1310 {
1311 .value = NID_id_smime_ct_compressedData,
1312 .tt = {
1313 .flags = ASN1_TFLG_EXPLICIT | ASN1_TFLG_NDEF,
1314 .tag = 0,
1315 .offset = offsetof(CMS_ContentInfo, d.compressedData),
1316 .field_name = "d.compressedData",
1317 .item = &CMS_CompressedData_it,
1318 },
1319
1320 },
1321 };
1322
1323 static const ASN1_ADB CMS_ContentInfo_adb = {
1324 .flags = 0,
1325 .offset = offsetof(CMS_ContentInfo, contentType),
1326 .tbl = CMS_ContentInfo_adbtbl,
1327 .tblcount = sizeof(CMS_ContentInfo_adbtbl) / sizeof(ASN1_ADB_TABLE),
1328 .default_tt = &cms_default_tt,
1329 .null_tt = NULL,
1330 };
1331
1332 /* CMS streaming support */
1333 static int
cms_cb(int operation,ASN1_VALUE ** pval,const ASN1_ITEM * it,void * exarg)1334 cms_cb(int operation, ASN1_VALUE **pval, const ASN1_ITEM *it, void *exarg)
1335 {
1336 ASN1_STREAM_ARG *sarg = exarg;
1337 CMS_ContentInfo *cms = NULL;
1338 if (pval)
1339 cms = (CMS_ContentInfo *)*pval;
1340 else
1341 return 1;
1342 switch (operation) {
1343
1344 case ASN1_OP_STREAM_PRE:
1345 if (CMS_stream(&sarg->boundary, cms) <= 0)
1346 return 0;
1347 /* fall thru */
1348 case ASN1_OP_DETACHED_PRE:
1349 sarg->ndef_bio = CMS_dataInit(cms, sarg->out);
1350 if (!sarg->ndef_bio)
1351 return 0;
1352 break;
1353
1354 case ASN1_OP_STREAM_POST:
1355 case ASN1_OP_DETACHED_POST:
1356 if (CMS_dataFinal(cms, sarg->ndef_bio) <= 0)
1357 return 0;
1358 break;
1359
1360 }
1361 return 1;
1362 }
1363
1364 static const ASN1_AUX CMS_ContentInfo_aux = {
1365 .app_data = NULL,
1366 .flags = 0,
1367 .ref_offset = 0,
1368 .ref_lock = 0,
1369 .asn1_cb = cms_cb,
1370 .enc_offset = 0,
1371 };
1372 static const ASN1_TEMPLATE CMS_ContentInfo_seq_tt[] = {
1373 {
1374 .flags = 0,
1375 .tag = 0,
1376 .offset = offsetof(CMS_ContentInfo, contentType),
1377 .field_name = "contentType",
1378 .item = &ASN1_OBJECT_it,
1379 },
1380 {
1381 .flags = ASN1_TFLG_ADB_OID,
1382 .tag = -1,
1383 .offset = 0,
1384 .field_name = "CMS_ContentInfo",
1385 .item = (const ASN1_ITEM *)&CMS_ContentInfo_adb,
1386 },
1387 };
1388
1389 const ASN1_ITEM CMS_ContentInfo_it = {
1390 .itype = ASN1_ITYPE_NDEF_SEQUENCE,
1391 .utype = V_ASN1_SEQUENCE,
1392 .templates = CMS_ContentInfo_seq_tt,
1393 .tcount = sizeof(CMS_ContentInfo_seq_tt) / sizeof(ASN1_TEMPLATE),
1394 .funcs = &CMS_ContentInfo_aux,
1395 .size = sizeof(CMS_ContentInfo),
1396 .sname = "CMS_ContentInfo",
1397 };
1398
1399 /* Specials for signed attributes */
1400
1401 /*
1402 * When signing attributes we want to reorder them to match the sorted
1403 * encoding.
1404 */
1405
1406 static const ASN1_TEMPLATE CMS_Attributes_Sign_item_tt = {
1407 .flags = ASN1_TFLG_SET_ORDER,
1408 .tag = 0,
1409 .offset = 0,
1410 .field_name = "CMS_ATTRIBUTES",
1411 .item = &X509_ATTRIBUTE_it,
1412 };
1413
1414 const ASN1_ITEM CMS_Attributes_Sign_it = {
1415 .itype = ASN1_ITYPE_PRIMITIVE,
1416 .utype = -1,
1417 .templates = &CMS_Attributes_Sign_item_tt,
1418 .tcount = 0,
1419 .funcs = NULL,
1420 .size = 0,
1421 .sname = "CMS_Attributes_Sign",
1422 };
1423
1424 /*
1425 * When verifying attributes we need to use the received order. So we use
1426 * SEQUENCE OF and tag it to SET OF
1427 */
1428
1429 static const ASN1_TEMPLATE CMS_Attributes_Verify_item_tt = {
1430 .flags = ASN1_TFLG_SEQUENCE_OF | ASN1_TFLG_IMPTAG | ASN1_TFLG_UNIVERSAL,
1431 .tag = V_ASN1_SET,
1432 .offset = 0,
1433 .field_name = "CMS_ATTRIBUTES",
1434 .item = &X509_ATTRIBUTE_it,
1435 };
1436
1437 const ASN1_ITEM CMS_Attributes_Verify_it = {
1438 .itype = ASN1_ITYPE_PRIMITIVE,
1439 .utype = -1,
1440 .templates = &CMS_Attributes_Verify_item_tt,
1441 .tcount = 0,
1442 .funcs = NULL,
1443 .size = 0,
1444 .sname = "CMS_Attributes_Verify",
1445 };
1446
1447
1448
1449 static const ASN1_TEMPLATE CMS_ReceiptsFrom_ch_tt[] = {
1450 {
1451 .flags = ASN1_TFLG_IMPLICIT,
1452 .tag = 0,
1453 .offset = offsetof(CMS_ReceiptsFrom, d.allOrFirstTier),
1454 .field_name = "d.allOrFirstTier",
1455 .item = &LONG_it,
1456 },
1457 {
1458 .flags = ASN1_TFLG_IMPLICIT | ASN1_TFLG_SEQUENCE_OF,
1459 .tag = 1,
1460 .offset = offsetof(CMS_ReceiptsFrom, d.receiptList),
1461 .field_name = "d.receiptList",
1462 .item = &GENERAL_NAMES_it,
1463 },
1464 };
1465
1466 static const ASN1_ITEM CMS_ReceiptsFrom_it = {
1467 .itype = ASN1_ITYPE_CHOICE,
1468 .utype = offsetof(CMS_ReceiptsFrom, type),
1469 .templates = CMS_ReceiptsFrom_ch_tt,
1470 .tcount = sizeof(CMS_ReceiptsFrom_ch_tt) / sizeof(ASN1_TEMPLATE),
1471 .funcs = NULL,
1472 .size = sizeof(CMS_ReceiptsFrom),
1473 .sname = "CMS_ReceiptsFrom",
1474 };
1475
1476 static const ASN1_TEMPLATE CMS_ReceiptRequest_seq_tt[] = {
1477 {
1478 .flags = 0,
1479 .tag = 0,
1480 .offset = offsetof(CMS_ReceiptRequest, signedContentIdentifier),
1481 .field_name = "signedContentIdentifier",
1482 .item = &ASN1_OCTET_STRING_it,
1483 },
1484 {
1485 .flags = 0,
1486 .tag = 0,
1487 .offset = offsetof(CMS_ReceiptRequest, receiptsFrom),
1488 .field_name = "receiptsFrom",
1489 .item = &CMS_ReceiptsFrom_it,
1490 },
1491 {
1492 .flags = ASN1_TFLG_SEQUENCE_OF,
1493 .tag = 0,
1494 .offset = offsetof(CMS_ReceiptRequest, receiptsTo),
1495 .field_name = "receiptsTo",
1496 .item = &GENERAL_NAMES_it,
1497 },
1498 };
1499
1500 const ASN1_ITEM CMS_ReceiptRequest_it = {
1501 .itype = ASN1_ITYPE_SEQUENCE,
1502 .utype = V_ASN1_SEQUENCE,
1503 .templates = CMS_ReceiptRequest_seq_tt,
1504 .tcount = sizeof(CMS_ReceiptRequest_seq_tt) / sizeof(ASN1_TEMPLATE),
1505 .funcs = NULL,
1506 .size = sizeof(CMS_ReceiptRequest),
1507 .sname = "CMS_ReceiptRequest",
1508 };
1509
1510 static const ASN1_TEMPLATE CMS_Receipt_seq_tt[] = {
1511 {
1512 .flags = 0,
1513 .tag = 0,
1514 .offset = offsetof(CMS_Receipt, version),
1515 .field_name = "version",
1516 .item = &LONG_it,
1517 },
1518 {
1519 .flags = 0,
1520 .tag = 0,
1521 .offset = offsetof(CMS_Receipt, contentType),
1522 .field_name = "contentType",
1523 .item = &ASN1_OBJECT_it,
1524 },
1525 {
1526 .flags = 0,
1527 .tag = 0,
1528 .offset = offsetof(CMS_Receipt, signedContentIdentifier),
1529 .field_name = "signedContentIdentifier",
1530 .item = &ASN1_OCTET_STRING_it,
1531 },
1532 {
1533 .flags = 0,
1534 .tag = 0,
1535 .offset = offsetof(CMS_Receipt, originatorSignatureValue),
1536 .field_name = "originatorSignatureValue",
1537 .item = &ASN1_OCTET_STRING_it,
1538 },
1539 };
1540
1541 const ASN1_ITEM CMS_Receipt_it = {
1542 .itype = ASN1_ITYPE_SEQUENCE,
1543 .utype = V_ASN1_SEQUENCE,
1544 .templates = CMS_Receipt_seq_tt,
1545 .tcount = sizeof(CMS_Receipt_seq_tt) / sizeof(ASN1_TEMPLATE),
1546 .funcs = NULL,
1547 .size = sizeof(CMS_Receipt),
1548 .sname = "CMS_Receipt",
1549 };
1550
1551 /*
1552 * Utilities to encode the CMS_SharedInfo structure used during key
1553 * derivation.
1554 */
1555
1556 typedef struct {
1557 X509_ALGOR *keyInfo;
1558 ASN1_OCTET_STRING *entityUInfo;
1559 ASN1_OCTET_STRING *suppPubInfo;
1560 } CMS_SharedInfo;
1561
1562 static const ASN1_TEMPLATE CMS_SharedInfo_seq_tt[] = {
1563 {
1564 .flags = 0,
1565 .tag = 0,
1566 .offset = offsetof(CMS_SharedInfo, keyInfo),
1567 .field_name = "keyInfo",
1568 .item = &X509_ALGOR_it,
1569 },
1570 {
1571 .flags = ASN1_TFLG_EXPLICIT | ASN1_TFLG_OPTIONAL,
1572 .tag = 0,
1573 .offset = offsetof(CMS_SharedInfo, entityUInfo),
1574 .field_name = "entityUInfo",
1575 .item = &ASN1_OCTET_STRING_it,
1576 },
1577 {
1578 .flags = ASN1_TFLG_EXPLICIT | ASN1_TFLG_OPTIONAL,
1579 .tag = 2,
1580 .offset = offsetof(CMS_SharedInfo, suppPubInfo),
1581 .field_name = "suppPubInfo",
1582 .item = &ASN1_OCTET_STRING_it,
1583 },
1584 };
1585
1586 static const ASN1_ITEM CMS_SharedInfo_it = {
1587 .itype = ASN1_ITYPE_SEQUENCE,
1588 .utype = V_ASN1_SEQUENCE,
1589 .templates = CMS_SharedInfo_seq_tt,
1590 .tcount = sizeof(CMS_SharedInfo_seq_tt) / sizeof(ASN1_TEMPLATE),
1591 .funcs = NULL,
1592 .size = sizeof(CMS_SharedInfo),
1593 .sname = "CMS_SharedInfo",
1594 };
1595
1596 int
CMS_SharedInfo_encode(unsigned char ** pder,X509_ALGOR * kekalg,ASN1_OCTET_STRING * ukm,int keylen)1597 CMS_SharedInfo_encode(unsigned char **pder, X509_ALGOR *kekalg,
1598 ASN1_OCTET_STRING *ukm, int keylen)
1599 {
1600 union {
1601 CMS_SharedInfo *pecsi;
1602 ASN1_VALUE *a;
1603 } intsi = {
1604 NULL
1605 };
1606
1607 ASN1_OCTET_STRING oklen;
1608 unsigned char kl[4];
1609 CMS_SharedInfo ecsi;
1610
1611 keylen <<= 3;
1612 kl[0] = (keylen >> 24) & 0xff;
1613 kl[1] = (keylen >> 16) & 0xff;
1614 kl[2] = (keylen >> 8) & 0xff;
1615 kl[3] = keylen & 0xff;
1616 oklen.length = 4;
1617 oklen.data = kl;
1618 oklen.type = V_ASN1_OCTET_STRING;
1619 oklen.flags = 0;
1620 ecsi.keyInfo = kekalg;
1621 ecsi.entityUInfo = ukm;
1622 ecsi.suppPubInfo = &oklen;
1623 intsi.pecsi = &ecsi;
1624
1625 return ASN1_item_i2d(intsi.a, pder, &CMS_SharedInfo_it);
1626 }
1627