test/cmp_hdr_test.c

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