crypto/cmp/cmp_ctx.c

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