apps/cmp_mock_srv.c

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