crypto/cmp/cmp_ctx.c

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