crypto/cmp/cmp_ctx.c

   1 /*
   2  * Copyright 2007-2021 The OpenSSL Project Authors. All Rights Reserved.
   3  * Copyright Nokia 2007-2019
   4  * Copyright Siemens AG 2015-2019
   5  *
   6  * Licensed under the Apache License 2.0 (the "License").  You may not use
   7  * this file except in compliance with the License.  You can obtain a copy
   8  * in the file LICENSE in the source distribution or at
   9  * https://www.openssl.org/source/license.html
  10  */
  11
  12 #include <openssl/trace.h>
  13 #include <openssl/bio.h>
  14 #include <openssl/ocsp.h> /* for OCSP_REVOKED_STATUS_* */
  15 #include "crypto/x509.h" /* for x509v3_cache_extensions() */
  16
  17 #include "cmp_local.h"
  18
  19 /* explicit #includes not strictly needed since implied by the above: */
  20 #include <openssl/cmp.h>
  21 #include <openssl/crmf.h>
  22 #include <openssl/err.h>
  23
  24 /*
  25  * Get current certificate store containing trusted root CA certs
  26  */
  27 X509_STORE *OSSL_CMP_CTX_get0_trustedStore(const OSSL_CMP_CTX *ctx)
  28 {
  29     if (ctx == NULL) {
  30         ERR_raise(ERR_LIB_CMP, CMP_R_NULL_ARGUMENT);
  31         return NULL;
  32     }
  33     return ctx->trusted;
  34 }
  35
  36 /*
  37  * Set certificate store containing trusted (root) CA certs and possibly CRLs
  38  * and a cert verification callback function used for CMP server authentication.
  39  * Any already existing store entry is freed. Given NULL, the entry is reset.
  40  */
  41 int OSSL_CMP_CTX_set0_trustedStore(OSSL_CMP_CTX *ctx, X509_STORE *store)
  42 {
  43     if (ctx == NULL) {
  44         ERR_raise(ERR_LIB_CMP, CMP_R_NULL_ARGUMENT);
  45         return 0;
  46     }
  47     X509_STORE_free(ctx->trusted);
  48     ctx->trusted = store;
  49     return 1;
  50 }
  51
  52 /* Get current list of non-trusted intermediate certs */
  53 STACK_OF(X509) *OSSL_CMP_CTX_get0_untrusted(const OSSL_CMP_CTX *ctx)
  54 {
  55     if (ctx == NULL) {
  56         ERR_raise(ERR_LIB_CMP, CMP_R_NULL_ARGUMENT);
  57         return NULL;
  58     }
  59     return ctx->untrusted;
  60 }
  61
  62 /*
  63  * Set untrusted certificates for path construction in authentication of
  64  * the CMP server and potentially others (TLS server, newly enrolled cert).
  65  */
  66 int OSSL_CMP_CTX_set1_untrusted(OSSL_CMP_CTX *ctx, STACK_OF(X509) *certs)
  67 {
  68     STACK_OF(X509) *untrusted;
  69     if (ctx == NULL) {
  70         ERR_raise(ERR_LIB_CMP, CMP_R_NULL_ARGUMENT);
  71         return 0;
  72     }
  73     if ((untrusted = sk_X509_new_null()) == NULL)
  74         return 0;
  75     if (X509_add_certs(untrusted, certs,
  76                        X509_ADD_FLAG_UP_REF | X509_ADD_FLAG_NO_DUP) != 1)
  77         goto err;
  78     sk_X509_pop_free(ctx->untrusted, X509_free);
  79     ctx->untrusted = untrusted;
  80     return 1;
  81  err:
  82     sk_X509_pop_free(untrusted, X509_free);
  83     return 0;
  84 }
  85
  86 static int cmp_ctx_set_md(OSSL_CMP_CTX *ctx, EVP_MD **pmd, int nid)
  87 {
  88     EVP_MD *md = EVP_MD_fetch(ctx->libctx, OBJ_nid2sn(nid), ctx->propq);
  89     /* fetching in advance to be able to throw error early if unsupported */
  90
  91     if (md == NULL) {
  92         ERR_raise(ERR_LIB_CMP, CMP_R_UNSUPPORTED_ALGORITHM);
  93         return 0;
  94     }
  95     EVP_MD_free(*pmd);
  96     *pmd = md;
  97     return 1;
  98 }
  99
 100 /*
 101  * Allocates and initializes OSSL_CMP_CTX context structure with default values.
 102  * Returns new context on success, NULL on error
 103  */
 104 OSSL_CMP_CTX *OSSL_CMP_CTX_new(OSSL_LIB_CTX *libctx, const char *propq)
 105 {
 106     OSSL_CMP_CTX *ctx = OPENSSL_zalloc(sizeof(*ctx));
 107
 108     if (ctx == NULL)
 109         goto err;
 110
 111     ctx->libctx = libctx;
 112     if (propq != NULL && (ctx->propq = OPENSSL_strdup(propq)) == NULL)
 113         goto err;
 114
 115     ctx->log_verbosity = OSSL_CMP_LOG_INFO;
 116
 117     ctx->status = -1;
 118     ctx->failInfoCode = -1;
 119
 120     ctx->msg_timeout = 2 * 60;
 121
 122     if ((ctx->untrusted = sk_X509_new_null()) == NULL)
 123         goto err;
 124
 125     ctx->pbm_slen = 16;
 126     if (!cmp_ctx_set_md(ctx, &ctx->pbm_owf, NID_sha256))
 127         goto err;
 128     ctx->pbm_itercnt = 500;
 129     ctx->pbm_mac = NID_hmac_sha1;
 130
 131     if (!cmp_ctx_set_md(ctx, &ctx->digest, NID_sha256))
 132         goto err;
 133     ctx->popoMethod = OSSL_CRMF_POPO_SIGNATURE;
 134     ctx->revocationReason = CRL_REASON_NONE;
 135
 136     /* all other elements are initialized to 0 or NULL, respectively */
 137     return ctx;
 138
 139  err:
 140     OSSL_CMP_CTX_free(ctx);
 141     ERR_raise(ERR_LIB_X509, ERR_R_MALLOC_FAILURE);
 142     return NULL;
 143 }
 144
 145 /* Prepare the OSSL_CMP_CTX for next use, partly re-initializing OSSL_CMP_CTX */
 146 int OSSL_CMP_CTX_reinit(OSSL_CMP_CTX *ctx)
 147 {
 148     if (ctx == NULL) {
 149         ERR_raise(ERR_LIB_CMP, CMP_R_NULL_ARGUMENT);
 150         return 0;
 151     }
 152
 153     ctx->status = -1;
 154     ctx->failInfoCode = -1;
 155
 156     return ossl_cmp_ctx_set0_statusString(ctx, NULL)
 157         && ossl_cmp_ctx_set0_newCert(ctx, NULL)
 158         && ossl_cmp_ctx_set1_newChain(ctx, NULL)
 159         && ossl_cmp_ctx_set1_caPubs(ctx, NULL)
 160         && ossl_cmp_ctx_set1_extraCertsIn(ctx, NULL)
 161         && ossl_cmp_ctx_set0_validatedSrvCert(ctx, NULL)
 162         && OSSL_CMP_CTX_set1_transactionID(ctx, NULL)
 163         && OSSL_CMP_CTX_set1_senderNonce(ctx, NULL)
 164         && ossl_cmp_ctx_set1_recipNonce(ctx, NULL);
 165 }
 166
 167 /* Frees OSSL_CMP_CTX variables allocated in OSSL_CMP_CTX_new() */
 168 void OSSL_CMP_CTX_free(OSSL_CMP_CTX *ctx)
 169 {
 170     if (ctx == NULL)
 171         return;
 172
 173     OPENSSL_free(ctx->serverPath);
 174     OPENSSL_free(ctx->server);
 175     OPENSSL_free(ctx->proxy);
 176     OPENSSL_free(ctx->no_proxy);
 177
 178     X509_free(ctx->srvCert);
 179     X509_free(ctx->validatedSrvCert);
 180     X509_NAME_free(ctx->expected_sender);
 181     X509_STORE_free(ctx->trusted);
 182     sk_X509_pop_free(ctx->untrusted, X509_free);
 183
 184     X509_free(ctx->cert);
 185     sk_X509_pop_free(ctx->chain, X509_free);
 186     EVP_PKEY_free(ctx->pkey);
 187     ASN1_OCTET_STRING_free(ctx->referenceValue);
 188     if (ctx->secretValue != NULL)
 189         OPENSSL_cleanse(ctx->secretValue->data, ctx->secretValue->length);
 190     ASN1_OCTET_STRING_free(ctx->secretValue);
 191     EVP_MD_free(ctx->pbm_owf);
 192
 193     X509_NAME_free(ctx->recipient);
 194     EVP_MD_free(ctx->digest);
 195     ASN1_OCTET_STRING_free(ctx->transactionID);
 196     ASN1_OCTET_STRING_free(ctx->senderNonce);
 197     ASN1_OCTET_STRING_free(ctx->recipNonce);
 198     sk_OSSL_CMP_ITAV_pop_free(ctx->geninfo_ITAVs, OSSL_CMP_ITAV_free);
 199     sk_X509_pop_free(ctx->extraCertsOut, X509_free);
 200
 201     EVP_PKEY_free(ctx->newPkey);
 202     X509_NAME_free(ctx->issuer);
 203     X509_NAME_free(ctx->subjectName);
 204     sk_GENERAL_NAME_pop_free(ctx->subjectAltNames, GENERAL_NAME_free);
 205     sk_X509_EXTENSION_pop_free(ctx->reqExtensions, X509_EXTENSION_free);
 206     sk_POLICYINFO_pop_free(ctx->policies, POLICYINFO_free);
 207     X509_free(ctx->oldCert);
 208     X509_REQ_free(ctx->p10CSR);
 209
 210     sk_OSSL_CMP_ITAV_pop_free(ctx->genm_ITAVs, OSSL_CMP_ITAV_free);
 211
 212     sk_ASN1_UTF8STRING_pop_free(ctx->statusString, ASN1_UTF8STRING_free);
 213     X509_free(ctx->newCert);
 214     sk_X509_pop_free(ctx->newChain, X509_free);
 215     sk_X509_pop_free(ctx->caPubs, X509_free);
 216     sk_X509_pop_free(ctx->extraCertsIn, X509_free);
 217
 218     OPENSSL_free(ctx);
 219 }
 220
 221 int ossl_cmp_ctx_set_status(OSSL_CMP_CTX *ctx, int status)
 222 {
 223     if (!ossl_assert(ctx != NULL))
 224         return 0;
 225     ctx->status = status;
 226     return 1;
 227 }
 228
 229 /*
 230  * Returns the PKIStatus from the last CertRepMessage
 231  * or Revocation Response or error message, -1 on error
 232  */
 233 int OSSL_CMP_CTX_get_status(const OSSL_CMP_CTX *ctx)
 234 {
 235     if (ctx == NULL) {
 236         ERR_raise(ERR_LIB_CMP, CMP_R_NULL_ARGUMENT);
 237         return -1;
 238     }
 239     return ctx->status;
 240 }
 241
 242 /*
 243  * Returns the statusString from the last CertRepMessage
 244  * or Revocation Response or error message, NULL on error
 245  */
 246 OSSL_CMP_PKIFREETEXT *OSSL_CMP_CTX_get0_statusString(const OSSL_CMP_CTX *ctx)
 247 {
 248     if (ctx == NULL) {
 249         ERR_raise(ERR_LIB_CMP, CMP_R_NULL_ARGUMENT);
 250         return NULL;
 251     }
 252     return ctx->statusString;
 253 }
 254
 255 int ossl_cmp_ctx_set0_statusString(OSSL_CMP_CTX *ctx,
 256                                    OSSL_CMP_PKIFREETEXT *text)
 257 {
 258     if (!ossl_assert(ctx != NULL))
 259         return 0;
 260     sk_ASN1_UTF8STRING_pop_free(ctx->statusString, ASN1_UTF8STRING_free);
 261     ctx->statusString = text;
 262     return 1;
 263 }
 264
 265 int ossl_cmp_ctx_set0_validatedSrvCert(OSSL_CMP_CTX *ctx, X509 *cert)
 266 {
 267     if (!ossl_assert(ctx != NULL))
 268         return 0;
 269     X509_free(ctx->validatedSrvCert);
 270     ctx->validatedSrvCert = cert;
 271     return 1;
 272 }
 273
 274 /* Set callback function for checking if the cert is ok or should be rejected */
 275 int OSSL_CMP_CTX_set_certConf_cb(OSSL_CMP_CTX *ctx, OSSL_CMP_certConf_cb_t cb)
 276 {
 277     if (ctx == NULL) {
 278         ERR_raise(ERR_LIB_CMP, CMP_R_NULL_ARGUMENT);
 279         return 0;
 280     }
 281     ctx->certConf_cb = cb;
 282     return 1;
 283 }
 284
 285 /*
 286  * Set argument, respectively a pointer to a structure containing arguments,
 287  * optionally to be used by the certConf callback.
 288  */
 289 int OSSL_CMP_CTX_set_certConf_cb_arg(OSSL_CMP_CTX *ctx, void *arg)
 290 {
 291     if (ctx == NULL) {
 292         ERR_raise(ERR_LIB_CMP, CMP_R_NULL_ARGUMENT);
 293         return 0;
 294     }
 295     ctx->certConf_cb_arg = arg;
 296     return 1;
 297 }
 298
 299 /*
 300  * Get argument, respectively the pointer to a structure containing arguments,
 301  * optionally to be used by certConf callback.
 302  * Returns callback argument set previously (NULL if not set or on error)
 303  */
 304 void *OSSL_CMP_CTX_get_certConf_cb_arg(const OSSL_CMP_CTX *ctx)
 305 {
 306     if (ctx == NULL) {
 307         ERR_raise(ERR_LIB_CMP, CMP_R_NULL_ARGUMENT);
 308         return NULL;
 309     }
 310     return ctx->certConf_cb_arg;
 311 }
 312
 313 #ifndef OPENSSL_NO_TRACE
 314 static size_t ossl_cmp_log_trace_cb(const char *buf, size_t cnt,
 315                                     int category, int cmd, void *vdata)
 316 {
 317     OSSL_CMP_CTX *ctx = vdata;
 318     const char *msg;
 319     OSSL_CMP_severity level = -1;
 320     char *func = NULL;
 321     char *file = NULL;
 322     int line = 0;
 323
 324     if (buf == NULL || cnt == 0 || cmd != OSSL_TRACE_CTRL_WRITE || ctx == NULL)
 325         return 0;
 326     if (ctx->log_cb == NULL)
 327         return 1; /* silently drop message */
 328
 329     msg = ossl_cmp_log_parse_metadata(buf, &level, &func, &file, &line);
 330
 331     if (level > ctx->log_verbosity) /* excludes the case level is unknown */
 332         goto end; /* suppress output since severity is not sufficient */
 333
 334     if (!ctx->log_cb(func != NULL ? func : "(no func)",
 335                      file != NULL ? file : "(no file)",
 336                      line, level, msg))
 337         cnt = 0;
 338
 339  end:
 340     OPENSSL_free(func);
 341     OPENSSL_free(file);
 342     return cnt;
 343 }
 344 #endif
 345
 346 /* Print CMP log messages (i.e., diagnostic info) via the log cb of the ctx */
 347 int ossl_cmp_print_log(OSSL_CMP_severity level, const OSSL_CMP_CTX *ctx,
 348                        const char *func, const char *file, int line,
 349                        const char *level_str, const char *format, ...)
 350 {
 351     va_list args;
 352     char hugebuf[1024 * 2];
 353     int res = 0;
 354
 355     if (ctx == NULL || ctx->log_cb == NULL)
 356         return 1; /* silently drop message */
 357
 358     if (level > ctx->log_verbosity) /* excludes the case level is unknown */
 359         return 1; /* suppress output since severity is not sufficient */
 360
 361     if (format == NULL)
 362         return 0;
 363
 364     va_start(args, format);
 365
 366     if (func == NULL)
 367         func = "(unset function name)";
 368     if (file == NULL)
 369         file = "(unset file name)";
 370     if (level_str == NULL)
 371         level_str = "(unset level string)";
 372
 373 #ifndef OPENSSL_NO_TRACE
 374     if (OSSL_TRACE_ENABLED(CMP)) {
 375         OSSL_TRACE_BEGIN(CMP) {
 376             int printed =
 377                 BIO_snprintf(hugebuf, sizeof(hugebuf),
 378                              "%s:%s:%d:" OSSL_CMP_LOG_PREFIX "%s: ",
 379                              func, file, line, level_str);
 380             if (printed > 0 && (size_t)printed < sizeof(hugebuf)) {
 381                 if (BIO_vsnprintf(hugebuf + printed,
 382                                   sizeof(hugebuf) - printed, format, args) > 0)
 383                     res = BIO_puts(trc_out, hugebuf) > 0;
 384             }
 385         } OSSL_TRACE_END(CMP);
 386     }
 387 #else /* compensate for disabled trace API */
 388     {
 389         if (BIO_vsnprintf(hugebuf, sizeof(hugebuf), format, args) > 0)
 390             res = ctx->log_cb(func, file, line, level, hugebuf);
 391     }
 392 #endif
 393     va_end(args);
 394     return res;
 395 }
 396
 397 /* Set a callback function for error reporting and logging messages */
 398 int OSSL_CMP_CTX_set_log_cb(OSSL_CMP_CTX *ctx, OSSL_CMP_log_cb_t cb)
 399 {
 400     if (ctx == NULL) {
 401         ERR_raise(ERR_LIB_CMP, CMP_R_NULL_ARGUMENT);
 402         return 0;
 403     }
 404     ctx->log_cb = cb;
 405
 406 #ifndef OPENSSL_NO_TRACE
 407     /* do also in case cb == NULL, to switch off logging output: */
 408     if (!OSSL_trace_set_callback(OSSL_TRACE_CATEGORY_CMP,
 409                                  ossl_cmp_log_trace_cb, ctx))
 410         return 0;
 411 #endif
 412
 413     return 1;
 414 }
 415
 416 /* Print OpenSSL and CMP errors via the log cb of the ctx or ERR_print_errors */
 417 void OSSL_CMP_CTX_print_errors(const OSSL_CMP_CTX *ctx)
 418 {
 419     if (ctx != NULL && OSSL_CMP_LOG_ERR > ctx->log_verbosity)
 420         return; /* suppress output since severity is not sufficient */
 421     OSSL_CMP_print_errors_cb(ctx == NULL ? NULL : ctx->log_cb);
 422 }
 423
 424 /*
 425  * Set or clear the reference value to be used for identification
 426  * (i.e., the user name) when using PBMAC.
 427  */
 428 int OSSL_CMP_CTX_set1_referenceValue(OSSL_CMP_CTX *ctx,
 429                                      const unsigned char *ref, int len)
 430 {
 431     if (ctx == NULL) {
 432         ERR_raise(ERR_LIB_CMP, CMP_R_NULL_ARGUMENT);
 433         return 0;
 434     }
 435     return ossl_cmp_asn1_octet_string_set1_bytes(&ctx->referenceValue, ref,
 436                                                  len);
 437 }
 438
 439 /* Set or clear the password to be used for protecting messages with PBMAC */
 440 int OSSL_CMP_CTX_set1_secretValue(OSSL_CMP_CTX *ctx, const unsigned char *sec,
 441                                   const int len)
 442 {
 443     ASN1_OCTET_STRING *secretValue = NULL;
 444     if (ctx == NULL) {
 445         ERR_raise(ERR_LIB_CMP, CMP_R_NULL_ARGUMENT);
 446         return 0;
 447     }
 448     if (ossl_cmp_asn1_octet_string_set1_bytes(&secretValue, sec, len) != 1)
 449         return 0;
 450     if (ctx->secretValue != NULL) {
 451         OPENSSL_cleanse(ctx->secretValue->data, ctx->secretValue->length);
 452         ASN1_OCTET_STRING_free(ctx->secretValue);
 453     }
 454     ctx->secretValue = secretValue;
 455     return 1;
 456 }
 457
 458 /* Returns the cert chain computed by OSSL_CMP_certConf_cb(), NULL on error */
 459 STACK_OF(X509) *OSSL_CMP_CTX_get1_newChain(const OSSL_CMP_CTX *ctx)
 460 {
 461     if (ctx == NULL) {
 462         ERR_raise(ERR_LIB_CMP, CMP_R_NULL_ARGUMENT);
 463         return NULL;
 464     }
 465     return X509_chain_up_ref(ctx->newChain);
 466 }
 467
 468 /*
 469  * Copies any given stack of inbound X509 certificates to newChain
 470  * of the OSSL_CMP_CTX structure so that they may be retrieved later.
 471  */
 472 int ossl_cmp_ctx_set1_newChain(OSSL_CMP_CTX *ctx, STACK_OF(X509) *newChain)
 473 {
 474     if (!ossl_assert(ctx != NULL))
 475         return 0;
 476
 477     sk_X509_pop_free(ctx->newChain, X509_free);
 478     ctx->newChain = NULL;
 479     return newChain == NULL ||
 480         (ctx->newChain = X509_chain_up_ref(newChain)) != NULL;
 481 }
 482
 483 /* Returns the stack of extraCerts received in CertRepMessage, NULL on error */
 484 STACK_OF(X509) *OSSL_CMP_CTX_get1_extraCertsIn(const OSSL_CMP_CTX *ctx)
 485 {
 486     if (ctx == NULL) {
 487         ERR_raise(ERR_LIB_CMP, CMP_R_NULL_ARGUMENT);
 488         return NULL;
 489     }
 490     return X509_chain_up_ref(ctx->extraCertsIn);
 491 }
 492
 493 /*
 494  * Copies any given stack of inbound X509 certificates to extraCertsIn
 495  * of the OSSL_CMP_CTX structure so that they may be retrieved later.
 496  */
 497 int ossl_cmp_ctx_set1_extraCertsIn(OSSL_CMP_CTX *ctx,
 498                                    STACK_OF(X509) *extraCertsIn)
 499 {
 500     if (!ossl_assert(ctx != NULL))
 501         return 0;
 502
 503     sk_X509_pop_free(ctx->extraCertsIn, X509_free);
 504     ctx->extraCertsIn = NULL;
 505     return extraCertsIn == NULL
 506         || (ctx->extraCertsIn = X509_chain_up_ref(extraCertsIn)) != NULL;
 507 }
 508
 509 /*
 510  * Copies any given stack as the new stack of X509
 511  * certificates to send out in the extraCerts field.
 512  */
 513 int OSSL_CMP_CTX_set1_extraCertsOut(OSSL_CMP_CTX *ctx,
 514                                     STACK_OF(X509) *extraCertsOut)
 515 {
 516     if (ctx == NULL) {
 517         ERR_raise(ERR_LIB_CMP, CMP_R_NULL_ARGUMENT);
 518         return 0;
 519     }
 520
 521     sk_X509_pop_free(ctx->extraCertsOut, X509_free);
 522     ctx->extraCertsOut = NULL;
 523     return extraCertsOut == NULL
 524         || (ctx->extraCertsOut = X509_chain_up_ref(extraCertsOut)) != NULL;
 525 }
 526
 527 /*
 528  * Add the given policy info object
 529  * to the X509_EXTENSIONS of the requested certificate template.
 530  */
 531 int OSSL_CMP_CTX_push0_policy(OSSL_CMP_CTX *ctx, POLICYINFO *pinfo)
 532 {
 533     if (ctx == NULL || pinfo == NULL) {
 534         ERR_raise(ERR_LIB_CMP, CMP_R_NULL_ARGUMENT);
 535         return 0;
 536     }
 537
 538     if (ctx->policies == NULL
 539             && (ctx->policies = CERTIFICATEPOLICIES_new()) == NULL)
 540         return 0;
 541
 542     return sk_POLICYINFO_push(ctx->policies, pinfo);
 543 }
 544
 545 /* Add an ITAV for geninfo of the PKI message header */
 546 int OSSL_CMP_CTX_push0_geninfo_ITAV(OSSL_CMP_CTX *ctx, OSSL_CMP_ITAV *itav)
 547 {
 548     if (ctx == NULL) {
 549         ERR_raise(ERR_LIB_CMP, CMP_R_NULL_ARGUMENT);
 550         return 0;
 551     }
 552     return OSSL_CMP_ITAV_push0_stack_item(&ctx->geninfo_ITAVs, itav);
 553 }
 554
 555 /* Add an itav for the body of outgoing general messages */
 556 int OSSL_CMP_CTX_push0_genm_ITAV(OSSL_CMP_CTX *ctx, OSSL_CMP_ITAV *itav)
 557 {
 558     if (ctx == NULL) {
 559         ERR_raise(ERR_LIB_CMP, CMP_R_NULL_ARGUMENT);
 560         return 0;
 561     }
 562     return OSSL_CMP_ITAV_push0_stack_item(&ctx->genm_ITAVs, itav);
 563 }
 564
 565 /*
 566  * Returns a duplicate of the stack of X509 certificates that
 567  * were received in the caPubs field of the last CertRepMessage.
 568  * Returns NULL on error
 569  */
 570 STACK_OF(X509) *OSSL_CMP_CTX_get1_caPubs(const OSSL_CMP_CTX *ctx)
 571 {
 572     if (ctx == NULL) {
 573         ERR_raise(ERR_LIB_CMP, CMP_R_NULL_ARGUMENT);
 574         return NULL;
 575     }
 576     return X509_chain_up_ref(ctx->caPubs);
 577 }
 578
 579 /*
 580  * Copies any given stack of certificates to the given
 581  * OSSL_CMP_CTX structure so that they may be retrieved later.
 582  */
 583 int ossl_cmp_ctx_set1_caPubs(OSSL_CMP_CTX *ctx, STACK_OF(X509) *caPubs)
 584 {
 585     if (!ossl_assert(ctx != NULL))
 586         return 0;
 587
 588     sk_X509_pop_free(ctx->caPubs, X509_free);
 589     ctx->caPubs = NULL;
 590     return caPubs == NULL || (ctx->caPubs = X509_chain_up_ref(caPubs)) != NULL;
 591 }
 592
 593 #define char_dup OPENSSL_strdup
 594 #define char_free OPENSSL_free
 595 #define DEFINE_OSSL_CMP_CTX_set1(FIELD, TYPE) /* this uses _dup */ \
 596 int OSSL_CMP_CTX_set1_##FIELD(OSSL_CMP_CTX *ctx, const TYPE *val) \
 597 { \
 598     TYPE *val_dup = NULL; \
 599     \
 600     if (ctx == NULL) { \
 601         ERR_raise(ERR_LIB_CMP, CMP_R_NULL_ARGUMENT); \
 602         return 0; \
 603     } \
 604     \
 605     if (val != NULL && (val_dup = TYPE##_dup(val)) == NULL) \
 606         return 0; \
 607     TYPE##_free(ctx->FIELD); \
 608     ctx->FIELD = val_dup; \
 609     return 1; \
 610 }
 611
 612 #define X509_invalid(cert) (!x509v3_cache_extensions(cert))
 613 #define EVP_PKEY_invalid(key) 0
 614 #define DEFINE_OSSL_CMP_CTX_set1_up_ref(FIELD, TYPE) \
 615 int OSSL_CMP_CTX_set1_##FIELD(OSSL_CMP_CTX *ctx, TYPE *val) \
 616 { \
 617     if (ctx == NULL) { \
 618         ERR_raise(ERR_LIB_CMP, CMP_R_NULL_ARGUMENT); \
 619         return 0; \
 620     } \
 621     \
 622     /* prevent misleading error later on malformed cert or provider issue */ \
 623     if (val != NULL && TYPE##_invalid(val)) { \
 624         ERR_raise(ERR_LIB_CMP, CMP_R_POTENTIALLY_INVALID_CERTIFICATE); \
 625         return 0; \
 626     } \
 627     if (val != NULL && !TYPE##_up_ref(val)) \
 628         return 0; \
 629     TYPE##_free(ctx->FIELD); \
 630     ctx->FIELD = val; \
 631     return 1; \
 632 }
 633
 634 /*
 635  * Pins the server certificate to be directly trusted (even if it is expired)
 636  * for verifying response messages.
 637  * Cert pointer is not consumed. It may be NULL to clear the entry.
 638  */
 639 DEFINE_OSSL_CMP_CTX_set1_up_ref(srvCert, X509)
 640
 641 /* Set the X509 name of the recipient. Set in the PKIHeader */
 642 DEFINE_OSSL_CMP_CTX_set1(recipient, X509_NAME)
 643
 644 /* Store the X509 name of the expected sender in the PKIHeader of responses */
 645 DEFINE_OSSL_CMP_CTX_set1(expected_sender, X509_NAME)
 646
 647 /* Set the X509 name of the issuer. Set in the PKIHeader */
 648 DEFINE_OSSL_CMP_CTX_set1(issuer, X509_NAME)
 649
 650 /*
 651  * Set the subject name that will be placed in the certificate
 652  * request. This will be the subject name on the received certificate.
 653  */
 654 DEFINE_OSSL_CMP_CTX_set1(subjectName, X509_NAME)
 655
 656 /* Set the X.509v3 certificate request extensions to be used in IR/CR/KUR */
 657 int OSSL_CMP_CTX_set0_reqExtensions(OSSL_CMP_CTX *ctx, X509_EXTENSIONS *exts)
 658 {
 659     if (ctx == NULL) {
 660         ERR_raise(ERR_LIB_CMP, CMP_R_NULL_ARGUMENT);
 661         return 0;
 662     }
 663
 664     if (sk_GENERAL_NAME_num(ctx->subjectAltNames) > 0 && exts != NULL
 665             && X509v3_get_ext_by_NID(exts, NID_subject_alt_name, -1) >= 0) {
 666         ERR_raise(ERR_LIB_CMP, CMP_R_MULTIPLE_SAN_SOURCES);
 667         return 0;
 668     }
 669     sk_X509_EXTENSION_pop_free(ctx->reqExtensions, X509_EXTENSION_free);
 670     ctx->reqExtensions = exts;
 671     return 1;
 672 }
 673
 674 /* returns 1 if ctx contains a Subject Alternative Name extension, else 0 */
 675 int OSSL_CMP_CTX_reqExtensions_have_SAN(OSSL_CMP_CTX *ctx)
 676 {
 677     if (ctx == NULL) {
 678         ERR_raise(ERR_LIB_CMP, CMP_R_NULL_ARGUMENT);
 679         return -1;
 680     }
 681     /* if one of the following conditions 'fail' this is not an error */
 682     return ctx->reqExtensions != NULL
 683         && X509v3_get_ext_by_NID(ctx->reqExtensions,
 684                                  NID_subject_alt_name, -1) >= 0;
 685 }
 686
 687 /*
 688  * Add a GENERAL_NAME structure that will be added to the CRMF
 689  * request's extensions field to request subject alternative names.
 690  */
 691 int OSSL_CMP_CTX_push1_subjectAltName(OSSL_CMP_CTX *ctx,
 692                                       const GENERAL_NAME *name)
 693 {
 694     GENERAL_NAME *name_dup;
 695
 696     if (ctx == NULL || name == NULL) {
 697         ERR_raise(ERR_LIB_CMP, CMP_R_NULL_ARGUMENT);
 698         return 0;
 699     }
 700
 701     if (OSSL_CMP_CTX_reqExtensions_have_SAN(ctx) == 1) {
 702         ERR_raise(ERR_LIB_CMP, CMP_R_MULTIPLE_SAN_SOURCES);
 703         return 0;
 704     }
 705
 706     if (ctx->subjectAltNames == NULL
 707             && (ctx->subjectAltNames = sk_GENERAL_NAME_new_null()) == NULL)
 708         return 0;
 709     if ((name_dup = GENERAL_NAME_dup(name)) == NULL)
 710         return 0;
 711     if (!sk_GENERAL_NAME_push(ctx->subjectAltNames, name_dup)) {
 712         GENERAL_NAME_free(name_dup);
 713         return 0;
 714     }
 715     return 1;
 716 }
 717
 718 /*
 719  * Set our own client certificate, used for example in KUR and when
 720  * doing the IR with existing certificate.
 721  */
 722 DEFINE_OSSL_CMP_CTX_set1_up_ref(cert, X509)
 723
 724 int OSSL_CMP_CTX_build_cert_chain(OSSL_CMP_CTX *ctx, X509_STORE *own_trusted,
 725                                   STACK_OF(X509) *candidates)
 726 {
 727     STACK_OF(X509) *chain;
 728
 729     if (ctx == NULL) {
 730         ERR_raise(ERR_LIB_CMP, CMP_R_NULL_ARGUMENT);
 731         return 0;
 732     }
 733
 734     if (ctx->untrusted != NULL ?
 735         !X509_add_certs(ctx->untrusted, candidates,
 736                         X509_ADD_FLAG_UP_REF | X509_ADD_FLAG_NO_DUP) :
 737         !OSSL_CMP_CTX_set1_untrusted(ctx, candidates))
 738         return 0;
 739
 740     ossl_cmp_debug(ctx, "trying to build chain for own CMP signer cert");
 741     chain = ossl_cmp_build_cert_chain(ctx->libctx, ctx->propq, own_trusted,
 742                                       ctx->untrusted, ctx->cert);
 743     if (chain == NULL) {
 744         ERR_raise(ERR_LIB_CMP, CMP_R_FAILED_BUILDING_OWN_CHAIN);
 745         return 0;
 746     }
 747     ossl_cmp_debug(ctx, "success building chain for own CMP signer cert");
 748     ctx->chain = chain;
 749     return 1;
 750 }
 751
 752 /*
 753  * Set the old certificate that we are updating in KUR
 754  * or the certificate to be revoked in RR, respectively.
 755  * Also used as reference cert (defaulting to cert) for deriving subject DN
 756  * and SANs. Its issuer is used as default recipient in the CMP message header.
 757  */
 758 DEFINE_OSSL_CMP_CTX_set1_up_ref(oldCert, X509)
 759
 760 /* Set the PKCS#10 CSR to be sent in P10CR */
 761 DEFINE_OSSL_CMP_CTX_set1(p10CSR, X509_REQ)
 762
 763 /*
 764  * Set the (newly received in IP/KUP/CP) certificate in the context.
 765  * TODO: this only permits for one cert to be enrolled at a time.
 766  */
 767 int ossl_cmp_ctx_set0_newCert(OSSL_CMP_CTX *ctx, X509 *cert)
 768 {
 769     if (!ossl_assert(ctx != NULL))
 770         return 0;
 771
 772     X509_free(ctx->newCert);
 773     ctx->newCert = cert;
 774     return 1;
 775 }
 776
 777 /*
 778  * Get the (newly received in IP/KUP/CP) client certificate from the context
 779  * TODO: this only permits for one client cert to be received...
 780  */
 781 X509 *OSSL_CMP_CTX_get0_newCert(const OSSL_CMP_CTX *ctx)
 782 {
 783     if (ctx == NULL) {
 784         ERR_raise(ERR_LIB_CMP, CMP_R_NULL_ARGUMENT);
 785         return NULL;
 786     }
 787     return ctx->newCert;
 788 }
 789
 790 /* Set the client's current private key */
 791 DEFINE_OSSL_CMP_CTX_set1_up_ref(pkey, EVP_PKEY)
 792
 793 /* Set new key pair. Used e.g. when doing Key Update */
 794 int OSSL_CMP_CTX_set0_newPkey(OSSL_CMP_CTX *ctx, int priv, EVP_PKEY *pkey)
 795 {
 796     if (ctx == NULL) {
 797         ERR_raise(ERR_LIB_CMP, CMP_R_NULL_ARGUMENT);
 798         return 0;
 799     }
 800
 801     EVP_PKEY_free(ctx->newPkey);
 802     ctx->newPkey = pkey;
 803     ctx->newPkey_priv = priv;
 804     return 1;
 805 }
 806
 807 /* Get the private/public key to use for cert enrollment, or NULL on error */
 808 EVP_PKEY *OSSL_CMP_CTX_get0_newPkey(const OSSL_CMP_CTX *ctx, int priv)
 809 {
 810     if (ctx == NULL) {
 811         ERR_raise(ERR_LIB_CMP, CMP_R_NULL_ARGUMENT);
 812         return NULL;
 813     }
 814
 815     if (ctx->newPkey != NULL)
 816         return priv && !ctx->newPkey_priv ? NULL : ctx->newPkey;
 817     if (ctx->p10CSR != NULL)
 818         return priv ? NULL : X509_REQ_get0_pubkey(ctx->p10CSR);
 819     return ctx->pkey; /* may be NULL */
 820 }
 821
 822 /* Set the given transactionID to the context */
 823 int OSSL_CMP_CTX_set1_transactionID(OSSL_CMP_CTX *ctx,
 824                                     const ASN1_OCTET_STRING *id)
 825 {
 826     if (ctx == NULL) {
 827         ERR_raise(ERR_LIB_CMP, CMP_R_NULL_ARGUMENT);
 828         return 0;
 829     }
 830     return ossl_cmp_asn1_octet_string_set1(&ctx->transactionID, id);
 831 }
 832
 833 /* Set the nonce to be used for the recipNonce in the message created next */
 834 int ossl_cmp_ctx_set1_recipNonce(OSSL_CMP_CTX *ctx,
 835                                  const ASN1_OCTET_STRING *nonce)
 836 {
 837     if (!ossl_assert(ctx != NULL))
 838         return 0;
 839     return ossl_cmp_asn1_octet_string_set1(&ctx->recipNonce, nonce);
 840 }
 841
 842 /* Stores the given nonce as the last senderNonce sent out */
 843 int OSSL_CMP_CTX_set1_senderNonce(OSSL_CMP_CTX *ctx,
 844                                   const ASN1_OCTET_STRING *nonce)
 845 {
 846     if (ctx == NULL) {
 847         ERR_raise(ERR_LIB_CMP, CMP_R_NULL_ARGUMENT);
 848         return 0;
 849     }
 850     return ossl_cmp_asn1_octet_string_set1(&ctx->senderNonce, nonce);
 851 }
 852
 853 /* Set the proxy server to use for HTTP(S) connections */
 854 DEFINE_OSSL_CMP_CTX_set1(proxy, char)
 855
 856 /* Set the (HTTP) host name of the CMP server */
 857 DEFINE_OSSL_CMP_CTX_set1(server, char)
 858
 859 /* Set the server exclusion list of the HTTP proxy server */
 860 DEFINE_OSSL_CMP_CTX_set1(no_proxy, char)
 861
 862 /* Set the http connect/disconnect callback function to be used for HTTP(S) */
 863 int OSSL_CMP_CTX_set_http_cb(OSSL_CMP_CTX *ctx, OSSL_HTTP_bio_cb_t cb)
 864 {
 865     if (ctx == NULL) {
 866         ERR_raise(ERR_LIB_CMP, CMP_R_NULL_ARGUMENT);
 867         return 0;
 868     }
 869     ctx->http_cb = cb;
 870     return 1;
 871 }
 872
 873 /* Set argument optionally to be used by the http connect/disconnect callback */
 874 int OSSL_CMP_CTX_set_http_cb_arg(OSSL_CMP_CTX *ctx, void *arg)
 875 {
 876     if (ctx == NULL) {
 877         ERR_raise(ERR_LIB_CMP, CMP_R_NULL_ARGUMENT);
 878         return 0;
 879     }
 880     ctx->http_cb_arg = arg;
 881     return 1;
 882 }
 883
 884 /*
 885  * Get argument optionally to be used by the http connect/disconnect callback
 886  * Returns callback argument set previously (NULL if not set or on error)
 887  */
 888 void *OSSL_CMP_CTX_get_http_cb_arg(const OSSL_CMP_CTX *ctx)
 889 {
 890     if (ctx == NULL) {
 891         ERR_raise(ERR_LIB_CMP, CMP_R_NULL_ARGUMENT);
 892         return NULL;
 893     }
 894     return ctx->http_cb_arg;
 895 }
 896
 897 /* Set callback function for sending CMP request and receiving response */
 898 int OSSL_CMP_CTX_set_transfer_cb(OSSL_CMP_CTX *ctx, OSSL_CMP_transfer_cb_t cb)
 899 {
 900     if (ctx == NULL) {
 901         ERR_raise(ERR_LIB_CMP, CMP_R_NULL_ARGUMENT);
 902         return 0;
 903     }
 904     ctx->transfer_cb = cb;
 905     return 1;
 906 }
 907
 908 /* Set argument optionally to be used by the transfer callback */
 909 int OSSL_CMP_CTX_set_transfer_cb_arg(OSSL_CMP_CTX *ctx, void *arg)
 910 {
 911     if (ctx == NULL) {
 912         ERR_raise(ERR_LIB_CMP, CMP_R_NULL_ARGUMENT);
 913         return 0;
 914     }
 915     ctx->transfer_cb_arg = arg;
 916     return 1;
 917 }
 918
 919 /*
 920  * Get argument optionally to be used by the transfer callback.
 921  * Returns callback argument set previously (NULL if not set or on error)
 922  */
 923 void *OSSL_CMP_CTX_get_transfer_cb_arg(const OSSL_CMP_CTX *ctx)
 924 {
 925     if (ctx == NULL) {
 926         ERR_raise(ERR_LIB_CMP, CMP_R_NULL_ARGUMENT);
 927         return NULL;
 928     }
 929     return ctx->transfer_cb_arg;
 930 }
 931
 932 /** Set the HTTP server port to be used */
 933 int OSSL_CMP_CTX_set_serverPort(OSSL_CMP_CTX *ctx, int port)
 934 {
 935     if (ctx == NULL) {
 936         ERR_raise(ERR_LIB_CMP, CMP_R_NULL_ARGUMENT);
 937         return 0;
 938     }
 939     ctx->serverPort = port;
 940     return 1;
 941 }
 942
 943 /* Set the HTTP path to be used on the server (e.g "pkix/") */
 944 DEFINE_OSSL_CMP_CTX_set1(serverPath, char)
 945
 946 /* Set the failInfo error code as bit encoding in OSSL_CMP_CTX */
 947 int ossl_cmp_ctx_set_failInfoCode(OSSL_CMP_CTX *ctx, int fail_info)
 948 {
 949     if (!ossl_assert(ctx != NULL))
 950         return 0;
 951     ctx->failInfoCode = fail_info;
 952     return 1;
 953 }
 954
 955 /*
 956  * Get the failInfo error code in OSSL_CMP_CTX as bit encoding.
 957  * Returns bit string as integer on success, -1 on error
 958  */
 959 int OSSL_CMP_CTX_get_failInfoCode(const OSSL_CMP_CTX *ctx)
 960 {
 961     if (ctx == NULL) {
 962         ERR_raise(ERR_LIB_CMP, CMP_R_NULL_ARGUMENT);
 963         return -1;
 964     }
 965     return ctx->failInfoCode;
 966 }
 967
 968 /* Set a Boolean or integer option of the context to the "val" arg */
 969 int OSSL_CMP_CTX_set_option(OSSL_CMP_CTX *ctx, int opt, int val)
 970 {
 971     int min_val;
 972
 973     if (ctx == NULL) {
 974         ERR_raise(ERR_LIB_CMP, CMP_R_NULL_ARGUMENT);
 975         return 0;
 976     }
 977
 978     switch (opt) {
 979     case OSSL_CMP_OPT_REVOCATION_REASON:
 980         min_val = OCSP_REVOKED_STATUS_NOSTATUS;
 981         break;
 982     case OSSL_CMP_OPT_POPO_METHOD:
 983         min_val = OSSL_CRMF_POPO_NONE;
 984         break;
 985     default:
 986         min_val = 0;
 987         break;
 988     }
 989     if (val < min_val) {
 990         ERR_raise(ERR_LIB_CMP, CMP_R_VALUE_TOO_SMALL);
 991         return 0;
 992     }
 993
 994     switch (opt) {
 995     case OSSL_CMP_OPT_LOG_VERBOSITY:
 996         if (val > OSSL_CMP_LOG_MAX) {
 997             ERR_raise(ERR_LIB_CMP, CMP_R_VALUE_TOO_LARGE);
 998             return 0;
 999         }
1000         ctx->log_verbosity = val;
1001         break;
1002     case OSSL_CMP_OPT_IMPLICIT_CONFIRM:
1003         ctx->implicitConfirm = val;
1004         break;
1005     case OSSL_CMP_OPT_DISABLE_CONFIRM:
1006         ctx->disableConfirm = val;
1007         break;
1008     case OSSL_CMP_OPT_UNPROTECTED_SEND:
1009         ctx->unprotectedSend = val;
1010         break;
1011     case OSSL_CMP_OPT_UNPROTECTED_ERRORS:
1012         ctx->unprotectedErrors = val;
1013         break;
1014     case OSSL_CMP_OPT_VALIDITY_DAYS:
1015         ctx->days = val;
1016         break;
1017     case OSSL_CMP_OPT_SUBJECTALTNAME_NODEFAULT:
1018         ctx->SubjectAltName_nodefault = val;
1019         break;
1020     case OSSL_CMP_OPT_SUBJECTALTNAME_CRITICAL:
1021         ctx->setSubjectAltNameCritical = val;
1022         break;
1023     case OSSL_CMP_OPT_POLICIES_CRITICAL:
1024         ctx->setPoliciesCritical = val;
1025         break;
1026     case OSSL_CMP_OPT_IGNORE_KEYUSAGE:
1027         ctx->ignore_keyusage = val;
1028         break;
1029     case OSSL_CMP_OPT_POPO_METHOD:
1030         if (val > OSSL_CRMF_POPO_KEYAGREE) {
1031             ERR_raise(ERR_LIB_CMP, CMP_R_VALUE_TOO_LARGE);
1032             return 0;
1033         }
1034         ctx->popoMethod = val;
1035         break;
1036     case OSSL_CMP_OPT_DIGEST_ALGNID:
1037         if (!cmp_ctx_set_md(ctx, &ctx->digest, val))
1038             return 0;
1039         break;
1040     case OSSL_CMP_OPT_OWF_ALGNID:
1041         if (!cmp_ctx_set_md(ctx, &ctx->pbm_owf, val))
1042             return 0;
1043         break;
1044     case OSSL_CMP_OPT_MAC_ALGNID:
1045         ctx->pbm_mac = val;
1046         break;
1047     case OSSL_CMP_OPT_MSG_TIMEOUT:
1048         ctx->msg_timeout = val;
1049         break;
1050     case OSSL_CMP_OPT_TOTAL_TIMEOUT:
1051         ctx->total_timeout = val;
1052         break;
1053     case OSSL_CMP_OPT_PERMIT_TA_IN_EXTRACERTS_FOR_IR:
1054         ctx->permitTAInExtraCertsForIR = val;
1055         break;
1056     case OSSL_CMP_OPT_REVOCATION_REASON:
1057         if (val > OCSP_REVOKED_STATUS_AACOMPROMISE) {
1058             ERR_raise(ERR_LIB_CMP, CMP_R_VALUE_TOO_LARGE);
1059             return 0;
1060         }
1061         ctx->revocationReason = val;
1062         break;
1063     default:
1064         ERR_raise(ERR_LIB_CMP, CMP_R_INVALID_OPTION);
1065         return 0;
1066     }
1067
1068     return 1;
1069 }
1070
1071 /*
1072  * Reads a Boolean or integer option value from the context.
1073  * Returns -1 on error (which is the default OSSL_CMP_OPT_REVOCATION_REASON)
1074  */
1075 int OSSL_CMP_CTX_get_option(const OSSL_CMP_CTX *ctx, int opt)
1076 {
1077     if (ctx == NULL) {
1078         ERR_raise(ERR_LIB_CMP, CMP_R_NULL_ARGUMENT);
1079         return -1;
1080     }
1081
1082     switch (opt) {
1083     case OSSL_CMP_OPT_LOG_VERBOSITY:
1084         return ctx->log_verbosity;
1085     case OSSL_CMP_OPT_IMPLICIT_CONFIRM:
1086         return ctx->implicitConfirm;
1087     case OSSL_CMP_OPT_DISABLE_CONFIRM:
1088         return ctx->disableConfirm;
1089     case OSSL_CMP_OPT_UNPROTECTED_SEND:
1090         return ctx->unprotectedSend;
1091     case OSSL_CMP_OPT_UNPROTECTED_ERRORS:
1092         return ctx->unprotectedErrors;
1093     case OSSL_CMP_OPT_VALIDITY_DAYS:
1094         return ctx->days;
1095     case OSSL_CMP_OPT_SUBJECTALTNAME_NODEFAULT:
1096         return ctx->SubjectAltName_nodefault;
1097     case OSSL_CMP_OPT_SUBJECTALTNAME_CRITICAL:
1098         return ctx->setSubjectAltNameCritical;
1099     case OSSL_CMP_OPT_POLICIES_CRITICAL:
1100         return ctx->setPoliciesCritical;
1101     case OSSL_CMP_OPT_IGNORE_KEYUSAGE:
1102         return ctx->ignore_keyusage;
1103     case OSSL_CMP_OPT_POPO_METHOD:
1104         return ctx->popoMethod;
1105     case OSSL_CMP_OPT_DIGEST_ALGNID:
1106         return EVP_MD_type(ctx->digest);
1107     case OSSL_CMP_OPT_OWF_ALGNID:
1108         return EVP_MD_type(ctx->pbm_owf);
1109     case OSSL_CMP_OPT_MAC_ALGNID:
1110         return ctx->pbm_mac;
1111     case OSSL_CMP_OPT_MSG_TIMEOUT:
1112         return ctx->msg_timeout;
1113     case OSSL_CMP_OPT_TOTAL_TIMEOUT:
1114         return ctx->total_timeout;
1115     case OSSL_CMP_OPT_PERMIT_TA_IN_EXTRACERTS_FOR_IR:
1116         return ctx->permitTAInExtraCertsForIR;
1117     case OSSL_CMP_OPT_REVOCATION_REASON:
1118         return ctx->revocationReason;
1119     default:
1120         ERR_raise(ERR_LIB_CMP, CMP_R_INVALID_OPTION);
1121         return -1;
1122     }
1123 }