summaryrefslogtreecommitdiff
path: root/src/lib/libcrypto/ocsp/ocsp_asn.c
diff options
context:
space:
mode:
Diffstat (limited to 'src/lib/libcrypto/ocsp/ocsp_asn.c')
-rw-r--r--src/lib/libcrypto/ocsp/ocsp_asn.c1066
1 files changed, 0 insertions, 1066 deletions
diff --git a/src/lib/libcrypto/ocsp/ocsp_asn.c b/src/lib/libcrypto/ocsp/ocsp_asn.c
deleted file mode 100644
index abceaac832..0000000000
--- a/src/lib/libcrypto/ocsp/ocsp_asn.c
+++ /dev/null
@@ -1,1066 +0,0 @@
1/* $OpenBSD: ocsp_asn.c,v 1.12 2024/07/08 14:53:11 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#include <openssl/asn1.h>
59#include <openssl/asn1t.h>
60#include <openssl/ocsp.h>
61
62#include "ocsp_local.h"
63
64static const ASN1_TEMPLATE OCSP_SIGNATURE_seq_tt[] = {
65 {
66 .flags = 0,
67 .tag = 0,
68 .offset = offsetof(OCSP_SIGNATURE, signatureAlgorithm),
69 .field_name = "signatureAlgorithm",
70 .item = &X509_ALGOR_it,
71 },
72 {
73 .flags = 0,
74 .tag = 0,
75 .offset = offsetof(OCSP_SIGNATURE, signature),
76 .field_name = "signature",
77 .item = &ASN1_BIT_STRING_it,
78 },
79 {
80 .flags = ASN1_TFLG_EXPLICIT | ASN1_TFLG_SEQUENCE_OF | ASN1_TFLG_OPTIONAL,
81 .tag = 0,
82 .offset = offsetof(OCSP_SIGNATURE, certs),
83 .field_name = "certs",
84 .item = &X509_it,
85 },
86};
87
88const ASN1_ITEM OCSP_SIGNATURE_it = {
89 .itype = ASN1_ITYPE_SEQUENCE,
90 .utype = V_ASN1_SEQUENCE,
91 .templates = OCSP_SIGNATURE_seq_tt,
92 .tcount = sizeof(OCSP_SIGNATURE_seq_tt) / sizeof(ASN1_TEMPLATE),
93 .funcs = NULL,
94 .size = sizeof(OCSP_SIGNATURE),
95 .sname = "OCSP_SIGNATURE",
96};
97LCRYPTO_ALIAS(OCSP_SIGNATURE_it);
98
99
100OCSP_SIGNATURE *
101d2i_OCSP_SIGNATURE(OCSP_SIGNATURE **a, const unsigned char **in, long len)
102{
103 return (OCSP_SIGNATURE *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,
104 &OCSP_SIGNATURE_it);
105}
106LCRYPTO_ALIAS(d2i_OCSP_SIGNATURE);
107
108int
109i2d_OCSP_SIGNATURE(OCSP_SIGNATURE *a, unsigned char **out)
110{
111 return ASN1_item_i2d((ASN1_VALUE *)a, out, &OCSP_SIGNATURE_it);
112}
113LCRYPTO_ALIAS(i2d_OCSP_SIGNATURE);
114
115OCSP_SIGNATURE *
116OCSP_SIGNATURE_new(void)
117{
118 return (OCSP_SIGNATURE *)ASN1_item_new(&OCSP_SIGNATURE_it);
119}
120LCRYPTO_ALIAS(OCSP_SIGNATURE_new);
121
122void
123OCSP_SIGNATURE_free(OCSP_SIGNATURE *a)
124{
125 ASN1_item_free((ASN1_VALUE *)a, &OCSP_SIGNATURE_it);
126}
127LCRYPTO_ALIAS(OCSP_SIGNATURE_free);
128
129static const ASN1_TEMPLATE OCSP_CERTID_seq_tt[] = {
130 {
131 .flags = 0,
132 .tag = 0,
133 .offset = offsetof(OCSP_CERTID, hashAlgorithm),
134 .field_name = "hashAlgorithm",
135 .item = &X509_ALGOR_it,
136 },
137 {
138 .flags = 0,
139 .tag = 0,
140 .offset = offsetof(OCSP_CERTID, issuerNameHash),
141 .field_name = "issuerNameHash",
142 .item = &ASN1_OCTET_STRING_it,
143 },
144 {
145 .flags = 0,
146 .tag = 0,
147 .offset = offsetof(OCSP_CERTID, issuerKeyHash),
148 .field_name = "issuerKeyHash",
149 .item = &ASN1_OCTET_STRING_it,
150 },
151 {
152 .flags = 0,
153 .tag = 0,
154 .offset = offsetof(OCSP_CERTID, serialNumber),
155 .field_name = "serialNumber",
156 .item = &ASN1_INTEGER_it,
157 },
158};
159
160const ASN1_ITEM OCSP_CERTID_it = {
161 .itype = ASN1_ITYPE_SEQUENCE,
162 .utype = V_ASN1_SEQUENCE,
163 .templates = OCSP_CERTID_seq_tt,
164 .tcount = sizeof(OCSP_CERTID_seq_tt) / sizeof(ASN1_TEMPLATE),
165 .funcs = NULL,
166 .size = sizeof(OCSP_CERTID),
167 .sname = "OCSP_CERTID",
168};
169LCRYPTO_ALIAS(OCSP_CERTID_it);
170
171
172OCSP_CERTID *
173d2i_OCSP_CERTID(OCSP_CERTID **a, const unsigned char **in, long len)
174{
175 return (OCSP_CERTID *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,
176 &OCSP_CERTID_it);
177}
178LCRYPTO_ALIAS(d2i_OCSP_CERTID);
179
180int
181i2d_OCSP_CERTID(OCSP_CERTID *a, unsigned char **out)
182{
183 return ASN1_item_i2d((ASN1_VALUE *)a, out, &OCSP_CERTID_it);
184}
185LCRYPTO_ALIAS(i2d_OCSP_CERTID);
186
187OCSP_CERTID *
188OCSP_CERTID_new(void)
189{
190 return (OCSP_CERTID *)ASN1_item_new(&OCSP_CERTID_it);
191}
192LCRYPTO_ALIAS(OCSP_CERTID_new);
193
194void
195OCSP_CERTID_free(OCSP_CERTID *a)
196{
197 ASN1_item_free((ASN1_VALUE *)a, &OCSP_CERTID_it);
198}
199LCRYPTO_ALIAS(OCSP_CERTID_free);
200
201static const ASN1_TEMPLATE OCSP_ONEREQ_seq_tt[] = {
202 {
203 .flags = 0,
204 .tag = 0,
205 .offset = offsetof(OCSP_ONEREQ, reqCert),
206 .field_name = "reqCert",
207 .item = &OCSP_CERTID_it,
208 },
209 {
210 .flags = ASN1_TFLG_EXPLICIT | ASN1_TFLG_SEQUENCE_OF | ASN1_TFLG_OPTIONAL,
211 .tag = 0,
212 .offset = offsetof(OCSP_ONEREQ, singleRequestExtensions),
213 .field_name = "singleRequestExtensions",
214 .item = &X509_EXTENSION_it,
215 },
216};
217
218const ASN1_ITEM OCSP_ONEREQ_it = {
219 .itype = ASN1_ITYPE_SEQUENCE,
220 .utype = V_ASN1_SEQUENCE,
221 .templates = OCSP_ONEREQ_seq_tt,
222 .tcount = sizeof(OCSP_ONEREQ_seq_tt) / sizeof(ASN1_TEMPLATE),
223 .funcs = NULL,
224 .size = sizeof(OCSP_ONEREQ),
225 .sname = "OCSP_ONEREQ",
226};
227LCRYPTO_ALIAS(OCSP_ONEREQ_it);
228
229
230OCSP_ONEREQ *
231d2i_OCSP_ONEREQ(OCSP_ONEREQ **a, const unsigned char **in, long len)
232{
233 return (OCSP_ONEREQ *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,
234 &OCSP_ONEREQ_it);
235}
236LCRYPTO_ALIAS(d2i_OCSP_ONEREQ);
237
238int
239i2d_OCSP_ONEREQ(OCSP_ONEREQ *a, unsigned char **out)
240{
241 return ASN1_item_i2d((ASN1_VALUE *)a, out, &OCSP_ONEREQ_it);
242}
243LCRYPTO_ALIAS(i2d_OCSP_ONEREQ);
244
245OCSP_ONEREQ *
246OCSP_ONEREQ_new(void)
247{
248 return (OCSP_ONEREQ *)ASN1_item_new(&OCSP_ONEREQ_it);
249}
250LCRYPTO_ALIAS(OCSP_ONEREQ_new);
251
252void
253OCSP_ONEREQ_free(OCSP_ONEREQ *a)
254{
255 ASN1_item_free((ASN1_VALUE *)a, &OCSP_ONEREQ_it);
256}
257LCRYPTO_ALIAS(OCSP_ONEREQ_free);
258
259static const ASN1_TEMPLATE OCSP_REQINFO_seq_tt[] = {
260 {
261 .flags = ASN1_TFLG_EXPLICIT | ASN1_TFLG_OPTIONAL,
262 .tag = 0,
263 .offset = offsetof(OCSP_REQINFO, version),
264 .field_name = "version",
265 .item = &ASN1_INTEGER_it,
266 },
267 {
268 .flags = ASN1_TFLG_EXPLICIT | ASN1_TFLG_OPTIONAL,
269 .tag = 1,
270 .offset = offsetof(OCSP_REQINFO, requestorName),
271 .field_name = "requestorName",
272 .item = &GENERAL_NAME_it,
273 },
274 {
275 .flags = ASN1_TFLG_SEQUENCE_OF,
276 .tag = 0,
277 .offset = offsetof(OCSP_REQINFO, requestList),
278 .field_name = "requestList",
279 .item = &OCSP_ONEREQ_it,
280 },
281 {
282 .flags = ASN1_TFLG_EXPLICIT | ASN1_TFLG_SEQUENCE_OF | ASN1_TFLG_OPTIONAL,
283 .tag = 2,
284 .offset = offsetof(OCSP_REQINFO, requestExtensions),
285 .field_name = "requestExtensions",
286 .item = &X509_EXTENSION_it,
287 },
288};
289
290const ASN1_ITEM OCSP_REQINFO_it = {
291 .itype = ASN1_ITYPE_SEQUENCE,
292 .utype = V_ASN1_SEQUENCE,
293 .templates = OCSP_REQINFO_seq_tt,
294 .tcount = sizeof(OCSP_REQINFO_seq_tt) / sizeof(ASN1_TEMPLATE),
295 .funcs = NULL,
296 .size = sizeof(OCSP_REQINFO),
297 .sname = "OCSP_REQINFO",
298};
299LCRYPTO_ALIAS(OCSP_REQINFO_it);
300
301
302OCSP_REQINFO *
303d2i_OCSP_REQINFO(OCSP_REQINFO **a, const unsigned char **in, long len)
304{
305 return (OCSP_REQINFO *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,
306 &OCSP_REQINFO_it);
307}
308LCRYPTO_ALIAS(d2i_OCSP_REQINFO);
309
310int
311i2d_OCSP_REQINFO(OCSP_REQINFO *a, unsigned char **out)
312{
313 return ASN1_item_i2d((ASN1_VALUE *)a, out, &OCSP_REQINFO_it);
314}
315LCRYPTO_ALIAS(i2d_OCSP_REQINFO);
316
317OCSP_REQINFO *
318OCSP_REQINFO_new(void)
319{
320 return (OCSP_REQINFO *)ASN1_item_new(&OCSP_REQINFO_it);
321}
322LCRYPTO_ALIAS(OCSP_REQINFO_new);
323
324void
325OCSP_REQINFO_free(OCSP_REQINFO *a)
326{
327 ASN1_item_free((ASN1_VALUE *)a, &OCSP_REQINFO_it);
328}
329LCRYPTO_ALIAS(OCSP_REQINFO_free);
330
331static const ASN1_TEMPLATE OCSP_REQUEST_seq_tt[] = {
332 {
333 .flags = 0,
334 .tag = 0,
335 .offset = offsetof(OCSP_REQUEST, tbsRequest),
336 .field_name = "tbsRequest",
337 .item = &OCSP_REQINFO_it,
338 },
339 {
340 .flags = ASN1_TFLG_EXPLICIT | ASN1_TFLG_OPTIONAL,
341 .tag = 0,
342 .offset = offsetof(OCSP_REQUEST, optionalSignature),
343 .field_name = "optionalSignature",
344 .item = &OCSP_SIGNATURE_it,
345 },
346};
347
348const ASN1_ITEM OCSP_REQUEST_it = {
349 .itype = ASN1_ITYPE_SEQUENCE,
350 .utype = V_ASN1_SEQUENCE,
351 .templates = OCSP_REQUEST_seq_tt,
352 .tcount = sizeof(OCSP_REQUEST_seq_tt) / sizeof(ASN1_TEMPLATE),
353 .funcs = NULL,
354 .size = sizeof(OCSP_REQUEST),
355 .sname = "OCSP_REQUEST",
356};
357LCRYPTO_ALIAS(OCSP_REQUEST_it);
358
359OCSP_REQUEST *
360d2i_OCSP_REQUEST(OCSP_REQUEST **a, const unsigned char **in, long len)
361{
362 return (OCSP_REQUEST *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,
363 &OCSP_REQUEST_it);
364}
365LCRYPTO_ALIAS(d2i_OCSP_REQUEST);
366
367int
368i2d_OCSP_REQUEST(OCSP_REQUEST *a, unsigned char **out)
369{
370 return ASN1_item_i2d((ASN1_VALUE *)a, out, &OCSP_REQUEST_it);
371}
372LCRYPTO_ALIAS(i2d_OCSP_REQUEST);
373
374OCSP_REQUEST *
375d2i_OCSP_REQUEST_bio(BIO *bp, OCSP_REQUEST **a)
376{
377 return ASN1_item_d2i_bio(&OCSP_REQUEST_it, bp, a);
378}
379LCRYPTO_ALIAS(d2i_OCSP_REQUEST_bio);
380
381int
382i2d_OCSP_REQUEST_bio(BIO *bp, OCSP_REQUEST *a)
383{
384 return ASN1_item_i2d_bio(&OCSP_REQUEST_it, bp, a);
385}
386LCRYPTO_ALIAS(i2d_OCSP_REQUEST_bio);
387
388OCSP_REQUEST *
389OCSP_REQUEST_new(void)
390{
391 return (OCSP_REQUEST *)ASN1_item_new(&OCSP_REQUEST_it);
392}
393LCRYPTO_ALIAS(OCSP_REQUEST_new);
394
395void
396OCSP_REQUEST_free(OCSP_REQUEST *a)
397{
398 ASN1_item_free((ASN1_VALUE *)a, &OCSP_REQUEST_it);
399}
400LCRYPTO_ALIAS(OCSP_REQUEST_free);
401
402/* OCSP_RESPONSE templates */
403
404static const ASN1_TEMPLATE OCSP_RESPBYTES_seq_tt[] = {
405 {
406 .flags = 0,
407 .tag = 0,
408 .offset = offsetof(OCSP_RESPBYTES, responseType),
409 .field_name = "responseType",
410 .item = &ASN1_OBJECT_it,
411 },
412 {
413 .flags = 0,
414 .tag = 0,
415 .offset = offsetof(OCSP_RESPBYTES, response),
416 .field_name = "response",
417 .item = &ASN1_OCTET_STRING_it,
418 },
419};
420
421const ASN1_ITEM OCSP_RESPBYTES_it = {
422 .itype = ASN1_ITYPE_SEQUENCE,
423 .utype = V_ASN1_SEQUENCE,
424 .templates = OCSP_RESPBYTES_seq_tt,
425 .tcount = sizeof(OCSP_RESPBYTES_seq_tt) / sizeof(ASN1_TEMPLATE),
426 .funcs = NULL,
427 .size = sizeof(OCSP_RESPBYTES),
428 .sname = "OCSP_RESPBYTES",
429};
430LCRYPTO_ALIAS(OCSP_RESPBYTES_it);
431
432
433OCSP_RESPBYTES *
434d2i_OCSP_RESPBYTES(OCSP_RESPBYTES **a, const unsigned char **in, long len)
435{
436 return (OCSP_RESPBYTES *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,
437 &OCSP_RESPBYTES_it);
438}
439LCRYPTO_ALIAS(d2i_OCSP_RESPBYTES);
440
441int
442i2d_OCSP_RESPBYTES(OCSP_RESPBYTES *a, unsigned char **out)
443{
444 return ASN1_item_i2d((ASN1_VALUE *)a, out, &OCSP_RESPBYTES_it);
445}
446LCRYPTO_ALIAS(i2d_OCSP_RESPBYTES);
447
448OCSP_RESPBYTES *
449OCSP_RESPBYTES_new(void)
450{
451 return (OCSP_RESPBYTES *)ASN1_item_new(&OCSP_RESPBYTES_it);
452}
453LCRYPTO_ALIAS(OCSP_RESPBYTES_new);
454
455void
456OCSP_RESPBYTES_free(OCSP_RESPBYTES *a)
457{
458 ASN1_item_free((ASN1_VALUE *)a, &OCSP_RESPBYTES_it);
459}
460LCRYPTO_ALIAS(OCSP_RESPBYTES_free);
461
462static const ASN1_TEMPLATE OCSP_RESPONSE_seq_tt[] = {
463 {
464 .flags = 0,
465 .tag = 0,
466 .offset = offsetof(OCSP_RESPONSE, responseStatus),
467 .field_name = "responseStatus",
468 .item = &ASN1_ENUMERATED_it,
469 },
470 {
471 .flags = ASN1_TFLG_EXPLICIT | ASN1_TFLG_OPTIONAL,
472 .tag = 0,
473 .offset = offsetof(OCSP_RESPONSE, responseBytes),
474 .field_name = "responseBytes",
475 .item = &OCSP_RESPBYTES_it,
476 },
477};
478
479const ASN1_ITEM OCSP_RESPONSE_it = {
480 .itype = ASN1_ITYPE_SEQUENCE,
481 .utype = V_ASN1_SEQUENCE,
482 .templates = OCSP_RESPONSE_seq_tt,
483 .tcount = sizeof(OCSP_RESPONSE_seq_tt) / sizeof(ASN1_TEMPLATE),
484 .funcs = NULL,
485 .size = sizeof(OCSP_RESPONSE),
486 .sname = "OCSP_RESPONSE",
487};
488LCRYPTO_ALIAS(OCSP_RESPONSE_it);
489
490
491OCSP_RESPONSE *
492d2i_OCSP_RESPONSE(OCSP_RESPONSE **a, const unsigned char **in, long len)
493{
494 return (OCSP_RESPONSE *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,
495 &OCSP_RESPONSE_it);
496}
497LCRYPTO_ALIAS(d2i_OCSP_RESPONSE);
498
499int
500i2d_OCSP_RESPONSE(OCSP_RESPONSE *a, unsigned char **out)
501{
502 return ASN1_item_i2d((ASN1_VALUE *)a, out, &OCSP_RESPONSE_it);
503}
504LCRYPTO_ALIAS(i2d_OCSP_RESPONSE);
505
506OCSP_RESPONSE *
507d2i_OCSP_RESPONSE_bio(BIO *bp, OCSP_RESPONSE **a)
508{
509 return ASN1_item_d2i_bio(&OCSP_RESPONSE_it, bp, a);
510}
511LCRYPTO_ALIAS(d2i_OCSP_RESPONSE_bio);
512
513int
514i2d_OCSP_RESPONSE_bio(BIO *bp, OCSP_RESPONSE *a)
515{
516 return ASN1_item_i2d_bio(&OCSP_RESPONSE_it, bp, a);
517}
518LCRYPTO_ALIAS(i2d_OCSP_RESPONSE_bio);
519
520OCSP_RESPONSE *
521OCSP_RESPONSE_new(void)
522{
523 return (OCSP_RESPONSE *)ASN1_item_new(&OCSP_RESPONSE_it);
524}
525LCRYPTO_ALIAS(OCSP_RESPONSE_new);
526
527void
528OCSP_RESPONSE_free(OCSP_RESPONSE *a)
529{
530 ASN1_item_free((ASN1_VALUE *)a, &OCSP_RESPONSE_it);
531}
532LCRYPTO_ALIAS(OCSP_RESPONSE_free);
533
534static const ASN1_TEMPLATE OCSP_RESPID_ch_tt[] = {
535 {
536 .flags = ASN1_TFLG_EXPLICIT,
537 .tag = 1,
538 .offset = offsetof(OCSP_RESPID, value.byName),
539 .field_name = "value.byName",
540 .item = &X509_NAME_it,
541 },
542 {
543 .flags = ASN1_TFLG_EXPLICIT,
544 .tag = 2,
545 .offset = offsetof(OCSP_RESPID, value.byKey),
546 .field_name = "value.byKey",
547 .item = &ASN1_OCTET_STRING_it,
548 },
549};
550
551const ASN1_ITEM OCSP_RESPID_it = {
552 .itype = ASN1_ITYPE_CHOICE,
553 .utype = offsetof(OCSP_RESPID, type),
554 .templates = OCSP_RESPID_ch_tt,
555 .tcount = sizeof(OCSP_RESPID_ch_tt) / sizeof(ASN1_TEMPLATE),
556 .funcs = NULL,
557 .size = sizeof(OCSP_RESPID),
558 .sname = "OCSP_RESPID",
559};
560LCRYPTO_ALIAS(OCSP_RESPID_it);
561
562
563OCSP_RESPID *
564d2i_OCSP_RESPID(OCSP_RESPID **a, const unsigned char **in, long len)
565{
566 return (OCSP_RESPID *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,
567 &OCSP_RESPID_it);
568}
569LCRYPTO_ALIAS(d2i_OCSP_RESPID);
570
571int
572i2d_OCSP_RESPID(OCSP_RESPID *a, unsigned char **out)
573{
574 return ASN1_item_i2d((ASN1_VALUE *)a, out, &OCSP_RESPID_it);
575}
576LCRYPTO_ALIAS(i2d_OCSP_RESPID);
577
578OCSP_RESPID *
579OCSP_RESPID_new(void)
580{
581 return (OCSP_RESPID *)ASN1_item_new(&OCSP_RESPID_it);
582}
583LCRYPTO_ALIAS(OCSP_RESPID_new);
584
585void
586OCSP_RESPID_free(OCSP_RESPID *a)
587{
588 ASN1_item_free((ASN1_VALUE *)a, &OCSP_RESPID_it);
589}
590LCRYPTO_ALIAS(OCSP_RESPID_free);
591
592static const ASN1_TEMPLATE OCSP_REVOKEDINFO_seq_tt[] = {
593 {
594 .flags = 0,
595 .tag = 0,
596 .offset = offsetof(OCSP_REVOKEDINFO, revocationTime),
597 .field_name = "revocationTime",
598 .item = &ASN1_GENERALIZEDTIME_it,
599 },
600 {
601 .flags = ASN1_TFLG_EXPLICIT | ASN1_TFLG_OPTIONAL,
602 .tag = 0,
603 .offset = offsetof(OCSP_REVOKEDINFO, revocationReason),
604 .field_name = "revocationReason",
605 .item = &ASN1_ENUMERATED_it,
606 },
607};
608
609const ASN1_ITEM OCSP_REVOKEDINFO_it = {
610 .itype = ASN1_ITYPE_SEQUENCE,
611 .utype = V_ASN1_SEQUENCE,
612 .templates = OCSP_REVOKEDINFO_seq_tt,
613 .tcount = sizeof(OCSP_REVOKEDINFO_seq_tt) / sizeof(ASN1_TEMPLATE),
614 .funcs = NULL,
615 .size = sizeof(OCSP_REVOKEDINFO),
616 .sname = "OCSP_REVOKEDINFO",
617};
618LCRYPTO_ALIAS(OCSP_REVOKEDINFO_it);
619
620
621OCSP_REVOKEDINFO *
622d2i_OCSP_REVOKEDINFO(OCSP_REVOKEDINFO **a, const unsigned char **in, long len)
623{
624 return (OCSP_REVOKEDINFO *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,
625 &OCSP_REVOKEDINFO_it);
626}
627LCRYPTO_ALIAS(d2i_OCSP_REVOKEDINFO);
628
629int
630i2d_OCSP_REVOKEDINFO(OCSP_REVOKEDINFO *a, unsigned char **out)
631{
632 return ASN1_item_i2d((ASN1_VALUE *)a, out, &OCSP_REVOKEDINFO_it);
633}
634LCRYPTO_ALIAS(i2d_OCSP_REVOKEDINFO);
635
636OCSP_REVOKEDINFO *
637OCSP_REVOKEDINFO_new(void)
638{
639 return (OCSP_REVOKEDINFO *)ASN1_item_new(&OCSP_REVOKEDINFO_it);
640}
641LCRYPTO_ALIAS(OCSP_REVOKEDINFO_new);
642
643void
644OCSP_REVOKEDINFO_free(OCSP_REVOKEDINFO *a)
645{
646 ASN1_item_free((ASN1_VALUE *)a, &OCSP_REVOKEDINFO_it);
647}
648LCRYPTO_ALIAS(OCSP_REVOKEDINFO_free);
649
650static const ASN1_TEMPLATE OCSP_CERTSTATUS_ch_tt[] = {
651 {
652 .flags = ASN1_TFLG_IMPLICIT,
653 .tag = 0,
654 .offset = offsetof(OCSP_CERTSTATUS, value.good),
655 .field_name = "value.good",
656 .item = &ASN1_NULL_it,
657 },
658 {
659 .flags = ASN1_TFLG_IMPLICIT,
660 .tag = 1,
661 .offset = offsetof(OCSP_CERTSTATUS, value.revoked),
662 .field_name = "value.revoked",
663 .item = &OCSP_REVOKEDINFO_it,
664 },
665 {
666 .flags = ASN1_TFLG_IMPLICIT,
667 .tag = 2,
668 .offset = offsetof(OCSP_CERTSTATUS, value.unknown),
669 .field_name = "value.unknown",
670 .item = &ASN1_NULL_it,
671 },
672};
673
674const ASN1_ITEM OCSP_CERTSTATUS_it = {
675 .itype = ASN1_ITYPE_CHOICE,
676 .utype = offsetof(OCSP_CERTSTATUS, type),
677 .templates = OCSP_CERTSTATUS_ch_tt,
678 .tcount = sizeof(OCSP_CERTSTATUS_ch_tt) / sizeof(ASN1_TEMPLATE),
679 .funcs = NULL,
680 .size = sizeof(OCSP_CERTSTATUS),
681 .sname = "OCSP_CERTSTATUS",
682};
683LCRYPTO_ALIAS(OCSP_CERTSTATUS_it);
684
685
686OCSP_CERTSTATUS *
687d2i_OCSP_CERTSTATUS(OCSP_CERTSTATUS **a, const unsigned char **in, long len)
688{
689 return (OCSP_CERTSTATUS *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,
690 &OCSP_CERTSTATUS_it);
691}
692LCRYPTO_ALIAS(d2i_OCSP_CERTSTATUS);
693
694int
695i2d_OCSP_CERTSTATUS(OCSP_CERTSTATUS *a, unsigned char **out)
696{
697 return ASN1_item_i2d((ASN1_VALUE *)a, out, &OCSP_CERTSTATUS_it);
698}
699LCRYPTO_ALIAS(i2d_OCSP_CERTSTATUS);
700
701OCSP_CERTSTATUS *
702OCSP_CERTSTATUS_new(void)
703{
704 return (OCSP_CERTSTATUS *)ASN1_item_new(&OCSP_CERTSTATUS_it);
705}
706LCRYPTO_ALIAS(OCSP_CERTSTATUS_new);
707
708void
709OCSP_CERTSTATUS_free(OCSP_CERTSTATUS *a)
710{
711 ASN1_item_free((ASN1_VALUE *)a, &OCSP_CERTSTATUS_it);
712}
713LCRYPTO_ALIAS(OCSP_CERTSTATUS_free);
714
715static const ASN1_TEMPLATE OCSP_SINGLERESP_seq_tt[] = {
716 {
717 .flags = 0,
718 .tag = 0,
719 .offset = offsetof(OCSP_SINGLERESP, certId),
720 .field_name = "certId",
721 .item = &OCSP_CERTID_it,
722 },
723 {
724 .flags = 0,
725 .tag = 0,
726 .offset = offsetof(OCSP_SINGLERESP, certStatus),
727 .field_name = "certStatus",
728 .item = &OCSP_CERTSTATUS_it,
729 },
730 {
731 .flags = 0,
732 .tag = 0,
733 .offset = offsetof(OCSP_SINGLERESP, thisUpdate),
734 .field_name = "thisUpdate",
735 .item = &ASN1_GENERALIZEDTIME_it,
736 },
737 {
738 .flags = ASN1_TFLG_EXPLICIT | ASN1_TFLG_OPTIONAL,
739 .tag = 0,
740 .offset = offsetof(OCSP_SINGLERESP, nextUpdate),
741 .field_name = "nextUpdate",
742 .item = &ASN1_GENERALIZEDTIME_it,
743 },
744 {
745 .flags = ASN1_TFLG_EXPLICIT | ASN1_TFLG_SEQUENCE_OF | ASN1_TFLG_OPTIONAL,
746 .tag = 1,
747 .offset = offsetof(OCSP_SINGLERESP, singleExtensions),
748 .field_name = "singleExtensions",
749 .item = &X509_EXTENSION_it,
750 },
751};
752
753const ASN1_ITEM OCSP_SINGLERESP_it = {
754 .itype = ASN1_ITYPE_SEQUENCE,
755 .utype = V_ASN1_SEQUENCE,
756 .templates = OCSP_SINGLERESP_seq_tt,
757 .tcount = sizeof(OCSP_SINGLERESP_seq_tt) / sizeof(ASN1_TEMPLATE),
758 .funcs = NULL,
759 .size = sizeof(OCSP_SINGLERESP),
760 .sname = "OCSP_SINGLERESP",
761};
762LCRYPTO_ALIAS(OCSP_SINGLERESP_it);
763
764
765OCSP_SINGLERESP *
766d2i_OCSP_SINGLERESP(OCSP_SINGLERESP **a, const unsigned char **in, long len)
767{
768 return (OCSP_SINGLERESP *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,
769 &OCSP_SINGLERESP_it);
770}
771LCRYPTO_ALIAS(d2i_OCSP_SINGLERESP);
772
773int
774i2d_OCSP_SINGLERESP(OCSP_SINGLERESP *a, unsigned char **out)
775{
776 return ASN1_item_i2d((ASN1_VALUE *)a, out, &OCSP_SINGLERESP_it);
777}
778LCRYPTO_ALIAS(i2d_OCSP_SINGLERESP);
779
780OCSP_SINGLERESP *
781OCSP_SINGLERESP_new(void)
782{
783 return (OCSP_SINGLERESP *)ASN1_item_new(&OCSP_SINGLERESP_it);
784}
785LCRYPTO_ALIAS(OCSP_SINGLERESP_new);
786
787void
788OCSP_SINGLERESP_free(OCSP_SINGLERESP *a)
789{
790 ASN1_item_free((ASN1_VALUE *)a, &OCSP_SINGLERESP_it);
791}
792LCRYPTO_ALIAS(OCSP_SINGLERESP_free);
793
794static const ASN1_TEMPLATE OCSP_RESPDATA_seq_tt[] = {
795 {
796 .flags = ASN1_TFLG_EXPLICIT | ASN1_TFLG_OPTIONAL,
797 .tag = 0,
798 .offset = offsetof(OCSP_RESPDATA, version),
799 .field_name = "version",
800 .item = &ASN1_INTEGER_it,
801 },
802 {
803 .flags = 0,
804 .tag = 0,
805 .offset = offsetof(OCSP_RESPDATA, responderId),
806 .field_name = "responderId",
807 .item = &OCSP_RESPID_it,
808 },
809 {
810 .flags = 0,
811 .tag = 0,
812 .offset = offsetof(OCSP_RESPDATA, producedAt),
813 .field_name = "producedAt",
814 .item = &ASN1_GENERALIZEDTIME_it,
815 },
816 {
817 .flags = ASN1_TFLG_SEQUENCE_OF,
818 .tag = 0,
819 .offset = offsetof(OCSP_RESPDATA, responses),
820 .field_name = "responses",
821 .item = &OCSP_SINGLERESP_it,
822 },
823 {
824 .flags = ASN1_TFLG_EXPLICIT | ASN1_TFLG_SEQUENCE_OF | ASN1_TFLG_OPTIONAL,
825 .tag = 1,
826 .offset = offsetof(OCSP_RESPDATA, responseExtensions),
827 .field_name = "responseExtensions",
828 .item = &X509_EXTENSION_it,
829 },
830};
831
832const ASN1_ITEM OCSP_RESPDATA_it = {
833 .itype = ASN1_ITYPE_SEQUENCE,
834 .utype = V_ASN1_SEQUENCE,
835 .templates = OCSP_RESPDATA_seq_tt,
836 .tcount = sizeof(OCSP_RESPDATA_seq_tt) / sizeof(ASN1_TEMPLATE),
837 .funcs = NULL,
838 .size = sizeof(OCSP_RESPDATA),
839 .sname = "OCSP_RESPDATA",
840};
841LCRYPTO_ALIAS(OCSP_RESPDATA_it);
842
843
844OCSP_RESPDATA *
845d2i_OCSP_RESPDATA(OCSP_RESPDATA **a, const unsigned char **in, long len)
846{
847 return (OCSP_RESPDATA *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,
848 &OCSP_RESPDATA_it);
849}
850LCRYPTO_ALIAS(d2i_OCSP_RESPDATA);
851
852int
853i2d_OCSP_RESPDATA(OCSP_RESPDATA *a, unsigned char **out)
854{
855 return ASN1_item_i2d((ASN1_VALUE *)a, out, &OCSP_RESPDATA_it);
856}
857LCRYPTO_ALIAS(i2d_OCSP_RESPDATA);
858
859OCSP_RESPDATA *
860OCSP_RESPDATA_new(void)
861{
862 return (OCSP_RESPDATA *)ASN1_item_new(&OCSP_RESPDATA_it);
863}
864LCRYPTO_ALIAS(OCSP_RESPDATA_new);
865
866void
867OCSP_RESPDATA_free(OCSP_RESPDATA *a)
868{
869 ASN1_item_free((ASN1_VALUE *)a, &OCSP_RESPDATA_it);
870}
871LCRYPTO_ALIAS(OCSP_RESPDATA_free);
872
873static const ASN1_TEMPLATE OCSP_BASICRESP_seq_tt[] = {
874 {
875 .flags = 0,
876 .tag = 0,
877 .offset = offsetof(OCSP_BASICRESP, tbsResponseData),
878 .field_name = "tbsResponseData",
879 .item = &OCSP_RESPDATA_it,
880 },
881 {
882 .flags = 0,
883 .tag = 0,
884 .offset = offsetof(OCSP_BASICRESP, signatureAlgorithm),
885 .field_name = "signatureAlgorithm",
886 .item = &X509_ALGOR_it,
887 },
888 {
889 .flags = 0,
890 .tag = 0,
891 .offset = offsetof(OCSP_BASICRESP, signature),
892 .field_name = "signature",
893 .item = &ASN1_BIT_STRING_it,
894 },
895 {
896 .flags = ASN1_TFLG_EXPLICIT | ASN1_TFLG_SEQUENCE_OF | ASN1_TFLG_OPTIONAL,
897 .tag = 0,
898 .offset = offsetof(OCSP_BASICRESP, certs),
899 .field_name = "certs",
900 .item = &X509_it,
901 },
902};
903
904const ASN1_ITEM OCSP_BASICRESP_it = {
905 .itype = ASN1_ITYPE_SEQUENCE,
906 .utype = V_ASN1_SEQUENCE,
907 .templates = OCSP_BASICRESP_seq_tt,
908 .tcount = sizeof(OCSP_BASICRESP_seq_tt) / sizeof(ASN1_TEMPLATE),
909 .funcs = NULL,
910 .size = sizeof(OCSP_BASICRESP),
911 .sname = "OCSP_BASICRESP",
912};
913LCRYPTO_ALIAS(OCSP_BASICRESP_it);
914
915
916OCSP_BASICRESP *
917d2i_OCSP_BASICRESP(OCSP_BASICRESP **a, const unsigned char **in, long len)
918{
919 return (OCSP_BASICRESP *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,
920 &OCSP_BASICRESP_it);
921}
922LCRYPTO_ALIAS(d2i_OCSP_BASICRESP);
923
924int
925i2d_OCSP_BASICRESP(OCSP_BASICRESP *a, unsigned char **out)
926{
927 return ASN1_item_i2d((ASN1_VALUE *)a, out, &OCSP_BASICRESP_it);
928}
929LCRYPTO_ALIAS(i2d_OCSP_BASICRESP);
930
931OCSP_BASICRESP *
932OCSP_BASICRESP_new(void)
933{
934 return (OCSP_BASICRESP *)ASN1_item_new(&OCSP_BASICRESP_it);
935}
936LCRYPTO_ALIAS(OCSP_BASICRESP_new);
937
938void
939OCSP_BASICRESP_free(OCSP_BASICRESP *a)
940{
941 ASN1_item_free((ASN1_VALUE *)a, &OCSP_BASICRESP_it);
942}
943LCRYPTO_ALIAS(OCSP_BASICRESP_free);
944
945static const ASN1_TEMPLATE OCSP_CRLID_seq_tt[] = {
946 {
947 .flags = ASN1_TFLG_EXPLICIT | ASN1_TFLG_OPTIONAL,
948 .tag = 0,
949 .offset = offsetof(OCSP_CRLID, crlUrl),
950 .field_name = "crlUrl",
951 .item = &ASN1_IA5STRING_it,
952 },
953 {
954 .flags = ASN1_TFLG_EXPLICIT | ASN1_TFLG_OPTIONAL,
955 .tag = 1,
956 .offset = offsetof(OCSP_CRLID, crlNum),
957 .field_name = "crlNum",
958 .item = &ASN1_INTEGER_it,
959 },
960 {
961 .flags = ASN1_TFLG_EXPLICIT | ASN1_TFLG_OPTIONAL,
962 .tag = 2,
963 .offset = offsetof(OCSP_CRLID, crlTime),
964 .field_name = "crlTime",
965 .item = &ASN1_GENERALIZEDTIME_it,
966 },
967};
968
969const ASN1_ITEM OCSP_CRLID_it = {
970 .itype = ASN1_ITYPE_SEQUENCE,
971 .utype = V_ASN1_SEQUENCE,
972 .templates = OCSP_CRLID_seq_tt,
973 .tcount = sizeof(OCSP_CRLID_seq_tt) / sizeof(ASN1_TEMPLATE),
974 .funcs = NULL,
975 .size = sizeof(OCSP_CRLID),
976 .sname = "OCSP_CRLID",
977};
978LCRYPTO_ALIAS(OCSP_CRLID_it);
979
980
981OCSP_CRLID *
982d2i_OCSP_CRLID(OCSP_CRLID **a, const unsigned char **in, long len)
983{
984 return (OCSP_CRLID *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,
985 &OCSP_CRLID_it);
986}
987LCRYPTO_ALIAS(d2i_OCSP_CRLID);
988
989int
990i2d_OCSP_CRLID(OCSP_CRLID *a, unsigned char **out)
991{
992 return ASN1_item_i2d((ASN1_VALUE *)a, out, &OCSP_CRLID_it);
993}
994LCRYPTO_ALIAS(i2d_OCSP_CRLID);
995
996OCSP_CRLID *
997OCSP_CRLID_new(void)
998{
999 return (OCSP_CRLID *)ASN1_item_new(&OCSP_CRLID_it);
1000}
1001LCRYPTO_ALIAS(OCSP_CRLID_new);
1002
1003void
1004OCSP_CRLID_free(OCSP_CRLID *a)
1005{
1006 ASN1_item_free((ASN1_VALUE *)a, &OCSP_CRLID_it);
1007}
1008LCRYPTO_ALIAS(OCSP_CRLID_free);
1009
1010static const ASN1_TEMPLATE OCSP_SERVICELOC_seq_tt[] = {
1011 {
1012 .flags = 0,
1013 .tag = 0,
1014 .offset = offsetof(OCSP_SERVICELOC, issuer),
1015 .field_name = "issuer",
1016 .item = &X509_NAME_it,
1017 },
1018 {
1019 .flags = ASN1_TFLG_SEQUENCE_OF | ASN1_TFLG_OPTIONAL,
1020 .tag = 0,
1021 .offset = offsetof(OCSP_SERVICELOC, locator),
1022 .field_name = "locator",
1023 .item = &ACCESS_DESCRIPTION_it,
1024 },
1025};
1026
1027const ASN1_ITEM OCSP_SERVICELOC_it = {
1028 .itype = ASN1_ITYPE_SEQUENCE,
1029 .utype = V_ASN1_SEQUENCE,
1030 .templates = OCSP_SERVICELOC_seq_tt,
1031 .tcount = sizeof(OCSP_SERVICELOC_seq_tt) / sizeof(ASN1_TEMPLATE),
1032 .funcs = NULL,
1033 .size = sizeof(OCSP_SERVICELOC),
1034 .sname = "OCSP_SERVICELOC",
1035};
1036LCRYPTO_ALIAS(OCSP_SERVICELOC_it);
1037
1038
1039OCSP_SERVICELOC *
1040d2i_OCSP_SERVICELOC(OCSP_SERVICELOC **a, const unsigned char **in, long len)
1041{
1042 return (OCSP_SERVICELOC *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,
1043 &OCSP_SERVICELOC_it);
1044}
1045LCRYPTO_ALIAS(d2i_OCSP_SERVICELOC);
1046
1047int
1048i2d_OCSP_SERVICELOC(OCSP_SERVICELOC *a, unsigned char **out)
1049{
1050 return ASN1_item_i2d((ASN1_VALUE *)a, out, &OCSP_SERVICELOC_it);
1051}
1052LCRYPTO_ALIAS(i2d_OCSP_SERVICELOC);
1053
1054OCSP_SERVICELOC *
1055OCSP_SERVICELOC_new(void)
1056{
1057 return (OCSP_SERVICELOC *)ASN1_item_new(&OCSP_SERVICELOC_it);
1058}
1059LCRYPTO_ALIAS(OCSP_SERVICELOC_new);
1060
1061void
1062OCSP_SERVICELOC_free(OCSP_SERVICELOC *a)
1063{
1064 ASN1_item_free((ASN1_VALUE *)a, &OCSP_SERVICELOC_it);
1065}
1066LCRYPTO_ALIAS(OCSP_SERVICELOC_free);
generated by cgit v1.2.3-55-g6feb (git 2.39.1) at 2025-05-06 16:34:50 +0000