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 397 static int execute_HDR_init_test(CMP_HDR_TEST_FIXTURE *fixture) 398 { 399 ASN1_OCTET_STRING *header_nonce, *header_transactionID; 400 ASN1_OCTET_STRING *ctx_nonce; 401 402 if (!TEST_int_eq(fixture->expected, 403 ossl_cmp_hdr_init(fixture->cmp_ctx, fixture->hdr))) 404 return 0; 405 if (fixture->expected == 0) 406 return 1; 407 408 if (!TEST_int_eq(ossl_cmp_hdr_get_pvno(fixture->hdr), OSSL_CMP_PVNO)) 409 return 0; 410 411 header_nonce = ossl_cmp_hdr_get0_senderNonce(fixture->hdr); 412 if (!TEST_int_eq(0, ASN1_OCTET_STRING_cmp(header_nonce, 413 fixture->cmp_ctx->senderNonce))) 414 return 0; 415 header_transactionID = OSSL_CMP_HDR_get0_transactionID(fixture->hdr); 416 if (!TEST_true(0 == ASN1_OCTET_STRING_cmp(header_transactionID, 417 fixture->cmp_ctx->transactionID))) 418 return 0; 419 420 header_nonce = OSSL_CMP_HDR_get0_recipNonce(fixture->hdr); 421 ctx_nonce = fixture->cmp_ctx->recipNonce; 422 if (ctx_nonce != NULL 423 && (!TEST_ptr(header_nonce) 424 || !TEST_int_eq(0, ASN1_OCTET_STRING_cmp(header_nonce, 425 ctx_nonce)))) 426 return 0; 427 428 return 1; 429 } 430 431 static int test_HDR_init_with_ref(void) 432 { 433 unsigned char ref[CMP_TEST_REFVALUE_LENGTH]; 434 435 SETUP_TEST_FIXTURE(CMP_HDR_TEST_FIXTURE, set_up); 436 437 fixture->expected = 1; 438 if (!TEST_int_eq(1, RAND_bytes(ref, sizeof(ref))) 439 || !TEST_true(OSSL_CMP_CTX_set1_referenceValue(fixture->cmp_ctx, 440 ref, sizeof(ref)))) { 441 tear_down(fixture); 442 fixture = NULL; 443 } 444 EXECUTE_TEST(execute_HDR_init_test, tear_down); 445 return result; 446 } 447 448 static int test_HDR_init_with_subject(void) 449 { 450 X509_NAME *subject = NULL; 451 452 SETUP_TEST_FIXTURE(CMP_HDR_TEST_FIXTURE, set_up); 453 fixture->expected = 1; 454 if (!TEST_ptr(subject = X509_NAME_new()) 455 || !TEST_true(X509_NAME_ADD(subject, "CN", "Common Name")) 456 || !TEST_true(OSSL_CMP_CTX_set1_subjectName(fixture->cmp_ctx, 457 subject))) { 458 tear_down(fixture); 459 fixture = NULL; 460 } 461 X509_NAME_free(subject); 462 EXECUTE_TEST(execute_HDR_init_test, tear_down); 463 return result; 464 } 465 466 467 void cleanup_tests(void) 468 { 469 return; 470 } 471 472 int setup_tests(void) 473 { 474 RAND_bytes(rand_data, OSSL_CMP_TRANSACTIONID_LENGTH); 475 /* Message header tests */ 476 ADD_TEST(test_HDR_set_get_pvno); 477 ADD_TEST(test_HDR_get0_senderNonce); 478 ADD_TEST(test_HDR_set1_sender); 479 ADD_TEST(test_HDR_set1_recipient); 480 ADD_TEST(test_HDR_update_messageTime); 481 ADD_TEST(test_HDR_set1_senderKID); 482 ADD_TEST(test_HDR_push0_freeText); 483 /* indirectly tests ossl_cmp_pkifreetext_push_str(): */ 484 ADD_TEST(test_HDR_push1_freeText); 485 ADD_TEST(test_HDR_generalInfo_push0_item); 486 ADD_TEST(test_HDR_generalInfo_push1_items); 487 ADD_TEST(test_HDR_set_and_check_implicit_confirm); 488 /* also tests public function OSSL_CMP_HDR_get0_transactionID(): */ 489 /* also tests public function OSSL_CMP_HDR_get0_recipNonce(): */ 490 /* also tests internal function ossl_cmp_hdr_get_pvno(): */ 491 ADD_TEST(test_HDR_init_with_ref); 492 ADD_TEST(test_HDR_init_with_subject); 493 return 1; 494 } 495