test/cmp_msg_test.c

   1 /*
   2  * Copyright 2007-2020 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 "cmp_testlib.h"
  13
  14 static const char *newkey_f;
  15 static const char *server_cert_f;
  16 static const char *pkcs10_f;
  17
  18 typedef struct test_fixture {
  19     const char *test_case_name;
  20     OSSL_CMP_CTX *cmp_ctx;
  21     /* for msg create tests */
  22     int bodytype;
  23     int err_code;
  24     /* for certConf */
  25     int fail_info;
  26     /* for protection tests */
  27     OSSL_CMP_MSG *msg;
  28     int expected;
  29     /* for error and response messages */
  30     OSSL_CMP_PKISI *si;
  31 } CMP_MSG_TEST_FIXTURE;
  32
  33 static OPENSSL_CTX *libctx = NULL;
  34 static OSSL_PROVIDER *default_null_provider = NULL, *provider = NULL;
  35
  36 /* TODO(3.0) Clean this up - See issue #12680 */
  37 static X509 *X509_dup_ex(const X509 *cert)
  38 {
  39     X509 *dup = X509_dup(cert);
  40
  41     if (dup != NULL)
  42         x509_set0_libctx(dup, libctx, NULL);
  43     return dup;
  44 }
  45
  46 static unsigned char ref[CMP_TEST_REFVALUE_LENGTH];
  47
  48 static void tear_down(CMP_MSG_TEST_FIXTURE *fixture)
  49 {
  50     OSSL_CMP_CTX_free(fixture->cmp_ctx);
  51     OSSL_CMP_MSG_free(fixture->msg);
  52     OSSL_CMP_PKISI_free(fixture->si);
  53     OPENSSL_free(fixture);
  54 }
  55
  56 #define SET_OPT_UNPROTECTED_SEND(ctx, val) \
  57     OSSL_CMP_CTX_set_option((ctx), OSSL_CMP_OPT_UNPROTECTED_SEND, (val))
  58 static CMP_MSG_TEST_FIXTURE *set_up(const char *const test_case_name)
  59 {
  60     CMP_MSG_TEST_FIXTURE *fixture;
  61
  62     if (!TEST_ptr(fixture = OPENSSL_zalloc(sizeof(*fixture))))
  63         return NULL;
  64     fixture->test_case_name = test_case_name;
  65
  66     if (!TEST_ptr(fixture->cmp_ctx = OSSL_CMP_CTX_new(libctx, NULL))
  67             || !TEST_true(SET_OPT_UNPROTECTED_SEND(fixture->cmp_ctx, 1))
  68             || !TEST_true(OSSL_CMP_CTX_set1_referenceValue(fixture->cmp_ctx,
  69                                                            ref, sizeof(ref)))) {
  70         tear_down(fixture);
  71         return NULL;
  72     }
  73     return fixture;
  74 }
  75
  76 static EVP_PKEY *newkey = NULL;
  77 static X509 *cert = NULL;
  78
  79 #define EXECUTE_MSG_CREATION_TEST(expr) \
  80     do { \
  81         OSSL_CMP_MSG *msg = NULL; \
  82         int good = fixture->expected != 0 ? \
  83             TEST_ptr(msg = (expr)) && TEST_true(valid_asn1_encoding(msg)) : \
  84             TEST_ptr_null(msg = (expr)); \
  85  \
  86         OSSL_CMP_MSG_free(msg); \
  87         ERR_print_errors_fp(stderr); \
  88         return good; \
  89     } while (0)
  90
  91 /*-
  92  * The following tests call a cmp message creation function.
  93  * if fixture->expected != 0:
  94  *         returns 1 if the message is created and syntactically correct.
  95  * if fixture->expected == 0
  96  *         returns 1 if message creation returns NULL
  97  */
  98 static int execute_certreq_create_test(CMP_MSG_TEST_FIXTURE *fixture)
  99 {
 100     EXECUTE_MSG_CREATION_TEST(ossl_cmp_certreq_new(fixture->cmp_ctx,
 101                                                    fixture->bodytype,
 102                                                    NULL));
 103 }
 104
 105 static int execute_errormsg_create_test(CMP_MSG_TEST_FIXTURE *fixture)
 106 {
 107     EXECUTE_MSG_CREATION_TEST(ossl_cmp_error_new(fixture->cmp_ctx, fixture->si,
 108                                                  fixture->err_code,
 109                                                  "details", 0));
 110 }
 111
 112 static int execute_rr_create_test(CMP_MSG_TEST_FIXTURE *fixture)
 113 {
 114     EXECUTE_MSG_CREATION_TEST(ossl_cmp_rr_new(fixture->cmp_ctx));
 115 }
 116
 117 static int execute_certconf_create_test(CMP_MSG_TEST_FIXTURE *fixture)
 118 {
 119     EXECUTE_MSG_CREATION_TEST(ossl_cmp_certConf_new
 120                               (fixture->cmp_ctx, fixture->fail_info, NULL));
 121 }
 122
 123 static int execute_genm_create_test(CMP_MSG_TEST_FIXTURE *fixture)
 124 {
 125     EXECUTE_MSG_CREATION_TEST(ossl_cmp_genm_new(fixture->cmp_ctx));
 126 }
 127
 128 static int execute_pollreq_create_test(CMP_MSG_TEST_FIXTURE *fixture)
 129 {
 130     EXECUTE_MSG_CREATION_TEST(ossl_cmp_pollReq_new(fixture->cmp_ctx, 4711));
 131 }
 132
 133 static int execute_pkimessage_create_test(CMP_MSG_TEST_FIXTURE *fixture)
 134 {
 135     EXECUTE_MSG_CREATION_TEST(ossl_cmp_msg_create
 136                               (fixture->cmp_ctx, fixture->bodytype));
 137 }
 138
 139 static int set1_newPkey(OSSL_CMP_CTX *ctx, EVP_PKEY *pkey)
 140 {
 141     if (!EVP_PKEY_up_ref(pkey))
 142         return 0;
 143
 144     if (!OSSL_CMP_CTX_set0_newPkey(ctx, 1, pkey)) {
 145         EVP_PKEY_free(pkey);
 146         return 0;
 147     }
 148     return 1;
 149 }
 150
 151 static int test_cmp_create_ir_protection_set(void)
 152 {
 153     OSSL_CMP_CTX *ctx;
 154     unsigned char secret[16];
 155
 156     SETUP_TEST_FIXTURE(CMP_MSG_TEST_FIXTURE, set_up);
 157
 158     ctx = fixture->cmp_ctx;
 159     fixture->bodytype = OSSL_CMP_PKIBODY_IR;
 160     fixture->err_code = -1;
 161     fixture->expected = 1;
 162     if (!TEST_int_eq(1, RAND_bytes_ex(libctx, secret, sizeof(secret)))
 163             || !TEST_true(SET_OPT_UNPROTECTED_SEND(ctx, 0))
 164             || !TEST_true(set1_newPkey(ctx, newkey))
 165             || !TEST_true(OSSL_CMP_CTX_set1_secretValue(ctx, secret,
 166                                                         sizeof(secret)))) {
 167         tear_down(fixture);
 168         fixture = NULL;
 169     }
 170     EXECUTE_TEST(execute_certreq_create_test, tear_down);
 171     return result;
 172 }
 173
 174 static int test_cmp_create_ir_protection_fails(void)
 175 {
 176     SETUP_TEST_FIXTURE(CMP_MSG_TEST_FIXTURE, set_up);
 177     fixture->bodytype = OSSL_CMP_PKIBODY_IR;
 178     fixture->err_code = -1;
 179     fixture->expected = 0;
 180     if (!TEST_true(OSSL_CMP_CTX_set1_pkey(fixture->cmp_ctx, newkey))
 181             || !TEST_true(SET_OPT_UNPROTECTED_SEND(fixture->cmp_ctx, 0))
 182             /* newkey used by default for signing does not match cert: */
 183             || !TEST_true(OSSL_CMP_CTX_set1_cert(fixture->cmp_ctx, cert))) {
 184         tear_down(fixture);
 185         fixture = NULL;
 186     }
 187     EXECUTE_TEST(execute_certreq_create_test, tear_down);
 188     return result;
 189 }
 190
 191 static int test_cmp_create_cr_without_key(void)
 192 {
 193     SETUP_TEST_FIXTURE(CMP_MSG_TEST_FIXTURE, set_up);
 194     fixture->bodytype = OSSL_CMP_PKIBODY_CR;
 195     fixture->err_code = -1;
 196     fixture->expected = 0;
 197     EXECUTE_TEST(execute_certreq_create_test, tear_down);
 198     return result;
 199 }
 200
 201 static int test_cmp_create_cr(void)
 202 {
 203     SETUP_TEST_FIXTURE(CMP_MSG_TEST_FIXTURE, set_up);
 204     fixture->bodytype = OSSL_CMP_PKIBODY_CR;
 205     fixture->err_code = -1;
 206     fixture->expected = 1;
 207     if (!TEST_true(set1_newPkey(fixture->cmp_ctx, newkey))) {
 208         tear_down(fixture);
 209         fixture = NULL;
 210     }
 211     EXECUTE_TEST(execute_certreq_create_test, tear_down);
 212     return result;
 213 }
 214
 215 static int test_cmp_create_certreq_with_invalid_bodytype(void)
 216 {
 217     SETUP_TEST_FIXTURE(CMP_MSG_TEST_FIXTURE, set_up);
 218     fixture->bodytype = OSSL_CMP_PKIBODY_RR;
 219     fixture->err_code = -1;
 220     fixture->expected = 0;
 221     if (!TEST_true(set1_newPkey(fixture->cmp_ctx, newkey))) {
 222         tear_down(fixture);
 223         fixture = NULL;
 224     }
 225     EXECUTE_TEST(execute_certreq_create_test, tear_down);
 226     return result;
 227 }
 228
 229 static int test_cmp_create_p10cr(void)
 230 {
 231     OSSL_CMP_CTX *ctx;
 232     X509_REQ *p10cr = NULL;
 233
 234     SETUP_TEST_FIXTURE(CMP_MSG_TEST_FIXTURE, set_up);
 235     ctx = fixture->cmp_ctx;
 236     fixture->bodytype = OSSL_CMP_PKIBODY_P10CR;
 237     fixture->err_code = CMP_R_ERROR_CREATING_CERTREQ;
 238     fixture->expected = 1;
 239     if (!TEST_ptr(p10cr = load_csr(pkcs10_f))
 240             || !TEST_true(set1_newPkey(ctx, newkey))
 241             || !TEST_true(OSSL_CMP_CTX_set1_p10CSR(ctx, p10cr))) {
 242         tear_down(fixture);
 243         fixture = NULL;
 244     }
 245     X509_REQ_free(p10cr);
 246     EXECUTE_TEST(execute_certreq_create_test, tear_down);
 247     return result;
 248 }
 249
 250 static int test_cmp_create_p10cr_null(void)
 251 {
 252     SETUP_TEST_FIXTURE(CMP_MSG_TEST_FIXTURE, set_up);
 253     fixture->bodytype = OSSL_CMP_PKIBODY_P10CR;
 254     fixture->err_code = CMP_R_ERROR_CREATING_CERTREQ;
 255     fixture->expected = 0;
 256     if (!TEST_true(set1_newPkey(fixture->cmp_ctx, newkey))) {
 257         tear_down(fixture);
 258         fixture = NULL;
 259     }
 260     EXECUTE_TEST(execute_certreq_create_test, tear_down);
 261     return result;
 262 }
 263
 264 static int test_cmp_create_kur(void)
 265 {
 266     SETUP_TEST_FIXTURE(CMP_MSG_TEST_FIXTURE, set_up);
 267     fixture->bodytype = OSSL_CMP_PKIBODY_KUR;
 268     fixture->err_code = -1;
 269     fixture->expected = 1;
 270     if (!TEST_true(set1_newPkey(fixture->cmp_ctx, newkey))
 271             || !TEST_true(OSSL_CMP_CTX_set1_oldCert(fixture->cmp_ctx, cert))) {
 272         tear_down(fixture);
 273         fixture = NULL;
 274     }
 275     EXECUTE_TEST(execute_certreq_create_test, tear_down);
 276     return result;
 277 }
 278
 279 static int test_cmp_create_kur_without_oldcert(void)
 280 {
 281     SETUP_TEST_FIXTURE(CMP_MSG_TEST_FIXTURE, set_up);
 282     fixture->bodytype = OSSL_CMP_PKIBODY_KUR;
 283     fixture->err_code = -1;
 284     fixture->expected = 0;
 285     if (!TEST_true(set1_newPkey(fixture->cmp_ctx, newkey))) {
 286         tear_down(fixture);
 287         fixture = NULL;
 288     }
 289     EXECUTE_TEST(execute_certreq_create_test, tear_down);
 290     return result;
 291 }
 292
 293 static int test_cmp_create_certconf(void)
 294 {
 295     SETUP_TEST_FIXTURE(CMP_MSG_TEST_FIXTURE, set_up);
 296     fixture->fail_info = 0;
 297     fixture->expected = 1;
 298     if (!TEST_true(ossl_cmp_ctx_set0_newCert(fixture->cmp_ctx,
 299                                              X509_dup_ex(cert)))) {
 300         tear_down(fixture);
 301         fixture = NULL;
 302     }
 303     EXECUTE_TEST(execute_certconf_create_test, tear_down);
 304     return result;
 305 }
 306
 307 static int test_cmp_create_certconf_badAlg(void)
 308 {
 309     SETUP_TEST_FIXTURE(CMP_MSG_TEST_FIXTURE, set_up);
 310     fixture->fail_info = 1 << OSSL_CMP_PKIFAILUREINFO_badAlg;
 311     fixture->expected = 1;
 312     if (!TEST_true(ossl_cmp_ctx_set0_newCert(fixture->cmp_ctx,
 313                                              X509_dup_ex(cert)))) {
 314         tear_down(fixture);
 315         fixture = NULL;
 316     }
 317     EXECUTE_TEST(execute_certconf_create_test, tear_down);
 318     return result;
 319 }
 320
 321 static int test_cmp_create_certconf_fail_info_max(void)
 322 {
 323     SETUP_TEST_FIXTURE(CMP_MSG_TEST_FIXTURE, set_up);
 324     fixture->fail_info = 1 << OSSL_CMP_PKIFAILUREINFO_MAX;
 325     fixture->expected = 1;
 326     if (!TEST_true(ossl_cmp_ctx_set0_newCert(fixture->cmp_ctx,
 327                                              X509_dup_ex(cert)))) {
 328         tear_down(fixture);
 329         fixture = NULL;
 330     }
 331     EXECUTE_TEST(execute_certconf_create_test, tear_down);
 332     return result;
 333 }
 334
 335 static int test_cmp_create_error_msg(void)
 336 {
 337     SETUP_TEST_FIXTURE(CMP_MSG_TEST_FIXTURE, set_up);
 338     fixture->si = OSSL_CMP_STATUSINFO_new(OSSL_CMP_PKISTATUS_rejection,
 339                                           OSSL_CMP_PKIFAILUREINFO_systemFailure,
 340                                           NULL);
 341     fixture->err_code = -1;
 342     fixture->expected = 1; /* expected: message creation is successful */
 343     if (!TEST_true(set1_newPkey(fixture->cmp_ctx, newkey))) {
 344         tear_down(fixture);
 345         fixture = NULL;
 346     }
 347     EXECUTE_TEST(execute_errormsg_create_test, tear_down);
 348     return result;
 349 }
 350
 351
 352 static int test_cmp_create_pollreq(void)
 353 {
 354     SETUP_TEST_FIXTURE(CMP_MSG_TEST_FIXTURE, set_up);
 355     fixture->expected = 1;
 356     EXECUTE_TEST(execute_pollreq_create_test, tear_down);
 357     return result;
 358 }
 359
 360 static int test_cmp_create_rr(void)
 361 {
 362     SETUP_TEST_FIXTURE(CMP_MSG_TEST_FIXTURE, set_up);
 363     fixture->expected = 1;
 364     if (!TEST_true(OSSL_CMP_CTX_set1_oldCert(fixture->cmp_ctx, cert))) {
 365         tear_down(fixture);
 366         fixture = NULL;
 367     }
 368     EXECUTE_TEST(execute_rr_create_test, tear_down);
 369     return result;
 370 }
 371
 372 static int test_cmp_create_genm(void)
 373 {
 374     OSSL_CMP_ITAV *iv = NULL;
 375
 376     SETUP_TEST_FIXTURE(CMP_MSG_TEST_FIXTURE, set_up);
 377     fixture->expected = 1;
 378     iv = OSSL_CMP_ITAV_create(OBJ_nid2obj(NID_id_it_implicitConfirm), NULL);
 379     if (!TEST_ptr(iv)
 380             || !TEST_true(OSSL_CMP_CTX_push0_genm_ITAV(fixture->cmp_ctx, iv))) {
 381         OSSL_CMP_ITAV_free(iv);
 382         tear_down(fixture);
 383         fixture = NULL;
 384     }
 385
 386     EXECUTE_TEST(execute_genm_create_test, tear_down);
 387     return result;
 388 }
 389
 390 static int execute_certrep_create(CMP_MSG_TEST_FIXTURE *fixture)
 391 {
 392     OSSL_CMP_CTX *ctx = fixture->cmp_ctx;
 393     OSSL_CMP_CERTREPMESSAGE *crepmsg = OSSL_CMP_CERTREPMESSAGE_new();
 394     OSSL_CMP_CERTRESPONSE *read_cresp, *cresp = OSSL_CMP_CERTRESPONSE_new();
 395     EVP_PKEY *privkey;
 396     X509 *certfromresp = NULL;
 397     int res = 0;
 398
 399     if (crepmsg == NULL || cresp == NULL)
 400         goto err;
 401     if (!ASN1_INTEGER_set(cresp->certReqId, 99))
 402         goto err;
 403     if ((cresp->certifiedKeyPair = OSSL_CMP_CERTIFIEDKEYPAIR_new()) == NULL)
 404         goto err;
 405     cresp->certifiedKeyPair->certOrEncCert->type =
 406         OSSL_CMP_CERTORENCCERT_CERTIFICATE;
 407     if ((cresp->certifiedKeyPair->certOrEncCert->value.certificate =
 408          X509_dup_ex(cert)) == NULL
 409             || !sk_OSSL_CMP_CERTRESPONSE_push(crepmsg->response, cresp))
 410         goto err;
 411     cresp = NULL;
 412     read_cresp = ossl_cmp_certrepmessage_get0_certresponse(crepmsg, 99);
 413     if (!TEST_ptr(read_cresp))
 414         goto err;
 415     if (!TEST_ptr_null(ossl_cmp_certrepmessage_get0_certresponse(crepmsg, 88)))
 416         goto err;
 417     privkey = OSSL_CMP_CTX_get0_newPkey(ctx, 1); /* may be NULL */
 418     certfromresp = ossl_cmp_certresponse_get1_cert(read_cresp, ctx, privkey);
 419     if (certfromresp == NULL || !TEST_int_eq(X509_cmp(cert, certfromresp), 0))
 420         goto err;
 421
 422     res = 1;
 423  err:
 424     X509_free(certfromresp);
 425     OSSL_CMP_CERTRESPONSE_free(cresp);
 426     OSSL_CMP_CERTREPMESSAGE_free(crepmsg);
 427     return res;
 428 }
 429
 430 static int test_cmp_create_certrep(void)
 431 {
 432     SETUP_TEST_FIXTURE(CMP_MSG_TEST_FIXTURE, set_up);
 433     EXECUTE_TEST(execute_certrep_create, tear_down);
 434     return result;
 435 }
 436
 437
 438 static int execute_rp_create(CMP_MSG_TEST_FIXTURE *fixture)
 439 {
 440     OSSL_CMP_PKISI *si = OSSL_CMP_STATUSINFO_new(33, 44, "a text");
 441     X509_NAME *issuer = X509_NAME_new();
 442     ASN1_INTEGER *serial = ASN1_INTEGER_new();
 443     OSSL_CRMF_CERTID *cid = NULL;
 444     OSSL_CMP_MSG *rpmsg = NULL;
 445     int res = 0;
 446
 447     if (si == NULL || issuer == NULL || serial == NULL)
 448         goto err;
 449
 450     if (!X509_NAME_add_entry_by_txt(issuer, "CN", MBSTRING_ASC,
 451                                     (unsigned char *)"The Issuer", -1, -1, 0)
 452             || !ASN1_INTEGER_set(serial, 99)
 453             || (cid = OSSL_CRMF_CERTID_gen(issuer, serial)) == NULL
 454             || (rpmsg = ossl_cmp_rp_new(fixture->cmp_ctx, si, cid, 1)) == NULL)
 455         goto err;
 456
 457     if (!TEST_ptr(ossl_cmp_revrepcontent_get_CertId(rpmsg->body->value.rp, 0)))
 458         goto err;
 459
 460     if (!TEST_ptr(ossl_cmp_revrepcontent_get_pkisi(rpmsg->body->value.rp, 0)))
 461         goto err;
 462
 463     res = 1;
 464  err:
 465     ASN1_INTEGER_free(serial);
 466     X509_NAME_free(issuer);
 467     OSSL_CRMF_CERTID_free(cid);
 468     OSSL_CMP_PKISI_free(si);
 469     OSSL_CMP_MSG_free(rpmsg);
 470     return res;
 471 }
 472
 473 static int test_cmp_create_rp(void)
 474 {
 475     SETUP_TEST_FIXTURE(CMP_MSG_TEST_FIXTURE, set_up);
 476     EXECUTE_TEST(execute_rp_create, tear_down);
 477     return result;
 478 }
 479
 480 static int execute_pollrep_create(CMP_MSG_TEST_FIXTURE *fixture)
 481 {
 482     OSSL_CMP_MSG *pollrep;
 483     int res = 0;
 484
 485     pollrep = ossl_cmp_pollRep_new(fixture->cmp_ctx, 77, 2000);
 486     if (!TEST_ptr(pollrep))
 487         return 0;
 488     if (!TEST_ptr(ossl_cmp_pollrepcontent_get0_pollrep(pollrep->body->
 489                                                        value.pollRep, 77)))
 490         goto err;
 491     if (!TEST_ptr_null(ossl_cmp_pollrepcontent_get0_pollrep(pollrep->body->
 492                                                             value.pollRep, 88)))
 493         goto err;
 494
 495     res = 1;
 496  err:
 497     OSSL_CMP_MSG_free(pollrep);
 498     return res;
 499 }
 500
 501 static int test_cmp_create_pollrep(void)
 502 {
 503     SETUP_TEST_FIXTURE(CMP_MSG_TEST_FIXTURE, set_up);
 504     EXECUTE_TEST(execute_pollrep_create, tear_down);
 505     return result;
 506 }
 507
 508 static int test_cmp_pkimessage_create(int bodytype)
 509 {
 510     X509_REQ *p10cr = NULL;
 511
 512     SETUP_TEST_FIXTURE(CMP_MSG_TEST_FIXTURE, set_up);
 513
 514     switch (fixture->bodytype = bodytype) {
 515     case OSSL_CMP_PKIBODY_P10CR:
 516         fixture->expected = 1;
 517         if (!TEST_true(OSSL_CMP_CTX_set1_p10CSR(fixture->cmp_ctx,
 518                                                 p10cr = load_csr(pkcs10_f)))) {
 519             tear_down(fixture);
 520             fixture = NULL;
 521         }
 522         X509_REQ_free(p10cr);
 523         break;
 524     case OSSL_CMP_PKIBODY_IR:
 525     case OSSL_CMP_PKIBODY_IP:
 526     case OSSL_CMP_PKIBODY_CR:
 527     case OSSL_CMP_PKIBODY_CP:
 528     case OSSL_CMP_PKIBODY_KUR:
 529     case OSSL_CMP_PKIBODY_KUP:
 530     case OSSL_CMP_PKIBODY_RR:
 531     case OSSL_CMP_PKIBODY_RP:
 532     case OSSL_CMP_PKIBODY_PKICONF:
 533     case OSSL_CMP_PKIBODY_GENM:
 534     case OSSL_CMP_PKIBODY_GENP:
 535     case OSSL_CMP_PKIBODY_ERROR:
 536     case OSSL_CMP_PKIBODY_CERTCONF:
 537     case OSSL_CMP_PKIBODY_POLLREQ:
 538     case OSSL_CMP_PKIBODY_POLLREP:
 539         fixture->expected = 1;
 540         break;
 541     default:
 542         fixture->expected = 0;
 543         break;
 544     }
 545
 546     EXECUTE_TEST(execute_pkimessage_create_test, tear_down);
 547     return result;
 548 }
 549
 550 void cleanup_tests(void)
 551 {
 552     EVP_PKEY_free(newkey);
 553     X509_free(cert);
 554     OPENSSL_CTX_free(libctx);
 555 }
 556
 557 #define USAGE "new.key server.crt pkcs10.der module_name [module_conf_file]\n"
 558 OPT_TEST_DECLARE_USAGE(USAGE)
 559
 560 int setup_tests(void)
 561 {
 562     if (!test_skip_common_options()) {
 563         TEST_error("Error parsing test options\n");
 564         return 0;
 565     }
 566
 567     if (!TEST_ptr(newkey_f = test_get_argument(0))
 568             || !TEST_ptr(server_cert_f = test_get_argument(1))
 569             || !TEST_ptr(pkcs10_f = test_get_argument(2))) {
 570         TEST_error("usage: cmp_msg_test %s", USAGE);
 571         return 0;
 572     }
 573
 574     if (!test_get_libctx(&libctx, &default_null_provider, &provider, 3, USAGE))
 575         return 0;
 576
 577     if (!TEST_ptr(newkey = load_pem_key(newkey_f, libctx))
 578             || !TEST_ptr(cert = load_pem_cert(server_cert_f, libctx))
 579             || !TEST_int_eq(1, RAND_bytes_ex(libctx, ref, sizeof(ref)))) {
 580         cleanup_tests();
 581         return 0;
 582     }
 583
 584     /* Message creation tests */
 585     ADD_TEST(test_cmp_create_certreq_with_invalid_bodytype);
 586     ADD_TEST(test_cmp_create_ir_protection_fails);
 587     ADD_TEST(test_cmp_create_ir_protection_set);
 588     ADD_TEST(test_cmp_create_error_msg);
 589     ADD_TEST(test_cmp_create_certconf);
 590     ADD_TEST(test_cmp_create_certconf_badAlg);
 591     ADD_TEST(test_cmp_create_certconf_fail_info_max);
 592     ADD_TEST(test_cmp_create_kur);
 593     ADD_TEST(test_cmp_create_kur_without_oldcert);
 594     ADD_TEST(test_cmp_create_cr);
 595     ADD_TEST(test_cmp_create_cr_without_key);
 596     ADD_TEST(test_cmp_create_p10cr);
 597     ADD_TEST(test_cmp_create_p10cr_null);
 598     ADD_TEST(test_cmp_create_pollreq);
 599     ADD_TEST(test_cmp_create_rr);
 600     ADD_TEST(test_cmp_create_rp);
 601     ADD_TEST(test_cmp_create_genm);
 602     ADD_TEST(test_cmp_create_certrep);
 603     ADD_TEST(test_cmp_create_pollrep);
 604     ADD_ALL_TESTS_NOSUBTEST(test_cmp_pkimessage_create,
 605                             OSSL_CMP_PKIBODY_POLLREP + 1);
 606     return 1;
 607 }