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