summaryrefslogtreecommitdiff
path: root/src/lib/libcrypto/pkcs7/pk7_asn1.c
diff options
context:
space:
mode:
Diffstat (limited to 'src/lib/libcrypto/pkcs7/pk7_asn1.c')
-rw-r--r--src/lib/libcrypto/pkcs7/pk7_asn1.c968
1 files changed, 0 insertions, 968 deletions
diff --git a/src/lib/libcrypto/pkcs7/pk7_asn1.c b/src/lib/libcrypto/pkcs7/pk7_asn1.c
deleted file mode 100644
index 81e4a01f14..0000000000
--- a/src/lib/libcrypto/pkcs7/pk7_asn1.c
+++ /dev/null
@@ -1,968 +0,0 @@
1/* $OpenBSD: pk7_asn1.c,v 1.12 2015/07/25 15:33:06 jsing Exp $ */
2/* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL
3 * project 2000.
4 */
5/* ====================================================================
6 * Copyright (c) 2000 The OpenSSL Project. All rights reserved.
7 *
8 * Redistribution and use in source and binary forms, with or without
9 * modification, are permitted provided that the following conditions
10 * are met:
11 *
12 * 1. Redistributions of source code must retain the above copyright
13 * notice, this list of conditions and the following disclaimer.
14 *
15 * 2. Redistributions in binary form must reproduce the above copyright
16 * notice, this list of conditions and the following disclaimer in
17 * the documentation and/or other materials provided with the
18 * distribution.
19 *
20 * 3. All advertising materials mentioning features or use of this
21 * software must display the following acknowledgment:
22 * "This product includes software developed by the OpenSSL Project
23 * for use in the OpenSSL Toolkit. (http://www.OpenSSL.org/)"
24 *
25 * 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to
26 * endorse or promote products derived from this software without
27 * prior written permission. For written permission, please contact
28 * licensing@OpenSSL.org.
29 *
30 * 5. Products derived from this software may not be called "OpenSSL"
31 * nor may "OpenSSL" appear in their names without prior written
32 * permission of the OpenSSL Project.
33 *
34 * 6. Redistributions of any form whatsoever must retain the following
35 * acknowledgment:
36 * "This product includes software developed by the OpenSSL Project
37 * for use in the OpenSSL Toolkit (http://www.OpenSSL.org/)"
38 *
39 * THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY
40 * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
41 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
42 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE OpenSSL PROJECT OR
43 * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
44 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
45 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
46 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
47 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
48 * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
49 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
50 * OF THE POSSIBILITY OF SUCH DAMAGE.
51 * ====================================================================
52 *
53 * This product includes cryptographic software written by Eric Young
54 * (eay@cryptsoft.com). This product includes software written by Tim
55 * Hudson (tjh@cryptsoft.com).
56 *
57 */
58
59#include <stdio.h>
60
61#include <openssl/asn1t.h>
62#include <openssl/pkcs7.h>
63#include <openssl/x509.h>
64
65/* PKCS#7 ASN1 module */
66
67/* This is the ANY DEFINED BY table for the top level PKCS#7 structure */
68
69static const ASN1_TEMPLATE p7default_tt = {
70 .flags = ASN1_TFLG_EXPLICIT | ASN1_TFLG_OPTIONAL,
71 .tag = 0,
72 .offset = offsetof(PKCS7, d.other),
73 .field_name = "d.other",
74 .item = &ASN1_ANY_it,
75};
76
77static const ASN1_ADB_TABLE PKCS7_adbtbl[] = {
78 {
79 .value = NID_pkcs7_data,
80 .tt = {
81 .flags = ASN1_TFLG_EXPLICIT | ASN1_TFLG_OPTIONAL | ASN1_TFLG_NDEF,
82 .tag = 0,
83 .offset = offsetof(PKCS7, d.data),
84 .field_name = "d.data",
85 .item = &ASN1_OCTET_STRING_NDEF_it,
86 },
87
88 },
89 {
90 .value = NID_pkcs7_signed,
91 .tt = {
92 .flags = ASN1_TFLG_EXPLICIT | ASN1_TFLG_OPTIONAL | ASN1_TFLG_NDEF,
93 .tag = 0,
94 .offset = offsetof(PKCS7, d.sign),
95 .field_name = "d.sign",
96 .item = &PKCS7_SIGNED_it,
97 },
98
99 },
100 {
101 .value = NID_pkcs7_enveloped,
102 .tt = {
103 .flags = ASN1_TFLG_EXPLICIT | ASN1_TFLG_OPTIONAL | ASN1_TFLG_NDEF,
104 .tag = 0,
105 .offset = offsetof(PKCS7, d.enveloped),
106 .field_name = "d.enveloped",
107 .item = &PKCS7_ENVELOPE_it,
108 },
109
110 },
111 {
112 .value = NID_pkcs7_signedAndEnveloped,
113 .tt = {
114 .flags = ASN1_TFLG_EXPLICIT | ASN1_TFLG_OPTIONAL | ASN1_TFLG_NDEF,
115 .tag = 0,
116 .offset = offsetof(PKCS7, d.signed_and_enveloped),
117 .field_name = "d.signed_and_enveloped",
118 .item = &PKCS7_SIGN_ENVELOPE_it,
119 },
120
121 },
122 {
123 .value = NID_pkcs7_digest,
124 .tt = {
125 .flags = ASN1_TFLG_EXPLICIT | ASN1_TFLG_OPTIONAL | ASN1_TFLG_NDEF,
126 .tag = 0,
127 .offset = offsetof(PKCS7, d.digest),
128 .field_name = "d.digest",
129 .item = &PKCS7_DIGEST_it,
130 },
131
132 },
133 {
134 .value = NID_pkcs7_encrypted,
135 .tt = {
136 .flags = ASN1_TFLG_EXPLICIT | ASN1_TFLG_OPTIONAL | ASN1_TFLG_NDEF,
137 .tag = 0,
138 .offset = offsetof(PKCS7, d.encrypted),
139 .field_name = "d.encrypted",
140 .item = &PKCS7_ENCRYPT_it,
141 },
142
143 },
144};
145
146static const ASN1_ADB PKCS7_adb = {
147 .flags = 0,
148 .offset = offsetof(PKCS7, type),
149 .app_items = 0,
150 .tbl = PKCS7_adbtbl,
151 .tblcount = sizeof(PKCS7_adbtbl) / sizeof(ASN1_ADB_TABLE),
152 .default_tt = &p7default_tt,
153 .null_tt = NULL,
154};
155
156/* PKCS#7 streaming support */
157static int
158pk7_cb(int operation, ASN1_VALUE **pval, const ASN1_ITEM *it, void *exarg)
159{
160 ASN1_STREAM_ARG *sarg = exarg;
161 PKCS7 **pp7 = (PKCS7 **)pval;
162
163 switch (operation) {
164 case ASN1_OP_STREAM_PRE:
165 if (PKCS7_stream(&sarg->boundary, *pp7) <= 0)
166 return 0;
167
168 case ASN1_OP_DETACHED_PRE:
169 sarg->ndef_bio = PKCS7_dataInit(*pp7, sarg->out);
170 if (!sarg->ndef_bio)
171 return 0;
172 break;
173
174 case ASN1_OP_STREAM_POST:
175 case ASN1_OP_DETACHED_POST:
176 if (PKCS7_dataFinal(*pp7, sarg->ndef_bio) <= 0)
177 return 0;
178 break;
179 }
180 return 1;
181}
182
183static const ASN1_AUX PKCS7_aux = {
184 .app_data = NULL,
185 .flags = 0,
186 .ref_offset = 0,
187 .ref_lock = 0,
188 .asn1_cb = pk7_cb,
189 .enc_offset = 0,
190};
191static const ASN1_TEMPLATE PKCS7_seq_tt[] = {
192 {
193 .flags = 0,
194 .tag = 0,
195 .offset = offsetof(PKCS7, type),
196 .field_name = "type",
197 .item = &ASN1_OBJECT_it,
198 },
199 {
200 .flags = ASN1_TFLG_ADB_OID,
201 .tag = -1,
202 .offset = 0,
203 .field_name = "PKCS7",
204 .item = (const ASN1_ITEM *)&PKCS7_adb,
205 },
206};
207
208const ASN1_ITEM PKCS7_it = {
209 .itype = ASN1_ITYPE_NDEF_SEQUENCE,
210 .utype = V_ASN1_SEQUENCE,
211 .templates = PKCS7_seq_tt,
212 .tcount = sizeof(PKCS7_seq_tt) / sizeof(ASN1_TEMPLATE),
213 .funcs = &PKCS7_aux,
214 .size = sizeof(PKCS7),
215 .sname = "PKCS7",
216};
217
218
219PKCS7 *
220d2i_PKCS7(PKCS7 **a, const unsigned char **in, long len)
221{
222 return (PKCS7 *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,
223 &PKCS7_it);
224}
225
226int
227i2d_PKCS7(PKCS7 *a, unsigned char **out)
228{
229 return ASN1_item_i2d((ASN1_VALUE *)a, out, &PKCS7_it);
230}
231
232PKCS7 *
233PKCS7_new(void)
234{
235 return (PKCS7 *)ASN1_item_new(&PKCS7_it);
236}
237
238void
239PKCS7_free(PKCS7 *a)
240{
241 ASN1_item_free((ASN1_VALUE *)a, &PKCS7_it);
242}
243
244int
245i2d_PKCS7_NDEF(PKCS7 *a, unsigned char **out)
246{
247 return ASN1_item_ndef_i2d((ASN1_VALUE *)a, out, &PKCS7_it);
248}
249
250PKCS7 *
251PKCS7_dup(PKCS7 *x)
252{
253 return ASN1_item_dup(&PKCS7_it, x);
254}
255
256static const ASN1_TEMPLATE PKCS7_SIGNED_seq_tt[] = {
257 {
258 .flags = 0,
259 .tag = 0,
260 .offset = offsetof(PKCS7_SIGNED, version),
261 .field_name = "version",
262 .item = &ASN1_INTEGER_it,
263 },
264 {
265 .flags = ASN1_TFLG_SET_OF,
266 .tag = 0,
267 .offset = offsetof(PKCS7_SIGNED, md_algs),
268 .field_name = "md_algs",
269 .item = &X509_ALGOR_it,
270 },
271 {
272 .flags = 0,
273 .tag = 0,
274 .offset = offsetof(PKCS7_SIGNED, contents),
275 .field_name = "contents",
276 .item = &PKCS7_it,
277 },
278 {
279 .flags = ASN1_TFLG_IMPLICIT | ASN1_TFLG_SEQUENCE_OF | ASN1_TFLG_OPTIONAL,
280 .tag = 0,
281 .offset = offsetof(PKCS7_SIGNED, cert),
282 .field_name = "cert",
283 .item = &X509_it,
284 },
285 {
286 .flags = ASN1_TFLG_IMPLICIT | ASN1_TFLG_SET_OF | ASN1_TFLG_OPTIONAL,
287 .tag = 1,
288 .offset = offsetof(PKCS7_SIGNED, crl),
289 .field_name = "crl",
290 .item = &X509_CRL_it,
291 },
292 {
293 .flags = ASN1_TFLG_SET_OF,
294 .tag = 0,
295 .offset = offsetof(PKCS7_SIGNED, signer_info),
296 .field_name = "signer_info",
297 .item = &PKCS7_SIGNER_INFO_it,
298 },
299};
300
301const ASN1_ITEM PKCS7_SIGNED_it = {
302 .itype = ASN1_ITYPE_NDEF_SEQUENCE,
303 .utype = V_ASN1_SEQUENCE,
304 .templates = PKCS7_SIGNED_seq_tt,
305 .tcount = sizeof(PKCS7_SIGNED_seq_tt) / sizeof(ASN1_TEMPLATE),
306 .funcs = NULL,
307 .size = sizeof(PKCS7_SIGNED),
308 .sname = "PKCS7_SIGNED",
309};
310
311
312PKCS7_SIGNED *
313d2i_PKCS7_SIGNED(PKCS7_SIGNED **a, const unsigned char **in, long len)
314{
315 return (PKCS7_SIGNED *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,
316 &PKCS7_SIGNED_it);
317}
318
319int
320i2d_PKCS7_SIGNED(PKCS7_SIGNED *a, unsigned char **out)
321{
322 return ASN1_item_i2d((ASN1_VALUE *)a, out, &PKCS7_SIGNED_it);
323}
324
325PKCS7_SIGNED *
326PKCS7_SIGNED_new(void)
327{
328 return (PKCS7_SIGNED *)ASN1_item_new(&PKCS7_SIGNED_it);
329}
330
331void
332PKCS7_SIGNED_free(PKCS7_SIGNED *a)
333{
334 ASN1_item_free((ASN1_VALUE *)a, &PKCS7_SIGNED_it);
335}
336
337/* Minor tweak to operation: free up EVP_PKEY */
338static int
339si_cb(int operation, ASN1_VALUE **pval, const ASN1_ITEM *it, void *exarg)
340{
341 if (operation == ASN1_OP_FREE_POST) {
342 PKCS7_SIGNER_INFO *si = (PKCS7_SIGNER_INFO *)*pval;
343 EVP_PKEY_free(si->pkey);
344 }
345 return 1;
346}
347
348static const ASN1_AUX PKCS7_SIGNER_INFO_aux = {
349 .app_data = NULL,
350 .flags = 0,
351 .ref_offset = 0,
352 .ref_lock = 0,
353 .asn1_cb = si_cb,
354 .enc_offset = 0,
355};
356static const ASN1_TEMPLATE PKCS7_SIGNER_INFO_seq_tt[] = {
357 {
358 .flags = 0,
359 .tag = 0,
360 .offset = offsetof(PKCS7_SIGNER_INFO, version),
361 .field_name = "version",
362 .item = &ASN1_INTEGER_it,
363 },
364 {
365 .flags = 0,
366 .tag = 0,
367 .offset = offsetof(PKCS7_SIGNER_INFO, issuer_and_serial),
368 .field_name = "issuer_and_serial",
369 .item = &PKCS7_ISSUER_AND_SERIAL_it,
370 },
371 {
372 .flags = 0,
373 .tag = 0,
374 .offset = offsetof(PKCS7_SIGNER_INFO, digest_alg),
375 .field_name = "digest_alg",
376 .item = &X509_ALGOR_it,
377 },
378 /* NB this should be a SET OF but we use a SEQUENCE OF so the
379 * original order * is retained when the structure is reencoded.
380 * Since the attributes are implicitly tagged this will not affect
381 * the encoding.
382 */
383 {
384 .flags = ASN1_TFLG_IMPLICIT | ASN1_TFLG_SEQUENCE_OF | ASN1_TFLG_OPTIONAL,
385 .tag = 0,
386 .offset = offsetof(PKCS7_SIGNER_INFO, auth_attr),
387 .field_name = "auth_attr",
388 .item = &X509_ATTRIBUTE_it,
389 },
390 {
391 .flags = 0,
392 .tag = 0,
393 .offset = offsetof(PKCS7_SIGNER_INFO, digest_enc_alg),
394 .field_name = "digest_enc_alg",
395 .item = &X509_ALGOR_it,
396 },
397 {
398 .flags = 0,
399 .tag = 0,
400 .offset = offsetof(PKCS7_SIGNER_INFO, enc_digest),
401 .field_name = "enc_digest",
402 .item = &ASN1_OCTET_STRING_it,
403 },
404 {
405 .flags = ASN1_TFLG_IMPLICIT | ASN1_TFLG_SET_OF | ASN1_TFLG_OPTIONAL,
406 .tag = 1,
407 .offset = offsetof(PKCS7_SIGNER_INFO, unauth_attr),
408 .field_name = "unauth_attr",
409 .item = &X509_ATTRIBUTE_it,
410 },
411};
412
413const ASN1_ITEM PKCS7_SIGNER_INFO_it = {
414 .itype = ASN1_ITYPE_SEQUENCE,
415 .utype = V_ASN1_SEQUENCE,
416 .templates = PKCS7_SIGNER_INFO_seq_tt,
417 .tcount = sizeof(PKCS7_SIGNER_INFO_seq_tt) / sizeof(ASN1_TEMPLATE),
418 .funcs = &PKCS7_SIGNER_INFO_aux,
419 .size = sizeof(PKCS7_SIGNER_INFO),
420 .sname = "PKCS7_SIGNER_INFO",
421};
422
423
424PKCS7_SIGNER_INFO *
425d2i_PKCS7_SIGNER_INFO(PKCS7_SIGNER_INFO **a, const unsigned char **in, long len)
426{
427 return (PKCS7_SIGNER_INFO *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,
428 &PKCS7_SIGNER_INFO_it);
429}
430
431int
432i2d_PKCS7_SIGNER_INFO(PKCS7_SIGNER_INFO *a, unsigned char **out)
433{
434 return ASN1_item_i2d((ASN1_VALUE *)a, out, &PKCS7_SIGNER_INFO_it);
435}
436
437PKCS7_SIGNER_INFO *
438PKCS7_SIGNER_INFO_new(void)
439{
440 return (PKCS7_SIGNER_INFO *)ASN1_item_new(&PKCS7_SIGNER_INFO_it);
441}
442
443void
444PKCS7_SIGNER_INFO_free(PKCS7_SIGNER_INFO *a)
445{
446 ASN1_item_free((ASN1_VALUE *)a, &PKCS7_SIGNER_INFO_it);
447}
448
449static const ASN1_TEMPLATE PKCS7_ISSUER_AND_SERIAL_seq_tt[] = {
450 {
451 .flags = 0,
452 .tag = 0,
453 .offset = offsetof(PKCS7_ISSUER_AND_SERIAL, issuer),
454 .field_name = "issuer",
455 .item = &X509_NAME_it,
456 },
457 {
458 .flags = 0,
459 .tag = 0,
460 .offset = offsetof(PKCS7_ISSUER_AND_SERIAL, serial),
461 .field_name = "serial",
462 .item = &ASN1_INTEGER_it,
463 },
464};
465
466const ASN1_ITEM PKCS7_ISSUER_AND_SERIAL_it = {
467 .itype = ASN1_ITYPE_SEQUENCE,
468 .utype = V_ASN1_SEQUENCE,
469 .templates = PKCS7_ISSUER_AND_SERIAL_seq_tt,
470 .tcount = sizeof(PKCS7_ISSUER_AND_SERIAL_seq_tt) / sizeof(ASN1_TEMPLATE),
471 .funcs = NULL,
472 .size = sizeof(PKCS7_ISSUER_AND_SERIAL),
473 .sname = "PKCS7_ISSUER_AND_SERIAL",
474};
475
476
477PKCS7_ISSUER_AND_SERIAL *
478d2i_PKCS7_ISSUER_AND_SERIAL(PKCS7_ISSUER_AND_SERIAL **a, const unsigned char **in, long len)
479{
480 return (PKCS7_ISSUER_AND_SERIAL *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,
481 &PKCS7_ISSUER_AND_SERIAL_it);
482}
483
484int
485i2d_PKCS7_ISSUER_AND_SERIAL(PKCS7_ISSUER_AND_SERIAL *a, unsigned char **out)
486{
487 return ASN1_item_i2d((ASN1_VALUE *)a, out, &PKCS7_ISSUER_AND_SERIAL_it);
488}
489
490PKCS7_ISSUER_AND_SERIAL *
491PKCS7_ISSUER_AND_SERIAL_new(void)
492{
493 return (PKCS7_ISSUER_AND_SERIAL *)ASN1_item_new(&PKCS7_ISSUER_AND_SERIAL_it);
494}
495
496void
497PKCS7_ISSUER_AND_SERIAL_free(PKCS7_ISSUER_AND_SERIAL *a)
498{
499 ASN1_item_free((ASN1_VALUE *)a, &PKCS7_ISSUER_AND_SERIAL_it);
500}
501
502static const ASN1_TEMPLATE PKCS7_ENVELOPE_seq_tt[] = {
503 {
504 .flags = 0,
505 .tag = 0,
506 .offset = offsetof(PKCS7_ENVELOPE, version),
507 .field_name = "version",
508 .item = &ASN1_INTEGER_it,
509 },
510 {
511 .flags = ASN1_TFLG_SET_OF,
512 .tag = 0,
513 .offset = offsetof(PKCS7_ENVELOPE, recipientinfo),
514 .field_name = "recipientinfo",
515 .item = &PKCS7_RECIP_INFO_it,
516 },
517 {
518 .flags = 0,
519 .tag = 0,
520 .offset = offsetof(PKCS7_ENVELOPE, enc_data),
521 .field_name = "enc_data",
522 .item = &PKCS7_ENC_CONTENT_it,
523 },
524};
525
526const ASN1_ITEM PKCS7_ENVELOPE_it = {
527 .itype = ASN1_ITYPE_NDEF_SEQUENCE,
528 .utype = V_ASN1_SEQUENCE,
529 .templates = PKCS7_ENVELOPE_seq_tt,
530 .tcount = sizeof(PKCS7_ENVELOPE_seq_tt) / sizeof(ASN1_TEMPLATE),
531 .funcs = NULL,
532 .size = sizeof(PKCS7_ENVELOPE),
533 .sname = "PKCS7_ENVELOPE",
534};
535
536
537PKCS7_ENVELOPE *
538d2i_PKCS7_ENVELOPE(PKCS7_ENVELOPE **a, const unsigned char **in, long len)
539{
540 return (PKCS7_ENVELOPE *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,
541 &PKCS7_ENVELOPE_it);
542}
543
544int
545i2d_PKCS7_ENVELOPE(PKCS7_ENVELOPE *a, unsigned char **out)
546{
547 return ASN1_item_i2d((ASN1_VALUE *)a, out, &PKCS7_ENVELOPE_it);
548}
549
550PKCS7_ENVELOPE *
551PKCS7_ENVELOPE_new(void)
552{
553 return (PKCS7_ENVELOPE *)ASN1_item_new(&PKCS7_ENVELOPE_it);
554}
555
556void
557PKCS7_ENVELOPE_free(PKCS7_ENVELOPE *a)
558{
559 ASN1_item_free((ASN1_VALUE *)a, &PKCS7_ENVELOPE_it);
560}
561
562/* Minor tweak to operation: free up X509 */
563static int
564ri_cb(int operation, ASN1_VALUE **pval, const ASN1_ITEM *it, void *exarg)
565{
566 if (operation == ASN1_OP_FREE_POST) {
567 PKCS7_RECIP_INFO *ri = (PKCS7_RECIP_INFO *)*pval;
568 X509_free(ri->cert);
569 }
570 return 1;
571}
572
573static const ASN1_AUX PKCS7_RECIP_INFO_aux = {
574 .app_data = NULL,
575 .flags = 0,
576 .ref_offset = 0,
577 .ref_lock = 0,
578 .asn1_cb = ri_cb,
579 .enc_offset = 0,
580};
581static const ASN1_TEMPLATE PKCS7_RECIP_INFO_seq_tt[] = {
582 {
583 .flags = 0,
584 .tag = 0,
585 .offset = offsetof(PKCS7_RECIP_INFO, version),
586 .field_name = "version",
587 .item = &ASN1_INTEGER_it,
588 },
589 {
590 .flags = 0,
591 .tag = 0,
592 .offset = offsetof(PKCS7_RECIP_INFO, issuer_and_serial),
593 .field_name = "issuer_and_serial",
594 .item = &PKCS7_ISSUER_AND_SERIAL_it,
595 },
596 {
597 .flags = 0,
598 .tag = 0,
599 .offset = offsetof(PKCS7_RECIP_INFO, key_enc_algor),
600 .field_name = "key_enc_algor",
601 .item = &X509_ALGOR_it,
602 },
603 {
604 .flags = 0,
605 .tag = 0,
606 .offset = offsetof(PKCS7_RECIP_INFO, enc_key),
607 .field_name = "enc_key",
608 .item = &ASN1_OCTET_STRING_it,
609 },
610};
611
612const ASN1_ITEM PKCS7_RECIP_INFO_it = {
613 .itype = ASN1_ITYPE_SEQUENCE,
614 .utype = V_ASN1_SEQUENCE,
615 .templates = PKCS7_RECIP_INFO_seq_tt,
616 .tcount = sizeof(PKCS7_RECIP_INFO_seq_tt) / sizeof(ASN1_TEMPLATE),
617 .funcs = &PKCS7_RECIP_INFO_aux,
618 .size = sizeof(PKCS7_RECIP_INFO),
619 .sname = "PKCS7_RECIP_INFO",
620};
621
622
623PKCS7_RECIP_INFO *
624d2i_PKCS7_RECIP_INFO(PKCS7_RECIP_INFO **a, const unsigned char **in, long len)
625{
626 return (PKCS7_RECIP_INFO *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,
627 &PKCS7_RECIP_INFO_it);
628}
629
630int
631i2d_PKCS7_RECIP_INFO(PKCS7_RECIP_INFO *a, unsigned char **out)
632{
633 return ASN1_item_i2d((ASN1_VALUE *)a, out, &PKCS7_RECIP_INFO_it);
634}
635
636PKCS7_RECIP_INFO *
637PKCS7_RECIP_INFO_new(void)
638{
639 return (PKCS7_RECIP_INFO *)ASN1_item_new(&PKCS7_RECIP_INFO_it);
640}
641
642void
643PKCS7_RECIP_INFO_free(PKCS7_RECIP_INFO *a)
644{
645 ASN1_item_free((ASN1_VALUE *)a, &PKCS7_RECIP_INFO_it);
646}
647
648static const ASN1_TEMPLATE PKCS7_ENC_CONTENT_seq_tt[] = {
649 {
650 .flags = 0,
651 .tag = 0,
652 .offset = offsetof(PKCS7_ENC_CONTENT, content_type),
653 .field_name = "content_type",
654 .item = &ASN1_OBJECT_it,
655 },
656 {
657 .flags = 0,
658 .tag = 0,
659 .offset = offsetof(PKCS7_ENC_CONTENT, algorithm),
660 .field_name = "algorithm",
661 .item = &X509_ALGOR_it,
662 },
663 {
664 .flags = ASN1_TFLG_IMPLICIT | ASN1_TFLG_OPTIONAL,
665 .tag = 0,
666 .offset = offsetof(PKCS7_ENC_CONTENT, enc_data),
667 .field_name = "enc_data",
668 .item = &ASN1_OCTET_STRING_NDEF_it,
669 },
670};
671
672const ASN1_ITEM PKCS7_ENC_CONTENT_it = {
673 .itype = ASN1_ITYPE_NDEF_SEQUENCE,
674 .utype = V_ASN1_SEQUENCE,
675 .templates = PKCS7_ENC_CONTENT_seq_tt,
676 .tcount = sizeof(PKCS7_ENC_CONTENT_seq_tt) / sizeof(ASN1_TEMPLATE),
677 .funcs = NULL,
678 .size = sizeof(PKCS7_ENC_CONTENT),
679 .sname = "PKCS7_ENC_CONTENT",
680};
681
682
683PKCS7_ENC_CONTENT *
684d2i_PKCS7_ENC_CONTENT(PKCS7_ENC_CONTENT **a, const unsigned char **in, long len)
685{
686 return (PKCS7_ENC_CONTENT *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,
687 &PKCS7_ENC_CONTENT_it);
688}
689
690int
691i2d_PKCS7_ENC_CONTENT(PKCS7_ENC_CONTENT *a, unsigned char **out)
692{
693 return ASN1_item_i2d((ASN1_VALUE *)a, out, &PKCS7_ENC_CONTENT_it);
694}
695
696PKCS7_ENC_CONTENT *
697PKCS7_ENC_CONTENT_new(void)
698{
699 return (PKCS7_ENC_CONTENT *)ASN1_item_new(&PKCS7_ENC_CONTENT_it);
700}
701
702void
703PKCS7_ENC_CONTENT_free(PKCS7_ENC_CONTENT *a)
704{
705 ASN1_item_free((ASN1_VALUE *)a, &PKCS7_ENC_CONTENT_it);
706}
707
708static const ASN1_TEMPLATE PKCS7_SIGN_ENVELOPE_seq_tt[] = {
709 {
710 .flags = 0,
711 .tag = 0,
712 .offset = offsetof(PKCS7_SIGN_ENVELOPE, version),
713 .field_name = "version",
714 .item = &ASN1_INTEGER_it,
715 },
716 {
717 .flags = ASN1_TFLG_SET_OF,
718 .tag = 0,
719 .offset = offsetof(PKCS7_SIGN_ENVELOPE, recipientinfo),
720 .field_name = "recipientinfo",
721 .item = &PKCS7_RECIP_INFO_it,
722 },
723 {
724 .flags = ASN1_TFLG_SET_OF,
725 .tag = 0,
726 .offset = offsetof(PKCS7_SIGN_ENVELOPE, md_algs),
727 .field_name = "md_algs",
728 .item = &X509_ALGOR_it,
729 },
730 {
731 .flags = 0,
732 .tag = 0,
733 .offset = offsetof(PKCS7_SIGN_ENVELOPE, enc_data),
734 .field_name = "enc_data",
735 .item = &PKCS7_ENC_CONTENT_it,
736 },
737 {
738 .flags = ASN1_TFLG_IMPLICIT | ASN1_TFLG_SET_OF | ASN1_TFLG_OPTIONAL,
739 .tag = 0,
740 .offset = offsetof(PKCS7_SIGN_ENVELOPE, cert),
741 .field_name = "cert",
742 .item = &X509_it,
743 },
744 {
745 .flags = ASN1_TFLG_IMPLICIT | ASN1_TFLG_SET_OF | ASN1_TFLG_OPTIONAL,
746 .tag = 1,
747 .offset = offsetof(PKCS7_SIGN_ENVELOPE, crl),
748 .field_name = "crl",
749 .item = &X509_CRL_it,
750 },
751 {
752 .flags = ASN1_TFLG_SET_OF,
753 .tag = 0,
754 .offset = offsetof(PKCS7_SIGN_ENVELOPE, signer_info),
755 .field_name = "signer_info",
756 .item = &PKCS7_SIGNER_INFO_it,
757 },
758};
759
760const ASN1_ITEM PKCS7_SIGN_ENVELOPE_it = {
761 .itype = ASN1_ITYPE_NDEF_SEQUENCE,
762 .utype = V_ASN1_SEQUENCE,
763 .templates = PKCS7_SIGN_ENVELOPE_seq_tt,
764 .tcount = sizeof(PKCS7_SIGN_ENVELOPE_seq_tt) / sizeof(ASN1_TEMPLATE),
765 .funcs = NULL,
766 .size = sizeof(PKCS7_SIGN_ENVELOPE),
767 .sname = "PKCS7_SIGN_ENVELOPE",
768};
769
770
771PKCS7_SIGN_ENVELOPE *
772d2i_PKCS7_SIGN_ENVELOPE(PKCS7_SIGN_ENVELOPE **a, const unsigned char **in, long len)
773{
774 return (PKCS7_SIGN_ENVELOPE *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,
775 &PKCS7_SIGN_ENVELOPE_it);
776}
777
778int
779i2d_PKCS7_SIGN_ENVELOPE(PKCS7_SIGN_ENVELOPE *a, unsigned char **out)
780{
781 return ASN1_item_i2d((ASN1_VALUE *)a, out, &PKCS7_SIGN_ENVELOPE_it);
782}
783
784PKCS7_SIGN_ENVELOPE *
785PKCS7_SIGN_ENVELOPE_new(void)
786{
787 return (PKCS7_SIGN_ENVELOPE *)ASN1_item_new(&PKCS7_SIGN_ENVELOPE_it);
788}
789
790void
791PKCS7_SIGN_ENVELOPE_free(PKCS7_SIGN_ENVELOPE *a)
792{
793 ASN1_item_free((ASN1_VALUE *)a, &PKCS7_SIGN_ENVELOPE_it);
794}
795
796static const ASN1_TEMPLATE PKCS7_ENCRYPT_seq_tt[] = {
797 {
798 .flags = 0,
799 .tag = 0,
800 .offset = offsetof(PKCS7_ENCRYPT, version),
801 .field_name = "version",
802 .item = &ASN1_INTEGER_it,
803 },
804 {
805 .flags = 0,
806 .tag = 0,
807 .offset = offsetof(PKCS7_ENCRYPT, enc_data),
808 .field_name = "enc_data",
809 .item = &PKCS7_ENC_CONTENT_it,
810 },
811};
812
813const ASN1_ITEM PKCS7_ENCRYPT_it = {
814 .itype = ASN1_ITYPE_NDEF_SEQUENCE,
815 .utype = V_ASN1_SEQUENCE,
816 .templates = PKCS7_ENCRYPT_seq_tt,
817 .tcount = sizeof(PKCS7_ENCRYPT_seq_tt) / sizeof(ASN1_TEMPLATE),
818 .funcs = NULL,
819 .size = sizeof(PKCS7_ENCRYPT),
820 .sname = "PKCS7_ENCRYPT",
821};
822
823
824PKCS7_ENCRYPT *
825d2i_PKCS7_ENCRYPT(PKCS7_ENCRYPT **a, const unsigned char **in, long len)
826{
827 return (PKCS7_ENCRYPT *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,
828 &PKCS7_ENCRYPT_it);
829}
830
831int
832i2d_PKCS7_ENCRYPT(PKCS7_ENCRYPT *a, unsigned char **out)
833{
834 return ASN1_item_i2d((ASN1_VALUE *)a, out, &PKCS7_ENCRYPT_it);
835}
836
837PKCS7_ENCRYPT *
838PKCS7_ENCRYPT_new(void)
839{
840 return (PKCS7_ENCRYPT *)ASN1_item_new(&PKCS7_ENCRYPT_it);
841}
842
843void
844PKCS7_ENCRYPT_free(PKCS7_ENCRYPT *a)
845{
846 ASN1_item_free((ASN1_VALUE *)a, &PKCS7_ENCRYPT_it);
847}
848
849static const ASN1_TEMPLATE PKCS7_DIGEST_seq_tt[] = {
850 {
851 .flags = 0,
852 .tag = 0,
853 .offset = offsetof(PKCS7_DIGEST, version),
854 .field_name = "version",
855 .item = &ASN1_INTEGER_it,
856 },
857 {
858 .flags = 0,
859 .tag = 0,
860 .offset = offsetof(PKCS7_DIGEST, md),
861 .field_name = "md",
862 .item = &X509_ALGOR_it,
863 },
864 {
865 .flags = 0,
866 .tag = 0,
867 .offset = offsetof(PKCS7_DIGEST, contents),
868 .field_name = "contents",
869 .item = &PKCS7_it,
870 },
871 {
872 .flags = 0,
873 .tag = 0,
874 .offset = offsetof(PKCS7_DIGEST, digest),
875 .field_name = "digest",
876 .item = &ASN1_OCTET_STRING_it,
877 },
878};
879
880const ASN1_ITEM PKCS7_DIGEST_it = {
881 .itype = ASN1_ITYPE_NDEF_SEQUENCE,
882 .utype = V_ASN1_SEQUENCE,
883 .templates = PKCS7_DIGEST_seq_tt,
884 .tcount = sizeof(PKCS7_DIGEST_seq_tt) / sizeof(ASN1_TEMPLATE),
885 .funcs = NULL,
886 .size = sizeof(PKCS7_DIGEST),
887 .sname = "PKCS7_DIGEST",
888};
889
890
891PKCS7_DIGEST *
892d2i_PKCS7_DIGEST(PKCS7_DIGEST **a, const unsigned char **in, long len)
893{
894 return (PKCS7_DIGEST *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,
895 &PKCS7_DIGEST_it);
896}
897
898int
899i2d_PKCS7_DIGEST(PKCS7_DIGEST *a, unsigned char **out)
900{
901 return ASN1_item_i2d((ASN1_VALUE *)a, out, &PKCS7_DIGEST_it);
902}
903
904PKCS7_DIGEST *
905PKCS7_DIGEST_new(void)
906{
907 return (PKCS7_DIGEST *)ASN1_item_new(&PKCS7_DIGEST_it);
908}
909
910void
911PKCS7_DIGEST_free(PKCS7_DIGEST *a)
912{
913 ASN1_item_free((ASN1_VALUE *)a, &PKCS7_DIGEST_it);
914}
915
916/* Specials for authenticated attributes */
917
918/* When signing attributes we want to reorder them to match the sorted
919 * encoding.
920 */
921
922static const ASN1_TEMPLATE PKCS7_ATTR_SIGN_item_tt = {
923 .flags = ASN1_TFLG_SET_ORDER,
924 .tag = 0,
925 .offset = 0,
926 .field_name = "PKCS7_ATTRIBUTES",
927 .item = &X509_ATTRIBUTE_it,
928};
929
930const ASN1_ITEM PKCS7_ATTR_SIGN_it = {
931 .itype = ASN1_ITYPE_PRIMITIVE,
932 .utype = -1,
933 .templates = &PKCS7_ATTR_SIGN_item_tt,
934 .tcount = 0,
935 .funcs = NULL,
936 .size = 0,
937 .sname = "PKCS7_ATTR_SIGN",
938};
939
940/* When verifying attributes we need to use the received order. So
941 * we use SEQUENCE OF and tag it to SET OF
942 */
943
944static const ASN1_TEMPLATE PKCS7_ATTR_VERIFY_item_tt = {
945 .flags = ASN1_TFLG_SEQUENCE_OF | ASN1_TFLG_IMPTAG | ASN1_TFLG_UNIVERSAL,
946 .tag = V_ASN1_SET,
947 .offset = 0,
948 .field_name = "PKCS7_ATTRIBUTES",
949 .item = &X509_ATTRIBUTE_it,
950};
951
952const ASN1_ITEM PKCS7_ATTR_VERIFY_it = {
953 .itype = ASN1_ITYPE_PRIMITIVE,
954 .utype = -1,
955 .templates = &PKCS7_ATTR_VERIFY_item_tt,
956 .tcount = 0,
957 .funcs = NULL,
958 .size = 0,
959 .sname = "PKCS7_ATTR_VERIFY",
960};
961
962
963int
964PKCS7_print_ctx(BIO *out, PKCS7 *x, int indent, const ASN1_PCTX *pctx)
965{
966 return ASN1_item_print(out, (ASN1_VALUE *)x, indent,
967 &PKCS7_it, pctx);
968}
generated by cgit v1.2.3-55-g6feb (git 2.39.1) at 2025-08-17 10:51:22 +0000