apps/cmp_mock_srv.c

   1 /*
   2  * Copyright 2018-2021 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 *certOut;             /* certificate to be returned in cp/ip/kup msg */
  22     STACK_OF(X509) *chainOut;  /* chain of certOut to add to extraCerts field */
  23     STACK_OF(X509) *caPubsOut; /* certs to return in caPubs field of ip msg */
  24     OSSL_CMP_PKISI *statusOut; /* status for ip/cp/kup/rp msg unless polling */
  25     int sendError;             /* send error response also on valid requests */
  26     OSSL_CMP_MSG *certReq;     /* ir/cr/p10cr/kur remembered while polling */
  27     int certReqId;             /* id of last ir/cr/kur, used for polling */
  28     int pollCount;             /* number of polls before actual cert response */
  29     int checkAfterTime;        /* time the client should wait between polling */
  30 } mock_srv_ctx;
  31
  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->certOut);
  40     sk_X509_pop_free(ctx->chainOut, X509_free);
  41     sk_X509_pop_free(ctx->caPubsOut, X509_free);
  42     OSSL_CMP_MSG_free(ctx->certReq);
  43     OPENSSL_free(ctx);
  44 }
  45
  46 static mock_srv_ctx *mock_srv_ctx_new(void)
  47 {
  48     mock_srv_ctx *ctx = OPENSSL_zalloc(sizeof(mock_srv_ctx));
  49
  50     if (ctx == NULL)
  51         goto err;
  52
  53     if ((ctx->statusOut = OSSL_CMP_PKISI_new()) == NULL)
  54         goto err;
  55
  56     ctx->certReqId = -1;
  57
  58     /* all other elements are initialized to 0 or NULL, respectively */
  59     return ctx;
  60  err:
  61     mock_srv_ctx_free(ctx);
  62     return NULL;
  63 }
  64
  65 int ossl_cmp_mock_srv_set1_certOut(OSSL_CMP_SRV_CTX *srv_ctx, X509 *cert)
  66 {
  67     mock_srv_ctx *ctx = OSSL_CMP_SRV_CTX_get0_custom_ctx(srv_ctx);
  68
  69     if (ctx == NULL) {
  70         ERR_raise(ERR_LIB_CMP, CMP_R_NULL_ARGUMENT);
  71         return 0;
  72     }
  73     if (cert == NULL || X509_up_ref(cert)) {
  74         X509_free(ctx->certOut);
  75         ctx->certOut = cert;
  76         return 1;
  77     }
  78     return 0;
  79 }
  80
  81 int ossl_cmp_mock_srv_set1_chainOut(OSSL_CMP_SRV_CTX *srv_ctx,
  82                                     STACK_OF(X509) *chain)
  83 {
  84     mock_srv_ctx *ctx = OSSL_CMP_SRV_CTX_get0_custom_ctx(srv_ctx);
  85     STACK_OF(X509) *chain_copy = NULL;
  86
  87     if (ctx == NULL) {
  88         ERR_raise(ERR_LIB_CMP, CMP_R_NULL_ARGUMENT);
  89         return 0;
  90     }
  91     if (chain != NULL && (chain_copy = X509_chain_up_ref(chain)) == NULL)
  92         return 0;
  93     sk_X509_pop_free(ctx->chainOut, X509_free);
  94     ctx->chainOut = chain_copy;
  95     return 1;
  96 }
  97
  98 int ossl_cmp_mock_srv_set1_caPubsOut(OSSL_CMP_SRV_CTX *srv_ctx,
  99                                      STACK_OF(X509) *caPubs)
 100 {
 101     mock_srv_ctx *ctx = OSSL_CMP_SRV_CTX_get0_custom_ctx(srv_ctx);
 102     STACK_OF(X509) *caPubs_copy = NULL;
 103
 104     if (ctx == NULL) {
 105         ERR_raise(ERR_LIB_CMP, CMP_R_NULL_ARGUMENT);
 106         return 0;
 107     }
 108     if (caPubs != NULL && (caPubs_copy = X509_chain_up_ref(caPubs)) == NULL)
 109         return 0;
 110     sk_X509_pop_free(ctx->caPubsOut, X509_free);
 111     ctx->caPubsOut = caPubs_copy;
 112     return 1;
 113 }
 114
 115 int ossl_cmp_mock_srv_set_statusInfo(OSSL_CMP_SRV_CTX *srv_ctx, int status,
 116                                      int fail_info, const char *text)
 117 {
 118     mock_srv_ctx *ctx = OSSL_CMP_SRV_CTX_get0_custom_ctx(srv_ctx);
 119     OSSL_CMP_PKISI *si;
 120
 121     if (ctx == NULL) {
 122         ERR_raise(ERR_LIB_CMP, CMP_R_NULL_ARGUMENT);
 123         return 0;
 124     }
 125     if ((si = OSSL_CMP_STATUSINFO_new(status, fail_info, text)) == NULL)
 126         return 0;
 127     OSSL_CMP_PKISI_free(ctx->statusOut);
 128     ctx->statusOut = si;
 129     return 1;
 130 }
 131
 132 int ossl_cmp_mock_srv_set_send_error(OSSL_CMP_SRV_CTX *srv_ctx, int val)
 133 {
 134     mock_srv_ctx *ctx = OSSL_CMP_SRV_CTX_get0_custom_ctx(srv_ctx);
 135
 136     if (ctx == NULL) {
 137         ERR_raise(ERR_LIB_CMP, CMP_R_NULL_ARGUMENT);
 138         return 0;
 139     }
 140     ctx->sendError = val != 0;
 141     return 1;
 142 }
 143
 144 int ossl_cmp_mock_srv_set_pollCount(OSSL_CMP_SRV_CTX *srv_ctx, int count)
 145 {
 146     mock_srv_ctx *ctx = OSSL_CMP_SRV_CTX_get0_custom_ctx(srv_ctx);
 147
 148     if (ctx == NULL) {
 149         ERR_raise(ERR_LIB_CMP, CMP_R_NULL_ARGUMENT);
 150         return 0;
 151     }
 152     if (count < 0) {
 153         ERR_raise(ERR_LIB_CMP, CMP_R_INVALID_ARGS);
 154         return 0;
 155     }
 156     ctx->pollCount = count;
 157     return 1;
 158 }
 159
 160 int ossl_cmp_mock_srv_set_checkAfterTime(OSSL_CMP_SRV_CTX *srv_ctx, int sec)
 161 {
 162     mock_srv_ctx *ctx = OSSL_CMP_SRV_CTX_get0_custom_ctx(srv_ctx);
 163
 164     if (ctx == NULL) {
 165         ERR_raise(ERR_LIB_CMP, CMP_R_NULL_ARGUMENT);
 166         return 0;
 167     }
 168     ctx->checkAfterTime = sec;
 169     return 1;
 170 }
 171
 172 static OSSL_CMP_PKISI *process_cert_request(OSSL_CMP_SRV_CTX *srv_ctx,
 173                                             const OSSL_CMP_MSG *cert_req,
 174                                             int certReqId,
 175                                             const OSSL_CRMF_MSG *crm,
 176                                             const X509_REQ *p10cr,
 177                                             X509 **certOut,
 178                                             STACK_OF(X509) **chainOut,
 179                                             STACK_OF(X509) **caPubs)
 180 {
 181     mock_srv_ctx *ctx = OSSL_CMP_SRV_CTX_get0_custom_ctx(srv_ctx);
 182     OSSL_CMP_PKISI *si = NULL;
 183
 184     if (ctx == NULL || cert_req == NULL
 185             || certOut == NULL || chainOut == NULL || caPubs == NULL) {
 186         ERR_raise(ERR_LIB_CMP, CMP_R_NULL_ARGUMENT);
 187         return NULL;
 188     }
 189     if (ctx->sendError) {
 190         ERR_raise(ERR_LIB_CMP, CMP_R_ERROR_PROCESSING_MESSAGE);
 191         return NULL;
 192     }
 193
 194     *certOut = NULL;
 195     *chainOut = NULL;
 196     *caPubs = NULL;
 197     ctx->certReqId = certReqId;
 198     if (ctx->pollCount > 0) {
 199         ctx->pollCount--;
 200         OSSL_CMP_MSG_free(ctx->certReq);
 201         if ((ctx->certReq = OSSL_CMP_MSG_dup(cert_req)) == NULL)
 202             return NULL;
 203         return OSSL_CMP_STATUSINFO_new(OSSL_CMP_PKISTATUS_waiting, 0, NULL);
 204     }
 205     if (ctx->certOut != NULL
 206             && (*certOut = X509_dup(ctx->certOut)) == NULL)
 207         /* TODO better return a cert produced from data in request template */
 208         goto err;
 209     if (ctx->chainOut != NULL
 210             && (*chainOut = X509_chain_up_ref(ctx->chainOut)) == NULL)
 211         goto err;
 212     if (ctx->caPubsOut != NULL
 213             && (*caPubs = X509_chain_up_ref(ctx->caPubsOut)) == NULL)
 214         goto err;
 215     if (ctx->statusOut != NULL
 216             && (si = OSSL_CMP_PKISI_dup(ctx->statusOut)) == NULL)
 217         goto err;
 218     return si;
 219
 220  err:
 221     X509_free(*certOut);
 222     *certOut = NULL;
 223     sk_X509_pop_free(*chainOut, X509_free);
 224     *chainOut = NULL;
 225     sk_X509_pop_free(*caPubs, X509_free);
 226     *caPubs = NULL;
 227     return NULL;
 228 }
 229
 230 static OSSL_CMP_PKISI *process_rr(OSSL_CMP_SRV_CTX *srv_ctx,
 231                                   const OSSL_CMP_MSG *rr,
 232                                   const X509_NAME *issuer,
 233                                   const ASN1_INTEGER *serial)
 234 {
 235     mock_srv_ctx *ctx = OSSL_CMP_SRV_CTX_get0_custom_ctx(srv_ctx);
 236
 237     if (ctx == NULL || rr == NULL) {
 238         ERR_raise(ERR_LIB_CMP, CMP_R_NULL_ARGUMENT);
 239         return NULL;
 240     }
 241     if (ctx->sendError || ctx->certOut == NULL) {
 242         ERR_raise(ERR_LIB_CMP, CMP_R_ERROR_PROCESSING_MESSAGE);
 243         return NULL;
 244     }
 245
 246     /* Allow any RR derived from CSR, which may include subject and serial */
 247     if (issuer == NULL || serial == NULL)
 248         return OSSL_CMP_PKISI_dup(ctx->statusOut);
 249
 250     /* accept revocation only for the certificate we sent in ir/cr/kur */
 251     if (X509_NAME_cmp(issuer, X509_get_issuer_name(ctx->certOut)) != 0
 252             || ASN1_INTEGER_cmp(serial,
 253                                 X509_get0_serialNumber(ctx->certOut)) != 0) {
 254         ERR_raise_data(ERR_LIB_CMP, CMP_R_REQUEST_NOT_ACCEPTED,
 255                        "wrong certificate to revoke");
 256         return NULL;
 257     }
 258     return OSSL_CMP_PKISI_dup(ctx->statusOut);
 259 }
 260
 261 static int process_genm(OSSL_CMP_SRV_CTX *srv_ctx,
 262                         const OSSL_CMP_MSG *genm,
 263                         const STACK_OF(OSSL_CMP_ITAV) *in,
 264                         STACK_OF(OSSL_CMP_ITAV) **out)
 265 {
 266     mock_srv_ctx *ctx = OSSL_CMP_SRV_CTX_get0_custom_ctx(srv_ctx);
 267
 268     if (ctx == NULL || genm == NULL || in == NULL || out == NULL) {
 269         ERR_raise(ERR_LIB_CMP, CMP_R_NULL_ARGUMENT);
 270         return 0;
 271     }
 272     if (ctx->sendError) {
 273         ERR_raise(ERR_LIB_CMP, CMP_R_ERROR_PROCESSING_MESSAGE);
 274         return 0;
 275     }
 276
 277     *out = sk_OSSL_CMP_ITAV_deep_copy(in, OSSL_CMP_ITAV_dup,
 278                                       OSSL_CMP_ITAV_free);
 279     return *out != NULL;
 280 }
 281
 282 static void process_error(OSSL_CMP_SRV_CTX *srv_ctx, const OSSL_CMP_MSG *error,
 283                           const OSSL_CMP_PKISI *statusInfo,
 284                           const ASN1_INTEGER *errorCode,
 285                           const OSSL_CMP_PKIFREETEXT *errorDetails)
 286 {
 287     mock_srv_ctx *ctx = OSSL_CMP_SRV_CTX_get0_custom_ctx(srv_ctx);
 288     char buf[OSSL_CMP_PKISI_BUFLEN];
 289     char *sibuf;
 290     int i;
 291
 292     if (ctx == NULL || error == NULL) {
 293         ERR_raise(ERR_LIB_CMP, CMP_R_NULL_ARGUMENT);
 294         return;
 295     }
 296
 297     BIO_printf(bio_err, "mock server received error:\n");
 298
 299     if (statusInfo == NULL) {
 300         BIO_printf(bio_err, "pkiStatusInfo absent\n");
 301     } else {
 302         sibuf = OSSL_CMP_snprint_PKIStatusInfo(statusInfo, buf, sizeof(buf));
 303         BIO_printf(bio_err, "pkiStatusInfo: %s\n",
 304                    sibuf != NULL ? sibuf: "<invalid>");
 305     }
 306
 307     if (errorCode == NULL)
 308         BIO_printf(bio_err, "errorCode absent\n");
 309     else
 310         BIO_printf(bio_err, "errorCode: %ld\n", ASN1_INTEGER_get(errorCode));
 311
 312     if (sk_ASN1_UTF8STRING_num(errorDetails) <= 0) {
 313         BIO_printf(bio_err, "errorDetails absent\n");
 314     } else {
 315         /* TODO could use sk_ASN1_UTF8STRING2text() if exported */
 316         BIO_printf(bio_err, "errorDetails: ");
 317         for (i = 0; i < sk_ASN1_UTF8STRING_num(errorDetails); i++) {
 318             if (i > 0)
 319                 BIO_printf(bio_err, ", ");
 320             BIO_printf(bio_err, "\"");
 321             ASN1_STRING_print(bio_err,
 322                               sk_ASN1_UTF8STRING_value(errorDetails, i));
 323             BIO_printf(bio_err, "\"");
 324         }
 325         BIO_printf(bio_err, "\n");
 326     }
 327 }
 328
 329 static int process_certConf(OSSL_CMP_SRV_CTX *srv_ctx,
 330                             const OSSL_CMP_MSG *certConf, int certReqId,
 331                             const ASN1_OCTET_STRING *certHash,
 332                             const OSSL_CMP_PKISI *si)
 333 {
 334     mock_srv_ctx *ctx = OSSL_CMP_SRV_CTX_get0_custom_ctx(srv_ctx);
 335     ASN1_OCTET_STRING *digest;
 336
 337     if (ctx == NULL || certConf == NULL || certHash == NULL) {
 338         ERR_raise(ERR_LIB_CMP, CMP_R_NULL_ARGUMENT);
 339         return 0;
 340     }
 341     if (ctx->sendError || ctx->certOut == NULL) {
 342         ERR_raise(ERR_LIB_CMP, CMP_R_ERROR_PROCESSING_MESSAGE);
 343         return 0;
 344     }
 345
 346     if (certReqId != ctx->certReqId) {
 347         /* in case of error, invalid reqId -1 */
 348         ERR_raise(ERR_LIB_CMP, CMP_R_BAD_REQUEST_ID);
 349         return 0;
 350     }
 351
 352     if ((digest = X509_digest_sig(ctx->certOut)) == NULL)
 353         return 0;
 354     if (ASN1_OCTET_STRING_cmp(certHash, digest) != 0) {
 355         ASN1_OCTET_STRING_free(digest);
 356         ERR_raise(ERR_LIB_CMP, CMP_R_CERTHASH_UNMATCHED);
 357         return 0;
 358     }
 359     ASN1_OCTET_STRING_free(digest);
 360     return 1;
 361 }
 362
 363 static int process_pollReq(OSSL_CMP_SRV_CTX *srv_ctx,
 364                            const OSSL_CMP_MSG *pollReq, int certReqId,
 365                            OSSL_CMP_MSG **certReq, int64_t *check_after)
 366 {
 367     mock_srv_ctx *ctx = OSSL_CMP_SRV_CTX_get0_custom_ctx(srv_ctx);
 368
 369     if (ctx == NULL || pollReq == NULL
 370             || certReq == NULL || check_after == NULL) {
 371         ERR_raise(ERR_LIB_CMP, CMP_R_NULL_ARGUMENT);
 372         return 0;
 373     }
 374     if (ctx->sendError || ctx->certReq == NULL) {
 375         *certReq = NULL;
 376         ERR_raise(ERR_LIB_CMP, CMP_R_ERROR_PROCESSING_MESSAGE);
 377         return 0;
 378     }
 379
 380     if (ctx->pollCount == 0) {
 381         *certReq = ctx->certReq;
 382         ctx->certReq = NULL;
 383         *check_after = 0;
 384     } else {
 385         ctx->pollCount--;
 386         *certReq = NULL;
 387         *check_after = ctx->checkAfterTime;
 388     }
 389     return 1;
 390 }
 391
 392 OSSL_CMP_SRV_CTX *ossl_cmp_mock_srv_new(OSSL_LIB_CTX *libctx, const char *propq)
 393 {
 394     OSSL_CMP_SRV_CTX *srv_ctx = OSSL_CMP_SRV_CTX_new(libctx, propq);
 395     mock_srv_ctx *ctx = mock_srv_ctx_new();
 396
 397     if (srv_ctx != NULL && ctx != NULL
 398             && OSSL_CMP_SRV_CTX_init(srv_ctx, ctx, process_cert_request,
 399                                      process_rr, process_genm, process_error,
 400                                      process_certConf, process_pollReq))
 401         return srv_ctx;
 402
 403     mock_srv_ctx_free(ctx);
 404     OSSL_CMP_SRV_CTX_free(srv_ctx);
 405     return NULL;
 406 }
 407
 408 void ossl_cmp_mock_srv_free(OSSL_CMP_SRV_CTX *srv_ctx)
 409 {
 410     if (srv_ctx != NULL)
 411         mock_srv_ctx_free(OSSL_CMP_SRV_CTX_get0_custom_ctx(srv_ctx));
 412     OSSL_CMP_SRV_CTX_free(srv_ctx);
 413 }