apps/lib/cmp_mock_srv.c

   1 /*
   2  * Copyright 2018-2022 The OpenSSL Project Authors. All Rights Reserved.
   3  * Copyright Siemens AG 2018-2020
   4  *
   5  * Licensed under the Apache License 2.0 (the "License").  You may not use
   6  * this file except in compliance with the License.  You can obtain a copy
   7  * in the file LICENSE in the source distribution or atf
   8  * https://www.openssl.org/source/license.html
   9  */
  10
  11 #include "apps.h"
  12 #include "cmp_mock_srv.h"
  13
  14 #include <openssl/cmp.h>
  15 #include <openssl/err.h>
  16 #include <openssl/cmperr.h>
  17
  18 /* the context for the CMP mock server */
  19 typedef struct
  20 {
  21     X509 *refCert;             /* cert to expect for oldCertID in kur/rr msg */
  22     X509 *certOut;             /* certificate to be returned in cp/ip/kup msg */
  23     STACK_OF(X509) *chainOut;  /* chain of certOut to add to extraCerts field */
  24     STACK_OF(X509) *caPubsOut; /* used in caPubs of ip and in caCerts of genp */
  25     OSSL_CMP_PKISI *statusOut; /* status for ip/cp/kup/rp msg unless polling */
  26     int sendError;             /* send error response on given request type */
  27     OSSL_CMP_MSG *certReq;     /* ir/cr/p10cr/kur remembered while polling */
  28     int pollCount;             /* number of polls before actual cert response */
  29     int curr_pollCount;        /* number of polls so far for current request */
  30     int checkAfterTime;        /* time the client should wait between polling */
  31 } mock_srv_ctx;
  32
  33 static void mock_srv_ctx_free(mock_srv_ctx *ctx)
  34 {
  35     if (ctx == NULL)
  36         return;
  37
  38     OSSL_CMP_PKISI_free(ctx->statusOut);
  39     X509_free(ctx->refCert);
  40     X509_free(ctx->certOut);
  41     OSSL_STACK_OF_X509_free(ctx->chainOut);
  42     OSSL_STACK_OF_X509_free(ctx->caPubsOut);
  43     OSSL_CMP_MSG_free(ctx->certReq);
  44     OPENSSL_free(ctx);
  45 }
  46
  47 static mock_srv_ctx *mock_srv_ctx_new(void)
  48 {
  49     mock_srv_ctx *ctx = OPENSSL_zalloc(sizeof(mock_srv_ctx));
  50
  51     if (ctx == NULL)
  52         goto err;
  53
  54     if ((ctx->statusOut = OSSL_CMP_PKISI_new()) == NULL)
  55         goto err;
  56
  57     ctx->sendError = -1;
  58
  59     /* all other elements are initialized to 0 or NULL, respectively */
  60     return ctx;
  61  err:
  62     mock_srv_ctx_free(ctx);
  63     return NULL;
  64 }
  65
  66 int ossl_cmp_mock_srv_set1_refCert(OSSL_CMP_SRV_CTX *srv_ctx, X509 *cert)
  67 {
  68     mock_srv_ctx *ctx = OSSL_CMP_SRV_CTX_get0_custom_ctx(srv_ctx);
  69
  70     if (ctx == NULL) {
  71         ERR_raise(ERR_LIB_CMP, CMP_R_NULL_ARGUMENT);
  72         return 0;
  73     }
  74     if (cert == NULL || X509_up_ref(cert)) {
  75         X509_free(ctx->refCert);
  76         ctx->refCert = cert;
  77         return 1;
  78     }
  79     return 0;
  80 }
  81
  82 int ossl_cmp_mock_srv_set1_certOut(OSSL_CMP_SRV_CTX *srv_ctx, X509 *cert)
  83 {
  84     mock_srv_ctx *ctx = OSSL_CMP_SRV_CTX_get0_custom_ctx(srv_ctx);
  85
  86     if (ctx == NULL) {
  87         ERR_raise(ERR_LIB_CMP, CMP_R_NULL_ARGUMENT);
  88         return 0;
  89     }
  90     if (cert == NULL || X509_up_ref(cert)) {
  91         X509_free(ctx->certOut);
  92         ctx->certOut = cert;
  93         return 1;
  94     }
  95     return 0;
  96 }
  97
  98 int ossl_cmp_mock_srv_set1_chainOut(OSSL_CMP_SRV_CTX *srv_ctx,
  99                                     STACK_OF(X509) *chain)
 100 {
 101     mock_srv_ctx *ctx = OSSL_CMP_SRV_CTX_get0_custom_ctx(srv_ctx);
 102     STACK_OF(X509) *chain_copy = NULL;
 103
 104     if (ctx == NULL) {
 105         ERR_raise(ERR_LIB_CMP, CMP_R_NULL_ARGUMENT);
 106         return 0;
 107     }
 108     if (chain != NULL && (chain_copy = X509_chain_up_ref(chain)) == NULL)
 109         return 0;
 110     OSSL_STACK_OF_X509_free(ctx->chainOut);
 111     ctx->chainOut = chain_copy;
 112     return 1;
 113 }
 114
 115 int ossl_cmp_mock_srv_set1_caPubsOut(OSSL_CMP_SRV_CTX *srv_ctx,
 116                                      STACK_OF(X509) *caPubs)
 117 {
 118     mock_srv_ctx *ctx = OSSL_CMP_SRV_CTX_get0_custom_ctx(srv_ctx);
 119     STACK_OF(X509) *caPubs_copy = NULL;
 120
 121     if (ctx == NULL) {
 122         ERR_raise(ERR_LIB_CMP, CMP_R_NULL_ARGUMENT);
 123         return 0;
 124     }
 125     if (caPubs != NULL && (caPubs_copy = X509_chain_up_ref(caPubs)) == NULL)
 126         return 0;
 127     OSSL_STACK_OF_X509_free(ctx->caPubsOut);
 128     ctx->caPubsOut = caPubs_copy;
 129     return 1;
 130 }
 131
 132 int ossl_cmp_mock_srv_set_statusInfo(OSSL_CMP_SRV_CTX *srv_ctx, int status,
 133                                      int fail_info, const char *text)
 134 {
 135     mock_srv_ctx *ctx = OSSL_CMP_SRV_CTX_get0_custom_ctx(srv_ctx);
 136     OSSL_CMP_PKISI *si;
 137
 138     if (ctx == NULL) {
 139         ERR_raise(ERR_LIB_CMP, CMP_R_NULL_ARGUMENT);
 140         return 0;
 141     }
 142     if ((si = OSSL_CMP_STATUSINFO_new(status, fail_info, text)) == NULL)
 143         return 0;
 144     OSSL_CMP_PKISI_free(ctx->statusOut);
 145     ctx->statusOut = si;
 146     return 1;
 147 }
 148
 149 int ossl_cmp_mock_srv_set_sendError(OSSL_CMP_SRV_CTX *srv_ctx, int bodytype)
 150 {
 151     mock_srv_ctx *ctx = OSSL_CMP_SRV_CTX_get0_custom_ctx(srv_ctx);
 152
 153     if (ctx == NULL) {
 154         ERR_raise(ERR_LIB_CMP, CMP_R_NULL_ARGUMENT);
 155         return 0;
 156     }
 157     /* might check bodytype, but this would require exporting all body types */
 158     ctx->sendError = bodytype;
 159     return 1;
 160 }
 161
 162 int ossl_cmp_mock_srv_set_pollCount(OSSL_CMP_SRV_CTX *srv_ctx, int count)
 163 {
 164     mock_srv_ctx *ctx = OSSL_CMP_SRV_CTX_get0_custom_ctx(srv_ctx);
 165
 166     if (ctx == NULL) {
 167         ERR_raise(ERR_LIB_CMP, CMP_R_NULL_ARGUMENT);
 168         return 0;
 169     }
 170     if (count < 0) {
 171         ERR_raise(ERR_LIB_CMP, CMP_R_INVALID_ARGS);
 172         return 0;
 173     }
 174     ctx->pollCount = count;
 175     return 1;
 176 }
 177
 178 int ossl_cmp_mock_srv_set_checkAfterTime(OSSL_CMP_SRV_CTX *srv_ctx, int sec)
 179 {
 180     mock_srv_ctx *ctx = OSSL_CMP_SRV_CTX_get0_custom_ctx(srv_ctx);
 181
 182     if (ctx == NULL) {
 183         ERR_raise(ERR_LIB_CMP, CMP_R_NULL_ARGUMENT);
 184         return 0;
 185     }
 186     ctx->checkAfterTime = sec;
 187     return 1;
 188 }
 189
 190 /* check for matching reference cert components, as far as given */
 191 static int refcert_cmp(const X509 *refcert,
 192                        const X509_NAME *issuer, const ASN1_INTEGER *serial)
 193 {
 194     const X509_NAME *ref_issuer;
 195     const ASN1_INTEGER *ref_serial;
 196
 197     if (refcert == NULL)
 198         return 1;
 199     ref_issuer = X509_get_issuer_name(refcert);
 200     ref_serial = X509_get0_serialNumber(refcert);
 201     return (ref_issuer == NULL || X509_NAME_cmp(issuer, ref_issuer) == 0)
 202         && (ref_serial == NULL || ASN1_INTEGER_cmp(serial, ref_serial) == 0);
 203 }
 204
 205 static OSSL_CMP_PKISI *process_cert_request(OSSL_CMP_SRV_CTX *srv_ctx,
 206                                             const OSSL_CMP_MSG *cert_req,
 207                                             ossl_unused int certReqId,
 208                                             const OSSL_CRMF_MSG *crm,
 209                                             const X509_REQ *p10cr,
 210                                             X509 **certOut,
 211                                             STACK_OF(X509) **chainOut,
 212                                             STACK_OF(X509) **caPubs)
 213 {
 214     mock_srv_ctx *ctx = OSSL_CMP_SRV_CTX_get0_custom_ctx(srv_ctx);
 215     OSSL_CMP_PKISI *si = NULL;
 216
 217     if (ctx == NULL || cert_req == NULL
 218             || certOut == NULL || chainOut == NULL || caPubs == NULL) {
 219         ERR_raise(ERR_LIB_CMP, CMP_R_NULL_ARGUMENT);
 220         return NULL;
 221     }
 222     if (ctx->sendError == 1
 223             || ctx->sendError == OSSL_CMP_MSG_get_bodytype(cert_req)) {
 224         ERR_raise(ERR_LIB_CMP, CMP_R_ERROR_PROCESSING_MESSAGE);
 225         return NULL;
 226     }
 227
 228     *certOut = NULL;
 229     *chainOut = NULL;
 230     *caPubs = NULL;
 231
 232     if (ctx->pollCount > 0 && ctx->curr_pollCount == 0) {
 233         /* start polling */
 234         if (ctx->certReq != NULL) {
 235             /* already in polling mode */
 236             ERR_raise(ERR_LIB_CMP, CMP_R_UNEXPECTED_PKIBODY);
 237             return NULL;
 238         }
 239         if ((ctx->certReq = OSSL_CMP_MSG_dup(cert_req)) == NULL)
 240             return NULL;
 241         return OSSL_CMP_STATUSINFO_new(OSSL_CMP_PKISTATUS_waiting, 0, NULL);
 242     }
 243     if (ctx->curr_pollCount >= ctx->pollCount)
 244         /* give final response after polling */
 245         ctx->curr_pollCount = 0;
 246
 247     /* accept cert update request only for the reference cert, if given */
 248     if (OSSL_CMP_MSG_get_bodytype(cert_req) == OSSL_CMP_KUR
 249             && crm != NULL /* thus not p10cr */ && ctx->refCert != NULL) {
 250         const OSSL_CRMF_CERTID *cid = OSSL_CRMF_MSG_get0_regCtrl_oldCertID(crm);
 251
 252         if (cid == NULL) {
 253             ERR_raise(ERR_LIB_CMP, CMP_R_MISSING_CERTID);
 254             return NULL;
 255         }
 256         if (!refcert_cmp(ctx->refCert,
 257                          OSSL_CRMF_CERTID_get0_issuer(cid),
 258                          OSSL_CRMF_CERTID_get0_serialNumber(cid))) {
 259             ERR_raise(ERR_LIB_CMP, CMP_R_WRONG_CERTID);
 260             return NULL;
 261         }
 262     }
 263
 264     if (ctx->certOut != NULL
 265             && (*certOut = X509_dup(ctx->certOut)) == NULL)
 266         /* Should return a cert produced from request template, see FR #16054 */
 267         goto err;
 268     if (ctx->chainOut != NULL
 269             && (*chainOut = X509_chain_up_ref(ctx->chainOut)) == NULL)
 270         goto err;
 271     if (ctx->caPubsOut != NULL
 272             && (*caPubs = X509_chain_up_ref(ctx->caPubsOut)) == NULL)
 273         goto err;
 274     if (ctx->statusOut != NULL
 275             && (si = OSSL_CMP_PKISI_dup(ctx->statusOut)) == NULL)
 276         goto err;
 277     return si;
 278
 279  err:
 280     X509_free(*certOut);
 281     *certOut = NULL;
 282     OSSL_STACK_OF_X509_free(*chainOut);
 283     *chainOut = NULL;
 284     OSSL_STACK_OF_X509_free(*caPubs);
 285     *caPubs = NULL;
 286     return NULL;
 287 }
 288
 289 static OSSL_CMP_PKISI *process_rr(OSSL_CMP_SRV_CTX *srv_ctx,
 290                                   const OSSL_CMP_MSG *rr,
 291                                   const X509_NAME *issuer,
 292                                   const ASN1_INTEGER *serial)
 293 {
 294     mock_srv_ctx *ctx = OSSL_CMP_SRV_CTX_get0_custom_ctx(srv_ctx);
 295
 296     if (ctx == NULL || rr == NULL) {
 297         ERR_raise(ERR_LIB_CMP, CMP_R_NULL_ARGUMENT);
 298         return NULL;
 299     }
 300     if (ctx->sendError == 1
 301             || ctx->sendError == OSSL_CMP_MSG_get_bodytype(rr)) {
 302         ERR_raise(ERR_LIB_CMP, CMP_R_ERROR_PROCESSING_MESSAGE);
 303         return NULL;
 304     }
 305
 306     /* allow any RR derived from CSR which does not include issuer and serial */
 307     if ((issuer != NULL || serial != NULL)
 308         /* accept revocation only for the reference cert, if given */
 309             && !refcert_cmp(ctx->refCert, issuer, serial)) {
 310         ERR_raise_data(ERR_LIB_CMP, CMP_R_REQUEST_NOT_ACCEPTED,
 311                        "wrong certificate to revoke");
 312         return NULL;
 313     }
 314     return OSSL_CMP_PKISI_dup(ctx->statusOut);
 315 }
 316
 317 static int process_genm(OSSL_CMP_SRV_CTX *srv_ctx,
 318                         const OSSL_CMP_MSG *genm,
 319                         const STACK_OF(OSSL_CMP_ITAV) *in,
 320                         STACK_OF(OSSL_CMP_ITAV) **out)
 321 {
 322     mock_srv_ctx *ctx = OSSL_CMP_SRV_CTX_get0_custom_ctx(srv_ctx);
 323
 324     if (ctx == NULL || genm == NULL || in == NULL || out == NULL) {
 325         ERR_raise(ERR_LIB_CMP, CMP_R_NULL_ARGUMENT);
 326         return 0;
 327     }
 328     if (ctx->sendError == 1
 329             || ctx->sendError == OSSL_CMP_MSG_get_bodytype(genm)
 330             || sk_OSSL_CMP_ITAV_num(in) > 1) {
 331         ERR_raise(ERR_LIB_CMP, CMP_R_ERROR_PROCESSING_MESSAGE);
 332         return 0;
 333     }
 334     if (sk_OSSL_CMP_ITAV_num(in) == 1) {
 335         OSSL_CMP_ITAV *req = sk_OSSL_CMP_ITAV_value(in, 0), *rsp;
 336         ASN1_OBJECT *obj = OSSL_CMP_ITAV_get0_type(req);
 337
 338         if (OBJ_obj2nid(obj) == NID_id_it_caCerts) {
 339             if ((*out = sk_OSSL_CMP_ITAV_new_reserve(NULL, 1)) == NULL)
 340                 return 0;
 341             if ((rsp = OSSL_CMP_ITAV_new_caCerts(ctx->caPubsOut)) == NULL) {
 342                 sk_OSSL_CMP_ITAV_free(*out);
 343                 return 0;
 344             }
 345             (void)sk_OSSL_CMP_ITAV_push(*out, rsp);
 346             return 1;
 347         }
 348     }
 349
 350     *out = sk_OSSL_CMP_ITAV_deep_copy(in, OSSL_CMP_ITAV_dup,
 351                                       OSSL_CMP_ITAV_free);
 352     return *out != NULL;
 353 }
 354
 355 static void process_error(OSSL_CMP_SRV_CTX *srv_ctx, const OSSL_CMP_MSG *error,
 356                           const OSSL_CMP_PKISI *statusInfo,
 357                           const ASN1_INTEGER *errorCode,
 358                           const OSSL_CMP_PKIFREETEXT *errorDetails)
 359 {
 360     mock_srv_ctx *ctx = OSSL_CMP_SRV_CTX_get0_custom_ctx(srv_ctx);
 361     char buf[OSSL_CMP_PKISI_BUFLEN];
 362     char *sibuf;
 363     int i;
 364
 365     if (ctx == NULL || error == NULL) {
 366         ERR_raise(ERR_LIB_CMP, CMP_R_NULL_ARGUMENT);
 367         return;
 368     }
 369
 370     BIO_printf(bio_err, "mock server received error:\n");
 371
 372     if (statusInfo == NULL) {
 373         BIO_printf(bio_err, "pkiStatusInfo absent\n");
 374     } else {
 375         sibuf = OSSL_CMP_snprint_PKIStatusInfo(statusInfo, buf, sizeof(buf));
 376         BIO_printf(bio_err, "pkiStatusInfo: %s\n",
 377                    sibuf != NULL ? sibuf: "<invalid>");
 378     }
 379
 380     if (errorCode == NULL)
 381         BIO_printf(bio_err, "errorCode absent\n");
 382     else
 383         BIO_printf(bio_err, "errorCode: %ld\n", ASN1_INTEGER_get(errorCode));
 384
 385     if (sk_ASN1_UTF8STRING_num(errorDetails) <= 0) {
 386         BIO_printf(bio_err, "errorDetails absent\n");
 387     } else {
 388         BIO_printf(bio_err, "errorDetails: ");
 389         for (i = 0; i < sk_ASN1_UTF8STRING_num(errorDetails); i++) {
 390             if (i > 0)
 391                 BIO_printf(bio_err, ", ");
 392             ASN1_STRING_print_ex(bio_err,
 393                                  sk_ASN1_UTF8STRING_value(errorDetails, i),
 394                                  ASN1_STRFLGS_ESC_QUOTE);
 395         }
 396         BIO_printf(bio_err, "\n");
 397     }
 398 }
 399
 400 static int process_certConf(OSSL_CMP_SRV_CTX *srv_ctx,
 401                             const OSSL_CMP_MSG *certConf,
 402                             ossl_unused int certReqId,
 403                             const ASN1_OCTET_STRING *certHash,
 404                             const OSSL_CMP_PKISI *si)
 405 {
 406     mock_srv_ctx *ctx = OSSL_CMP_SRV_CTX_get0_custom_ctx(srv_ctx);
 407     ASN1_OCTET_STRING *digest;
 408
 409     if (ctx == NULL || certConf == NULL || certHash == NULL) {
 410         ERR_raise(ERR_LIB_CMP, CMP_R_NULL_ARGUMENT);
 411         return 0;
 412     }
 413     if (ctx->sendError == 1
 414             || ctx->sendError == OSSL_CMP_MSG_get_bodytype(certConf)
 415             || ctx->certOut == NULL) {
 416         ERR_raise(ERR_LIB_CMP, CMP_R_ERROR_PROCESSING_MESSAGE);
 417         return 0;
 418     }
 419
 420     if ((digest = X509_digest_sig(ctx->certOut, NULL, NULL)) == NULL)
 421         return 0;
 422     if (ASN1_OCTET_STRING_cmp(certHash, digest) != 0) {
 423         ASN1_OCTET_STRING_free(digest);
 424         ERR_raise(ERR_LIB_CMP, CMP_R_CERTHASH_UNMATCHED);
 425         return 0;
 426     }
 427     ASN1_OCTET_STRING_free(digest);
 428     return 1;
 429 }
 430
 431 static int process_pollReq(OSSL_CMP_SRV_CTX *srv_ctx,
 432                            const OSSL_CMP_MSG *pollReq,
 433                            ossl_unused int certReqId,
 434                            OSSL_CMP_MSG **certReq, int64_t *check_after)
 435 {
 436     mock_srv_ctx *ctx = OSSL_CMP_SRV_CTX_get0_custom_ctx(srv_ctx);
 437
 438     if (ctx == NULL || pollReq == NULL
 439             || certReq == NULL || check_after == NULL) {
 440         ERR_raise(ERR_LIB_CMP, CMP_R_NULL_ARGUMENT);
 441         return 0;
 442     }
 443     if (ctx->sendError == 1
 444             || ctx->sendError == OSSL_CMP_MSG_get_bodytype(pollReq)) {
 445         *certReq = NULL;
 446         ERR_raise(ERR_LIB_CMP, CMP_R_ERROR_PROCESSING_MESSAGE);
 447         return 0;
 448     }
 449     if (ctx->certReq == NULL) {
 450         /* not currently in polling mode */
 451         *certReq = NULL;
 452         ERR_raise(ERR_LIB_CMP, CMP_R_UNEXPECTED_PKIBODY);
 453         return 0;
 454     }
 455
 456     if (++ctx->curr_pollCount >= ctx->pollCount) {
 457         /* end polling */
 458         *certReq = ctx->certReq;
 459         ctx->certReq = NULL;
 460         *check_after = 0;
 461     } else {
 462         *certReq = NULL;
 463         *check_after = ctx->checkAfterTime;
 464     }
 465     return 1;
 466 }
 467
 468 OSSL_CMP_SRV_CTX *ossl_cmp_mock_srv_new(OSSL_LIB_CTX *libctx, const char *propq)
 469 {
 470     OSSL_CMP_SRV_CTX *srv_ctx = OSSL_CMP_SRV_CTX_new(libctx, propq);
 471     mock_srv_ctx *ctx = mock_srv_ctx_new();
 472
 473     if (srv_ctx != NULL && ctx != NULL
 474             && OSSL_CMP_SRV_CTX_init(srv_ctx, ctx, process_cert_request,
 475                                      process_rr, process_genm, process_error,
 476                                      process_certConf, process_pollReq))
 477         return srv_ctx;
 478
 479     mock_srv_ctx_free(ctx);
 480     OSSL_CMP_SRV_CTX_free(srv_ctx);
 481     return NULL;
 482 }
 483
 484 void ossl_cmp_mock_srv_free(OSSL_CMP_SRV_CTX *srv_ctx)
 485 {
 486     if (srv_ctx != NULL)
 487         mock_srv_ctx_free(OSSL_CMP_SRV_CTX_get0_custom_ctx(srv_ctx));
 488     OSSL_CMP_SRV_CTX_free(srv_ctx);
 489 }