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 64 static 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 88 const 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 }; 97 LCRYPTO_ALIAS(OCSP_SIGNATURE_it); 98 99 100 OCSP_SIGNATURE * 101 d2i_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 } 106 LCRYPTO_ALIAS(d2i_OCSP_SIGNATURE); 107 108 int 109 i2d_OCSP_SIGNATURE(OCSP_SIGNATURE *a, unsigned char **out) 110 { 111 return ASN1_item_i2d((ASN1_VALUE *)a, out, &OCSP_SIGNATURE_it); 112 } 113 LCRYPTO_ALIAS(i2d_OCSP_SIGNATURE); 114 115 OCSP_SIGNATURE * 116 OCSP_SIGNATURE_new(void) 117 { 118 return (OCSP_SIGNATURE *)ASN1_item_new(&OCSP_SIGNATURE_it); 119 } 120 LCRYPTO_ALIAS(OCSP_SIGNATURE_new); 121 122 void 123 OCSP_SIGNATURE_free(OCSP_SIGNATURE *a) 124 { 125 ASN1_item_free((ASN1_VALUE *)a, &OCSP_SIGNATURE_it); 126 } 127 LCRYPTO_ALIAS(OCSP_SIGNATURE_free); 128 129 static 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 160 const 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 }; 169 LCRYPTO_ALIAS(OCSP_CERTID_it); 170 171 172 OCSP_CERTID * 173 d2i_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 } 178 LCRYPTO_ALIAS(d2i_OCSP_CERTID); 179 180 int 181 i2d_OCSP_CERTID(OCSP_CERTID *a, unsigned char **out) 182 { 183 return ASN1_item_i2d((ASN1_VALUE *)a, out, &OCSP_CERTID_it); 184 } 185 LCRYPTO_ALIAS(i2d_OCSP_CERTID); 186 187 OCSP_CERTID * 188 OCSP_CERTID_new(void) 189 { 190 return (OCSP_CERTID *)ASN1_item_new(&OCSP_CERTID_it); 191 } 192 LCRYPTO_ALIAS(OCSP_CERTID_new); 193 194 void 195 OCSP_CERTID_free(OCSP_CERTID *a) 196 { 197 ASN1_item_free((ASN1_VALUE *)a, &OCSP_CERTID_it); 198 } 199 LCRYPTO_ALIAS(OCSP_CERTID_free); 200 201 static 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 218 const 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 }; 227 LCRYPTO_ALIAS(OCSP_ONEREQ_it); 228 229 230 OCSP_ONEREQ * 231 d2i_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 } 236 LCRYPTO_ALIAS(d2i_OCSP_ONEREQ); 237 238 int 239 i2d_OCSP_ONEREQ(OCSP_ONEREQ *a, unsigned char **out) 240 { 241 return ASN1_item_i2d((ASN1_VALUE *)a, out, &OCSP_ONEREQ_it); 242 } 243 LCRYPTO_ALIAS(i2d_OCSP_ONEREQ); 244 245 OCSP_ONEREQ * 246 OCSP_ONEREQ_new(void) 247 { 248 return (OCSP_ONEREQ *)ASN1_item_new(&OCSP_ONEREQ_it); 249 } 250 LCRYPTO_ALIAS(OCSP_ONEREQ_new); 251 252 void 253 OCSP_ONEREQ_free(OCSP_ONEREQ *a) 254 { 255 ASN1_item_free((ASN1_VALUE *)a, &OCSP_ONEREQ_it); 256 } 257 LCRYPTO_ALIAS(OCSP_ONEREQ_free); 258 259 static 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 290 const 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 }; 299 LCRYPTO_ALIAS(OCSP_REQINFO_it); 300 301 302 OCSP_REQINFO * 303 d2i_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 } 308 LCRYPTO_ALIAS(d2i_OCSP_REQINFO); 309 310 int 311 i2d_OCSP_REQINFO(OCSP_REQINFO *a, unsigned char **out) 312 { 313 return ASN1_item_i2d((ASN1_VALUE *)a, out, &OCSP_REQINFO_it); 314 } 315 LCRYPTO_ALIAS(i2d_OCSP_REQINFO); 316 317 OCSP_REQINFO * 318 OCSP_REQINFO_new(void) 319 { 320 return (OCSP_REQINFO *)ASN1_item_new(&OCSP_REQINFO_it); 321 } 322 LCRYPTO_ALIAS(OCSP_REQINFO_new); 323 324 void 325 OCSP_REQINFO_free(OCSP_REQINFO *a) 326 { 327 ASN1_item_free((ASN1_VALUE *)a, &OCSP_REQINFO_it); 328 } 329 LCRYPTO_ALIAS(OCSP_REQINFO_free); 330 331 static 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 348 const 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 }; 357 LCRYPTO_ALIAS(OCSP_REQUEST_it); 358 359 OCSP_REQUEST * 360 d2i_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 } 365 LCRYPTO_ALIAS(d2i_OCSP_REQUEST); 366 367 int 368 i2d_OCSP_REQUEST(OCSP_REQUEST *a, unsigned char **out) 369 { 370 return ASN1_item_i2d((ASN1_VALUE *)a, out, &OCSP_REQUEST_it); 371 } 372 LCRYPTO_ALIAS(i2d_OCSP_REQUEST); 373 374 OCSP_REQUEST * 375 d2i_OCSP_REQUEST_bio(BIO *bp, OCSP_REQUEST **a) 376 { 377 return ASN1_item_d2i_bio(&OCSP_REQUEST_it, bp, a); 378 } 379 LCRYPTO_ALIAS(d2i_OCSP_REQUEST_bio); 380 381 int 382 i2d_OCSP_REQUEST_bio(BIO *bp, OCSP_REQUEST *a) 383 { 384 return ASN1_item_i2d_bio(&OCSP_REQUEST_it, bp, a); 385 } 386 LCRYPTO_ALIAS(i2d_OCSP_REQUEST_bio); 387 388 OCSP_REQUEST * 389 OCSP_REQUEST_new(void) 390 { 391 return (OCSP_REQUEST *)ASN1_item_new(&OCSP_REQUEST_it); 392 } 393 LCRYPTO_ALIAS(OCSP_REQUEST_new); 394 395 void 396 OCSP_REQUEST_free(OCSP_REQUEST *a) 397 { 398 ASN1_item_free((ASN1_VALUE *)a, &OCSP_REQUEST_it); 399 } 400 LCRYPTO_ALIAS(OCSP_REQUEST_free); 401 402 /* OCSP_RESPONSE templates */ 403 404 static 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 421 const 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 }; 430 LCRYPTO_ALIAS(OCSP_RESPBYTES_it); 431 432 433 OCSP_RESPBYTES * 434 d2i_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 } 439 LCRYPTO_ALIAS(d2i_OCSP_RESPBYTES); 440 441 int 442 i2d_OCSP_RESPBYTES(OCSP_RESPBYTES *a, unsigned char **out) 443 { 444 return ASN1_item_i2d((ASN1_VALUE *)a, out, &OCSP_RESPBYTES_it); 445 } 446 LCRYPTO_ALIAS(i2d_OCSP_RESPBYTES); 447 448 OCSP_RESPBYTES * 449 OCSP_RESPBYTES_new(void) 450 { 451 return (OCSP_RESPBYTES *)ASN1_item_new(&OCSP_RESPBYTES_it); 452 } 453 LCRYPTO_ALIAS(OCSP_RESPBYTES_new); 454 455 void 456 OCSP_RESPBYTES_free(OCSP_RESPBYTES *a) 457 { 458 ASN1_item_free((ASN1_VALUE *)a, &OCSP_RESPBYTES_it); 459 } 460 LCRYPTO_ALIAS(OCSP_RESPBYTES_free); 461 462 static 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 479 const 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 }; 488 LCRYPTO_ALIAS(OCSP_RESPONSE_it); 489 490 491 OCSP_RESPONSE * 492 d2i_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 } 497 LCRYPTO_ALIAS(d2i_OCSP_RESPONSE); 498 499 int 500 i2d_OCSP_RESPONSE(OCSP_RESPONSE *a, unsigned char **out) 501 { 502 return ASN1_item_i2d((ASN1_VALUE *)a, out, &OCSP_RESPONSE_it); 503 } 504 LCRYPTO_ALIAS(i2d_OCSP_RESPONSE); 505 506 OCSP_RESPONSE * 507 d2i_OCSP_RESPONSE_bio(BIO *bp, OCSP_RESPONSE **a) 508 { 509 return ASN1_item_d2i_bio(&OCSP_RESPONSE_it, bp, a); 510 } 511 LCRYPTO_ALIAS(d2i_OCSP_RESPONSE_bio); 512 513 int 514 i2d_OCSP_RESPONSE_bio(BIO *bp, OCSP_RESPONSE *a) 515 { 516 return ASN1_item_i2d_bio(&OCSP_RESPONSE_it, bp, a); 517 } 518 LCRYPTO_ALIAS(i2d_OCSP_RESPONSE_bio); 519 520 OCSP_RESPONSE * 521 OCSP_RESPONSE_new(void) 522 { 523 return (OCSP_RESPONSE *)ASN1_item_new(&OCSP_RESPONSE_it); 524 } 525 LCRYPTO_ALIAS(OCSP_RESPONSE_new); 526 527 void 528 OCSP_RESPONSE_free(OCSP_RESPONSE *a) 529 { 530 ASN1_item_free((ASN1_VALUE *)a, &OCSP_RESPONSE_it); 531 } 532 LCRYPTO_ALIAS(OCSP_RESPONSE_free); 533 534 static 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 551 const 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 }; 560 LCRYPTO_ALIAS(OCSP_RESPID_it); 561 562 563 OCSP_RESPID * 564 d2i_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 } 569 LCRYPTO_ALIAS(d2i_OCSP_RESPID); 570 571 int 572 i2d_OCSP_RESPID(OCSP_RESPID *a, unsigned char **out) 573 { 574 return ASN1_item_i2d((ASN1_VALUE *)a, out, &OCSP_RESPID_it); 575 } 576 LCRYPTO_ALIAS(i2d_OCSP_RESPID); 577 578 OCSP_RESPID * 579 OCSP_RESPID_new(void) 580 { 581 return (OCSP_RESPID *)ASN1_item_new(&OCSP_RESPID_it); 582 } 583 LCRYPTO_ALIAS(OCSP_RESPID_new); 584 585 void 586 OCSP_RESPID_free(OCSP_RESPID *a) 587 { 588 ASN1_item_free((ASN1_VALUE *)a, &OCSP_RESPID_it); 589 } 590 LCRYPTO_ALIAS(OCSP_RESPID_free); 591 592 static 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 609 const 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 }; 618 LCRYPTO_ALIAS(OCSP_REVOKEDINFO_it); 619 620 621 OCSP_REVOKEDINFO * 622 d2i_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 } 627 LCRYPTO_ALIAS(d2i_OCSP_REVOKEDINFO); 628 629 int 630 i2d_OCSP_REVOKEDINFO(OCSP_REVOKEDINFO *a, unsigned char **out) 631 { 632 return ASN1_item_i2d((ASN1_VALUE *)a, out, &OCSP_REVOKEDINFO_it); 633 } 634 LCRYPTO_ALIAS(i2d_OCSP_REVOKEDINFO); 635 636 OCSP_REVOKEDINFO * 637 OCSP_REVOKEDINFO_new(void) 638 { 639 return (OCSP_REVOKEDINFO *)ASN1_item_new(&OCSP_REVOKEDINFO_it); 640 } 641 LCRYPTO_ALIAS(OCSP_REVOKEDINFO_new); 642 643 void 644 OCSP_REVOKEDINFO_free(OCSP_REVOKEDINFO *a) 645 { 646 ASN1_item_free((ASN1_VALUE *)a, &OCSP_REVOKEDINFO_it); 647 } 648 LCRYPTO_ALIAS(OCSP_REVOKEDINFO_free); 649 650 static 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 674 const 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 }; 683 LCRYPTO_ALIAS(OCSP_CERTSTATUS_it); 684 685 686 OCSP_CERTSTATUS * 687 d2i_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 } 692 LCRYPTO_ALIAS(d2i_OCSP_CERTSTATUS); 693 694 int 695 i2d_OCSP_CERTSTATUS(OCSP_CERTSTATUS *a, unsigned char **out) 696 { 697 return ASN1_item_i2d((ASN1_VALUE *)a, out, &OCSP_CERTSTATUS_it); 698 } 699 LCRYPTO_ALIAS(i2d_OCSP_CERTSTATUS); 700 701 OCSP_CERTSTATUS * 702 OCSP_CERTSTATUS_new(void) 703 { 704 return (OCSP_CERTSTATUS *)ASN1_item_new(&OCSP_CERTSTATUS_it); 705 } 706 LCRYPTO_ALIAS(OCSP_CERTSTATUS_new); 707 708 void 709 OCSP_CERTSTATUS_free(OCSP_CERTSTATUS *a) 710 { 711 ASN1_item_free((ASN1_VALUE *)a, &OCSP_CERTSTATUS_it); 712 } 713 LCRYPTO_ALIAS(OCSP_CERTSTATUS_free); 714 715 static 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 753 const 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 }; 762 LCRYPTO_ALIAS(OCSP_SINGLERESP_it); 763 764 765 OCSP_SINGLERESP * 766 d2i_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 } 771 LCRYPTO_ALIAS(d2i_OCSP_SINGLERESP); 772 773 int 774 i2d_OCSP_SINGLERESP(OCSP_SINGLERESP *a, unsigned char **out) 775 { 776 return ASN1_item_i2d((ASN1_VALUE *)a, out, &OCSP_SINGLERESP_it); 777 } 778 LCRYPTO_ALIAS(i2d_OCSP_SINGLERESP); 779 780 OCSP_SINGLERESP * 781 OCSP_SINGLERESP_new(void) 782 { 783 return (OCSP_SINGLERESP *)ASN1_item_new(&OCSP_SINGLERESP_it); 784 } 785 LCRYPTO_ALIAS(OCSP_SINGLERESP_new); 786 787 void 788 OCSP_SINGLERESP_free(OCSP_SINGLERESP *a) 789 { 790 ASN1_item_free((ASN1_VALUE *)a, &OCSP_SINGLERESP_it); 791 } 792 LCRYPTO_ALIAS(OCSP_SINGLERESP_free); 793 794 static 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 832 const 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 }; 841 LCRYPTO_ALIAS(OCSP_RESPDATA_it); 842 843 844 OCSP_RESPDATA * 845 d2i_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 } 850 LCRYPTO_ALIAS(d2i_OCSP_RESPDATA); 851 852 int 853 i2d_OCSP_RESPDATA(OCSP_RESPDATA *a, unsigned char **out) 854 { 855 return ASN1_item_i2d((ASN1_VALUE *)a, out, &OCSP_RESPDATA_it); 856 } 857 LCRYPTO_ALIAS(i2d_OCSP_RESPDATA); 858 859 OCSP_RESPDATA * 860 OCSP_RESPDATA_new(void) 861 { 862 return (OCSP_RESPDATA *)ASN1_item_new(&OCSP_RESPDATA_it); 863 } 864 LCRYPTO_ALIAS(OCSP_RESPDATA_new); 865 866 void 867 OCSP_RESPDATA_free(OCSP_RESPDATA *a) 868 { 869 ASN1_item_free((ASN1_VALUE *)a, &OCSP_RESPDATA_it); 870 } 871 LCRYPTO_ALIAS(OCSP_RESPDATA_free); 872 873 static 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 904 const 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 }; 913 LCRYPTO_ALIAS(OCSP_BASICRESP_it); 914 915 916 OCSP_BASICRESP * 917 d2i_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 } 922 LCRYPTO_ALIAS(d2i_OCSP_BASICRESP); 923 924 int 925 i2d_OCSP_BASICRESP(OCSP_BASICRESP *a, unsigned char **out) 926 { 927 return ASN1_item_i2d((ASN1_VALUE *)a, out, &OCSP_BASICRESP_it); 928 } 929 LCRYPTO_ALIAS(i2d_OCSP_BASICRESP); 930 931 OCSP_BASICRESP * 932 OCSP_BASICRESP_new(void) 933 { 934 return (OCSP_BASICRESP *)ASN1_item_new(&OCSP_BASICRESP_it); 935 } 936 LCRYPTO_ALIAS(OCSP_BASICRESP_new); 937 938 void 939 OCSP_BASICRESP_free(OCSP_BASICRESP *a) 940 { 941 ASN1_item_free((ASN1_VALUE *)a, &OCSP_BASICRESP_it); 942 } 943 LCRYPTO_ALIAS(OCSP_BASICRESP_free); 944 945 static 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 969 const 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 }; 978 LCRYPTO_ALIAS(OCSP_CRLID_it); 979 980 981 OCSP_CRLID * 982 d2i_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 } 987 LCRYPTO_ALIAS(d2i_OCSP_CRLID); 988 989 int 990 i2d_OCSP_CRLID(OCSP_CRLID *a, unsigned char **out) 991 { 992 return ASN1_item_i2d((ASN1_VALUE *)a, out, &OCSP_CRLID_it); 993 } 994 LCRYPTO_ALIAS(i2d_OCSP_CRLID); 995 996 OCSP_CRLID * 997 OCSP_CRLID_new(void) 998 { 999 return (OCSP_CRLID *)ASN1_item_new(&OCSP_CRLID_it); 1000 } 1001 LCRYPTO_ALIAS(OCSP_CRLID_new); 1002 1003 void 1004 OCSP_CRLID_free(OCSP_CRLID *a) 1005 { 1006 ASN1_item_free((ASN1_VALUE *)a, &OCSP_CRLID_it); 1007 } 1008 LCRYPTO_ALIAS(OCSP_CRLID_free); 1009 1010 static 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 1027 const 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 }; 1036 LCRYPTO_ALIAS(OCSP_SERVICELOC_it); 1037 1038 1039 OCSP_SERVICELOC * 1040 d2i_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 } 1045 LCRYPTO_ALIAS(d2i_OCSP_SERVICELOC); 1046 1047 int 1048 i2d_OCSP_SERVICELOC(OCSP_SERVICELOC *a, unsigned char **out) 1049 { 1050 return ASN1_item_i2d((ASN1_VALUE *)a, out, &OCSP_SERVICELOC_it); 1051 } 1052 LCRYPTO_ALIAS(i2d_OCSP_SERVICELOC); 1053 1054 OCSP_SERVICELOC * 1055 OCSP_SERVICELOC_new(void) 1056 { 1057 return (OCSP_SERVICELOC *)ASN1_item_new(&OCSP_SERVICELOC_it); 1058 } 1059 LCRYPTO_ALIAS(OCSP_SERVICELOC_new); 1060 1061 void 1062 OCSP_SERVICELOC_free(OCSP_SERVICELOC *a) 1063 { 1064 ASN1_item_free((ASN1_VALUE *)a, &OCSP_SERVICELOC_it); 1065 } 1066 LCRYPTO_ALIAS(OCSP_SERVICELOC_free); 1067