crypto/cmp/cmp_server.c

   1 /*
   2  * Copyright 2007-2023 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 /* general CMP server functions */
  13
  14 #include <openssl/asn1t.h>
  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/err.h>
  21
  22 /* the context for the generic CMP server */
  23 struct ossl_cmp_srv_ctx_st
  24 {
  25     OSSL_CMP_CTX *ctx; /* CMP client context reused for transactionID etc. */
  26     void *custom_ctx;  /* application-specific server context */
  27     int certReqId;     /* of ir/cr/kur, OSSL_CMP_CERTREQID_NONE for p10cr */
  28     int polling;       /* current transaction is in polling mode */
  29
  30     OSSL_CMP_SRV_cert_request_cb_t process_cert_request;
  31     OSSL_CMP_SRV_rr_cb_t process_rr;
  32     OSSL_CMP_SRV_genm_cb_t process_genm;
  33     OSSL_CMP_SRV_error_cb_t process_error;
  34     OSSL_CMP_SRV_certConf_cb_t process_certConf;
  35     OSSL_CMP_SRV_pollReq_cb_t process_pollReq;
  36     OSSL_CMP_SRV_delayed_delivery_cb_t delayed_delivery;
  37     OSSL_CMP_SRV_clean_transaction_cb_t clean_transaction;
  38
  39     int sendUnprotectedErrors; /* Send error and rejection msgs unprotected */
  40     int acceptUnprotected;     /* Accept requests with no/invalid prot. */
  41     int acceptRAVerified;      /* Accept ir/cr/kur with POPO RAVerified */
  42     int grantImplicitConfirm;  /* Grant implicit confirmation if requested */
  43
  44 }; /* OSSL_CMP_SRV_CTX */
  45
  46 void OSSL_CMP_SRV_CTX_free(OSSL_CMP_SRV_CTX *srv_ctx)
  47 {
  48     if (srv_ctx == NULL)
  49         return;
  50
  51     OSSL_CMP_CTX_free(srv_ctx->ctx);
  52     OPENSSL_free(srv_ctx);
  53 }
  54
  55 OSSL_CMP_SRV_CTX *OSSL_CMP_SRV_CTX_new(OSSL_LIB_CTX *libctx, const char *propq)
  56 {
  57     OSSL_CMP_SRV_CTX *ctx = OPENSSL_zalloc(sizeof(OSSL_CMP_SRV_CTX));
  58
  59     if (ctx == NULL)
  60         goto err;
  61
  62     if ((ctx->ctx = OSSL_CMP_CTX_new(libctx, propq)) == NULL)
  63         goto err;
  64     ctx->certReqId = OSSL_CMP_CERTREQID_INVALID;
  65     ctx->polling = 0;
  66
  67     /* all other elements are initialized to 0 or NULL, respectively */
  68     return ctx;
  69  err:
  70     OSSL_CMP_SRV_CTX_free(ctx);
  71     return NULL;
  72 }
  73
  74 int OSSL_CMP_SRV_CTX_init(OSSL_CMP_SRV_CTX *srv_ctx, void *custom_ctx,
  75                           OSSL_CMP_SRV_cert_request_cb_t process_cert_request,
  76                           OSSL_CMP_SRV_rr_cb_t process_rr,
  77                           OSSL_CMP_SRV_genm_cb_t process_genm,
  78                           OSSL_CMP_SRV_error_cb_t process_error,
  79                           OSSL_CMP_SRV_certConf_cb_t process_certConf,
  80                           OSSL_CMP_SRV_pollReq_cb_t process_pollReq)
  81 {
  82     if (srv_ctx == NULL) {
  83         ERR_raise(ERR_LIB_CMP, CMP_R_NULL_ARGUMENT);
  84         return 0;
  85     }
  86     srv_ctx->custom_ctx = custom_ctx;
  87     srv_ctx->process_cert_request = process_cert_request;
  88     srv_ctx->process_rr = process_rr;
  89     srv_ctx->process_genm = process_genm;
  90     srv_ctx->process_error = process_error;
  91     srv_ctx->process_certConf = process_certConf;
  92     srv_ctx->process_pollReq = process_pollReq;
  93     return 1;
  94 }
  95
  96 int OSSL_CMP_SRV_CTX_init_trans(OSSL_CMP_SRV_CTX *srv_ctx,
  97                                 OSSL_CMP_SRV_delayed_delivery_cb_t delay,
  98                                 OSSL_CMP_SRV_clean_transaction_cb_t clean)
  99 {
 100     if (srv_ctx == NULL) {
 101         ERR_raise(ERR_LIB_CMP, CMP_R_NULL_ARGUMENT);
 102         return 0;
 103     }
 104     srv_ctx->delayed_delivery = delay;
 105     srv_ctx->clean_transaction = clean;
 106     return 1;
 107 }
 108
 109 OSSL_CMP_CTX *OSSL_CMP_SRV_CTX_get0_cmp_ctx(const OSSL_CMP_SRV_CTX *srv_ctx)
 110 {
 111     if (srv_ctx == NULL) {
 112         ERR_raise(ERR_LIB_CMP, CMP_R_NULL_ARGUMENT);
 113         return NULL;
 114     }
 115     return srv_ctx->ctx;
 116 }
 117
 118 void *OSSL_CMP_SRV_CTX_get0_custom_ctx(const OSSL_CMP_SRV_CTX *srv_ctx)
 119 {
 120     if (srv_ctx == NULL) {
 121         ERR_raise(ERR_LIB_CMP, CMP_R_NULL_ARGUMENT);
 122         return NULL;
 123     }
 124     return srv_ctx->custom_ctx;
 125 }
 126
 127 int OSSL_CMP_SRV_CTX_set_send_unprotected_errors(OSSL_CMP_SRV_CTX *srv_ctx,
 128                                                  int val)
 129 {
 130     if (srv_ctx == NULL) {
 131         ERR_raise(ERR_LIB_CMP, CMP_R_NULL_ARGUMENT);
 132         return 0;
 133     }
 134     srv_ctx->sendUnprotectedErrors = val != 0;
 135     return 1;
 136 }
 137
 138 int OSSL_CMP_SRV_CTX_set_accept_unprotected(OSSL_CMP_SRV_CTX *srv_ctx, int val)
 139 {
 140     if (srv_ctx == NULL) {
 141         ERR_raise(ERR_LIB_CMP, CMP_R_NULL_ARGUMENT);
 142         return 0;
 143     }
 144     srv_ctx->acceptUnprotected = val != 0;
 145     return 1;
 146 }
 147
 148 int OSSL_CMP_SRV_CTX_set_accept_raverified(OSSL_CMP_SRV_CTX *srv_ctx, int val)
 149 {
 150     if (srv_ctx == NULL) {
 151         ERR_raise(ERR_LIB_CMP, CMP_R_NULL_ARGUMENT);
 152         return 0;
 153     }
 154     srv_ctx->acceptRAVerified = val != 0;
 155     return 1;
 156 }
 157
 158 int OSSL_CMP_SRV_CTX_set_grant_implicit_confirm(OSSL_CMP_SRV_CTX *srv_ctx,
 159                                                 int val)
 160 {
 161     if (srv_ctx == NULL) {
 162         ERR_raise(ERR_LIB_CMP, CMP_R_NULL_ARGUMENT);
 163         return 0;
 164     }
 165     srv_ctx->grantImplicitConfirm = val != 0;
 166     return 1;
 167 }
 168
 169 /* return error msg with waiting status if polling is initiated, else NULL */
 170 static OSSL_CMP_MSG *delayed_delivery(OSSL_CMP_SRV_CTX *srv_ctx,
 171                                       const OSSL_CMP_MSG *req)
 172 {
 173     int ret;
 174     unsigned long err;
 175     int status = OSSL_CMP_PKISTATUS_waiting,
 176         fail_info = 0, errorCode = 0;
 177     const char *txt = NULL, *details = NULL;
 178     OSSL_CMP_PKISI *si;
 179     OSSL_CMP_MSG *msg;
 180
 181     if (!ossl_assert(srv_ctx != NULL && srv_ctx->ctx != NULL && req != NULL
 182                      && srv_ctx->delayed_delivery != NULL))
 183         return NULL;
 184
 185     ret = srv_ctx->delayed_delivery(srv_ctx, req);
 186     if (ret == 0)
 187         return NULL;
 188     if (ret == 1) {
 189         srv_ctx->polling = 1;
 190     } else {
 191         status = OSSL_CMP_PKISTATUS_rejection;
 192         fail_info = 1 << OSSL_CMP_PKIFAILUREINFO_systemFailure;
 193         txt = "server application error";
 194         err = ERR_peek_error();
 195         errorCode = ERR_GET_REASON(err);
 196         details = ERR_reason_error_string(err);
 197     }
 198
 199     si = OSSL_CMP_STATUSINFO_new(status, fail_info, txt);
 200     if (si == NULL)
 201         return NULL;
 202
 203     msg = ossl_cmp_error_new(srv_ctx->ctx, si, errorCode, details,
 204                              srv_ctx->sendUnprotectedErrors);
 205     OSSL_CMP_PKISI_free(si);
 206     return msg;
 207 }
 208
 209 /*
 210  * Processes an ir/cr/p10cr/kur and returns a certification response.
 211  * Only handles the first certification request contained in req
 212  * returns an ip/cp/kup on success and NULL on error
 213  */
 214 static OSSL_CMP_MSG *process_cert_request(OSSL_CMP_SRV_CTX *srv_ctx,
 215                                           const OSSL_CMP_MSG *req)
 216 {
 217     OSSL_CMP_MSG *msg = NULL;
 218     OSSL_CMP_PKISI *si = NULL;
 219     X509 *certOut = NULL;
 220     STACK_OF(X509) *chainOut = NULL, *caPubs = NULL;
 221     const OSSL_CRMF_MSG *crm = NULL;
 222     const X509_REQ *p10cr = NULL;
 223     int bodytype;
 224     int certReqId;
 225
 226     if (!ossl_assert(srv_ctx != NULL && srv_ctx->ctx != NULL && req != NULL))
 227         return NULL;
 228
 229     switch (OSSL_CMP_MSG_get_bodytype(req)) {
 230     case OSSL_CMP_PKIBODY_P10CR:
 231     case OSSL_CMP_PKIBODY_CR:
 232         bodytype = OSSL_CMP_PKIBODY_CP;
 233         break;
 234     case OSSL_CMP_PKIBODY_IR:
 235         bodytype = OSSL_CMP_PKIBODY_IP;
 236         break;
 237     case OSSL_CMP_PKIBODY_KUR:
 238         bodytype = OSSL_CMP_PKIBODY_KUP;
 239         break;
 240     default:
 241         ERR_raise(ERR_LIB_CMP, CMP_R_UNEXPECTED_PKIBODY);
 242         return NULL;
 243     }
 244
 245     if (OSSL_CMP_MSG_get_bodytype(req) == OSSL_CMP_PKIBODY_P10CR) {
 246         certReqId = OSSL_CMP_CERTREQID_NONE; /* p10cr does not include an Id */
 247         p10cr = req->body->value.p10cr;
 248     } else {
 249         OSSL_CRMF_MSGS *reqs = req->body->value.ir; /* same for cr and kur */
 250
 251         if (sk_OSSL_CRMF_MSG_num(reqs) != 1) {
 252             ERR_raise(ERR_LIB_CMP, CMP_R_MULTIPLE_REQUESTS_NOT_SUPPORTED);
 253             return NULL;
 254         }
 255         if ((crm = sk_OSSL_CRMF_MSG_value(reqs, 0)) == NULL) {
 256             ERR_raise(ERR_LIB_CMP, CMP_R_CERTREQMSG_NOT_FOUND);
 257             return NULL;
 258         }
 259         certReqId = OSSL_CRMF_MSG_get_certReqId(crm);
 260         if (certReqId != OSSL_CMP_CERTREQID) { /* so far, only possible value */
 261             ERR_raise(ERR_LIB_CMP, CMP_R_BAD_REQUEST_ID);
 262             return NULL;
 263         }
 264     }
 265     srv_ctx->certReqId = certReqId;
 266
 267     if (!ossl_cmp_verify_popo(srv_ctx->ctx, req, srv_ctx->acceptRAVerified)) {
 268         /* Proof of possession could not be verified */
 269         si = OSSL_CMP_STATUSINFO_new(OSSL_CMP_PKISTATUS_rejection,
 270                                      1 << OSSL_CMP_PKIFAILUREINFO_badPOP,
 271                                      ERR_reason_error_string(ERR_peek_error()));
 272         if (si == NULL)
 273             return NULL;
 274     } else {
 275         OSSL_CMP_PKIHEADER *hdr = OSSL_CMP_MSG_get0_header(req);
 276
 277         si = srv_ctx->process_cert_request(srv_ctx, req, certReqId, crm, p10cr,
 278                                            &certOut, &chainOut, &caPubs);
 279         if (si == NULL)
 280             goto err;
 281         if (ossl_cmp_pkisi_get_status(si) == OSSL_CMP_PKISTATUS_waiting)
 282             srv_ctx->polling = 1;
 283         /* set OSSL_CMP_OPT_IMPLICIT_CONFIRM if and only if transaction ends */
 284         if (!OSSL_CMP_CTX_set_option(srv_ctx->ctx,
 285                                      OSSL_CMP_OPT_IMPLICIT_CONFIRM,
 286                                      ossl_cmp_hdr_has_implicitConfirm(hdr)
 287                                          && srv_ctx->grantImplicitConfirm
 288                                          /* do not set if polling starts: */
 289                                          && certOut != NULL))
 290             goto err;
 291     }
 292
 293     msg = ossl_cmp_certrep_new(srv_ctx->ctx, bodytype, certReqId, si,
 294                                certOut, NULL /* enc */, chainOut, caPubs,
 295                                srv_ctx->sendUnprotectedErrors);
 296     /* When supporting OSSL_CRMF_POPO_KEYENC, "enc" will need to be set */
 297     if (msg == NULL)
 298         ERR_raise(ERR_LIB_CMP, CMP_R_ERROR_CREATING_CERTREP);
 299
 300  err:
 301     OSSL_CMP_PKISI_free(si);
 302     X509_free(certOut);
 303     OSSL_STACK_OF_X509_free(chainOut);
 304     OSSL_STACK_OF_X509_free(caPubs);
 305     return msg;
 306 }
 307
 308 static OSSL_CMP_MSG *process_rr(OSSL_CMP_SRV_CTX *srv_ctx,
 309                                 const OSSL_CMP_MSG *req)
 310 {
 311     OSSL_CMP_MSG *msg = NULL;
 312     OSSL_CMP_REVDETAILS *details;
 313     OSSL_CRMF_CERTID *certId = NULL;
 314     OSSL_CRMF_CERTTEMPLATE *tmpl;
 315     const X509_NAME *issuer;
 316     const ASN1_INTEGER *serial;
 317     OSSL_CMP_PKISI *si;
 318
 319     if (!ossl_assert(srv_ctx != NULL && srv_ctx->ctx != NULL && req != NULL))
 320         return NULL;
 321
 322     if (sk_OSSL_CMP_REVDETAILS_num(req->body->value.rr) != 1) {
 323         ERR_raise(ERR_LIB_CMP, CMP_R_MULTIPLE_REQUESTS_NOT_SUPPORTED);
 324         return NULL;
 325     }
 326     details = sk_OSSL_CMP_REVDETAILS_value(req->body->value.rr, 0);
 327     if (details == NULL) {
 328         ERR_raise(ERR_LIB_CMP, CMP_R_ERROR_PROCESSING_MESSAGE);
 329         return NULL;
 330     }
 331
 332     tmpl = details->certDetails;
 333     issuer = OSSL_CRMF_CERTTEMPLATE_get0_issuer(tmpl);
 334     serial = OSSL_CRMF_CERTTEMPLATE_get0_serialNumber(tmpl);
 335     if (issuer != NULL && serial != NULL
 336             && (certId = OSSL_CRMF_CERTID_gen(issuer, serial)) == NULL)
 337         return NULL;
 338     if ((si = srv_ctx->process_rr(srv_ctx, req, issuer, serial)) == NULL)
 339         goto err;
 340
 341     if ((msg = ossl_cmp_rp_new(srv_ctx->ctx, si, certId,
 342                                srv_ctx->sendUnprotectedErrors)) == NULL)
 343         ERR_raise(ERR_LIB_CMP, CMP_R_ERROR_CREATING_RR);
 344
 345  err:
 346     OSSL_CRMF_CERTID_free(certId);
 347     OSSL_CMP_PKISI_free(si);
 348     return msg;
 349 }
 350
 351 /*
 352  * Processes genm and creates a genp message mirroring the contents of the
 353  * incoming message
 354  */
 355 static OSSL_CMP_MSG *process_genm(OSSL_CMP_SRV_CTX *srv_ctx,
 356                                   const OSSL_CMP_MSG *req)
 357 {
 358     OSSL_CMP_GENMSGCONTENT *itavs;
 359     OSSL_CMP_MSG *msg;
 360
 361     if (!ossl_assert(srv_ctx != NULL && srv_ctx->ctx != NULL && req != NULL))
 362         return NULL;
 363
 364     if (!srv_ctx->process_genm(srv_ctx, req, req->body->value.genm, &itavs))
 365         return NULL;
 366
 367     msg = ossl_cmp_genp_new(srv_ctx->ctx, itavs);
 368     sk_OSSL_CMP_ITAV_pop_free(itavs, OSSL_CMP_ITAV_free);
 369     return msg;
 370 }
 371
 372 static OSSL_CMP_MSG *process_error(OSSL_CMP_SRV_CTX *srv_ctx,
 373                                    const OSSL_CMP_MSG *req)
 374 {
 375     OSSL_CMP_ERRORMSGCONTENT *errorContent;
 376     OSSL_CMP_MSG *msg;
 377
 378     if (!ossl_assert(srv_ctx != NULL && srv_ctx->ctx != NULL && req != NULL))
 379         return NULL;
 380     errorContent = req->body->value.error;
 381     srv_ctx->process_error(srv_ctx, req, errorContent->pKIStatusInfo,
 382                            errorContent->errorCode, errorContent->errorDetails);
 383
 384     if ((msg = ossl_cmp_pkiconf_new(srv_ctx->ctx)) == NULL)
 385         ERR_raise(ERR_LIB_CMP, CMP_R_ERROR_CREATING_PKICONF);
 386     return msg;
 387 }
 388
 389 static OSSL_CMP_MSG *process_certConf(OSSL_CMP_SRV_CTX *srv_ctx,
 390                                       const OSSL_CMP_MSG *req)
 391 {
 392     OSSL_CMP_CTX *ctx;
 393     OSSL_CMP_CERTCONFIRMCONTENT *ccc;
 394     int num;
 395     OSSL_CMP_MSG *msg = NULL;
 396     OSSL_CMP_CERTSTATUS *status = NULL;
 397
 398     if (!ossl_assert(srv_ctx != NULL && srv_ctx->ctx != NULL && req != NULL))
 399         return NULL;
 400
 401     ctx = srv_ctx->ctx;
 402     ccc = req->body->value.certConf;
 403     num = sk_OSSL_CMP_CERTSTATUS_num(ccc);
 404
 405     if (OSSL_CMP_CTX_get_option(ctx, OSSL_CMP_OPT_IMPLICIT_CONFIRM) == 1
 406             || ctx->status != OSSL_CMP_PKISTATUS_trans) {
 407         ERR_raise(ERR_LIB_CMP, CMP_R_ERROR_UNEXPECTED_CERTCONF);
 408         return NULL;
 409     }
 410
 411     if (num == 0) {
 412         ossl_cmp_err(ctx, "certificate rejected by client");
 413     } else {
 414         if (num > 1)
 415             ossl_cmp_warn(ctx, "All CertStatus but the first will be ignored");
 416         status = sk_OSSL_CMP_CERTSTATUS_value(ccc, 0);
 417     }
 418
 419     if (status != NULL) {
 420         int certReqId = ossl_cmp_asn1_get_int(status->certReqId);
 421         ASN1_OCTET_STRING *certHash = status->certHash;
 422         OSSL_CMP_PKISI *si = status->statusInfo;
 423
 424         if (certReqId != srv_ctx->certReqId) {
 425             ERR_raise(ERR_LIB_CMP, CMP_R_BAD_REQUEST_ID);
 426             return NULL;
 427         }
 428         if (!srv_ctx->process_certConf(srv_ctx, req, certReqId, certHash, si))
 429             return NULL; /* reason code may be: CMP_R_CERTHASH_UNMATCHED */
 430
 431         if (si != NULL
 432             && ossl_cmp_pkisi_get_status(si) != OSSL_CMP_PKISTATUS_accepted) {
 433             int pki_status = ossl_cmp_pkisi_get_status(si);
 434             const char *str = ossl_cmp_PKIStatus_to_string(pki_status);
 435
 436             ossl_cmp_log2(INFO, ctx, "certificate rejected by client %s %s",
 437                           str == NULL ? "without" : "with",
 438                           str == NULL ? "PKIStatus" : str);
 439         }
 440     }
 441
 442     if ((msg = ossl_cmp_pkiconf_new(ctx)) == NULL)
 443         ERR_raise(ERR_LIB_CMP, CMP_R_ERROR_CREATING_PKICONF);
 444     return msg;
 445 }
 446
 447 /* pollReq is handled separately, to avoid recursive call */
 448 static OSSL_CMP_MSG *process_non_polling_request(OSSL_CMP_SRV_CTX *srv_ctx,
 449                                                  const OSSL_CMP_MSG *req)
 450 {
 451     OSSL_CMP_MSG *rsp = NULL;
 452
 453     if (!ossl_assert(srv_ctx != NULL && srv_ctx->ctx != NULL && req != NULL
 454                      && req->body != NULL))
 455         return NULL;
 456
 457     switch (OSSL_CMP_MSG_get_bodytype(req)) {
 458     case OSSL_CMP_PKIBODY_IR:
 459     case OSSL_CMP_PKIBODY_CR:
 460     case OSSL_CMP_PKIBODY_P10CR:
 461     case OSSL_CMP_PKIBODY_KUR:
 462         if (srv_ctx->process_cert_request == NULL)
 463             ERR_raise(ERR_LIB_CMP, CMP_R_UNSUPPORTED_PKIBODY);
 464         else
 465             rsp = process_cert_request(srv_ctx, req);
 466         break;
 467     case OSSL_CMP_PKIBODY_RR:
 468         if (srv_ctx->process_rr == NULL)
 469             ERR_raise(ERR_LIB_CMP, CMP_R_UNSUPPORTED_PKIBODY);
 470         else
 471             rsp = process_rr(srv_ctx, req);
 472         break;
 473     case OSSL_CMP_PKIBODY_GENM:
 474         if (srv_ctx->process_genm == NULL)
 475             ERR_raise(ERR_LIB_CMP, CMP_R_UNSUPPORTED_PKIBODY);
 476         else
 477             rsp = process_genm(srv_ctx, req);
 478         break;
 479     case OSSL_CMP_PKIBODY_ERROR:
 480         if (srv_ctx->process_error == NULL)
 481             ERR_raise(ERR_LIB_CMP, CMP_R_UNSUPPORTED_PKIBODY);
 482         else
 483             rsp = process_error(srv_ctx, req);
 484         break;
 485     case OSSL_CMP_PKIBODY_CERTCONF:
 486         if (srv_ctx->process_certConf == NULL)
 487             ERR_raise(ERR_LIB_CMP, CMP_R_UNSUPPORTED_PKIBODY);
 488         else
 489             rsp = process_certConf(srv_ctx, req);
 490         break;
 491
 492     case OSSL_CMP_PKIBODY_POLLREQ:
 493         ERR_raise(ERR_LIB_CMP, CMP_R_UNEXPECTED_PKIBODY);
 494         break;
 495     default:
 496         ERR_raise(ERR_LIB_CMP, CMP_R_UNSUPPORTED_PKIBODY);
 497         break;
 498     }
 499
 500     return rsp;
 501 }
 502
 503 static OSSL_CMP_MSG *process_pollReq(OSSL_CMP_SRV_CTX *srv_ctx,
 504                                      const OSSL_CMP_MSG *req)
 505 {
 506     OSSL_CMP_POLLREQCONTENT *prc;
 507     OSSL_CMP_POLLREQ *pr;
 508     int certReqId;
 509     OSSL_CMP_MSG *orig_req;
 510     int64_t check_after = 0;
 511     OSSL_CMP_MSG *msg = NULL;
 512
 513     if (!ossl_assert(srv_ctx != NULL && srv_ctx->ctx != NULL && req != NULL))
 514         return NULL;
 515
 516     if (!srv_ctx->polling) {
 517         ERR_raise(ERR_LIB_CMP, CMP_R_UNEXPECTED_PKIBODY);
 518         return NULL;
 519     }
 520
 521     prc = req->body->value.pollReq;
 522     if (sk_OSSL_CMP_POLLREQ_num(prc) != 1) {
 523         ERR_raise(ERR_LIB_CMP, CMP_R_MULTIPLE_REQUESTS_NOT_SUPPORTED);
 524         return NULL;
 525     }
 526
 527     pr = sk_OSSL_CMP_POLLREQ_value(prc, 0);
 528     certReqId = ossl_cmp_asn1_get_int(pr->certReqId);
 529     if (!srv_ctx->process_pollReq(srv_ctx, req, certReqId,
 530                                   &orig_req, &check_after))
 531         return NULL;
 532
 533     if (orig_req != NULL) {
 534         srv_ctx->polling = 0;
 535         msg = process_non_polling_request(srv_ctx, orig_req);
 536         OSSL_CMP_MSG_free(orig_req);
 537     } else {
 538         if ((msg = ossl_cmp_pollRep_new(srv_ctx->ctx, certReqId,
 539                                         check_after)) == NULL)
 540             ERR_raise(ERR_LIB_CMP, CMP_R_ERROR_CREATING_POLLREP);
 541     }
 542     return msg;
 543 }
 544
 545 /*
 546  * Determine whether missing/invalid protection of request message is allowed.
 547  * Return 1 on acceptance, 0 on rejection, or -1 on (internal) error.
 548  */
 549 static int unprotected_exception(const OSSL_CMP_CTX *ctx,
 550                                  const OSSL_CMP_MSG *req,
 551                                  int invalid_protection,
 552                                  int accept_unprotected_requests)
 553 {
 554     if (!ossl_assert(ctx != NULL && req != NULL))
 555         return -1;
 556
 557     if (accept_unprotected_requests) {
 558         ossl_cmp_log1(WARN, ctx, "ignoring %s protection of request message",
 559                       invalid_protection ? "invalid" : "missing");
 560         return 1;
 561     }
 562     if (OSSL_CMP_MSG_get_bodytype(req) == OSSL_CMP_PKIBODY_ERROR
 563         && OSSL_CMP_CTX_get_option(ctx, OSSL_CMP_OPT_UNPROTECTED_ERRORS) == 1) {
 564         ossl_cmp_warn(ctx, "ignoring missing protection of error message");
 565         return 1;
 566     }
 567     return 0;
 568 }
 569
 570 /*
 571  * returns created message and NULL on internal error
 572  */
 573 OSSL_CMP_MSG *OSSL_CMP_SRV_process_request(OSSL_CMP_SRV_CTX *srv_ctx,
 574                                            const OSSL_CMP_MSG *req)
 575 {
 576     OSSL_CMP_CTX *ctx;
 577     ASN1_OCTET_STRING *backup_secret;
 578     OSSL_CMP_PKIHEADER *hdr;
 579     int req_type, rsp_type;
 580     int req_verified = 0;
 581     OSSL_CMP_MSG *rsp = NULL;
 582
 583     if (srv_ctx == NULL || srv_ctx->ctx == NULL
 584             || req == NULL || req->body == NULL
 585             || (hdr = OSSL_CMP_MSG_get0_header(req)) == NULL) {
 586         ERR_raise(ERR_LIB_CMP, CMP_R_NULL_ARGUMENT);
 587         return 0;
 588     }
 589     ctx = srv_ctx->ctx;
 590     backup_secret = ctx->secretValue;
 591     req_type = OSSL_CMP_MSG_get_bodytype(req);
 592     ossl_cmp_log1(DEBUG, ctx,
 593                   "received %s", ossl_cmp_bodytype_to_string(req_type));
 594
 595     /*
 596      * Some things need to be done already before validating the message in
 597      * order to be able to send an error message as far as needed and possible.
 598      */
 599     if (hdr->sender->type != GEN_DIRNAME) {
 600         ERR_raise(ERR_LIB_CMP, CMP_R_SENDER_GENERALNAME_TYPE_NOT_SUPPORTED);
 601         goto err;
 602     }
 603     if (!OSSL_CMP_CTX_set1_recipient(ctx, hdr->sender->d.directoryName))
 604         goto err;
 605
 606     if (srv_ctx->polling && req_type != OSSL_CMP_PKIBODY_POLLREQ
 607             && req_type != OSSL_CMP_PKIBODY_ERROR) {
 608         ERR_raise(ERR_LIB_CMP, CMP_R_EXPECTED_POLLREQ);
 609         goto err;
 610     }
 611
 612     switch (req_type) {
 613     case OSSL_CMP_PKIBODY_IR:
 614     case OSSL_CMP_PKIBODY_CR:
 615     case OSSL_CMP_PKIBODY_P10CR:
 616     case OSSL_CMP_PKIBODY_KUR:
 617     case OSSL_CMP_PKIBODY_RR:
 618     case OSSL_CMP_PKIBODY_GENM:
 619     case OSSL_CMP_PKIBODY_ERROR:
 620         if (ctx->transactionID != NULL) {
 621             char *tid = i2s_ASN1_OCTET_STRING(NULL, ctx->transactionID);
 622
 623             if (tid != NULL)
 624                 ossl_cmp_log1(WARN, ctx,
 625                               "Assuming that last transaction with ID=%s got aborted",
 626                               tid);
 627             OPENSSL_free(tid);
 628         }
 629         /* start of a new transaction, reset transactionID and senderNonce */
 630         if (!OSSL_CMP_CTX_set1_transactionID(ctx, NULL)
 631                 || !OSSL_CMP_CTX_set1_senderNonce(ctx, NULL))
 632             goto err;
 633
 634         if (srv_ctx->clean_transaction != NULL
 635                 && !srv_ctx->clean_transaction(srv_ctx, NULL)) {
 636             ERR_raise(ERR_LIB_CMP, CMP_R_ERROR_PROCESSING_MESSAGE);
 637             goto err;
 638         }
 639
 640         break;
 641     default:
 642         /* transactionID should be already initialized */
 643         if (ctx->transactionID == NULL) {
 644 #ifndef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
 645             ERR_raise(ERR_LIB_CMP, CMP_R_UNEXPECTED_PKIBODY);
 646             goto err;
 647 #endif
 648         }
 649     }
 650
 651     req_verified = ossl_cmp_msg_check_update(ctx, req, unprotected_exception,
 652                                              srv_ctx->acceptUnprotected);
 653     if (ctx->secretValue != NULL && ctx->pkey != NULL
 654             && ossl_cmp_hdr_get_protection_nid(hdr) != NID_id_PasswordBasedMAC)
 655         ctx->secretValue = NULL; /* use MSG_SIG_ALG when protecting rsp */
 656     if (!req_verified)
 657         goto err;
 658
 659     if (req_type == OSSL_CMP_PKIBODY_POLLREQ) {
 660         if (srv_ctx->process_pollReq == NULL)
 661             ERR_raise(ERR_LIB_CMP, CMP_R_UNSUPPORTED_PKIBODY);
 662         else
 663             rsp = process_pollReq(srv_ctx, req);
 664     } else {
 665         if (srv_ctx->delayed_delivery != NULL
 666             && (rsp = delayed_delivery(srv_ctx, req)) != NULL) {
 667             goto err;
 668         }
 669         rsp = process_non_polling_request(srv_ctx, req);
 670     }
 671
 672  err:
 673     if (rsp == NULL) {
 674         /* on error, try to respond with CMP error message to client */
 675         const char *data = NULL, *reason = NULL;
 676         int flags = 0;
 677         unsigned long err = ERR_peek_error_data(&data, &flags);
 678         int fail_info = 1 << OSSL_CMP_PKIFAILUREINFO_badRequest;
 679         /* fail_info is not very specific */
 680         OSSL_CMP_PKISI *si = NULL;
 681
 682         if (!req_verified) {
 683             /*
 684              * Above ossl_cmp_msg_check_update() was not successfully executed,
 685              * which normally would set ctx->transactionID and ctx->recipNonce.
 686              * So anyway try to provide the right transactionID and recipNonce,
 687              * while ignoring any (extra) error in next two function calls.
 688              */
 689             if (ctx->transactionID == NULL)
 690                 (void)OSSL_CMP_CTX_set1_transactionID(ctx, hdr->transactionID);
 691             (void)ossl_cmp_ctx_set1_recipNonce(ctx, hdr->senderNonce);
 692         }
 693
 694         if ((flags & ERR_TXT_STRING) == 0 || *data == '\0')
 695             data = NULL;
 696         reason = ERR_reason_error_string(err);
 697         if ((si = OSSL_CMP_STATUSINFO_new(OSSL_CMP_PKISTATUS_rejection,
 698                                           fail_info, reason)) != NULL) {
 699             rsp = ossl_cmp_error_new(srv_ctx->ctx, si, err,
 700                                      data, srv_ctx->sendUnprotectedErrors);
 701             OSSL_CMP_PKISI_free(si);
 702         }
 703     }
 704     OSSL_CMP_CTX_print_errors(ctx);
 705     ctx->secretValue = backup_secret;
 706
 707     rsp_type =
 708         rsp != NULL ? OSSL_CMP_MSG_get_bodytype(rsp) : OSSL_CMP_PKIBODY_ERROR;
 709     if (rsp != NULL)
 710         ossl_cmp_log1(DEBUG, ctx,
 711                       "sending %s", ossl_cmp_bodytype_to_string(rsp_type));
 712     else
 713         ossl_cmp_log(ERR, ctx, "cannot send proper CMP response");
 714
 715     /* determine whether to keep the transaction open or not */
 716     ctx->status = OSSL_CMP_PKISTATUS_trans;
 717     switch (rsp_type) {
 718     case OSSL_CMP_PKIBODY_IP:
 719     case OSSL_CMP_PKIBODY_CP:
 720     case OSSL_CMP_PKIBODY_KUP:
 721         if (OSSL_CMP_CTX_get_option(ctx, OSSL_CMP_OPT_IMPLICIT_CONFIRM) == 0)
 722             break;
 723         /* fall through */
 724
 725     case OSSL_CMP_PKIBODY_ERROR:
 726         if (rsp != NULL && ossl_cmp_is_error_with_waiting(rsp))
 727             break;
 728         /* fall through */
 729
 730     case OSSL_CMP_PKIBODY_RP:
 731     case OSSL_CMP_PKIBODY_PKICONF:
 732     case OSSL_CMP_PKIBODY_GENP:
 733         /* Other terminating response message types are not supported */
 734         srv_ctx->certReqId = OSSL_CMP_CERTREQID_INVALID;
 735         /* Prepare for next transaction, ignoring any errors here: */
 736         if (srv_ctx->clean_transaction != NULL)
 737             (void)srv_ctx->clean_transaction(srv_ctx, ctx->transactionID);
 738         (void)OSSL_CMP_CTX_set1_transactionID(ctx, NULL);
 739         (void)OSSL_CMP_CTX_set1_senderNonce(ctx, NULL);
 740         ctx->status = OSSL_CMP_PKISTATUS_unspecified; /* transaction closed */
 741
 742     default: /* not closing transaction in other cases */
 743         break;
 744     }
 745     return rsp;
 746 }
 747
 748 /*
 749  * Server interface that may substitute OSSL_CMP_MSG_http_perform at the client.
 750  * The OSSL_CMP_SRV_CTX must be set as client_ctx->transfer_cb_arg.
 751  * returns received message on success, else NULL and pushes an element on the
 752  * error stack.
 753  */
 754 OSSL_CMP_MSG *OSSL_CMP_CTX_server_perform(OSSL_CMP_CTX *client_ctx,
 755                                           const OSSL_CMP_MSG *req)
 756 {
 757     OSSL_CMP_SRV_CTX *srv_ctx = NULL;
 758
 759     if (client_ctx == NULL || req == NULL) {
 760         ERR_raise(ERR_LIB_CMP, CMP_R_NULL_ARGUMENT);
 761         return NULL;
 762     }
 763
 764     if ((srv_ctx = OSSL_CMP_CTX_get_transfer_cb_arg(client_ctx)) == NULL) {
 765         ERR_raise(ERR_LIB_CMP, CMP_R_TRANSFER_ERROR);
 766         return NULL;
 767     }
 768
 769     return OSSL_CMP_SRV_process_request(srv_ctx, req);
 770 }