lib/libcrypto/ocsp/ocsp_asn.c

   1 /* $OpenBSD: ocsp_asn.c,v 1.9 2016/11/04 18:35:30 jsing Exp $ */
   2 /* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL
   3  * project 2000.
   4  */
   5 /* ====================================================================
   6  * Copyright (c) 2000 The OpenSSL Project.  All rights reserved.
   7  *
   8  * Redistribution and use in source and binary forms, with or without
   9  * modification, are permitted provided that the following conditions
  10  * are met:
  11  *
  12  * 1. Redistributions of source code must retain the above copyright
  13  *    notice, this list of conditions and the following disclaimer.
  14  *
  15  * 2. Redistributions in binary form must reproduce the above copyright
  16  *    notice, this list of conditions and the following disclaimer in
  17  *    the documentation and/or other materials provided with the
  18  *    distribution.
  19  *
  20  * 3. All advertising materials mentioning features or use of this
  21  *    software must display the following acknowledgment:
  22  *    "This product includes software developed by the OpenSSL Project
  23  *    for use in the OpenSSL Toolkit. (http://www.OpenSSL.org/)"
  24  *
  25  * 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to
  26  *    endorse or promote products derived from this software without
  27  *    prior written permission. For written permission, please contact
  28  *    licensing@OpenSSL.org.
  29  *
  30  * 5. Products derived from this software may not be called "OpenSSL"
  31  *    nor may "OpenSSL" appear in their names without prior written
  32  *    permission of the OpenSSL Project.
  33  *
  34  * 6. Redistributions of any form whatsoever must retain the following
  35  *    acknowledgment:
  36  *    "This product includes software developed by the OpenSSL Project
  37  *    for use in the OpenSSL Toolkit (http://www.OpenSSL.org/)"
  38  *
  39  * THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY
  40  * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  41  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  42  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE OpenSSL PROJECT OR
  43  * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  44  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  45  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  46  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  47  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
  48  * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  49  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
  50  * OF THE POSSIBILITY OF SUCH DAMAGE.
  51  * ====================================================================
  52  *
  53  * This product includes cryptographic software written by Eric Young
  54  * (eay@cryptsoft.com).  This product includes software written by Tim
  55  * Hudson (tjh@cryptsoft.com).
  56  *
  57  */
  58 #include <openssl/asn1.h>
  59 #include <openssl/asn1t.h>
  60 #include <openssl/ocsp.h>
  61
  62 static const ASN1_TEMPLATE OCSP_SIGNATURE_seq_tt[] = {
  63         {
  64                 .flags = 0,
  65                 .tag = 0,
  66                 .offset = offsetof(OCSP_SIGNATURE, signatureAlgorithm),
  67                 .field_name = "signatureAlgorithm",
  68                 .item = &X509_ALGOR_it,
  69         },
  70         {
  71                 .flags = 0,
  72                 .tag = 0,
  73                 .offset = offsetof(OCSP_SIGNATURE, signature),
  74                 .field_name = "signature",
  75                 .item = &ASN1_BIT_STRING_it,
  76         },
  77         {
  78                 .flags = ASN1_TFLG_EXPLICIT | ASN1_TFLG_SEQUENCE_OF | ASN1_TFLG_OPTIONAL,
  79                 .tag = 0,
  80                 .offset = offsetof(OCSP_SIGNATURE, certs),
  81                 .field_name = "certs",
  82                 .item = &X509_it,
  83         },
  84 };
  85
  86 const ASN1_ITEM OCSP_SIGNATURE_it = {
  87         .itype = ASN1_ITYPE_SEQUENCE,
  88         .utype = V_ASN1_SEQUENCE,
  89         .templates = OCSP_SIGNATURE_seq_tt,
  90         .tcount = sizeof(OCSP_SIGNATURE_seq_tt) / sizeof(ASN1_TEMPLATE),
  91         .funcs = NULL,
  92         .size = sizeof(OCSP_SIGNATURE),
  93         .sname = "OCSP_SIGNATURE",
  94 };
  95
  96
  97 OCSP_SIGNATURE *
  98 d2i_OCSP_SIGNATURE(OCSP_SIGNATURE **a, const unsigned char **in, long len)
  99 {
 100         return (OCSP_SIGNATURE *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,
 101             &OCSP_SIGNATURE_it);
 102 }
 103
 104 int
 105 i2d_OCSP_SIGNATURE(OCSP_SIGNATURE *a, unsigned char **out)
 106 {
 107         return ASN1_item_i2d((ASN1_VALUE *)a, out, &OCSP_SIGNATURE_it);
 108 }
 109
 110 OCSP_SIGNATURE *
 111 OCSP_SIGNATURE_new(void)
 112 {
 113         return (OCSP_SIGNATURE *)ASN1_item_new(&OCSP_SIGNATURE_it);
 114 }
 115
 116 void
 117 OCSP_SIGNATURE_free(OCSP_SIGNATURE *a)
 118 {
 119         ASN1_item_free((ASN1_VALUE *)a, &OCSP_SIGNATURE_it);
 120 }
 121
 122 static const ASN1_TEMPLATE OCSP_CERTID_seq_tt[] = {
 123         {
 124                 .flags = 0,
 125                 .tag = 0,
 126                 .offset = offsetof(OCSP_CERTID, hashAlgorithm),
 127                 .field_name = "hashAlgorithm",
 128                 .item = &X509_ALGOR_it,
 129         },
 130         {
 131                 .flags = 0,
 132                 .tag = 0,
 133                 .offset = offsetof(OCSP_CERTID, issuerNameHash),
 134                 .field_name = "issuerNameHash",
 135                 .item = &ASN1_OCTET_STRING_it,
 136         },
 137         {
 138                 .flags = 0,
 139                 .tag = 0,
 140                 .offset = offsetof(OCSP_CERTID, issuerKeyHash),
 141                 .field_name = "issuerKeyHash",
 142                 .item = &ASN1_OCTET_STRING_it,
 143         },
 144         {
 145                 .flags = 0,
 146                 .tag = 0,
 147                 .offset = offsetof(OCSP_CERTID, serialNumber),
 148                 .field_name = "serialNumber",
 149                 .item = &ASN1_INTEGER_it,
 150         },
 151 };
 152
 153 const ASN1_ITEM OCSP_CERTID_it = {
 154         .itype = ASN1_ITYPE_SEQUENCE,
 155         .utype = V_ASN1_SEQUENCE,
 156         .templates = OCSP_CERTID_seq_tt,
 157         .tcount = sizeof(OCSP_CERTID_seq_tt) / sizeof(ASN1_TEMPLATE),
 158         .funcs = NULL,
 159         .size = sizeof(OCSP_CERTID),
 160         .sname = "OCSP_CERTID",
 161 };
 162
 163
 164 OCSP_CERTID *
 165 d2i_OCSP_CERTID(OCSP_CERTID **a, const unsigned char **in, long len)
 166 {
 167         return (OCSP_CERTID *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,
 168             &OCSP_CERTID_it);
 169 }
 170
 171 int
 172 i2d_OCSP_CERTID(OCSP_CERTID *a, unsigned char **out)
 173 {
 174         return ASN1_item_i2d((ASN1_VALUE *)a, out, &OCSP_CERTID_it);
 175 }
 176
 177 OCSP_CERTID *
 178 OCSP_CERTID_new(void)
 179 {
 180         return (OCSP_CERTID *)ASN1_item_new(&OCSP_CERTID_it);
 181 }
 182
 183 void
 184 OCSP_CERTID_free(OCSP_CERTID *a)
 185 {
 186         ASN1_item_free((ASN1_VALUE *)a, &OCSP_CERTID_it);
 187 }
 188
 189 static const ASN1_TEMPLATE OCSP_ONEREQ_seq_tt[] = {
 190         {
 191                 .flags = 0,
 192                 .tag = 0,
 193                 .offset = offsetof(OCSP_ONEREQ, reqCert),
 194                 .field_name = "reqCert",
 195                 .item = &OCSP_CERTID_it,
 196         },
 197         {
 198                 .flags = ASN1_TFLG_EXPLICIT | ASN1_TFLG_SEQUENCE_OF | ASN1_TFLG_OPTIONAL,
 199                 .tag = 0,
 200                 .offset = offsetof(OCSP_ONEREQ, singleRequestExtensions),
 201                 .field_name = "singleRequestExtensions",
 202                 .item = &X509_EXTENSION_it,
 203         },
 204 };
 205
 206 const ASN1_ITEM OCSP_ONEREQ_it = {
 207         .itype = ASN1_ITYPE_SEQUENCE,
 208         .utype = V_ASN1_SEQUENCE,
 209         .templates = OCSP_ONEREQ_seq_tt,
 210         .tcount = sizeof(OCSP_ONEREQ_seq_tt) / sizeof(ASN1_TEMPLATE),
 211         .funcs = NULL,
 212         .size = sizeof(OCSP_ONEREQ),
 213         .sname = "OCSP_ONEREQ",
 214 };
 215
 216
 217 OCSP_ONEREQ *
 218 d2i_OCSP_ONEREQ(OCSP_ONEREQ **a, const unsigned char **in, long len)
 219 {
 220         return (OCSP_ONEREQ *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,
 221             &OCSP_ONEREQ_it);
 222 }
 223
 224 int
 225 i2d_OCSP_ONEREQ(OCSP_ONEREQ *a, unsigned char **out)
 226 {
 227         return ASN1_item_i2d((ASN1_VALUE *)a, out, &OCSP_ONEREQ_it);
 228 }
 229
 230 OCSP_ONEREQ *
 231 OCSP_ONEREQ_new(void)
 232 {
 233         return (OCSP_ONEREQ *)ASN1_item_new(&OCSP_ONEREQ_it);
 234 }
 235
 236 void
 237 OCSP_ONEREQ_free(OCSP_ONEREQ *a)
 238 {
 239         ASN1_item_free((ASN1_VALUE *)a, &OCSP_ONEREQ_it);
 240 }
 241
 242 static const ASN1_TEMPLATE OCSP_REQINFO_seq_tt[] = {
 243         {
 244                 .flags = ASN1_TFLG_EXPLICIT | ASN1_TFLG_OPTIONAL,
 245                 .tag = 0,
 246                 .offset = offsetof(OCSP_REQINFO, version),
 247                 .field_name = "version",
 248                 .item = &ASN1_INTEGER_it,
 249         },
 250         {
 251                 .flags = ASN1_TFLG_EXPLICIT | ASN1_TFLG_OPTIONAL,
 252                 .tag = 1,
 253                 .offset = offsetof(OCSP_REQINFO, requestorName),
 254                 .field_name = "requestorName",
 255                 .item = &GENERAL_NAME_it,
 256         },
 257         {
 258                 .flags = ASN1_TFLG_SEQUENCE_OF,
 259                 .tag = 0,
 260                 .offset = offsetof(OCSP_REQINFO, requestList),
 261                 .field_name = "requestList",
 262                 .item = &OCSP_ONEREQ_it,
 263         },
 264         {
 265                 .flags = ASN1_TFLG_EXPLICIT | ASN1_TFLG_SEQUENCE_OF | ASN1_TFLG_OPTIONAL,
 266                 .tag = 2,
 267                 .offset = offsetof(OCSP_REQINFO, requestExtensions),
 268                 .field_name = "requestExtensions",
 269                 .item = &X509_EXTENSION_it,
 270         },
 271 };
 272
 273 const ASN1_ITEM OCSP_REQINFO_it = {
 274         .itype = ASN1_ITYPE_SEQUENCE,
 275         .utype = V_ASN1_SEQUENCE,
 276         .templates = OCSP_REQINFO_seq_tt,
 277         .tcount = sizeof(OCSP_REQINFO_seq_tt) / sizeof(ASN1_TEMPLATE),
 278         .funcs = NULL,
 279         .size = sizeof(OCSP_REQINFO),
 280         .sname = "OCSP_REQINFO",
 281 };
 282
 283
 284 OCSP_REQINFO *
 285 d2i_OCSP_REQINFO(OCSP_REQINFO **a, const unsigned char **in, long len)
 286 {
 287         return (OCSP_REQINFO *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,
 288             &OCSP_REQINFO_it);
 289 }
 290
 291 int
 292 i2d_OCSP_REQINFO(OCSP_REQINFO *a, unsigned char **out)
 293 {
 294         return ASN1_item_i2d((ASN1_VALUE *)a, out, &OCSP_REQINFO_it);
 295 }
 296
 297 OCSP_REQINFO *
 298 OCSP_REQINFO_new(void)
 299 {
 300         return (OCSP_REQINFO *)ASN1_item_new(&OCSP_REQINFO_it);
 301 }
 302
 303 void
 304 OCSP_REQINFO_free(OCSP_REQINFO *a)
 305 {
 306         ASN1_item_free((ASN1_VALUE *)a, &OCSP_REQINFO_it);
 307 }
 308
 309 static const ASN1_TEMPLATE OCSP_REQUEST_seq_tt[] = {
 310         {
 311                 .flags = 0,
 312                 .tag = 0,
 313                 .offset = offsetof(OCSP_REQUEST, tbsRequest),
 314                 .field_name = "tbsRequest",
 315                 .item = &OCSP_REQINFO_it,
 316         },
 317         {
 318                 .flags = ASN1_TFLG_EXPLICIT | ASN1_TFLG_OPTIONAL,
 319                 .tag = 0,
 320                 .offset = offsetof(OCSP_REQUEST, optionalSignature),
 321                 .field_name = "optionalSignature",
 322                 .item = &OCSP_SIGNATURE_it,
 323         },
 324 };
 325
 326 const ASN1_ITEM OCSP_REQUEST_it = {
 327         .itype = ASN1_ITYPE_SEQUENCE,
 328         .utype = V_ASN1_SEQUENCE,
 329         .templates = OCSP_REQUEST_seq_tt,
 330         .tcount = sizeof(OCSP_REQUEST_seq_tt) / sizeof(ASN1_TEMPLATE),
 331         .funcs = NULL,
 332         .size = sizeof(OCSP_REQUEST),
 333         .sname = "OCSP_REQUEST",
 334 };
 335
 336 OCSP_REQUEST *
 337 d2i_OCSP_REQUEST(OCSP_REQUEST **a, const unsigned char **in, long len)
 338 {
 339         return (OCSP_REQUEST *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,
 340             &OCSP_REQUEST_it);
 341 }
 342
 343 int
 344 i2d_OCSP_REQUEST(OCSP_REQUEST *a, unsigned char **out)
 345 {
 346         return ASN1_item_i2d((ASN1_VALUE *)a, out, &OCSP_REQUEST_it);
 347 }
 348
 349 OCSP_REQUEST *
 350 d2i_OCSP_REQUEST_bio(BIO *bp, OCSP_REQUEST **a)
 351 {
 352         return ASN1_item_d2i_bio(&OCSP_REQUEST_it, bp, a);
 353 }
 354
 355 int
 356 i2d_OCSP_REQUEST_bio(BIO *bp, OCSP_REQUEST *a)
 357 {
 358         return ASN1_item_i2d_bio(&OCSP_REQUEST_it, bp, a);
 359 }
 360
 361 OCSP_REQUEST *
 362 OCSP_REQUEST_new(void)
 363 {
 364         return (OCSP_REQUEST *)ASN1_item_new(&OCSP_REQUEST_it);
 365 }
 366
 367 void
 368 OCSP_REQUEST_free(OCSP_REQUEST *a)
 369 {
 370         ASN1_item_free((ASN1_VALUE *)a, &OCSP_REQUEST_it);
 371 }
 372
 373 /* OCSP_RESPONSE templates */
 374
 375 static const ASN1_TEMPLATE OCSP_RESPBYTES_seq_tt[] = {
 376         {
 377                 .flags = 0,
 378                 .tag = 0,
 379                 .offset = offsetof(OCSP_RESPBYTES, responseType),
 380                 .field_name = "responseType",
 381                 .item = &ASN1_OBJECT_it,
 382         },
 383         {
 384                 .flags = 0,
 385                 .tag = 0,
 386                 .offset = offsetof(OCSP_RESPBYTES, response),
 387                 .field_name = "response",
 388                 .item = &ASN1_OCTET_STRING_it,
 389         },
 390 };
 391
 392 const ASN1_ITEM OCSP_RESPBYTES_it = {
 393         .itype = ASN1_ITYPE_SEQUENCE,
 394         .utype = V_ASN1_SEQUENCE,
 395         .templates = OCSP_RESPBYTES_seq_tt,
 396         .tcount = sizeof(OCSP_RESPBYTES_seq_tt) / sizeof(ASN1_TEMPLATE),
 397         .funcs = NULL,
 398         .size = sizeof(OCSP_RESPBYTES),
 399         .sname = "OCSP_RESPBYTES",
 400 };
 401
 402
 403 OCSP_RESPBYTES *
 404 d2i_OCSP_RESPBYTES(OCSP_RESPBYTES **a, const unsigned char **in, long len)
 405 {
 406         return (OCSP_RESPBYTES *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,
 407             &OCSP_RESPBYTES_it);
 408 }
 409
 410 int
 411 i2d_OCSP_RESPBYTES(OCSP_RESPBYTES *a, unsigned char **out)
 412 {
 413         return ASN1_item_i2d((ASN1_VALUE *)a, out, &OCSP_RESPBYTES_it);
 414 }
 415
 416 OCSP_RESPBYTES *
 417 OCSP_RESPBYTES_new(void)
 418 {
 419         return (OCSP_RESPBYTES *)ASN1_item_new(&OCSP_RESPBYTES_it);
 420 }
 421
 422 void
 423 OCSP_RESPBYTES_free(OCSP_RESPBYTES *a)
 424 {
 425         ASN1_item_free((ASN1_VALUE *)a, &OCSP_RESPBYTES_it);
 426 }
 427
 428 static const ASN1_TEMPLATE OCSP_RESPONSE_seq_tt[] = {
 429         {
 430                 .flags = 0,
 431                 .tag = 0,
 432                 .offset = offsetof(OCSP_RESPONSE, responseStatus),
 433                 .field_name = "responseStatus",
 434                 .item = &ASN1_ENUMERATED_it,
 435         },
 436         {
 437                 .flags = ASN1_TFLG_EXPLICIT | ASN1_TFLG_OPTIONAL,
 438                 .tag = 0,
 439                 .offset = offsetof(OCSP_RESPONSE, responseBytes),
 440                 .field_name = "responseBytes",
 441                 .item = &OCSP_RESPBYTES_it,
 442         },
 443 };
 444
 445 const ASN1_ITEM OCSP_RESPONSE_it = {
 446         .itype = ASN1_ITYPE_SEQUENCE,
 447         .utype = V_ASN1_SEQUENCE,
 448         .templates = OCSP_RESPONSE_seq_tt,
 449         .tcount = sizeof(OCSP_RESPONSE_seq_tt) / sizeof(ASN1_TEMPLATE),
 450         .funcs = NULL,
 451         .size = sizeof(OCSP_RESPONSE),
 452         .sname = "OCSP_RESPONSE",
 453 };
 454
 455
 456 OCSP_RESPONSE *
 457 d2i_OCSP_RESPONSE(OCSP_RESPONSE **a, const unsigned char **in, long len)
 458 {
 459         return (OCSP_RESPONSE *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,
 460             &OCSP_RESPONSE_it);
 461 }
 462
 463 int
 464 i2d_OCSP_RESPONSE(OCSP_RESPONSE *a, unsigned char **out)
 465 {
 466         return ASN1_item_i2d((ASN1_VALUE *)a, out, &OCSP_RESPONSE_it);
 467 }
 468
 469 OCSP_RESPONSE *
 470 d2i_OCSP_RESPONSE_bio(BIO *bp, OCSP_RESPONSE **a)
 471 {
 472         return ASN1_item_d2i_bio(&OCSP_RESPONSE_it, bp, a);
 473 }
 474
 475 int
 476 i2d_OCSP_RESPONSE_bio(BIO *bp, OCSP_RESPONSE *a)
 477 {
 478         return ASN1_item_i2d_bio(&OCSP_RESPONSE_it, bp, a);
 479 }
 480
 481 OCSP_RESPONSE *
 482 OCSP_RESPONSE_new(void)
 483 {
 484         return (OCSP_RESPONSE *)ASN1_item_new(&OCSP_RESPONSE_it);
 485 }
 486
 487 void
 488 OCSP_RESPONSE_free(OCSP_RESPONSE *a)
 489 {
 490         ASN1_item_free((ASN1_VALUE *)a, &OCSP_RESPONSE_it);
 491 }
 492
 493 static const ASN1_TEMPLATE OCSP_RESPID_ch_tt[] = {
 494         {
 495                 .flags = ASN1_TFLG_EXPLICIT,
 496                 .tag = 1,
 497                 .offset = offsetof(OCSP_RESPID, value.byName),
 498                 .field_name = "value.byName",
 499                 .item = &X509_NAME_it,
 500         },
 501         {
 502                 .flags = ASN1_TFLG_EXPLICIT,
 503                 .tag = 2,
 504                 .offset = offsetof(OCSP_RESPID, value.byKey),
 505                 .field_name = "value.byKey",
 506                 .item = &ASN1_OCTET_STRING_it,
 507         },
 508 };
 509
 510 const ASN1_ITEM OCSP_RESPID_it = {
 511         .itype = ASN1_ITYPE_CHOICE,
 512         .utype = offsetof(OCSP_RESPID, type),
 513         .templates = OCSP_RESPID_ch_tt,
 514         .tcount = sizeof(OCSP_RESPID_ch_tt) / sizeof(ASN1_TEMPLATE),
 515         .funcs = NULL,
 516         .size = sizeof(OCSP_RESPID),
 517         .sname = "OCSP_RESPID",
 518 };
 519
 520
 521 OCSP_RESPID *
 522 d2i_OCSP_RESPID(OCSP_RESPID **a, const unsigned char **in, long len)
 523 {
 524         return (OCSP_RESPID *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,
 525             &OCSP_RESPID_it);
 526 }
 527
 528 int
 529 i2d_OCSP_RESPID(OCSP_RESPID *a, unsigned char **out)
 530 {
 531         return ASN1_item_i2d((ASN1_VALUE *)a, out, &OCSP_RESPID_it);
 532 }
 533
 534 OCSP_RESPID *
 535 OCSP_RESPID_new(void)
 536 {
 537         return (OCSP_RESPID *)ASN1_item_new(&OCSP_RESPID_it);
 538 }
 539
 540 void
 541 OCSP_RESPID_free(OCSP_RESPID *a)
 542 {
 543         ASN1_item_free((ASN1_VALUE *)a, &OCSP_RESPID_it);
 544 }
 545
 546 static const ASN1_TEMPLATE OCSP_REVOKEDINFO_seq_tt[] = {
 547         {
 548                 .flags = 0,
 549                 .tag = 0,
 550                 .offset = offsetof(OCSP_REVOKEDINFO, revocationTime),
 551                 .field_name = "revocationTime",
 552                 .item = &ASN1_GENERALIZEDTIME_it,
 553         },
 554         {
 555                 .flags = ASN1_TFLG_EXPLICIT | ASN1_TFLG_OPTIONAL,
 556                 .tag = 0,
 557                 .offset = offsetof(OCSP_REVOKEDINFO, revocationReason),
 558                 .field_name = "revocationReason",
 559                 .item = &ASN1_ENUMERATED_it,
 560         },
 561 };
 562
 563 const ASN1_ITEM OCSP_REVOKEDINFO_it = {
 564         .itype = ASN1_ITYPE_SEQUENCE,
 565         .utype = V_ASN1_SEQUENCE,
 566         .templates = OCSP_REVOKEDINFO_seq_tt,
 567         .tcount = sizeof(OCSP_REVOKEDINFO_seq_tt) / sizeof(ASN1_TEMPLATE),
 568         .funcs = NULL,
 569         .size = sizeof(OCSP_REVOKEDINFO),
 570         .sname = "OCSP_REVOKEDINFO",
 571 };
 572
 573
 574 OCSP_REVOKEDINFO *
 575 d2i_OCSP_REVOKEDINFO(OCSP_REVOKEDINFO **a, const unsigned char **in, long len)
 576 {
 577         return (OCSP_REVOKEDINFO *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,
 578             &OCSP_REVOKEDINFO_it);
 579 }
 580
 581 int
 582 i2d_OCSP_REVOKEDINFO(OCSP_REVOKEDINFO *a, unsigned char **out)
 583 {
 584         return ASN1_item_i2d((ASN1_VALUE *)a, out, &OCSP_REVOKEDINFO_it);
 585 }
 586
 587 OCSP_REVOKEDINFO *
 588 OCSP_REVOKEDINFO_new(void)
 589 {
 590         return (OCSP_REVOKEDINFO *)ASN1_item_new(&OCSP_REVOKEDINFO_it);
 591 }
 592
 593 void
 594 OCSP_REVOKEDINFO_free(OCSP_REVOKEDINFO *a)
 595 {
 596         ASN1_item_free((ASN1_VALUE *)a, &OCSP_REVOKEDINFO_it);
 597 }
 598
 599 static const ASN1_TEMPLATE OCSP_CERTSTATUS_ch_tt[] = {
 600         {
 601                 .flags = ASN1_TFLG_IMPLICIT,
 602                 .tag = 0,
 603                 .offset = offsetof(OCSP_CERTSTATUS, value.good),
 604                 .field_name = "value.good",
 605                 .item = &ASN1_NULL_it,
 606         },
 607         {
 608                 .flags = ASN1_TFLG_IMPLICIT,
 609                 .tag = 1,
 610                 .offset = offsetof(OCSP_CERTSTATUS, value.revoked),
 611                 .field_name = "value.revoked",
 612                 .item = &OCSP_REVOKEDINFO_it,
 613         },
 614         {
 615                 .flags = ASN1_TFLG_IMPLICIT,
 616                 .tag = 2,
 617                 .offset = offsetof(OCSP_CERTSTATUS, value.unknown),
 618                 .field_name = "value.unknown",
 619                 .item = &ASN1_NULL_it,
 620         },
 621 };
 622
 623 const ASN1_ITEM OCSP_CERTSTATUS_it = {
 624         .itype = ASN1_ITYPE_CHOICE,
 625         .utype = offsetof(OCSP_CERTSTATUS, type),
 626         .templates = OCSP_CERTSTATUS_ch_tt,
 627         .tcount = sizeof(OCSP_CERTSTATUS_ch_tt) / sizeof(ASN1_TEMPLATE),
 628         .funcs = NULL,
 629         .size = sizeof(OCSP_CERTSTATUS),
 630         .sname = "OCSP_CERTSTATUS",
 631 };
 632
 633
 634 OCSP_CERTSTATUS *
 635 d2i_OCSP_CERTSTATUS(OCSP_CERTSTATUS **a, const unsigned char **in, long len)
 636 {
 637         return (OCSP_CERTSTATUS *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,
 638             &OCSP_CERTSTATUS_it);
 639 }
 640
 641 int
 642 i2d_OCSP_CERTSTATUS(OCSP_CERTSTATUS *a, unsigned char **out)
 643 {
 644         return ASN1_item_i2d((ASN1_VALUE *)a, out, &OCSP_CERTSTATUS_it);
 645 }
 646
 647 OCSP_CERTSTATUS *
 648 OCSP_CERTSTATUS_new(void)
 649 {
 650         return (OCSP_CERTSTATUS *)ASN1_item_new(&OCSP_CERTSTATUS_it);
 651 }
 652
 653 void
 654 OCSP_CERTSTATUS_free(OCSP_CERTSTATUS *a)
 655 {
 656         ASN1_item_free((ASN1_VALUE *)a, &OCSP_CERTSTATUS_it);
 657 }
 658
 659 static const ASN1_TEMPLATE OCSP_SINGLERESP_seq_tt[] = {
 660         {
 661                 .flags = 0,
 662                 .tag = 0,
 663                 .offset = offsetof(OCSP_SINGLERESP, certId),
 664                 .field_name = "certId",
 665                 .item = &OCSP_CERTID_it,
 666         },
 667         {
 668                 .flags = 0,
 669                 .tag = 0,
 670                 .offset = offsetof(OCSP_SINGLERESP, certStatus),
 671                 .field_name = "certStatus",
 672                 .item = &OCSP_CERTSTATUS_it,
 673         },
 674         {
 675                 .flags = 0,
 676                 .tag = 0,
 677                 .offset = offsetof(OCSP_SINGLERESP, thisUpdate),
 678                 .field_name = "thisUpdate",
 679                 .item = &ASN1_GENERALIZEDTIME_it,
 680         },
 681         {
 682                 .flags = ASN1_TFLG_EXPLICIT | ASN1_TFLG_OPTIONAL,
 683                 .tag = 0,
 684                 .offset = offsetof(OCSP_SINGLERESP, nextUpdate),
 685                 .field_name = "nextUpdate",
 686                 .item = &ASN1_GENERALIZEDTIME_it,
 687         },
 688         {
 689                 .flags = ASN1_TFLG_EXPLICIT | ASN1_TFLG_SEQUENCE_OF | ASN1_TFLG_OPTIONAL,
 690                 .tag = 1,
 691                 .offset = offsetof(OCSP_SINGLERESP, singleExtensions),
 692                 .field_name = "singleExtensions",
 693                 .item = &X509_EXTENSION_it,
 694         },
 695 };
 696
 697 const ASN1_ITEM OCSP_SINGLERESP_it = {
 698         .itype = ASN1_ITYPE_SEQUENCE,
 699         .utype = V_ASN1_SEQUENCE,
 700         .templates = OCSP_SINGLERESP_seq_tt,
 701         .tcount = sizeof(OCSP_SINGLERESP_seq_tt) / sizeof(ASN1_TEMPLATE),
 702         .funcs = NULL,
 703         .size = sizeof(OCSP_SINGLERESP),
 704         .sname = "OCSP_SINGLERESP",
 705 };
 706
 707
 708 OCSP_SINGLERESP *
 709 d2i_OCSP_SINGLERESP(OCSP_SINGLERESP **a, const unsigned char **in, long len)
 710 {
 711         return (OCSP_SINGLERESP *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,
 712             &OCSP_SINGLERESP_it);
 713 }
 714
 715 int
 716 i2d_OCSP_SINGLERESP(OCSP_SINGLERESP *a, unsigned char **out)
 717 {
 718         return ASN1_item_i2d((ASN1_VALUE *)a, out, &OCSP_SINGLERESP_it);
 719 }
 720
 721 OCSP_SINGLERESP *
 722 OCSP_SINGLERESP_new(void)
 723 {
 724         return (OCSP_SINGLERESP *)ASN1_item_new(&OCSP_SINGLERESP_it);
 725 }
 726
 727 void
 728 OCSP_SINGLERESP_free(OCSP_SINGLERESP *a)
 729 {
 730         ASN1_item_free((ASN1_VALUE *)a, &OCSP_SINGLERESP_it);
 731 }
 732
 733 static const ASN1_TEMPLATE OCSP_RESPDATA_seq_tt[] = {
 734         {
 735                 .flags = ASN1_TFLG_EXPLICIT | ASN1_TFLG_OPTIONAL,
 736                 .tag = 0,
 737                 .offset = offsetof(OCSP_RESPDATA, version),
 738                 .field_name = "version",
 739                 .item = &ASN1_INTEGER_it,
 740         },
 741         {
 742                 .flags = 0,
 743                 .tag = 0,
 744                 .offset = offsetof(OCSP_RESPDATA, responderId),
 745                 .field_name = "responderId",
 746                 .item = &OCSP_RESPID_it,
 747         },
 748         {
 749                 .flags = 0,
 750                 .tag = 0,
 751                 .offset = offsetof(OCSP_RESPDATA, producedAt),
 752                 .field_name = "producedAt",
 753                 .item = &ASN1_GENERALIZEDTIME_it,
 754         },
 755         {
 756                 .flags = ASN1_TFLG_SEQUENCE_OF,
 757                 .tag = 0,
 758                 .offset = offsetof(OCSP_RESPDATA, responses),
 759                 .field_name = "responses",
 760                 .item = &OCSP_SINGLERESP_it,
 761         },
 762         {
 763                 .flags = ASN1_TFLG_EXPLICIT | ASN1_TFLG_SEQUENCE_OF | ASN1_TFLG_OPTIONAL,
 764                 .tag = 1,
 765                 .offset = offsetof(OCSP_RESPDATA, responseExtensions),
 766                 .field_name = "responseExtensions",
 767                 .item = &X509_EXTENSION_it,
 768         },
 769 };
 770
 771 const ASN1_ITEM OCSP_RESPDATA_it = {
 772         .itype = ASN1_ITYPE_SEQUENCE,
 773         .utype = V_ASN1_SEQUENCE,
 774         .templates = OCSP_RESPDATA_seq_tt,
 775         .tcount = sizeof(OCSP_RESPDATA_seq_tt) / sizeof(ASN1_TEMPLATE),
 776         .funcs = NULL,
 777         .size = sizeof(OCSP_RESPDATA),
 778         .sname = "OCSP_RESPDATA",
 779 };
 780
 781
 782 OCSP_RESPDATA *
 783 d2i_OCSP_RESPDATA(OCSP_RESPDATA **a, const unsigned char **in, long len)
 784 {
 785         return (OCSP_RESPDATA *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,
 786             &OCSP_RESPDATA_it);
 787 }
 788
 789 int
 790 i2d_OCSP_RESPDATA(OCSP_RESPDATA *a, unsigned char **out)
 791 {
 792         return ASN1_item_i2d((ASN1_VALUE *)a, out, &OCSP_RESPDATA_it);
 793 }
 794
 795 OCSP_RESPDATA *
 796 OCSP_RESPDATA_new(void)
 797 {
 798         return (OCSP_RESPDATA *)ASN1_item_new(&OCSP_RESPDATA_it);
 799 }
 800
 801 void
 802 OCSP_RESPDATA_free(OCSP_RESPDATA *a)
 803 {
 804         ASN1_item_free((ASN1_VALUE *)a, &OCSP_RESPDATA_it);
 805 }
 806
 807 static const ASN1_TEMPLATE OCSP_BASICRESP_seq_tt[] = {
 808         {
 809                 .flags = 0,
 810                 .tag = 0,
 811                 .offset = offsetof(OCSP_BASICRESP, tbsResponseData),
 812                 .field_name = "tbsResponseData",
 813                 .item = &OCSP_RESPDATA_it,
 814         },
 815         {
 816                 .flags = 0,
 817                 .tag = 0,
 818                 .offset = offsetof(OCSP_BASICRESP, signatureAlgorithm),
 819                 .field_name = "signatureAlgorithm",
 820                 .item = &X509_ALGOR_it,
 821         },
 822         {
 823                 .flags = 0,
 824                 .tag = 0,
 825                 .offset = offsetof(OCSP_BASICRESP, signature),
 826                 .field_name = "signature",
 827                 .item = &ASN1_BIT_STRING_it,
 828         },
 829         {
 830                 .flags = ASN1_TFLG_EXPLICIT | ASN1_TFLG_SEQUENCE_OF | ASN1_TFLG_OPTIONAL,
 831                 .tag = 0,
 832                 .offset = offsetof(OCSP_BASICRESP, certs),
 833                 .field_name = "certs",
 834                 .item = &X509_it,
 835         },
 836 };
 837
 838 const ASN1_ITEM OCSP_BASICRESP_it = {
 839         .itype = ASN1_ITYPE_SEQUENCE,
 840         .utype = V_ASN1_SEQUENCE,
 841         .templates = OCSP_BASICRESP_seq_tt,
 842         .tcount = sizeof(OCSP_BASICRESP_seq_tt) / sizeof(ASN1_TEMPLATE),
 843         .funcs = NULL,
 844         .size = sizeof(OCSP_BASICRESP),
 845         .sname = "OCSP_BASICRESP",
 846 };
 847
 848
 849 OCSP_BASICRESP *
 850 d2i_OCSP_BASICRESP(OCSP_BASICRESP **a, const unsigned char **in, long len)
 851 {
 852         return (OCSP_BASICRESP *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,
 853             &OCSP_BASICRESP_it);
 854 }
 855
 856 int
 857 i2d_OCSP_BASICRESP(OCSP_BASICRESP *a, unsigned char **out)
 858 {
 859         return ASN1_item_i2d((ASN1_VALUE *)a, out, &OCSP_BASICRESP_it);
 860 }
 861
 862 OCSP_BASICRESP *
 863 OCSP_BASICRESP_new(void)
 864 {
 865         return (OCSP_BASICRESP *)ASN1_item_new(&OCSP_BASICRESP_it);
 866 }
 867
 868 void
 869 OCSP_BASICRESP_free(OCSP_BASICRESP *a)
 870 {
 871         ASN1_item_free((ASN1_VALUE *)a, &OCSP_BASICRESP_it);
 872 }
 873
 874 static const ASN1_TEMPLATE OCSP_CRLID_seq_tt[] = {
 875         {
 876                 .flags = ASN1_TFLG_EXPLICIT | ASN1_TFLG_OPTIONAL,
 877                 .tag = 0,
 878                 .offset = offsetof(OCSP_CRLID, crlUrl),
 879                 .field_name = "crlUrl",
 880                 .item = &ASN1_IA5STRING_it,
 881         },
 882         {
 883                 .flags = ASN1_TFLG_EXPLICIT | ASN1_TFLG_OPTIONAL,
 884                 .tag = 1,
 885                 .offset = offsetof(OCSP_CRLID, crlNum),
 886                 .field_name = "crlNum",
 887                 .item = &ASN1_INTEGER_it,
 888         },
 889         {
 890                 .flags = ASN1_TFLG_EXPLICIT | ASN1_TFLG_OPTIONAL,
 891                 .tag = 2,
 892                 .offset = offsetof(OCSP_CRLID, crlTime),
 893                 .field_name = "crlTime",
 894                 .item = &ASN1_GENERALIZEDTIME_it,
 895         },
 896 };
 897
 898 const ASN1_ITEM OCSP_CRLID_it = {
 899         .itype = ASN1_ITYPE_SEQUENCE,
 900         .utype = V_ASN1_SEQUENCE,
 901         .templates = OCSP_CRLID_seq_tt,
 902         .tcount = sizeof(OCSP_CRLID_seq_tt) / sizeof(ASN1_TEMPLATE),
 903         .funcs = NULL,
 904         .size = sizeof(OCSP_CRLID),
 905         .sname = "OCSP_CRLID",
 906 };
 907
 908
 909 OCSP_CRLID *
 910 d2i_OCSP_CRLID(OCSP_CRLID **a, const unsigned char **in, long len)
 911 {
 912         return (OCSP_CRLID *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,
 913             &OCSP_CRLID_it);
 914 }
 915
 916 int
 917 i2d_OCSP_CRLID(OCSP_CRLID *a, unsigned char **out)
 918 {
 919         return ASN1_item_i2d((ASN1_VALUE *)a, out, &OCSP_CRLID_it);
 920 }
 921
 922 OCSP_CRLID *
 923 OCSP_CRLID_new(void)
 924 {
 925         return (OCSP_CRLID *)ASN1_item_new(&OCSP_CRLID_it);
 926 }
 927
 928 void
 929 OCSP_CRLID_free(OCSP_CRLID *a)
 930 {
 931         ASN1_item_free((ASN1_VALUE *)a, &OCSP_CRLID_it);
 932 }
 933
 934 static const ASN1_TEMPLATE OCSP_SERVICELOC_seq_tt[] = {
 935         {
 936                 .flags = 0,
 937                 .tag = 0,
 938                 .offset = offsetof(OCSP_SERVICELOC, issuer),
 939                 .field_name = "issuer",
 940                 .item = &X509_NAME_it,
 941         },
 942         {
 943                 .flags = ASN1_TFLG_SEQUENCE_OF | ASN1_TFLG_OPTIONAL,
 944                 .tag = 0,
 945                 .offset = offsetof(OCSP_SERVICELOC, locator),
 946                 .field_name = "locator",
 947                 .item = &ACCESS_DESCRIPTION_it,
 948         },
 949 };
 950
 951 const ASN1_ITEM OCSP_SERVICELOC_it = {
 952         .itype = ASN1_ITYPE_SEQUENCE,
 953         .utype = V_ASN1_SEQUENCE,
 954         .templates = OCSP_SERVICELOC_seq_tt,
 955         .tcount = sizeof(OCSP_SERVICELOC_seq_tt) / sizeof(ASN1_TEMPLATE),
 956         .funcs = NULL,
 957         .size = sizeof(OCSP_SERVICELOC),
 958         .sname = "OCSP_SERVICELOC",
 959 };
 960
 961
 962 OCSP_SERVICELOC *
 963 d2i_OCSP_SERVICELOC(OCSP_SERVICELOC **a, const unsigned char **in, long len)
 964 {
 965         return (OCSP_SERVICELOC *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,
 966             &OCSP_SERVICELOC_it);
 967 }
 968
 969 int
 970 i2d_OCSP_SERVICELOC(OCSP_SERVICELOC *a, unsigned char **out)
 971 {
 972         return ASN1_item_i2d((ASN1_VALUE *)a, out, &OCSP_SERVICELOC_it);
 973 }
 974
 975 OCSP_SERVICELOC *
 976 OCSP_SERVICELOC_new(void)
 977 {
 978         return (OCSP_SERVICELOC *)ASN1_item_new(&OCSP_SERVICELOC_it);
 979 }
 980
 981 void
 982 OCSP_SERVICELOC_free(OCSP_SERVICELOC *a)
 983 {
 984         ASN1_item_free((ASN1_VALUE *)a, &OCSP_SERVICELOC_it);
 985 }