]>
Commit | Line | Data |
---|---|---|
4dde554c | 1 | /* |
da1c088f | 2 | * Copyright 2007-2023 The OpenSSL Project Authors. All Rights Reserved. |
4dde554c DDO |
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 | ||
20f8bc72 | 12 | #include "helpers/cmp_testlib.h" |
4dde554c DDO |
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; | |
1a7cd250 | 38 | if (!TEST_ptr(fixture->cmp_ctx = OSSL_CMP_CTX_new(NULL, NULL))) |
4dde554c DDO |
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 | ||
235595c4 DDO |
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) | |
4dde554c DDO |
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 | ||
235595c4 DDO |
116 | if (!TEST_int_eq(X509_NAME_cmp(fixture->hdr->sender->d.directoryName, |
117 | x509name), 0)) | |
4dde554c DDO |
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 | ||
235595c4 DDO |
146 | if (!TEST_int_eq(X509_NAME_cmp(fixture->hdr->recipient->d.directoryName, |
147 | x509name), 0)) | |
4dde554c DDO |
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 | { | |
3c0d0eca | 164 | struct tm hdrtm, tmptm; |
4dde554c DDO |
165 | time_t hdrtime, before, after, now; |
166 | ||
167 | now = time(NULL); | |
3c0d0eca MC |
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 | ||
4dde554c DDO |
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); | |
3c0d0eca | 182 | |
4616a614 | 183 | if (!TEST_time_t_le(before, hdrtime)) |
4dde554c DDO |
184 | return 0; |
185 | now = time(NULL); | |
3c0d0eca MC |
186 | tmptm = *gmtime(&now); |
187 | after = mktime(&tmptm); | |
188 | ||
4616a614 | 189 | return TEST_time_t_le(hdrtime, after); |
4dde554c DDO |
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 | { | |
235595c4 | 202 | ASN1_OCTET_STRING *senderKID = ASN1_OCTET_STRING_new(); |
015b221a | 203 | int res = 0; |
4dde554c DDO |
204 | |
205 | if (!TEST_ptr(senderKID)) | |
206 | return 0; | |
207 | ||
3dbc5156 DDO |
208 | if (!TEST_int_eq(ASN1_OCTET_STRING_set(senderKID, rand_data, |
209 | sizeof(rand_data)), 1)) | |
015b221a | 210 | goto err; |
4dde554c | 211 | if (!TEST_int_eq(ossl_cmp_hdr_set1_senderKID(fixture->hdr, senderKID), 1)) |
015b221a | 212 | goto err; |
235595c4 DDO |
213 | if (!TEST_int_eq(ASN1_OCTET_STRING_cmp(fixture->hdr->senderKID, |
214 | senderKID), 0)) | |
015b221a P |
215 | goto err; |
216 | res = 1; | |
217 | err: | |
4dde554c | 218 | ASN1_OCTET_STRING_free(senderKID); |
015b221a | 219 | return res; |
4dde554c DDO |
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 | { | |
235595c4 | 232 | ASN1_UTF8STRING *text = ASN1_UTF8STRING_new(); |
4dde554c DDO |
233 | |
234 | if (!TEST_ptr(text)) | |
235 | return 0; | |
236 | ||
237 | if (!ASN1_STRING_set(text, "A free text", -1)) | |
015b221a | 238 | goto err; |
4dde554c | 239 | |
235595c4 | 240 | if (!TEST_int_eq(ossl_cmp_hdr_push0_freeText(fixture->hdr, text), 1)) |
015b221a | 241 | goto err; |
235595c4 DDO |
242 | |
243 | if (!TEST_true(text == sk_ASN1_UTF8STRING_value(fixture->hdr->freeText, 0))) | |
015b221a | 244 | goto err; |
4dde554c DDO |
245 | |
246 | return 1; | |
015b221a P |
247 | |
248 | err: | |
249 | ASN1_UTF8STRING_free(text); | |
250 | return 0; | |
4dde554c DDO |
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 | { | |
235595c4 DDO |
263 | ASN1_UTF8STRING *text = ASN1_UTF8STRING_new(); |
264 | ASN1_UTF8STRING *pushed_text; | |
015b221a | 265 | int res = 0; |
4dde554c DDO |
266 | |
267 | if (!TEST_ptr(text)) | |
268 | return 0; | |
269 | ||
270 | if (!ASN1_STRING_set(text, "A free text", -1)) | |
015b221a | 271 | goto err; |
4dde554c | 272 | |
235595c4 | 273 | if (!TEST_int_eq(ossl_cmp_hdr_push1_freeText(fixture->hdr, text), 1)) |
015b221a | 274 | goto err; |
235595c4 DDO |
275 | |
276 | pushed_text = sk_ASN1_UTF8STRING_value(fixture->hdr->freeText, 0); | |
277 | if (!TEST_int_eq(ASN1_STRING_cmp(text, pushed_text), 0)) | |
015b221a | 278 | goto err; |
4dde554c | 279 | |
015b221a P |
280 | res = 1; |
281 | err: | |
4dde554c | 282 | ASN1_UTF8STRING_free(text); |
015b221a | 283 | return res; |
4dde554c DDO |
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 | ||
235595c4 DDO |
302 | if (!TEST_int_eq(ossl_cmp_hdr_generalInfo_push0_item(fixture->hdr, itav), |
303 | 1)) | |
4dde554c | 304 | return 0; |
235595c4 DDO |
305 | |
306 | if (!TEST_true(itav == sk_OSSL_CMP_ITAV_value(fixture->hdr->generalInfo, | |
307 | 0))) | |
4dde554c DDO |
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]; | |
235595c4 DDO |
326 | OSSL_CMP_ITAV *itav, *pushed_itav; |
327 | STACK_OF(OSSL_CMP_ITAV) *itavs = NULL, *ginfo; | |
4dde554c DDO |
328 | ASN1_INTEGER *asn1int = ASN1_INTEGER_new(); |
329 | ASN1_TYPE *val = ASN1_TYPE_new(); | |
235595c4 | 330 | ASN1_TYPE *pushed_val; |
015b221a | 331 | int res = 0; |
4dde554c DDO |
332 | |
333 | if (!TEST_ptr(asn1int)) | |
334 | return 0; | |
335 | ||
00407fbf P |
336 | if (!TEST_ptr(val) |
337 | || !TEST_true(ASN1_INTEGER_set(asn1int, 88))) { | |
015b221a | 338 | ASN1_INTEGER_free(asn1int); |
4dde554c | 339 | return 0; |
015b221a | 340 | } |
4dde554c | 341 | |
4dde554c | 342 | ASN1_TYPE_set(val, V_ASN1_INTEGER, asn1int); |
015b221a P |
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 | } | |
4dde554c | 351 | |
235595c4 DDO |
352 | if (!TEST_int_eq(ossl_cmp_hdr_generalInfo_push1_items(fixture->hdr, itavs), |
353 | 1)) | |
015b221a | 354 | goto err; |
235595c4 DDO |
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); | |
4dde554c | 358 | if (!TEST_int_eq(memcmp(oid, buf, sizeof(oid)), 0)) |
015b221a | 359 | goto err; |
4dde554c | 360 | |
235595c4 DDO |
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)) | |
015b221a P |
363 | goto err; |
364 | ||
365 | res = 1; | |
4dde554c | 366 | |
015b221a | 367 | err: |
4dde554c | 368 | sk_OSSL_CMP_ITAV_pop_free(itavs, OSSL_CMP_ITAV_free); |
015b221a | 369 | return res; |
4dde554c DDO |
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 | { | |
62dcd2aa | 384 | return TEST_false(ossl_cmp_hdr_has_implicitConfirm(fixture->hdr)) |
4dde554c | 385 | && TEST_true(ossl_cmp_hdr_set_implicitConfirm(fixture->hdr)) |
62dcd2aa | 386 | && TEST_true(ossl_cmp_hdr_has_implicitConfirm(fixture->hdr)); |
4dde554c DDO |
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 | ||
4dde554c DDO |
396 | static int execute_HDR_init_test(CMP_HDR_TEST_FIXTURE *fixture) |
397 | { | |
235595c4 DDO |
398 | ASN1_OCTET_STRING *header_nonce, *header_transactionID; |
399 | ASN1_OCTET_STRING *ctx_nonce; | |
4dde554c DDO |
400 | |
401 | if (!TEST_int_eq(fixture->expected, | |
402 | ossl_cmp_hdr_init(fixture->cmp_ctx, fixture->hdr))) | |
235595c4 DDO |
403 | return 0; |
404 | if (fixture->expected == 0) | |
405 | return 1; | |
4dde554c | 406 | |
235595c4 DDO |
407 | if (!TEST_int_eq(ossl_cmp_hdr_get_pvno(fixture->hdr), OSSL_CMP_PVNO)) |
408 | return 0; | |
4dde554c | 409 | |
235595c4 DDO |
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); | |
357bfe73 DDO |
415 | if (!TEST_true(ASN1_OCTET_STRING_cmp(header_transactionID, |
416 | fixture->cmp_ctx->transactionID) == 0)) | |
235595c4 DDO |
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; | |
4dde554c DDO |
428 | } |
429 | ||
cfca56df | 430 | static int test_HDR_init_with_ref(void) |
4dde554c | 431 | { |
4dde554c DDO |
432 | unsigned char ref[CMP_TEST_REFVALUE_LENGTH]; |
433 | ||
06cee80a DDO |
434 | SETUP_TEST_FIXTURE(CMP_HDR_TEST_FIXTURE, set_up); |
435 | ||
4dde554c DDO |
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 | { | |
4dde554c DDO |
449 | X509_NAME *subject = NULL; |
450 | ||
06cee80a | 451 | SETUP_TEST_FIXTURE(CMP_HDR_TEST_FIXTURE, set_up); |
4dde554c DDO |
452 | fixture->expected = 1; |
453 | if (!TEST_ptr(subject = X509_NAME_new()) | |
3dbc5156 DDO |
454 | || !TEST_true(X509_NAME_ADD(subject, "CN", "Common Name")) |
455 | || !TEST_true(OSSL_CMP_CTX_set1_subjectName(fixture->cmp_ctx, | |
456 | subject))) { | |
4dde554c DDO |
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 | ||
4dde554c DDO |
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(): */ | |
cfca56df | 489 | ADD_TEST(test_HDR_init_with_ref); |
4dde554c | 490 | ADD_TEST(test_HDR_init_with_subject); |
4dde554c DDO |
491 | return 1; |
492 | } |