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