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
tear_down(CMP_HDR_TEST_FIXTURE * fixture)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
set_up(const char * const test_case_name)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
execute_HDR_set_get_pvno_test(CMP_HDR_TEST_FIXTURE * fixture)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
test_HDR_set_get_pvno(void)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
execute_HDR_get0_senderNonce_test(CMP_HDR_TEST_FIXTURE * fixture)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
test_HDR_get0_senderNonce(void)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
execute_HDR_set1_sender_test(CMP_HDR_TEST_FIXTURE * fixture)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
test_HDR_set1_sender(void)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
execute_HDR_set1_recipient_test(CMP_HDR_TEST_FIXTURE * fixture)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
test_HDR_set1_recipient(void)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
execute_HDR_update_messageTime_test(CMP_HDR_TEST_FIXTURE * fixture)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
test_HDR_update_messageTime(void)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
execute_HDR_set1_senderKID_test(CMP_HDR_TEST_FIXTURE * fixture)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
test_HDR_set1_senderKID(void)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
execute_HDR_push0_freeText_test(CMP_HDR_TEST_FIXTURE * fixture)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
test_HDR_push0_freeText(void)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
execute_HDR_push1_freeText_test(CMP_HDR_TEST_FIXTURE * fixture)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
test_HDR_push1_freeText(void)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
execute_HDR_generalInfo_push0_item_test(CMP_HDR_TEST_FIXTURE * fixture)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
test_HDR_generalInfo_push0_item(void)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
execute_HDR_generalInfo_push1_items_test(CMP_HDR_TEST_FIXTURE * fixture)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
test_HDR_generalInfo_push1_items(void)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
execute_HDR_set_and_check_implicitConfirm_test(CMP_HDR_TEST_FIXTURE * fixture)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
test_HDR_set_and_check_implicit_confirm(void)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
execute_HDR_init_test(CMP_HDR_TEST_FIXTURE * fixture)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
test_HDR_init_with_ref(void)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
test_HDR_init_with_subject(void)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
cleanup_tests(void)482 void cleanup_tests(void)
483 {
484 return;
485 }
486
setup_tests(void)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