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