test/cmp_hdr_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 DEFINE_STACK_OF(OSSL_CMP_ITAV)
  15 DEFINE_STACK_OF(ASN1_UTF8STRING)
  16
  17 static unsigned char rand_data[OSSL_CMP_TRANSACTIONID_LENGTH];
  18
  19 typedef struct test_fixture {
  20     const char *test_case_name;
  21     int expected;
  22     OSSL_CMP_CTX *cmp_ctx;
  23     OSSL_CMP_PKIHEADER *hdr;
  24
  25 } CMP_HDR_TEST_FIXTURE;
  26
  27 static void tear_down(CMP_HDR_TEST_FIXTURE *fixture)
  28 {
  29     OSSL_CMP_PKIHEADER_free(fixture->hdr);
  30     OSSL_CMP_CTX_free(fixture->cmp_ctx);
  31     OPENSSL_free(fixture);
  32 }
  33
  34 static CMP_HDR_TEST_FIXTURE *set_up(const char *const test_case_name)
  35 {
  36     CMP_HDR_TEST_FIXTURE *fixture;
  37
  38     if (!TEST_ptr(fixture = OPENSSL_zalloc(sizeof(*fixture))))
  39         return NULL;
  40     fixture->test_case_name = test_case_name;
  41     if (!TEST_ptr(fixture->cmp_ctx = OSSL_CMP_CTX_new()))
  42         goto err;
  43     if (!TEST_ptr(fixture->hdr = OSSL_CMP_PKIHEADER_new()))
  44         goto err;
  45     return fixture;
  46
  47  err:
  48     tear_down(fixture);
  49     return NULL;
  50 }
  51
  52 static int execute_HDR_set_get_pvno_test(CMP_HDR_TEST_FIXTURE *fixture)
  53 {
  54     int pvno = 77;
  55
  56     if (!TEST_int_eq(ossl_cmp_hdr_set_pvno(fixture->hdr, pvno), 1))
  57         return 0;
  58     if (!TEST_int_eq(ossl_cmp_hdr_get_pvno(fixture->hdr), pvno))
  59         return 0;
  60     return 1;
  61 }
  62
  63 static int test_HDR_set_get_pvno(void)
  64 {
  65     SETUP_TEST_FIXTURE(CMP_HDR_TEST_FIXTURE, set_up);
  66     fixture->expected = 1;
  67     EXECUTE_TEST(execute_HDR_set_get_pvno_test, tear_down);
  68     return result;
  69 }
  70
  71 #define X509_NAME_ADD(n, rd, s) \
  72     X509_NAME_add_entry_by_txt((n), (rd), MBSTRING_ASC, (unsigned char *)(s), \
  73                                -1, -1, 0)
  74
  75 static int execute_HDR_get0_senderNonce_test(CMP_HDR_TEST_FIXTURE *fixture)
  76 {
  77     X509_NAME *sender = X509_NAME_new();
  78     ASN1_OCTET_STRING *sn;
  79
  80     if (!TEST_ptr(sender))
  81         return 0;
  82
  83     X509_NAME_ADD(sender, "CN", "A common sender name");
  84     if (!TEST_int_eq(OSSL_CMP_CTX_set1_subjectName(fixture->cmp_ctx, sender),
  85                      1))
  86         return 0;
  87     if (!TEST_int_eq(ossl_cmp_hdr_init(fixture->cmp_ctx, fixture->hdr),
  88                      1))
  89         return 0;
  90     sn = ossl_cmp_hdr_get0_senderNonce(fixture->hdr);
  91     if (!TEST_int_eq(ASN1_OCTET_STRING_cmp(fixture->cmp_ctx->senderNonce, sn),
  92                      0))
  93         return 0;
  94     X509_NAME_free(sender);
  95     return 1;
  96 }
  97
  98 static int test_HDR_get0_senderNonce(void)
  99 {
 100     SETUP_TEST_FIXTURE(CMP_HDR_TEST_FIXTURE, set_up);
 101     fixture->expected = 1;
 102     EXECUTE_TEST(execute_HDR_get0_senderNonce_test, tear_down);
 103     return result;
 104 }
 105
 106 static int execute_HDR_set1_sender_test(CMP_HDR_TEST_FIXTURE *fixture)
 107 {
 108     X509_NAME *x509name = X509_NAME_new();
 109
 110     if (!TEST_ptr(x509name))
 111         return 0;
 112
 113     X509_NAME_ADD(x509name, "CN", "A common sender name");
 114     if (!TEST_int_eq(ossl_cmp_hdr_set1_sender(fixture->hdr, x509name), 1))
 115         return 0;
 116     if (!TEST_int_eq(fixture->hdr->sender->type, GEN_DIRNAME))
 117         return 0;
 118
 119     if (!TEST_int_eq(X509_NAME_cmp(fixture->hdr->sender->d.directoryName,
 120                                    x509name), 0))
 121         return 0;
 122
 123     X509_NAME_free(x509name);
 124     return 1;
 125 }
 126
 127 static int test_HDR_set1_sender(void)
 128 {
 129     SETUP_TEST_FIXTURE(CMP_HDR_TEST_FIXTURE, set_up);
 130     fixture->expected = 1;
 131     EXECUTE_TEST(execute_HDR_set1_sender_test, tear_down);
 132     return result;
 133 }
 134
 135 static int execute_HDR_set1_recipient_test(CMP_HDR_TEST_FIXTURE *fixture)
 136 {
 137     X509_NAME *x509name = X509_NAME_new();
 138
 139     if (!TEST_ptr(x509name))
 140         return 0;
 141
 142     X509_NAME_ADD(x509name, "CN", "A common recipient name");
 143     if (!TEST_int_eq(ossl_cmp_hdr_set1_recipient(fixture->hdr, x509name), 1))
 144         return 0;
 145
 146     if (!TEST_int_eq(fixture->hdr->recipient->type, GEN_DIRNAME))
 147         return 0;
 148
 149     if (!TEST_int_eq(X509_NAME_cmp(fixture->hdr->recipient->d.directoryName,
 150                                    x509name), 0))
 151         return 0;
 152
 153     X509_NAME_free(x509name);
 154     return 1;
 155 }
 156
 157 static int test_HDR_set1_recipient(void)
 158 {
 159     SETUP_TEST_FIXTURE(CMP_HDR_TEST_FIXTURE, set_up);
 160     fixture->expected = 1;
 161     EXECUTE_TEST(execute_HDR_set1_recipient_test, tear_down);
 162     return result;
 163 }
 164
 165 static int execute_HDR_update_messageTime_test(CMP_HDR_TEST_FIXTURE *fixture)
 166 {
 167     struct tm hdrtm;
 168     time_t hdrtime, before, after, now;
 169
 170     now = time(NULL);
 171     before = mktime(gmtime(&now));
 172     if (!TEST_true(ossl_cmp_hdr_update_messageTime(fixture->hdr)))
 173         return 0;
 174     if (!TEST_true(ASN1_TIME_to_tm(fixture->hdr->messageTime, &hdrtm)))
 175         return 0;
 176
 177     hdrtime = mktime(&hdrtm);
 178     if (!TEST_true(before <= hdrtime))
 179         return 0;
 180     now = time(NULL);
 181     after = mktime(gmtime(&now));
 182     return TEST_true(hdrtime <= after);
 183 }
 184
 185 static int test_HDR_update_messageTime(void)
 186 {
 187     SETUP_TEST_FIXTURE(CMP_HDR_TEST_FIXTURE, set_up);
 188     fixture->expected = 1;
 189     EXECUTE_TEST(execute_HDR_update_messageTime_test, tear_down);
 190     return result;
 191 }
 192
 193 static int execute_HDR_set1_senderKID_test(CMP_HDR_TEST_FIXTURE *fixture)
 194 {
 195     ASN1_OCTET_STRING *senderKID = ASN1_OCTET_STRING_new();
 196
 197     if (!TEST_ptr(senderKID))
 198         return 0;
 199
 200     if (!TEST_int_eq(ASN1_OCTET_STRING_set(senderKID, rand_data,
 201                                            sizeof(rand_data)), 1))
 202         return 0;
 203     if (!TEST_int_eq(ossl_cmp_hdr_set1_senderKID(fixture->hdr, senderKID), 1))
 204         return 0;
 205     if (!TEST_int_eq(ASN1_OCTET_STRING_cmp(fixture->hdr->senderKID,
 206                                            senderKID), 0))
 207         return 0;
 208
 209     ASN1_OCTET_STRING_free(senderKID);
 210     return 1;
 211 }
 212
 213 static int test_HDR_set1_senderKID(void)
 214 {
 215     SETUP_TEST_FIXTURE(CMP_HDR_TEST_FIXTURE, set_up);
 216     fixture->expected = 1;
 217     EXECUTE_TEST(execute_HDR_set1_senderKID_test, tear_down);
 218     return result;
 219 }
 220
 221 static int execute_HDR_push0_freeText_test(CMP_HDR_TEST_FIXTURE *fixture)
 222 {
 223     ASN1_UTF8STRING *text = ASN1_UTF8STRING_new();
 224
 225     if (!TEST_ptr(text))
 226         return 0;
 227
 228     if (!ASN1_STRING_set(text, "A free text", -1))
 229         return 0;
 230
 231     if (!TEST_int_eq(ossl_cmp_hdr_push0_freeText(fixture->hdr, text), 1))
 232         return 0;
 233
 234     if (!TEST_true(text == sk_ASN1_UTF8STRING_value(fixture->hdr->freeText, 0)))
 235         return 0;
 236
 237     return 1;
 238 }
 239
 240 static int test_HDR_push0_freeText(void)
 241 {
 242     SETUP_TEST_FIXTURE(CMP_HDR_TEST_FIXTURE, set_up);
 243     fixture->expected = 1;
 244     EXECUTE_TEST(execute_HDR_push0_freeText_test, tear_down);
 245     return result;
 246 }
 247
 248 static int execute_HDR_push1_freeText_test(CMP_HDR_TEST_FIXTURE *fixture)
 249 {
 250     ASN1_UTF8STRING *text = ASN1_UTF8STRING_new();
 251     ASN1_UTF8STRING *pushed_text;
 252
 253     if (!TEST_ptr(text))
 254         return 0;
 255
 256     if (!ASN1_STRING_set(text, "A free text", -1))
 257         return 0;
 258
 259     if (!TEST_int_eq(ossl_cmp_hdr_push1_freeText(fixture->hdr, text), 1))
 260         return 0;
 261
 262     pushed_text = sk_ASN1_UTF8STRING_value(fixture->hdr->freeText, 0);
 263     if (!TEST_int_eq(ASN1_STRING_cmp(text, pushed_text), 0))
 264         return 0;
 265
 266     ASN1_UTF8STRING_free(text);
 267     return 1;
 268 }
 269
 270 static int test_HDR_push1_freeText(void)
 271 {
 272     SETUP_TEST_FIXTURE(CMP_HDR_TEST_FIXTURE, set_up);
 273     fixture->expected = 1;
 274     EXECUTE_TEST(execute_HDR_push1_freeText_test, tear_down);
 275     return result;
 276 }
 277
 278 static int
 279 execute_HDR_generalInfo_push0_item_test(CMP_HDR_TEST_FIXTURE *fixture)
 280 {
 281     OSSL_CMP_ITAV *itav = OSSL_CMP_ITAV_new();
 282
 283     if (!TEST_ptr(itav))
 284         return 0;
 285
 286     if (!TEST_int_eq(ossl_cmp_hdr_generalInfo_push0_item(fixture->hdr, itav),
 287                      1))
 288         return 0;
 289
 290     if (!TEST_true(itav == sk_OSSL_CMP_ITAV_value(fixture->hdr->generalInfo,
 291                                                   0)))
 292         return 0;
 293
 294     return 1;
 295 }
 296
 297 static int test_HDR_generalInfo_push0_item(void)
 298 {
 299     SETUP_TEST_FIXTURE(CMP_HDR_TEST_FIXTURE, set_up);
 300     fixture->expected = 1;
 301     EXECUTE_TEST(execute_HDR_generalInfo_push0_item_test, tear_down);
 302     return result;
 303 }
 304
 305 static int
 306 execute_HDR_generalInfo_push1_items_test(CMP_HDR_TEST_FIXTURE *fixture)
 307 {
 308     const char oid[] = "1.2.3.4";
 309     char buf[20];
 310     OSSL_CMP_ITAV *itav, *pushed_itav;
 311     STACK_OF(OSSL_CMP_ITAV) *itavs = NULL, *ginfo;
 312     ASN1_INTEGER *asn1int = ASN1_INTEGER_new();
 313     ASN1_TYPE *val = ASN1_TYPE_new();
 314     ASN1_TYPE *pushed_val;
 315
 316     if (!TEST_ptr(asn1int))
 317         return 0;
 318
 319     if (!TEST_ptr(val))
 320         return 0;
 321
 322     ASN1_INTEGER_set(asn1int, 88);
 323     ASN1_TYPE_set(val, V_ASN1_INTEGER, asn1int);
 324     itav = OSSL_CMP_ITAV_create(OBJ_txt2obj(oid, 1), val);
 325     OSSL_CMP_ITAV_push0_stack_item(&itavs, itav);
 326
 327     if (!TEST_int_eq(ossl_cmp_hdr_generalInfo_push1_items(fixture->hdr, itavs),
 328                      1))
 329         return 0;
 330     ginfo = fixture->hdr->generalInfo;
 331     pushed_itav = sk_OSSL_CMP_ITAV_value(ginfo, 0);
 332     OBJ_obj2txt(buf, sizeof(buf), OSSL_CMP_ITAV_get0_type(pushed_itav), 0);
 333     if (!TEST_int_eq(memcmp(oid, buf, sizeof(oid)), 0))
 334         return 0;
 335
 336     pushed_val = OSSL_CMP_ITAV_get0_value(sk_OSSL_CMP_ITAV_value(ginfo, 0));
 337     if (!TEST_int_eq(ASN1_TYPE_cmp(itav->infoValue.other, pushed_val), 0))
 338         return 0;
 339
 340     sk_OSSL_CMP_ITAV_pop_free(itavs, OSSL_CMP_ITAV_free);
 341     return 1;
 342 }
 343
 344 static int test_HDR_generalInfo_push1_items(void)
 345 {
 346     SETUP_TEST_FIXTURE(CMP_HDR_TEST_FIXTURE, set_up);
 347     fixture->expected = 1;
 348     EXECUTE_TEST(execute_HDR_generalInfo_push1_items_test, tear_down);
 349     return result;
 350 }
 351
 352 static int
 353 execute_HDR_set_and_check_implicitConfirm_test(CMP_HDR_TEST_FIXTURE
 354                                                * fixture)
 355 {
 356     return TEST_false(ossl_cmp_hdr_has_implicitConfirm(fixture->hdr))
 357         && TEST_true(ossl_cmp_hdr_set_implicitConfirm(fixture->hdr))
 358         && TEST_true(ossl_cmp_hdr_has_implicitConfirm(fixture->hdr));
 359 }
 360
 361 static int test_HDR_set_and_check_implicit_confirm(void)
 362 {
 363     SETUP_TEST_FIXTURE(CMP_HDR_TEST_FIXTURE, set_up);
 364     EXECUTE_TEST(execute_HDR_set_and_check_implicitConfirm_test, tear_down);
 365     return result;
 366 }
 367
 368
 369 static int execute_HDR_init_test(CMP_HDR_TEST_FIXTURE *fixture)
 370 {
 371     ASN1_OCTET_STRING *header_nonce, *header_transactionID;
 372     ASN1_OCTET_STRING *ctx_nonce;
 373
 374     if (!TEST_int_eq(fixture->expected,
 375                      ossl_cmp_hdr_init(fixture->cmp_ctx, fixture->hdr)))
 376         return 0;
 377     if (fixture->expected == 0)
 378         return 1;
 379
 380     if (!TEST_int_eq(ossl_cmp_hdr_get_pvno(fixture->hdr), OSSL_CMP_PVNO))
 381         return 0;
 382
 383     header_nonce = ossl_cmp_hdr_get0_senderNonce(fixture->hdr);
 384     if (!TEST_int_eq(0, ASN1_OCTET_STRING_cmp(header_nonce,
 385                                               fixture->cmp_ctx->senderNonce)))
 386         return 0;
 387     header_transactionID = OSSL_CMP_HDR_get0_transactionID(fixture->hdr);
 388     if (!TEST_true(0 == ASN1_OCTET_STRING_cmp(header_transactionID,
 389                                               fixture->cmp_ctx->transactionID)))
 390         return 0;
 391
 392     header_nonce = OSSL_CMP_HDR_get0_recipNonce(fixture->hdr);
 393     ctx_nonce = fixture->cmp_ctx->recipNonce;
 394     if (ctx_nonce != NULL
 395             && (!TEST_ptr(header_nonce)
 396                     || !TEST_int_eq(0, ASN1_OCTET_STRING_cmp(header_nonce,
 397                                                              ctx_nonce))))
 398         return 0;
 399
 400     return 1;
 401 }
 402
 403 static int test_HDR_init_with_ref(void)
 404 {
 405     SETUP_TEST_FIXTURE(CMP_HDR_TEST_FIXTURE, set_up);
 406     unsigned char ref[CMP_TEST_REFVALUE_LENGTH];
 407
 408     fixture->expected = 1;
 409     if (!TEST_int_eq(1, RAND_bytes(ref, sizeof(ref)))
 410             || !TEST_true(OSSL_CMP_CTX_set1_referenceValue(fixture->cmp_ctx,
 411                                                            ref, sizeof(ref)))) {
 412         tear_down(fixture);
 413         fixture = NULL;
 414     }
 415     EXECUTE_TEST(execute_HDR_init_test, tear_down);
 416     return result;
 417 }
 418
 419 static int test_HDR_init_with_subject(void)
 420 {
 421     SETUP_TEST_FIXTURE(CMP_HDR_TEST_FIXTURE, set_up);
 422     X509_NAME *subject = NULL;
 423
 424     fixture->expected = 1;
 425     if (!TEST_ptr(subject = X509_NAME_new())
 426             || !TEST_true(X509_NAME_ADD(subject, "CN", "Common Name"))
 427             || !TEST_true(OSSL_CMP_CTX_set1_subjectName(fixture->cmp_ctx,
 428                                                         subject))) {
 429         tear_down(fixture);
 430         fixture = NULL;
 431     }
 432     X509_NAME_free(subject);
 433     EXECUTE_TEST(execute_HDR_init_test, tear_down);
 434     return result;
 435 }
 436
 437
 438 void cleanup_tests(void)
 439 {
 440     return;
 441 }
 442
 443 int setup_tests(void)
 444 {
 445     RAND_bytes(rand_data, OSSL_CMP_TRANSACTIONID_LENGTH);
 446     /* Message header tests */
 447     ADD_TEST(test_HDR_set_get_pvno);
 448     ADD_TEST(test_HDR_get0_senderNonce);
 449     ADD_TEST(test_HDR_set1_sender);
 450     ADD_TEST(test_HDR_set1_recipient);
 451     ADD_TEST(test_HDR_update_messageTime);
 452     ADD_TEST(test_HDR_set1_senderKID);
 453     ADD_TEST(test_HDR_push0_freeText);
 454     /* indirectly tests ossl_cmp_pkifreetext_push_str(): */
 455     ADD_TEST(test_HDR_push1_freeText);
 456     ADD_TEST(test_HDR_generalInfo_push0_item);
 457     ADD_TEST(test_HDR_generalInfo_push1_items);
 458     ADD_TEST(test_HDR_set_and_check_implicit_confirm);
 459     /* also tests public function OSSL_CMP_HDR_get0_transactionID(): */
 460     /* also tests public function OSSL_CMP_HDR_get0_recipNonce(): */
 461     /* also tests internal function ossl_cmp_hdr_get_pvno(): */
 462     ADD_TEST(test_HDR_init_with_ref);
 463     ADD_TEST(test_HDR_init_with_subject);
 464     /*
 465      *  TODO make sure that total number of tests (here currently 24) is shown,
 466      *  also for other cmp_*text.c. Currently the test drivers always show 1.
 467      */
 468
 469     return 1;
 470 }