summaryrefslogtreecommitdiff
path: root/src/lib/libcrypto/pkcs7/pk7_asn1.c
diff options
context:
space:
mode:
Diffstat (limited to '')
-rw-r--r--src/lib/libcrypto/pkcs7/pk7_asn1.c1053
1 files changed, 0 insertions, 1053 deletions
diff --git a/src/lib/libcrypto/pkcs7/pk7_asn1.c b/src/lib/libcrypto/pkcs7/pk7_asn1.c
deleted file mode 100644
index 8a6ae487da..0000000000
--- a/src/lib/libcrypto/pkcs7/pk7_asn1.c
+++ /dev/null
@@ -1,1053 +0,0 @@
1/* $OpenBSD: pk7_asn1.c,v 1.18 2024/07/08 16:23:27 beck 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 .tbl = PKCS7_adbtbl,
150 .tblcount = sizeof(PKCS7_adbtbl) / sizeof(ASN1_ADB_TABLE),
151 .default_tt = &p7default_tt,
152 .null_tt = NULL,
153};
154
155/* PKCS#7 streaming support */
156static int
157pk7_cb(int operation, ASN1_VALUE **pval, const ASN1_ITEM *it, void *exarg)
158{
159 ASN1_STREAM_ARG *sarg = exarg;
160 PKCS7 **pp7 = (PKCS7 **)pval;
161
162 switch (operation) {
163 case ASN1_OP_STREAM_PRE:
164 if (PKCS7_stream(&sarg->boundary, *pp7) <= 0)
165 return 0;
166 /* FALLTHROUGH */
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};
217LCRYPTO_ALIAS(PKCS7_it);
218
219
220PKCS7 *
221d2i_PKCS7(PKCS7 **a, const unsigned char **in, long len)
222{
223 return (PKCS7 *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,
224 &PKCS7_it);
225}
226LCRYPTO_ALIAS(d2i_PKCS7);
227
228int
229i2d_PKCS7(PKCS7 *a, unsigned char **out)
230{
231 return ASN1_item_i2d((ASN1_VALUE *)a, out, &PKCS7_it);
232}
233LCRYPTO_ALIAS(i2d_PKCS7);
234
235PKCS7 *
236PKCS7_new(void)
237{
238 return (PKCS7 *)ASN1_item_new(&PKCS7_it);
239}
240LCRYPTO_ALIAS(PKCS7_new);
241
242void
243PKCS7_free(PKCS7 *a)
244{
245 ASN1_item_free((ASN1_VALUE *)a, &PKCS7_it);
246}
247LCRYPTO_ALIAS(PKCS7_free);
248
249PKCS7 *
250PKCS7_dup(PKCS7 *x)
251{
252 return ASN1_item_dup(&PKCS7_it, x);
253}
254LCRYPTO_ALIAS(PKCS7_dup);
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};
310LCRYPTO_ALIAS(PKCS7_SIGNED_it);
311
312
313PKCS7_SIGNED *
314d2i_PKCS7_SIGNED(PKCS7_SIGNED **a, const unsigned char **in, long len)
315{
316 return (PKCS7_SIGNED *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,
317 &PKCS7_SIGNED_it);
318}
319LCRYPTO_ALIAS(d2i_PKCS7_SIGNED);
320
321int
322i2d_PKCS7_SIGNED(PKCS7_SIGNED *a, unsigned char **out)
323{
324 return ASN1_item_i2d((ASN1_VALUE *)a, out, &PKCS7_SIGNED_it);
325}
326LCRYPTO_ALIAS(i2d_PKCS7_SIGNED);
327
328PKCS7_SIGNED *
329PKCS7_SIGNED_new(void)
330{
331 return (PKCS7_SIGNED *)ASN1_item_new(&PKCS7_SIGNED_it);
332}
333LCRYPTO_ALIAS(PKCS7_SIGNED_new);
334
335void
336PKCS7_SIGNED_free(PKCS7_SIGNED *a)
337{
338 ASN1_item_free((ASN1_VALUE *)a, &PKCS7_SIGNED_it);
339}
340LCRYPTO_ALIAS(PKCS7_SIGNED_free);
341
342/* Minor tweak to operation: free up EVP_PKEY */
343static int
344si_cb(int operation, ASN1_VALUE **pval, const ASN1_ITEM *it, void *exarg)
345{
346 if (operation == ASN1_OP_FREE_POST) {
347 PKCS7_SIGNER_INFO *si = (PKCS7_SIGNER_INFO *)*pval;
348 EVP_PKEY_free(si->pkey);
349 }
350 return 1;
351}
352
353static const ASN1_AUX PKCS7_SIGNER_INFO_aux = {
354 .app_data = NULL,
355 .flags = 0,
356 .ref_offset = 0,
357 .ref_lock = 0,
358 .asn1_cb = si_cb,
359 .enc_offset = 0,
360};
361static const ASN1_TEMPLATE PKCS7_SIGNER_INFO_seq_tt[] = {
362 {
363 .flags = 0,
364 .tag = 0,
365 .offset = offsetof(PKCS7_SIGNER_INFO, version),
366 .field_name = "version",
367 .item = &ASN1_INTEGER_it,
368 },
369 {
370 .flags = 0,
371 .tag = 0,
372 .offset = offsetof(PKCS7_SIGNER_INFO, issuer_and_serial),
373 .field_name = "issuer_and_serial",
374 .item = &PKCS7_ISSUER_AND_SERIAL_it,
375 },
376 {
377 .flags = 0,
378 .tag = 0,
379 .offset = offsetof(PKCS7_SIGNER_INFO, digest_alg),
380 .field_name = "digest_alg",
381 .item = &X509_ALGOR_it,
382 },
383 /* NB this should be a SET OF but we use a SEQUENCE OF so the
384 * original order * is retained when the structure is reencoded.
385 * Since the attributes are implicitly tagged this will not affect
386 * the encoding.
387 */
388 {
389 .flags = ASN1_TFLG_IMPLICIT | ASN1_TFLG_SEQUENCE_OF | ASN1_TFLG_OPTIONAL,
390 .tag = 0,
391 .offset = offsetof(PKCS7_SIGNER_INFO, auth_attr),
392 .field_name = "auth_attr",
393 .item = &X509_ATTRIBUTE_it,
394 },
395 {
396 .flags = 0,
397 .tag = 0,
398 .offset = offsetof(PKCS7_SIGNER_INFO, digest_enc_alg),
399 .field_name = "digest_enc_alg",
400 .item = &X509_ALGOR_it,
401 },
402 {
403 .flags = 0,
404 .tag = 0,
405 .offset = offsetof(PKCS7_SIGNER_INFO, enc_digest),
406 .field_name = "enc_digest",
407 .item = &ASN1_OCTET_STRING_it,
408 },
409 {
410 .flags = ASN1_TFLG_IMPLICIT | ASN1_TFLG_SET_OF | ASN1_TFLG_OPTIONAL,
411 .tag = 1,
412 .offset = offsetof(PKCS7_SIGNER_INFO, unauth_attr),
413 .field_name = "unauth_attr",
414 .item = &X509_ATTRIBUTE_it,
415 },
416};
417
418const ASN1_ITEM PKCS7_SIGNER_INFO_it = {
419 .itype = ASN1_ITYPE_SEQUENCE,
420 .utype = V_ASN1_SEQUENCE,
421 .templates = PKCS7_SIGNER_INFO_seq_tt,
422 .tcount = sizeof(PKCS7_SIGNER_INFO_seq_tt) / sizeof(ASN1_TEMPLATE),
423 .funcs = &PKCS7_SIGNER_INFO_aux,
424 .size = sizeof(PKCS7_SIGNER_INFO),
425 .sname = "PKCS7_SIGNER_INFO",
426};
427LCRYPTO_ALIAS(PKCS7_SIGNER_INFO_it);
428
429
430PKCS7_SIGNER_INFO *
431d2i_PKCS7_SIGNER_INFO(PKCS7_SIGNER_INFO **a, const unsigned char **in, long len)
432{
433 return (PKCS7_SIGNER_INFO *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,
434 &PKCS7_SIGNER_INFO_it);
435}
436LCRYPTO_ALIAS(d2i_PKCS7_SIGNER_INFO);
437
438int
439i2d_PKCS7_SIGNER_INFO(PKCS7_SIGNER_INFO *a, unsigned char **out)
440{
441 return ASN1_item_i2d((ASN1_VALUE *)a, out, &PKCS7_SIGNER_INFO_it);
442}
443LCRYPTO_ALIAS(i2d_PKCS7_SIGNER_INFO);
444
445PKCS7_SIGNER_INFO *
446PKCS7_SIGNER_INFO_new(void)
447{
448 return (PKCS7_SIGNER_INFO *)ASN1_item_new(&PKCS7_SIGNER_INFO_it);
449}
450LCRYPTO_ALIAS(PKCS7_SIGNER_INFO_new);
451
452void
453PKCS7_SIGNER_INFO_free(PKCS7_SIGNER_INFO *a)
454{
455 ASN1_item_free((ASN1_VALUE *)a, &PKCS7_SIGNER_INFO_it);
456}
457LCRYPTO_ALIAS(PKCS7_SIGNER_INFO_free);
458
459static const ASN1_TEMPLATE PKCS7_ISSUER_AND_SERIAL_seq_tt[] = {
460 {
461 .flags = 0,
462 .tag = 0,
463 .offset = offsetof(PKCS7_ISSUER_AND_SERIAL, issuer),
464 .field_name = "issuer",
465 .item = &X509_NAME_it,
466 },
467 {
468 .flags = 0,
469 .tag = 0,
470 .offset = offsetof(PKCS7_ISSUER_AND_SERIAL, serial),
471 .field_name = "serial",
472 .item = &ASN1_INTEGER_it,
473 },
474};
475
476const ASN1_ITEM PKCS7_ISSUER_AND_SERIAL_it = {
477 .itype = ASN1_ITYPE_SEQUENCE,
478 .utype = V_ASN1_SEQUENCE,
479 .templates = PKCS7_ISSUER_AND_SERIAL_seq_tt,
480 .tcount = sizeof(PKCS7_ISSUER_AND_SERIAL_seq_tt) / sizeof(ASN1_TEMPLATE),
481 .funcs = NULL,
482 .size = sizeof(PKCS7_ISSUER_AND_SERIAL),
483 .sname = "PKCS7_ISSUER_AND_SERIAL",
484};
485LCRYPTO_ALIAS(PKCS7_ISSUER_AND_SERIAL_it);
486
487
488PKCS7_ISSUER_AND_SERIAL *
489d2i_PKCS7_ISSUER_AND_SERIAL(PKCS7_ISSUER_AND_SERIAL **a, const unsigned char **in, long len)
490{
491 return (PKCS7_ISSUER_AND_SERIAL *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,
492 &PKCS7_ISSUER_AND_SERIAL_it);
493}
494LCRYPTO_ALIAS(d2i_PKCS7_ISSUER_AND_SERIAL);
495
496int
497i2d_PKCS7_ISSUER_AND_SERIAL(PKCS7_ISSUER_AND_SERIAL *a, unsigned char **out)
498{
499 return ASN1_item_i2d((ASN1_VALUE *)a, out, &PKCS7_ISSUER_AND_SERIAL_it);
500}
501LCRYPTO_ALIAS(i2d_PKCS7_ISSUER_AND_SERIAL);
502
503PKCS7_ISSUER_AND_SERIAL *
504PKCS7_ISSUER_AND_SERIAL_new(void)
505{
506 return (PKCS7_ISSUER_AND_SERIAL *)ASN1_item_new(&PKCS7_ISSUER_AND_SERIAL_it);
507}
508LCRYPTO_ALIAS(PKCS7_ISSUER_AND_SERIAL_new);
509
510void
511PKCS7_ISSUER_AND_SERIAL_free(PKCS7_ISSUER_AND_SERIAL *a)
512{
513 ASN1_item_free((ASN1_VALUE *)a, &PKCS7_ISSUER_AND_SERIAL_it);
514}
515LCRYPTO_ALIAS(PKCS7_ISSUER_AND_SERIAL_free);
516
517static const ASN1_TEMPLATE PKCS7_ENVELOPE_seq_tt[] = {
518 {
519 .flags = 0,
520 .tag = 0,
521 .offset = offsetof(PKCS7_ENVELOPE, version),
522 .field_name = "version",
523 .item = &ASN1_INTEGER_it,
524 },
525 {
526 .flags = ASN1_TFLG_SET_OF,
527 .tag = 0,
528 .offset = offsetof(PKCS7_ENVELOPE, recipientinfo),
529 .field_name = "recipientinfo",
530 .item = &PKCS7_RECIP_INFO_it,
531 },
532 {
533 .flags = 0,
534 .tag = 0,
535 .offset = offsetof(PKCS7_ENVELOPE, enc_data),
536 .field_name = "enc_data",
537 .item = &PKCS7_ENC_CONTENT_it,
538 },
539};
540
541const ASN1_ITEM PKCS7_ENVELOPE_it = {
542 .itype = ASN1_ITYPE_NDEF_SEQUENCE,
543 .utype = V_ASN1_SEQUENCE,
544 .templates = PKCS7_ENVELOPE_seq_tt,
545 .tcount = sizeof(PKCS7_ENVELOPE_seq_tt) / sizeof(ASN1_TEMPLATE),
546 .funcs = NULL,
547 .size = sizeof(PKCS7_ENVELOPE),
548 .sname = "PKCS7_ENVELOPE",
549};
550LCRYPTO_ALIAS(PKCS7_ENVELOPE_it);
551
552
553PKCS7_ENVELOPE *
554d2i_PKCS7_ENVELOPE(PKCS7_ENVELOPE **a, const unsigned char **in, long len)
555{
556 return (PKCS7_ENVELOPE *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,
557 &PKCS7_ENVELOPE_it);
558}
559LCRYPTO_ALIAS(d2i_PKCS7_ENVELOPE);
560
561int
562i2d_PKCS7_ENVELOPE(PKCS7_ENVELOPE *a, unsigned char **out)
563{
564 return ASN1_item_i2d((ASN1_VALUE *)a, out, &PKCS7_ENVELOPE_it);
565}
566LCRYPTO_ALIAS(i2d_PKCS7_ENVELOPE);
567
568PKCS7_ENVELOPE *
569PKCS7_ENVELOPE_new(void)
570{
571 return (PKCS7_ENVELOPE *)ASN1_item_new(&PKCS7_ENVELOPE_it);
572}
573LCRYPTO_ALIAS(PKCS7_ENVELOPE_new);
574
575void
576PKCS7_ENVELOPE_free(PKCS7_ENVELOPE *a)
577{
578 ASN1_item_free((ASN1_VALUE *)a, &PKCS7_ENVELOPE_it);
579}
580LCRYPTO_ALIAS(PKCS7_ENVELOPE_free);
581
582/* Minor tweak to operation: free up X509 */
583static int
584ri_cb(int operation, ASN1_VALUE **pval, const ASN1_ITEM *it, void *exarg)
585{
586 if (operation == ASN1_OP_FREE_POST) {
587 PKCS7_RECIP_INFO *ri = (PKCS7_RECIP_INFO *)*pval;
588 X509_free(ri->cert);
589 }
590 return 1;
591}
592
593static const ASN1_AUX PKCS7_RECIP_INFO_aux = {
594 .app_data = NULL,
595 .flags = 0,
596 .ref_offset = 0,
597 .ref_lock = 0,
598 .asn1_cb = ri_cb,
599 .enc_offset = 0,
600};
601static const ASN1_TEMPLATE PKCS7_RECIP_INFO_seq_tt[] = {
602 {
603 .flags = 0,
604 .tag = 0,
605 .offset = offsetof(PKCS7_RECIP_INFO, version),
606 .field_name = "version",
607 .item = &ASN1_INTEGER_it,
608 },
609 {
610 .flags = 0,
611 .tag = 0,
612 .offset = offsetof(PKCS7_RECIP_INFO, issuer_and_serial),
613 .field_name = "issuer_and_serial",
614 .item = &PKCS7_ISSUER_AND_SERIAL_it,
615 },
616 {
617 .flags = 0,
618 .tag = 0,
619 .offset = offsetof(PKCS7_RECIP_INFO, key_enc_algor),
620 .field_name = "key_enc_algor",
621 .item = &X509_ALGOR_it,
622 },
623 {
624 .flags = 0,
625 .tag = 0,
626 .offset = offsetof(PKCS7_RECIP_INFO, enc_key),
627 .field_name = "enc_key",
628 .item = &ASN1_OCTET_STRING_it,
629 },
630};
631
632const ASN1_ITEM PKCS7_RECIP_INFO_it = {
633 .itype = ASN1_ITYPE_SEQUENCE,
634 .utype = V_ASN1_SEQUENCE,
635 .templates = PKCS7_RECIP_INFO_seq_tt,
636 .tcount = sizeof(PKCS7_RECIP_INFO_seq_tt) / sizeof(ASN1_TEMPLATE),
637 .funcs = &PKCS7_RECIP_INFO_aux,
638 .size = sizeof(PKCS7_RECIP_INFO),
639 .sname = "PKCS7_RECIP_INFO",
640};
641LCRYPTO_ALIAS(PKCS7_RECIP_INFO_it);
642
643
644PKCS7_RECIP_INFO *
645d2i_PKCS7_RECIP_INFO(PKCS7_RECIP_INFO **a, const unsigned char **in, long len)
646{
647 return (PKCS7_RECIP_INFO *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,
648 &PKCS7_RECIP_INFO_it);
649}
650LCRYPTO_ALIAS(d2i_PKCS7_RECIP_INFO);
651
652int
653i2d_PKCS7_RECIP_INFO(PKCS7_RECIP_INFO *a, unsigned char **out)
654{
655 return ASN1_item_i2d((ASN1_VALUE *)a, out, &PKCS7_RECIP_INFO_it);
656}
657LCRYPTO_ALIAS(i2d_PKCS7_RECIP_INFO);
658
659PKCS7_RECIP_INFO *
660PKCS7_RECIP_INFO_new(void)
661{
662 return (PKCS7_RECIP_INFO *)ASN1_item_new(&PKCS7_RECIP_INFO_it);
663}
664LCRYPTO_ALIAS(PKCS7_RECIP_INFO_new);
665
666void
667PKCS7_RECIP_INFO_free(PKCS7_RECIP_INFO *a)
668{
669 ASN1_item_free((ASN1_VALUE *)a, &PKCS7_RECIP_INFO_it);
670}
671LCRYPTO_ALIAS(PKCS7_RECIP_INFO_free);
672
673static const ASN1_TEMPLATE PKCS7_ENC_CONTENT_seq_tt[] = {
674 {
675 .flags = 0,
676 .tag = 0,
677 .offset = offsetof(PKCS7_ENC_CONTENT, content_type),
678 .field_name = "content_type",
679 .item = &ASN1_OBJECT_it,
680 },
681 {
682 .flags = 0,
683 .tag = 0,
684 .offset = offsetof(PKCS7_ENC_CONTENT, algorithm),
685 .field_name = "algorithm",
686 .item = &X509_ALGOR_it,
687 },
688 {
689 .flags = ASN1_TFLG_IMPLICIT | ASN1_TFLG_OPTIONAL,
690 .tag = 0,
691 .offset = offsetof(PKCS7_ENC_CONTENT, enc_data),
692 .field_name = "enc_data",
693 .item = &ASN1_OCTET_STRING_NDEF_it,
694 },
695};
696
697const ASN1_ITEM PKCS7_ENC_CONTENT_it = {
698 .itype = ASN1_ITYPE_NDEF_SEQUENCE,
699 .utype = V_ASN1_SEQUENCE,
700 .templates = PKCS7_ENC_CONTENT_seq_tt,
701 .tcount = sizeof(PKCS7_ENC_CONTENT_seq_tt) / sizeof(ASN1_TEMPLATE),
702 .funcs = NULL,
703 .size = sizeof(PKCS7_ENC_CONTENT),
704 .sname = "PKCS7_ENC_CONTENT",
705};
706LCRYPTO_ALIAS(PKCS7_ENC_CONTENT_it);
707
708
709PKCS7_ENC_CONTENT *
710d2i_PKCS7_ENC_CONTENT(PKCS7_ENC_CONTENT **a, const unsigned char **in, long len)
711{
712 return (PKCS7_ENC_CONTENT *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,
713 &PKCS7_ENC_CONTENT_it);
714}
715LCRYPTO_ALIAS(d2i_PKCS7_ENC_CONTENT);
716
717int
718i2d_PKCS7_ENC_CONTENT(PKCS7_ENC_CONTENT *a, unsigned char **out)
719{
720 return ASN1_item_i2d((ASN1_VALUE *)a, out, &PKCS7_ENC_CONTENT_it);
721}
722LCRYPTO_ALIAS(i2d_PKCS7_ENC_CONTENT);
723
724PKCS7_ENC_CONTENT *
725PKCS7_ENC_CONTENT_new(void)
726{
727 return (PKCS7_ENC_CONTENT *)ASN1_item_new(&PKCS7_ENC_CONTENT_it);
728}
729LCRYPTO_ALIAS(PKCS7_ENC_CONTENT_new);
730
731void
732PKCS7_ENC_CONTENT_free(PKCS7_ENC_CONTENT *a)
733{
734 ASN1_item_free((ASN1_VALUE *)a, &PKCS7_ENC_CONTENT_it);
735}
736LCRYPTO_ALIAS(PKCS7_ENC_CONTENT_free);
737
738static const ASN1_TEMPLATE PKCS7_SIGN_ENVELOPE_seq_tt[] = {
739 {
740 .flags = 0,
741 .tag = 0,
742 .offset = offsetof(PKCS7_SIGN_ENVELOPE, version),
743 .field_name = "version",
744 .item = &ASN1_INTEGER_it,
745 },
746 {
747 .flags = ASN1_TFLG_SET_OF,
748 .tag = 0,
749 .offset = offsetof(PKCS7_SIGN_ENVELOPE, recipientinfo),
750 .field_name = "recipientinfo",
751 .item = &PKCS7_RECIP_INFO_it,
752 },
753 {
754 .flags = ASN1_TFLG_SET_OF,
755 .tag = 0,
756 .offset = offsetof(PKCS7_SIGN_ENVELOPE, md_algs),
757 .field_name = "md_algs",
758 .item = &X509_ALGOR_it,
759 },
760 {
761 .flags = 0,
762 .tag = 0,
763 .offset = offsetof(PKCS7_SIGN_ENVELOPE, enc_data),
764 .field_name = "enc_data",
765 .item = &PKCS7_ENC_CONTENT_it,
766 },
767 {
768 .flags = ASN1_TFLG_IMPLICIT | ASN1_TFLG_SET_OF | ASN1_TFLG_OPTIONAL,
769 .tag = 0,
770 .offset = offsetof(PKCS7_SIGN_ENVELOPE, cert),
771 .field_name = "cert",
772 .item = &X509_it,
773 },
774 {
775 .flags = ASN1_TFLG_IMPLICIT | ASN1_TFLG_SET_OF | ASN1_TFLG_OPTIONAL,
776 .tag = 1,
777 .offset = offsetof(PKCS7_SIGN_ENVELOPE, crl),
778 .field_name = "crl",
779 .item = &X509_CRL_it,
780 },
781 {
782 .flags = ASN1_TFLG_SET_OF,
783 .tag = 0,
784 .offset = offsetof(PKCS7_SIGN_ENVELOPE, signer_info),
785 .field_name = "signer_info",
786 .item = &PKCS7_SIGNER_INFO_it,
787 },
788};
789
790const ASN1_ITEM PKCS7_SIGN_ENVELOPE_it = {
791 .itype = ASN1_ITYPE_NDEF_SEQUENCE,
792 .utype = V_ASN1_SEQUENCE,
793 .templates = PKCS7_SIGN_ENVELOPE_seq_tt,
794 .tcount = sizeof(PKCS7_SIGN_ENVELOPE_seq_tt) / sizeof(ASN1_TEMPLATE),
795 .funcs = NULL,
796 .size = sizeof(PKCS7_SIGN_ENVELOPE),
797 .sname = "PKCS7_SIGN_ENVELOPE",
798};
799LCRYPTO_ALIAS(PKCS7_SIGN_ENVELOPE_it);
800
801
802PKCS7_SIGN_ENVELOPE *
803d2i_PKCS7_SIGN_ENVELOPE(PKCS7_SIGN_ENVELOPE **a, const unsigned char **in, long len)
804{
805 return (PKCS7_SIGN_ENVELOPE *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,
806 &PKCS7_SIGN_ENVELOPE_it);
807}
808LCRYPTO_ALIAS(d2i_PKCS7_SIGN_ENVELOPE);
809
810int
811i2d_PKCS7_SIGN_ENVELOPE(PKCS7_SIGN_ENVELOPE *a, unsigned char **out)
812{
813 return ASN1_item_i2d((ASN1_VALUE *)a, out, &PKCS7_SIGN_ENVELOPE_it);
814}
815LCRYPTO_ALIAS(i2d_PKCS7_SIGN_ENVELOPE);
816
817PKCS7_SIGN_ENVELOPE *
818PKCS7_SIGN_ENVELOPE_new(void)
819{
820 return (PKCS7_SIGN_ENVELOPE *)ASN1_item_new(&PKCS7_SIGN_ENVELOPE_it);
821}
822LCRYPTO_ALIAS(PKCS7_SIGN_ENVELOPE_new);
823
824void
825PKCS7_SIGN_ENVELOPE_free(PKCS7_SIGN_ENVELOPE *a)
826{
827 ASN1_item_free((ASN1_VALUE *)a, &PKCS7_SIGN_ENVELOPE_it);
828}
829LCRYPTO_ALIAS(PKCS7_SIGN_ENVELOPE_free);
830
831static const ASN1_TEMPLATE PKCS7_ENCRYPT_seq_tt[] = {
832 {
833 .flags = 0,
834 .tag = 0,
835 .offset = offsetof(PKCS7_ENCRYPT, version),
836 .field_name = "version",
837 .item = &ASN1_INTEGER_it,
838 },
839 {
840 .flags = 0,
841 .tag = 0,
842 .offset = offsetof(PKCS7_ENCRYPT, enc_data),
843 .field_name = "enc_data",
844 .item = &PKCS7_ENC_CONTENT_it,
845 },
846};
847
848const ASN1_ITEM PKCS7_ENCRYPT_it = {
849 .itype = ASN1_ITYPE_NDEF_SEQUENCE,
850 .utype = V_ASN1_SEQUENCE,
851 .templates = PKCS7_ENCRYPT_seq_tt,
852 .tcount = sizeof(PKCS7_ENCRYPT_seq_tt) / sizeof(ASN1_TEMPLATE),
853 .funcs = NULL,
854 .size = sizeof(PKCS7_ENCRYPT),
855 .sname = "PKCS7_ENCRYPT",
856};
857LCRYPTO_ALIAS(PKCS7_ENCRYPT_it);
858
859
860PKCS7_ENCRYPT *
861d2i_PKCS7_ENCRYPT(PKCS7_ENCRYPT **a, const unsigned char **in, long len)
862{
863 return (PKCS7_ENCRYPT *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,
864 &PKCS7_ENCRYPT_it);
865}
866LCRYPTO_ALIAS(d2i_PKCS7_ENCRYPT);
867
868int
869i2d_PKCS7_ENCRYPT(PKCS7_ENCRYPT *a, unsigned char **out)
870{
871 return ASN1_item_i2d((ASN1_VALUE *)a, out, &PKCS7_ENCRYPT_it);
872}
873LCRYPTO_ALIAS(i2d_PKCS7_ENCRYPT);
874
875PKCS7_ENCRYPT *
876PKCS7_ENCRYPT_new(void)
877{
878 return (PKCS7_ENCRYPT *)ASN1_item_new(&PKCS7_ENCRYPT_it);
879}
880LCRYPTO_ALIAS(PKCS7_ENCRYPT_new);
881
882void
883PKCS7_ENCRYPT_free(PKCS7_ENCRYPT *a)
884{
885 ASN1_item_free((ASN1_VALUE *)a, &PKCS7_ENCRYPT_it);
886}
887LCRYPTO_ALIAS(PKCS7_ENCRYPT_free);
888
889static const ASN1_TEMPLATE PKCS7_DIGEST_seq_tt[] = {
890 {
891 .flags = 0,
892 .tag = 0,
893 .offset = offsetof(PKCS7_DIGEST, version),
894 .field_name = "version",
895 .item = &ASN1_INTEGER_it,
896 },
897 {
898 .flags = 0,
899 .tag = 0,
900 .offset = offsetof(PKCS7_DIGEST, md),
901 .field_name = "md",
902 .item = &X509_ALGOR_it,
903 },
904 {
905 .flags = 0,
906 .tag = 0,
907 .offset = offsetof(PKCS7_DIGEST, contents),
908 .field_name = "contents",
909 .item = &PKCS7_it,
910 },
911 {
912 .flags = 0,
913 .tag = 0,
914 .offset = offsetof(PKCS7_DIGEST, digest),
915 .field_name = "digest",
916 .item = &ASN1_OCTET_STRING_it,
917 },
918};
919
920const ASN1_ITEM PKCS7_DIGEST_it = {
921 .itype = ASN1_ITYPE_NDEF_SEQUENCE,
922 .utype = V_ASN1_SEQUENCE,
923 .templates = PKCS7_DIGEST_seq_tt,
924 .tcount = sizeof(PKCS7_DIGEST_seq_tt) / sizeof(ASN1_TEMPLATE),
925 .funcs = NULL,
926 .size = sizeof(PKCS7_DIGEST),
927 .sname = "PKCS7_DIGEST",
928};
929LCRYPTO_ALIAS(PKCS7_DIGEST_it);
930
931
932PKCS7_DIGEST *
933d2i_PKCS7_DIGEST(PKCS7_DIGEST **a, const unsigned char **in, long len)
934{
935 return (PKCS7_DIGEST *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,
936 &PKCS7_DIGEST_it);
937}
938LCRYPTO_ALIAS(d2i_PKCS7_DIGEST);
939
940int
941i2d_PKCS7_DIGEST(PKCS7_DIGEST *a, unsigned char **out)
942{
943 return ASN1_item_i2d((ASN1_VALUE *)a, out, &PKCS7_DIGEST_it);
944}
945LCRYPTO_ALIAS(i2d_PKCS7_DIGEST);
946
947PKCS7_DIGEST *
948PKCS7_DIGEST_new(void)
949{
950 return (PKCS7_DIGEST *)ASN1_item_new(&PKCS7_DIGEST_it);
951}
952LCRYPTO_ALIAS(PKCS7_DIGEST_new);
953
954void
955PKCS7_DIGEST_free(PKCS7_DIGEST *a)
956{
957 ASN1_item_free((ASN1_VALUE *)a, &PKCS7_DIGEST_it);
958}
959LCRYPTO_ALIAS(PKCS7_DIGEST_free);
960
961/* Specials for authenticated attributes */
962
963/* When signing attributes we want to reorder them to match the sorted
964 * encoding.
965 */
966
967static const ASN1_TEMPLATE PKCS7_ATTR_SIGN_item_tt = {
968 .flags = ASN1_TFLG_SET_ORDER,
969 .tag = 0,
970 .offset = 0,
971 .field_name = "PKCS7_ATTRIBUTES",
972 .item = &X509_ATTRIBUTE_it,
973};
974
975const ASN1_ITEM PKCS7_ATTR_SIGN_it = {
976 .itype = ASN1_ITYPE_PRIMITIVE,
977 .utype = -1,
978 .templates = &PKCS7_ATTR_SIGN_item_tt,
979 .tcount = 0,
980 .funcs = NULL,
981 .size = 0,
982 .sname = "PKCS7_ATTR_SIGN",
983};
984LCRYPTO_ALIAS(PKCS7_ATTR_SIGN_it);
985
986/* When verifying attributes we need to use the received order. So
987 * we use SEQUENCE OF and tag it to SET OF
988 */
989
990static const ASN1_TEMPLATE PKCS7_ATTR_VERIFY_item_tt = {
991 .flags = ASN1_TFLG_SEQUENCE_OF | ASN1_TFLG_IMPTAG | ASN1_TFLG_UNIVERSAL,
992 .tag = V_ASN1_SET,
993 .offset = 0,
994 .field_name = "PKCS7_ATTRIBUTES",
995 .item = &X509_ATTRIBUTE_it,
996};
997
998const ASN1_ITEM PKCS7_ATTR_VERIFY_it = {
999 .itype = ASN1_ITYPE_PRIMITIVE,
1000 .utype = -1,
1001 .templates = &PKCS7_ATTR_VERIFY_item_tt,
1002 .tcount = 0,
1003 .funcs = NULL,
1004 .size = 0,
1005 .sname = "PKCS7_ATTR_VERIFY",
1006};
1007LCRYPTO_ALIAS(PKCS7_ATTR_VERIFY_it);
1008
1009
1010int
1011PKCS7_print_ctx(BIO *out, PKCS7 *x, int indent, const ASN1_PCTX *pctx)
1012{
1013 return ASN1_item_print(out, (ASN1_VALUE *)x, indent,
1014 &PKCS7_it, pctx);
1015}
1016LCRYPTO_ALIAS(PKCS7_print_ctx);
1017
1018PKCS7 *
1019d2i_PKCS7_bio(BIO *bp, PKCS7 **p7)
1020{
1021 return ASN1_item_d2i_bio(&PKCS7_it, bp, p7);
1022}
1023LCRYPTO_ALIAS(d2i_PKCS7_bio);
1024
1025int
1026i2d_PKCS7_bio(BIO *bp, PKCS7 *p7)
1027{
1028 return ASN1_item_i2d_bio(&PKCS7_it, bp, p7);
1029}
1030LCRYPTO_ALIAS(i2d_PKCS7_bio);
1031
1032PKCS7 *
1033d2i_PKCS7_fp(FILE *fp, PKCS7 **p7)
1034{
1035 return ASN1_item_d2i_fp(&PKCS7_it, fp, p7);
1036}
1037LCRYPTO_ALIAS(d2i_PKCS7_fp);
1038
1039int
1040i2d_PKCS7_fp(FILE *fp, PKCS7 *p7)
1041{
1042 return ASN1_item_i2d_fp(&PKCS7_it, fp, p7);
1043}
1044LCRYPTO_ALIAS(i2d_PKCS7_fp);
1045
1046int
1047PKCS7_ISSUER_AND_SERIAL_digest(PKCS7_ISSUER_AND_SERIAL *data,
1048 const EVP_MD *type, unsigned char *md, unsigned int *len)
1049{
1050 return(ASN1_item_digest(&PKCS7_ISSUER_AND_SERIAL_it, type,
1051 (char *)data, md, len));
1052}
1053LCRYPTO_ALIAS(PKCS7_ISSUER_AND_SERIAL_digest);
generated by cgit v1.2.3-55-g6feb (git 2.39.1) at 2025-05-08 10:35:06 +0000