]>
Commit | Line | Data |
---|---|---|
7960dbec | 1 | /* |
33388b44 | 2 | * Copyright 2007-2020 The OpenSSL Project Authors. All Rights Reserved. |
7960dbec 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 | ||
12 | #include "cmp_testlib.h" | |
13 | ||
14 | #include <openssl/x509_vfy.h> | |
15 | ||
852c2ed2 | 16 | DEFINE_STACK_OF(OSSL_CMP_ITAV) |
852c2ed2 | 17 | |
7960dbec DDO |
18 | typedef struct test_fixture { |
19 | const char *test_case_name; | |
20 | OSSL_CMP_CTX *ctx; | |
21 | } OSSL_CMP_CTX_TEST_FIXTURE; | |
22 | ||
23 | static void tear_down(OSSL_CMP_CTX_TEST_FIXTURE *fixture) | |
24 | { | |
25 | if (fixture != NULL) | |
26 | OSSL_CMP_CTX_free(fixture->ctx); | |
27 | OPENSSL_free(fixture); | |
28 | } | |
29 | ||
30 | static OSSL_CMP_CTX_TEST_FIXTURE *set_up(const char *const test_case_name) | |
31 | { | |
32 | OSSL_CMP_CTX_TEST_FIXTURE *fixture; | |
33 | ||
4dde554c DDO |
34 | if (!TEST_ptr(fixture = OPENSSL_zalloc(sizeof(*fixture)))) |
35 | return NULL; | |
1a7cd250 | 36 | if (!TEST_ptr(fixture->ctx = OSSL_CMP_CTX_new(NULL, NULL))) { |
7960dbec DDO |
37 | tear_down(fixture); |
38 | return NULL; | |
39 | } | |
40 | fixture->test_case_name = test_case_name; | |
41 | return fixture; | |
42 | } | |
43 | ||
3dbc5156 DDO |
44 | static STACK_OF(X509) *sk_X509_new_1(void) |
45 | { | |
7960dbec DDO |
46 | STACK_OF(X509) *sk = sk_X509_new_null(); |
47 | X509 *x = X509_new(); | |
48 | ||
49 | if (x == NULL || !sk_X509_push(sk, x)) { | |
50 | sk_X509_free(sk); | |
51 | X509_free(x); | |
52 | sk = NULL; | |
53 | } | |
54 | return sk; | |
55 | } | |
56 | ||
3dbc5156 DDO |
57 | static void sk_X509_pop_X509_free(STACK_OF(X509) *sk) |
58 | { | |
7960dbec DDO |
59 | sk_X509_pop_free(sk, X509_free); |
60 | } | |
61 | ||
62 | static int execute_CTX_reinit_test(OSSL_CMP_CTX_TEST_FIXTURE *fixture) | |
63 | { | |
64 | OSSL_CMP_CTX *ctx = fixture->ctx; | |
65 | ASN1_OCTET_STRING *bytes = NULL; | |
66 | STACK_OF(X509) *certs = NULL; | |
67 | int res = 0; | |
68 | ||
69 | /* set non-default values in all relevant fields */ | |
70 | ctx->status = 1; | |
71 | ctx->failInfoCode = 1; | |
72 | if (!ossl_cmp_ctx_set0_statusString(ctx, sk_ASN1_UTF8STRING_new_null()) | |
73 | || !ossl_cmp_ctx_set0_newCert(ctx, X509_new()) | |
74 | || !TEST_ptr(certs = sk_X509_new_1()) | |
39082af2 | 75 | || !ossl_cmp_ctx_set1_newChain(ctx, certs) |
7960dbec DDO |
76 | || !ossl_cmp_ctx_set1_caPubs(ctx, certs) |
77 | || !ossl_cmp_ctx_set1_extraCertsIn(ctx, certs) | |
78 | || !ossl_cmp_ctx_set0_validatedSrvCert(ctx, X509_new()) | |
79 | || !TEST_ptr(bytes = ASN1_OCTET_STRING_new()) | |
80 | || !OSSL_CMP_CTX_set1_transactionID(ctx, bytes) | |
81 | || !OSSL_CMP_CTX_set1_senderNonce(ctx, bytes) | |
82 | || !ossl_cmp_ctx_set1_recipNonce(ctx, bytes)) | |
7960dbec DDO |
83 | goto err; |
84 | ||
85 | if (!TEST_true(OSSL_CMP_CTX_reinit(ctx))) | |
86 | goto err; | |
87 | ||
88 | /* check whether values have been reset to default in all relevant fields */ | |
89 | if (!TEST_true(ctx->status == -1 | |
90 | && ctx->failInfoCode == -1 | |
91 | && ctx->statusString == NULL | |
92 | && ctx->newCert == NULL | |
39082af2 | 93 | && ctx->newChain == NULL |
7960dbec DDO |
94 | && ctx->caPubs == NULL |
95 | && ctx->extraCertsIn == NULL | |
96 | && ctx->validatedSrvCert == NULL | |
97 | && ctx->transactionID == NULL | |
98 | && ctx->senderNonce == NULL | |
99 | && ctx->recipNonce == NULL)) | |
100 | goto err; | |
101 | ||
102 | /* this does not check that all remaining fields are untouched */ | |
103 | res = 1; | |
104 | ||
105 | err: | |
106 | sk_X509_pop_X509_free(certs); | |
107 | ASN1_OCTET_STRING_free(bytes); | |
108 | return res; | |
109 | } | |
110 | ||
111 | static int test_CTX_reinit(void) | |
112 | { | |
113 | SETUP_TEST_FIXTURE(OSSL_CMP_CTX_TEST_FIXTURE, set_up); | |
114 | EXECUTE_TEST(execute_CTX_reinit_test, tear_down); | |
115 | return result; | |
116 | } | |
117 | ||
8e1a1582 | 118 | #if !defined(OPENSSL_NO_ERR) && !defined(OPENSSL_NO_AUTOERRINIT) |
85870311 | 119 | |
7960dbec DDO |
120 | static int msg_total_size = 0; |
121 | static int msg_total_size_log_cb(const char *func, const char *file, int line, | |
122 | OSSL_CMP_severity level, const char *msg) | |
123 | { | |
124 | msg_total_size += strlen(msg); | |
0acaa795 | 125 | TEST_note("total=%d len=%zu msg='%s'\n", msg_total_size, strlen(msg), msg); |
7960dbec DDO |
126 | return 1; |
127 | } | |
128 | ||
85870311 | 129 | # define STR64 "This is a 64 bytes looooooooooooooooooooooooooooooooong string.\n" |
7960dbec | 130 | /* max string length ISO C90 compilers are required to support is 509. */ |
85870311 | 131 | # define STR509 STR64 STR64 STR64 STR64 STR64 STR64 STR64 \ |
7960dbec DDO |
132 | "This is a 61 bytes loooooooooooooooooooooooooooooong string.\n" |
133 | static const char *const max_str_literal = STR509; | |
85870311 | 134 | # define STR_SEP "<SEP>" |
7960dbec DDO |
135 | |
136 | static int execute_CTX_print_errors_test(OSSL_CMP_CTX_TEST_FIXTURE *fixture) | |
137 | { | |
138 | OSSL_CMP_CTX *ctx = fixture->ctx; | |
139 | int base_err_msg_size, expected_size; | |
140 | int res = 1; | |
141 | ||
142 | if (!TEST_true(OSSL_CMP_CTX_set_log_cb(ctx, NULL))) | |
143 | res = 0; | |
144 | if (!TEST_true(ctx->log_cb == NULL)) | |
145 | res = 0; | |
146 | ||
85870311 | 147 | # ifndef OPENSSL_NO_STDIO |
7960dbec DDO |
148 | CMPerr(0, CMP_R_MULTIPLE_SAN_SOURCES); |
149 | OSSL_CMP_CTX_print_errors(ctx); /* should print above error to STDERR */ | |
85870311 | 150 | # endif |
7960dbec DDO |
151 | |
152 | /* this should work regardless of OPENSSL_NO_STDIO and OPENSSL_NO_TRACE: */ | |
153 | if (!TEST_true(OSSL_CMP_CTX_set_log_cb(ctx, msg_total_size_log_cb))) | |
154 | res = 0; | |
155 | if (!TEST_true(ctx->log_cb == msg_total_size_log_cb)) { | |
156 | res = 0; | |
157 | } else { | |
158 | CMPerr(0, CMP_R_INVALID_ARGS); | |
159 | base_err_msg_size = strlen("INVALID_ARGS"); | |
160 | CMPerr(0, CMP_R_NULL_ARGUMENT); | |
161 | base_err_msg_size += strlen("NULL_ARGUMENT"); | |
162 | expected_size = base_err_msg_size; | |
163 | ossl_cmp_add_error_data("data1"); /* should prepend separator " : " */ | |
164 | expected_size += strlen(" : " "data1"); | |
165 | ossl_cmp_add_error_data("data2"); /* should prepend separator " : " */ | |
166 | expected_size += strlen(" : " "data2"); | |
167 | ossl_cmp_add_error_line("new line"); /* should prepend separator "\n" */ | |
168 | expected_size += strlen("\n" "new line"); | |
169 | OSSL_CMP_CTX_print_errors(ctx); | |
170 | if (!TEST_int_eq(msg_total_size, expected_size)) | |
171 | res = 0; | |
172 | ||
173 | CMPerr(0, CMP_R_INVALID_ARGS); | |
174 | base_err_msg_size = strlen("INVALID_ARGS") + strlen(" : "); | |
175 | expected_size = base_err_msg_size; | |
176 | while (expected_size < 4096) { /* force split */ | |
31b28ad9 | 177 | ERR_add_error_txt(STR_SEP, max_str_literal); |
7960dbec DDO |
178 | expected_size += strlen(STR_SEP) + strlen(max_str_literal); |
179 | } | |
180 | expected_size += base_err_msg_size - 2 * strlen(STR_SEP); | |
181 | msg_total_size = 0; | |
182 | OSSL_CMP_CTX_print_errors(ctx); | |
183 | if (!TEST_int_eq(msg_total_size, expected_size)) | |
184 | res = 0; | |
185 | } | |
186 | ||
187 | return res; | |
188 | } | |
189 | ||
190 | static int test_CTX_print_errors(void) | |
191 | { | |
192 | SETUP_TEST_FIXTURE(OSSL_CMP_CTX_TEST_FIXTURE, set_up); | |
193 | EXECUTE_TEST(execute_CTX_print_errors_test, tear_down); | |
194 | return result; | |
195 | } | |
85870311 | 196 | #endif |
7960dbec | 197 | |
235595c4 DDO |
198 | static |
199 | int execute_CTX_reqExtensions_have_SAN_test(OSSL_CMP_CTX_TEST_FIXTURE *fixture) | |
7960dbec DDO |
200 | { |
201 | OSSL_CMP_CTX *ctx = fixture->ctx; | |
202 | const int len = 16; | |
ebf30069 | 203 | unsigned char str[16 /* = len */]; |
7960dbec DDO |
204 | ASN1_OCTET_STRING *data = NULL; |
205 | X509_EXTENSION *ext = NULL; | |
206 | X509_EXTENSIONS *exts = NULL; | |
207 | int res = 0; | |
208 | ||
209 | if (!TEST_false(OSSL_CMP_CTX_reqExtensions_have_SAN(ctx))) | |
210 | return 0; | |
211 | ||
212 | if (!TEST_int_eq(1, RAND_bytes(str, len)) | |
213 | || !TEST_ptr(data = ASN1_OCTET_STRING_new()) | |
214 | || !TEST_true(ASN1_OCTET_STRING_set(data, str, len))) | |
215 | goto err; | |
216 | ext = X509_EXTENSION_create_by_NID(NULL, NID_subject_alt_name, 0, data); | |
217 | if (!TEST_ptr(ext) | |
218 | || !TEST_ptr(exts = sk_X509_EXTENSION_new_null()) | |
219 | || !TEST_true(sk_X509_EXTENSION_push(exts, ext)) | |
220 | || !TEST_true(OSSL_CMP_CTX_set0_reqExtensions(ctx, exts))) { | |
221 | X509_EXTENSION_free(ext); | |
222 | sk_X509_EXTENSION_free(exts); | |
223 | goto err; | |
224 | } | |
225 | if (TEST_int_eq(OSSL_CMP_CTX_reqExtensions_have_SAN(ctx), 1)) { | |
226 | ext = sk_X509_EXTENSION_pop(exts); | |
227 | res = TEST_false(OSSL_CMP_CTX_reqExtensions_have_SAN(ctx)); | |
228 | X509_EXTENSION_free(ext); | |
229 | } | |
230 | err: | |
231 | ASN1_OCTET_STRING_free(data); | |
232 | return res; | |
233 | } | |
234 | ||
235 | static int test_CTX_reqExtensions_have_SAN(void) | |
236 | { | |
237 | SETUP_TEST_FIXTURE(OSSL_CMP_CTX_TEST_FIXTURE, set_up); | |
238 | EXECUTE_TEST(execute_CTX_reqExtensions_have_SAN_test, tear_down); | |
239 | return result; | |
240 | } | |
241 | ||
7960dbec DDO |
242 | static int test_log_line; |
243 | static int test_log_cb_res = 0; | |
244 | static int test_log_cb(const char *func, const char *file, int line, | |
245 | OSSL_CMP_severity level, const char *msg) | |
246 | { | |
247 | test_log_cb_res = | |
235595c4 | 248 | #ifndef PEDANTIC |
ebf30069 DDO |
249 | (TEST_str_eq(func, "execute_cmp_ctx_log_cb_test") |
250 | || TEST_str_eq(func, "(unknown function)")) && | |
235595c4 | 251 | #endif |
ebf30069 DDO |
252 | (TEST_str_eq(file, OPENSSL_FILE) |
253 | || TEST_str_eq(file, "(no file)")) | |
254 | && (TEST_int_eq(line, test_log_line) || TEST_int_eq(line, 0)) | |
255 | && (TEST_int_eq(level, OSSL_CMP_LOG_INFO) || TEST_int_eq(level, -1)) | |
256 | && TEST_str_eq(msg, "ok"); | |
7960dbec DDO |
257 | return 1; |
258 | } | |
7960dbec DDO |
259 | |
260 | static int execute_cmp_ctx_log_cb_test(OSSL_CMP_CTX_TEST_FIXTURE *fixture) | |
261 | { | |
262 | int res = 1; | |
7960dbec DDO |
263 | OSSL_CMP_CTX *ctx = fixture->ctx; |
264 | ||
265 | OSSL_TRACE(ALL, "this general trace message is not shown by default\n"); | |
266 | ||
267 | OSSL_CMP_log_open(); | |
268 | OSSL_CMP_log_open(); /* multiple calls should be harmless */ | |
269 | ||
270 | if (!TEST_true(OSSL_CMP_CTX_set_log_cb(ctx, NULL))) { | |
271 | res = 0; | |
272 | } else { | |
ebf30069 DDO |
273 | ossl_cmp_err(ctx, "this should be printed as CMP error message"); |
274 | ossl_cmp_warn(ctx, "this should be printed as CMP warning message"); | |
275 | ossl_cmp_debug(ctx, "this should not be printed"); | |
7960dbec | 276 | TEST_true(OSSL_CMP_CTX_set_log_verbosity(ctx, OSSL_CMP_LOG_DEBUG)); |
ebf30069 | 277 | ossl_cmp_debug(ctx, "this should be printed as CMP debug message"); |
7960dbec DDO |
278 | TEST_true(OSSL_CMP_CTX_set_log_verbosity(ctx, OSSL_CMP_LOG_INFO)); |
279 | } | |
280 | if (!TEST_true(OSSL_CMP_CTX_set_log_cb(ctx, test_log_cb))) { | |
281 | res = 0; | |
282 | } else { | |
283 | test_log_line = OPENSSL_LINE + 1; | |
ebf30069 | 284 | ossl_cmp_log2(INFO, ctx, "%s%c", "o", 'k'); |
7960dbec DDO |
285 | if (!TEST_int_eq(test_log_cb_res, 1)) |
286 | res = 0; | |
287 | OSSL_CMP_CTX_set_log_verbosity(ctx, OSSL_CMP_LOG_ERR); | |
288 | test_log_cb_res = -1; /* callback should not be called at all */ | |
289 | test_log_line = OPENSSL_LINE + 1; | |
ebf30069 | 290 | ossl_cmp_log2(INFO, ctx, "%s%c", "o", 'k'); |
7960dbec DDO |
291 | if (!TEST_int_eq(test_log_cb_res, -1)) |
292 | res = 0; | |
293 | } | |
294 | OSSL_CMP_log_close(); | |
295 | OSSL_CMP_log_close(); /* multiple calls should be harmless */ | |
7960dbec DDO |
296 | return res; |
297 | } | |
298 | ||
299 | static int test_cmp_ctx_log_cb(void) | |
300 | { | |
301 | SETUP_TEST_FIXTURE(OSSL_CMP_CTX_TEST_FIXTURE, set_up); | |
302 | EXECUTE_TEST(execute_cmp_ctx_log_cb_test, tear_down); | |
303 | return result; | |
304 | } | |
305 | ||
29f178bd | 306 | static BIO *test_http_cb(BIO *bio, void *arg, int use_ssl, int detail) |
7960dbec DDO |
307 | { |
308 | return NULL; | |
309 | } | |
310 | ||
29f178bd DDO |
311 | static OSSL_CMP_MSG *test_transfer_cb(OSSL_CMP_CTX *ctx, |
312 | const OSSL_CMP_MSG *req) | |
7960dbec | 313 | { |
29f178bd | 314 | return NULL; |
7960dbec DDO |
315 | } |
316 | ||
317 | static int test_certConf_cb(OSSL_CMP_CTX *ctx, X509 *cert, int fail_info, | |
318 | const char **txt) | |
319 | { | |
320 | return 0; | |
321 | } | |
322 | ||
323 | typedef OSSL_CMP_CTX CMP_CTX; /* prevents rewriting type name by below macro */ | |
324 | #define OSSL_CMP_CTX 1 /* name prefix for exported setter functions */ | |
325 | #define ossl_cmp_ctx 0 /* name prefix for internal setter functions */ | |
326 | #define set 0 | |
327 | #define set0 0 | |
328 | #define set1 1 | |
329 | #define get 0 | |
330 | #define get0 0 | |
331 | #define get1 1 | |
332 | ||
333 | #define DEFINE_SET_GET_BASE_TEST(PREFIX, SETN, GETN, DUP, FIELD, TYPE, ERR, \ | |
334 | DEFAULT, NEW, FREE) \ | |
235595c4 DDO |
335 | static int \ |
336 | execute_CTX_##SETN##_##GETN##_##FIELD(OSSL_CMP_CTX_TEST_FIXTURE *fixture) \ | |
7960dbec DDO |
337 | { \ |
338 | CMP_CTX *ctx = fixture->ctx; \ | |
339 | int (*set_fn)(CMP_CTX *ctx, TYPE) = \ | |
340 | (int (*)(CMP_CTX *ctx, TYPE))PREFIX##_##SETN##_##FIELD; \ | |
235595c4 | 341 | /* need type cast in above assignment as TYPE arg sometimes is const */ \ |
7960dbec DDO |
342 | TYPE (*get_fn)(const CMP_CTX *ctx) = OSSL_CMP_CTX_##GETN##_##FIELD; \ |
343 | TYPE val1_to_free = NEW; \ | |
344 | TYPE val1 = val1_to_free; \ | |
345 | TYPE val1_read = 0; /* 0 works for any type */ \ | |
346 | TYPE val2_to_free = NEW; \ | |
347 | TYPE val2 = val2_to_free; \ | |
348 | TYPE val2_read = 0; \ | |
349 | TYPE val3_read = 0; \ | |
350 | int res = 1; \ | |
351 | \ | |
352 | if (!TEST_int_eq(ERR_peek_error(), 0)) \ | |
353 | res = 0; \ | |
354 | if (PREFIX == 1) { /* exported setter functions must test ctx == NULL */ \ | |
355 | if ((*set_fn)(NULL, val1) || ERR_peek_error() == 0) { \ | |
356 | TEST_error("setter did not return error on ctx == NULL"); \ | |
357 | res = 0; \ | |
358 | } \ | |
359 | } \ | |
360 | ERR_clear_error(); \ | |
361 | \ | |
362 | if ((*get_fn)(NULL) != ERR || ERR_peek_error() == 0) { \ | |
363 | TEST_error("getter did not return error on ctx == NULL"); \ | |
364 | res = 0; \ | |
365 | } \ | |
366 | ERR_clear_error(); \ | |
367 | \ | |
368 | val1_read = (*get_fn)(ctx); \ | |
369 | if (!DEFAULT(val1_read)) { \ | |
370 | TEST_error("did not get default value"); \ | |
371 | res = 0; \ | |
372 | } \ | |
373 | if (!(*set_fn)(ctx, val1)) { \ | |
374 | TEST_error("setting first value failed"); \ | |
375 | res = 0; \ | |
376 | } \ | |
377 | if (SETN == 0) \ | |
378 | val1_to_free = 0; /* 0 works for any type */ \ | |
379 | \ | |
380 | if (GETN == 1) \ | |
381 | FREE(val1_read); \ | |
382 | val1_read = (*get_fn)(ctx); \ | |
383 | if (SETN == 0) { \ | |
384 | if (val1_read != val1) { \ | |
385 | TEST_error("set/get first value did not match"); \ | |
386 | res = 0; \ | |
387 | } \ | |
388 | } else { \ | |
389 | if (DUP && val1_read == val1) { \ | |
390 | TEST_error("first set did not dup the value"); \ | |
391 | res = 0; \ | |
392 | } \ | |
393 | if (DEFAULT(val1_read)) { \ | |
394 | TEST_error("first set had no effect"); \ | |
395 | res = 0; \ | |
396 | } \ | |
397 | } \ | |
398 | \ | |
399 | if (!(*set_fn)(ctx, val2)) { \ | |
400 | TEST_error("setting second value failed"); \ | |
401 | res = 0; \ | |
402 | } \ | |
403 | if (SETN == 0) \ | |
404 | val2_to_free = 0; \ | |
405 | \ | |
406 | val2_read = (*get_fn)(ctx); \ | |
407 | if (DEFAULT(val2_read)) { \ | |
408 | TEST_error("second set reset the value"); \ | |
409 | res = 0; \ | |
410 | } \ | |
411 | if (SETN == 0 && GETN == 0) { \ | |
412 | if (val2_read != val2) { \ | |
413 | TEST_error("set/get second value did not match"); \ | |
414 | res = 0; \ | |
415 | } \ | |
416 | } else { \ | |
417 | if (DUP && val2_read == val2) { \ | |
418 | TEST_error("second set did not dup the value"); \ | |
419 | res = 0; \ | |
420 | } \ | |
421 | if (val2 == val1) { \ | |
422 | TEST_error("second value is same as first value"); \ | |
423 | res = 0; \ | |
424 | } \ | |
425 | if (GETN == 1 && val2_read == val1_read) { \ | |
426 | /* \ | |
427 | * Note that if GETN == 0 then possibly val2_read == val1_read \ | |
428 | * because set1 may allocate the new copy at the same location. \ | |
429 | */ \ | |
430 | TEST_error("second get returned same as first get"); \ | |
431 | res = 0; \ | |
432 | } \ | |
433 | } \ | |
434 | \ | |
435 | val3_read = (*get_fn)(ctx); \ | |
436 | if (DEFAULT(val3_read)) { \ | |
437 | TEST_error("third set reset the value"); \ | |
438 | res = 0; \ | |
439 | } \ | |
440 | if (GETN == 0) { \ | |
441 | if (val3_read != val2_read) { \ | |
442 | TEST_error("third get gave different value"); \ | |
443 | res = 0; \ | |
444 | } \ | |
235595c4 | 445 | } else { \ |
7960dbec DDO |
446 | if (DUP && val3_read == val2_read) { \ |
447 | TEST_error("third get did not create a new dup"); \ | |
448 | res = 0; \ | |
449 | } \ | |
450 | } \ | |
451 | /* this does not check that all remaining fields are untouched */ \ | |
452 | \ | |
453 | if (!TEST_int_eq(ERR_peek_error(), 0)) \ | |
454 | res = 0; \ | |
455 | \ | |
456 | FREE(val1_to_free); \ | |
457 | FREE(val2_to_free); \ | |
458 | if (GETN == 1) { \ | |
459 | FREE(val1_read); \ | |
460 | FREE(val2_read); \ | |
461 | FREE(val3_read); \ | |
462 | } \ | |
463 | return TEST_true(res); \ | |
464 | } \ | |
465 | \ | |
466 | static int test_CTX_##SETN##_##GETN##_##FIELD(void) \ | |
467 | { \ | |
468 | SETUP_TEST_FIXTURE(OSSL_CMP_CTX_TEST_FIXTURE, set_up); \ | |
469 | EXECUTE_TEST(execute_CTX_##SETN##_##GETN##_##FIELD, tear_down); \ | |
470 | return result; \ | |
471 | } | |
472 | ||
3dbc5156 DDO |
473 | static char *char_new(void) |
474 | { | |
7960dbec DDO |
475 | return OPENSSL_strdup("test"); |
476 | } | |
477 | ||
3dbc5156 DDO |
478 | static void char_free(char *val) |
479 | { | |
7960dbec DDO |
480 | OPENSSL_free(val); |
481 | } | |
482 | ||
483 | #define EMPTY_SK_X509(x) ((x) == NULL || sk_X509_num(x) == 0) | |
484 | ||
3dbc5156 DDO |
485 | static X509_STORE *X509_STORE_new_1(void) |
486 | { | |
7960dbec DDO |
487 | X509_STORE *store = X509_STORE_new(); |
488 | ||
489 | if (store != NULL) | |
490 | X509_VERIFY_PARAM_set_flags(X509_STORE_get0_param(store), 1); | |
491 | return store; | |
492 | } | |
493 | ||
235595c4 DDO |
494 | #define DEFAULT_STORE(x) \ |
495 | ((x) == NULL || X509_VERIFY_PARAM_get_flags(X509_STORE_get0_param(x)) == 0) | |
7960dbec DDO |
496 | |
497 | #define IS_NEG(x) ((x) < 0) | |
498 | #define IS_0(x) ((x) == 0) /* for any type */ | |
7960dbec DDO |
499 | #define DROP(x) (void)(x) /* dummy free() for non-pointer and function types */ |
500 | ||
3327c8d6 SL |
501 | #define RET_IF_NULL_ARG(ctx, ret) \ |
502 | if (ctx == NULL) { \ | |
503 | CMPerr(0, CMP_R_NULL_ARGUMENT); \ | |
504 | return ret; \ | |
505 | } | |
7960dbec DDO |
506 | |
507 | #define DEFINE_SET_GET_TEST(OSSL_CMP, CTX, N, M, DUP, FIELD, TYPE) \ | |
508 | DEFINE_SET_GET_BASE_TEST(OSSL_CMP##_##CTX, set##N, get##M, DUP, FIELD, \ | |
235595c4 | 509 | TYPE *, NULL, IS_0, TYPE##_new(), TYPE##_free) |
7960dbec DDO |
510 | |
511 | #define DEFINE_SET_GET_SK_TEST_DEFAULT(OSSL_CMP, CTX, N, M, FIELD, ELEM_TYPE, \ | |
512 | DEFAULT, NEW, FREE) \ | |
513 | DEFINE_SET_GET_BASE_TEST(OSSL_CMP##_##CTX, set##N, get##M, 1, FIELD, \ | |
3dbc5156 | 514 | STACK_OF(ELEM_TYPE)*, NULL, DEFAULT, NEW, FREE) |
7960dbec DDO |
515 | #define DEFINE_SET_GET_SK_TEST(OSSL_CMP, CTX, N, M, FIELD, T) \ |
516 | DEFINE_SET_GET_SK_TEST_DEFAULT(OSSL_CMP, CTX, N, M, FIELD, T, \ | |
3dbc5156 | 517 | IS_0, sk_##T##_new_null(), sk_##T##_free) |
7960dbec DDO |
518 | #define DEFINE_SET_GET_SK_X509_TEST(OSSL_CMP, CTX, N, M, FNAME) \ |
519 | DEFINE_SET_GET_SK_TEST_DEFAULT(OSSL_CMP, CTX, N, M, FNAME, X509, \ | |
3dbc5156 DDO |
520 | EMPTY_SK_X509, \ |
521 | sk_X509_new_1(), sk_X509_pop_X509_free) | |
7960dbec DDO |
522 | |
523 | #define DEFINE_SET_GET_TEST_DEFAULT(OSSL_CMP, CTX, N, M, DUP, FIELD, TYPE, \ | |
524 | DEFAULT) \ | |
525 | DEFINE_SET_GET_BASE_TEST(OSSL_CMP##_##CTX, set##N, get##M, DUP, FIELD, \ | |
235595c4 | 526 | TYPE *, NULL, DEFAULT, TYPE##_new(), TYPE##_free) |
7960dbec DDO |
527 | #define DEFINE_SET_TEST_DEFAULT(OSSL_CMP, CTX, N, DUP, FIELD, TYPE, DEFAULT) \ |
528 | static TYPE *OSSL_CMP_CTX_get0_##FIELD(const CMP_CTX *ctx) \ | |
529 | { \ | |
3327c8d6 SL |
530 | RET_IF_NULL_ARG(ctx, NULL); \ |
531 | return (TYPE *)ctx->FIELD; \ | |
7960dbec DDO |
532 | } \ |
533 | DEFINE_SET_GET_TEST_DEFAULT(OSSL_CMP, CTX, N, 0, DUP, FIELD, TYPE, DEFAULT) | |
534 | #define DEFINE_SET_TEST(OSSL_CMP, CTX, N, DUP, FIELD, TYPE) \ | |
535 | DEFINE_SET_TEST_DEFAULT(OSSL_CMP, CTX, N, DUP, FIELD, TYPE, IS_0) | |
536 | ||
537 | #define DEFINE_SET_SK_TEST(OSSL_CMP, CTX, N, FIELD, TYPE) \ | |
538 | static STACK_OF(TYPE) *OSSL_CMP_CTX_get0_##FIELD(const CMP_CTX *ctx) \ | |
539 | { \ | |
3327c8d6 SL |
540 | RET_IF_NULL_ARG(ctx, NULL); \ |
541 | return ctx->FIELD; \ | |
7960dbec DDO |
542 | } \ |
543 | DEFINE_SET_GET_BASE_TEST(OSSL_CMP##_##CTX, set##N, get0, 1, FIELD, \ | |
3dbc5156 DDO |
544 | STACK_OF(TYPE)*, NULL, IS_0, \ |
545 | sk_##TYPE##_new_null(), sk_##TYPE##_free) | |
7960dbec | 546 | |
7e765f46 | 547 | typedef OSSL_HTTP_bio_cb_t OSSL_CMP_http_cb_t; |
7960dbec | 548 | #define DEFINE_SET_CB_TEST(FIELD) \ |
7e765f46 | 549 | static OSSL_CMP_##FIELD##_t OSSL_CMP_CTX_get_##FIELD(const CMP_CTX *ctx) \ |
7960dbec | 550 | { \ |
3327c8d6 SL |
551 | RET_IF_NULL_ARG(ctx, NULL); \ |
552 | return ctx->FIELD; \ | |
7960dbec DDO |
553 | } \ |
554 | DEFINE_SET_GET_BASE_TEST(OSSL_CMP_CTX, set, get, 0, FIELD, \ | |
7e765f46 | 555 | OSSL_CMP_##FIELD##_t, NULL, IS_0, \ |
3dbc5156 | 556 | test_##FIELD, DROP) |
7960dbec | 557 | #define DEFINE_SET_GET_P_VOID_TEST(FIELD) \ |
235595c4 | 558 | DEFINE_SET_GET_BASE_TEST(OSSL_CMP_CTX, set, get, 0, FIELD, void *, \ |
3dbc5156 | 559 | NULL, IS_0, ((void *)1), DROP) |
7960dbec DDO |
560 | |
561 | #define DEFINE_SET_GET_INT_TEST_DEFAULT(OSSL_CMP, CTX, FIELD, DEFAULT) \ | |
562 | DEFINE_SET_GET_BASE_TEST(OSSL_CMP##_##CTX, set, get, 0, FIELD, int, -1, \ | |
3dbc5156 | 563 | DEFAULT, 1, DROP) |
7960dbec DDO |
564 | #define DEFINE_SET_GET_INT_TEST(OSSL_CMP, CTX, FIELD) \ |
565 | DEFINE_SET_GET_INT_TEST_DEFAULT(OSSL_CMP, CTX, FIELD, IS_NEG) | |
4b1fe471 | 566 | #define DEFINE_SET_INT_TEST(FIELD) \ |
7960dbec DDO |
567 | static int OSSL_CMP_CTX_get_##FIELD(const CMP_CTX *ctx) \ |
568 | { \ | |
3327c8d6 SL |
569 | RET_IF_NULL_ARG(ctx, -1); \ |
570 | return ctx->FIELD; \ | |
7960dbec | 571 | } \ |
4b1fe471 | 572 | DEFINE_SET_GET_INT_TEST_DEFAULT(OSSL_CMP, CTX, FIELD, IS_0) |
7960dbec DDO |
573 | |
574 | #define DEFINE_SET_GET_ARG_FN(SETN, GETN, FIELD, ARG, T) \ | |
575 | static int OSSL_CMP_CTX_##SETN##_##FIELD##_##ARG(CMP_CTX *ctx, T val) \ | |
576 | { \ | |
577 | return OSSL_CMP_CTX_##SETN##_##FIELD(ctx, ARG, val); \ | |
578 | } \ | |
579 | \ | |
580 | static T OSSL_CMP_CTX_##GETN##_##FIELD##_##ARG(const CMP_CTX *ctx) \ | |
581 | { \ | |
582 | return OSSL_CMP_CTX_##GETN##_##FIELD(ctx, ARG); \ | |
583 | } | |
584 | ||
585 | #define DEFINE_SET_GET1_STR_FN(SETN, FIELD) \ | |
586 | static int OSSL_CMP_CTX_##SETN##_##FIELD##_str(CMP_CTX *ctx, char *val)\ | |
587 | { \ | |
588 | return OSSL_CMP_CTX_##SETN##_##FIELD(ctx, (unsigned char *)val, \ | |
235595c4 | 589 | strlen(val)); \ |
7960dbec DDO |
590 | } \ |
591 | \ | |
592 | static char *OSSL_CMP_CTX_get1_##FIELD##_str(const CMP_CTX *ctx) \ | |
593 | { \ | |
3327c8d6 | 594 | const ASN1_OCTET_STRING *bytes = NULL; \ |
7960dbec | 595 | \ |
3327c8d6 SL |
596 | RET_IF_NULL_ARG(ctx, NULL); \ |
597 | bytes = ctx->FIELD; \ | |
7960dbec DDO |
598 | return bytes == NULL ? NULL : \ |
599 | OPENSSL_strndup((char *)bytes->data, bytes->length); \ | |
600 | } | |
601 | ||
602 | #define push 0 | |
603 | #define push0 0 | |
604 | #define push1 1 | |
605 | #define DEFINE_PUSH_BASE_TEST(PUSHN, DUP, FIELD, ELEM, TYPE, T, \ | |
3dbc5156 DDO |
606 | DEFAULT, NEW, FREE) \ |
607 | static TYPE sk_top_##FIELD(const CMP_CTX *ctx) \ | |
608 | { \ | |
7960dbec DDO |
609 | return sk_##T##_value(ctx->FIELD, sk_##T##_num(ctx->FIELD) - 1); \ |
610 | } \ | |
611 | \ | |
612 | static int execute_CTX_##PUSHN##_##ELEM(OSSL_CMP_CTX_TEST_FIXTURE *fixture) \ | |
613 | { \ | |
614 | CMP_CTX *ctx = fixture->ctx; \ | |
615 | int (*push_fn)(CMP_CTX *ctx, TYPE) = \ | |
616 | (int (*)(CMP_CTX *ctx, TYPE))OSSL_CMP_CTX_##PUSHN##_##ELEM; \ | |
3dbc5156 DDO |
617 | /* \ |
618 | * need type cast in above assignment because TYPE arg sometimes is const \ | |
619 | */ \ | |
7960dbec DDO |
620 | int n_elem = sk_##T##_num(ctx->FIELD); \ |
621 | STACK_OF(TYPE) field_read; \ | |
622 | TYPE val1_to_free = NEW; \ | |
623 | TYPE val1 = val1_to_free; \ | |
624 | TYPE val1_read = 0; /* 0 works for any type */ \ | |
625 | TYPE val2_to_free = NEW; \ | |
626 | TYPE val2 = val2_to_free; \ | |
627 | TYPE val2_read = 0; \ | |
628 | int res = 1; \ | |
629 | \ | |
630 | if (!TEST_int_eq(ERR_peek_error(), 0)) \ | |
631 | res = 0; \ | |
632 | if ((*push_fn)(NULL, val1) || ERR_peek_error() == 0) { \ | |
633 | TEST_error("pusher did not return error on ctx == NULL"); \ | |
634 | res = 0; \ | |
635 | } \ | |
636 | ERR_clear_error(); \ | |
637 | \ | |
638 | if (n_elem < 0) /* can happen for NULL stack */ \ | |
639 | n_elem = 0; \ | |
640 | field_read = ctx->FIELD; \ | |
641 | if (!DEFAULT(field_read)) { \ | |
642 | TEST_error("did not get default value for stack field"); \ | |
643 | res = 0; \ | |
644 | } \ | |
645 | if (!(*push_fn)(ctx, val1)) { \ | |
646 | TEST_error("pushing first value failed"); \ | |
647 | res = 0; \ | |
648 | } \ | |
649 | if (PUSHN == 0) \ | |
650 | val1_to_free = 0; /* 0 works for any type */ \ | |
651 | \ | |
652 | if (sk_##T##_num(ctx->FIELD) != ++n_elem) { \ | |
653 | TEST_error("pushing first value did not increment number"); \ | |
654 | res = 0; \ | |
655 | } \ | |
656 | val1_read = sk_top_##FIELD(ctx); \ | |
657 | if (PUSHN == 0) { \ | |
658 | if (val1_read != val1) { \ | |
659 | TEST_error("push/sk_top first value did not match"); \ | |
660 | res = 0; \ | |
661 | } \ | |
662 | } else { \ | |
663 | if (DUP && val1_read == val1) { \ | |
664 | TEST_error("first push did not dup the value"); \ | |
665 | res = 0; \ | |
666 | } \ | |
667 | } \ | |
668 | \ | |
669 | if (!(*push_fn)(ctx, val2)) { \ | |
670 | TEST_error("pushting second value failed"); \ | |
671 | res = 0; \ | |
672 | } \ | |
673 | if (PUSHN == 0) \ | |
674 | val2_to_free = 0; \ | |
675 | \ | |
676 | if (sk_##T##_num(ctx->FIELD) != ++n_elem) { \ | |
677 | TEST_error("pushing second value did not increment number"); \ | |
678 | res = 0; \ | |
679 | } \ | |
680 | val2_read = sk_top_##FIELD(ctx); \ | |
681 | if (PUSHN == 0) { \ | |
682 | if (val2_read != val2) { \ | |
683 | TEST_error("push/sk_top second value did not match"); \ | |
684 | res = 0; \ | |
685 | } \ | |
686 | } else { \ | |
687 | if (DUP && val2_read == val2) { \ | |
688 | TEST_error("second push did not dup the value"); \ | |
689 | res = 0; \ | |
690 | } \ | |
691 | if (val2 == val1) { \ | |
692 | TEST_error("second value is same as first value"); \ | |
693 | res = 0; \ | |
694 | } \ | |
695 | } \ | |
235595c4 | 696 | /* this does not check if all remaining fields and elems are untouched */ \ |
7960dbec DDO |
697 | \ |
698 | if (!TEST_int_eq(ERR_peek_error(), 0)) \ | |
699 | res = 0; \ | |
700 | \ | |
701 | FREE(val1_to_free); \ | |
702 | FREE(val2_to_free); \ | |
703 | return TEST_true(res); \ | |
704 | } \ | |
705 | \ | |
706 | static int test_CTX_##PUSHN##_##ELEM(void) \ | |
707 | { \ | |
708 | SETUP_TEST_FIXTURE(OSSL_CMP_CTX_TEST_FIXTURE, set_up); \ | |
709 | EXECUTE_TEST(execute_CTX_##PUSHN##_##ELEM, tear_down); \ | |
710 | return result; \ | |
711 | } \ | |
712 | ||
713 | #define DEFINE_PUSH_TEST(N, DUP, FIELD, ELEM, TYPE) \ | |
235595c4 | 714 | DEFINE_PUSH_BASE_TEST(push##N, DUP, FIELD, ELEM, TYPE *, TYPE, \ |
3dbc5156 | 715 | IS_0, TYPE##_new(), TYPE##_free) |
7960dbec DDO |
716 | |
717 | void cleanup_tests(void) | |
718 | { | |
719 | return; | |
720 | } | |
721 | ||
722 | DEFINE_SET_GET_ARG_FN(set, get, option, 16, int) | |
3dbc5156 | 723 | /* option == OSSL_CMP_OPT_IGNORE_KEYUSAGE */ |
7960dbec | 724 | DEFINE_SET_GET_BASE_TEST(OSSL_CMP_CTX, set, get, 0, option_16, int, -1, IS_0, \ |
3dbc5156 | 725 | 1 /* true */, DROP) |
7960dbec | 726 | |
7960dbec | 727 | DEFINE_SET_CB_TEST(log_cb) |
7960dbec DDO |
728 | |
729 | DEFINE_SET_TEST_DEFAULT(OSSL_CMP, CTX, 1, 1, serverPath, char, IS_0) | |
4b1fe471 DDO |
730 | DEFINE_SET_TEST(OSSL_CMP, CTX, 1, 1, server, char) |
731 | DEFINE_SET_INT_TEST(serverPort) | |
afe554c2 DDO |
732 | DEFINE_SET_TEST(OSSL_CMP, CTX, 1, 1, proxy, char) |
733 | DEFINE_SET_TEST(OSSL_CMP, CTX, 1, 1, no_proxy, char) | |
7960dbec DDO |
734 | DEFINE_SET_CB_TEST(http_cb) |
735 | DEFINE_SET_GET_P_VOID_TEST(http_cb_arg) | |
736 | DEFINE_SET_CB_TEST(transfer_cb) | |
737 | DEFINE_SET_GET_P_VOID_TEST(transfer_cb_arg) | |
738 | ||
739 | DEFINE_SET_TEST(OSSL_CMP, CTX, 1, 0, srvCert, X509) | |
740 | DEFINE_SET_TEST(ossl_cmp, ctx, 0, 0, validatedSrvCert, X509) | |
741 | DEFINE_SET_TEST(OSSL_CMP, CTX, 1, 1, expected_sender, X509_NAME) | |
742 | DEFINE_SET_GET_BASE_TEST(OSSL_CMP_CTX, set0, get0, 0, trustedStore, | |
235595c4 | 743 | X509_STORE *, NULL, |
3dbc5156 | 744 | DEFAULT_STORE, X509_STORE_new_1(), X509_STORE_free) |
0b86eefd | 745 | DEFINE_SET_GET_SK_X509_TEST(OSSL_CMP, CTX, 1, 0, untrusted) |
7960dbec | 746 | |
63f1883d | 747 | DEFINE_SET_TEST(OSSL_CMP, CTX, 1, 0, cert, X509) |
7960dbec DDO |
748 | DEFINE_SET_TEST(OSSL_CMP, CTX, 1, 0, pkey, EVP_PKEY) |
749 | ||
750 | DEFINE_SET_TEST(OSSL_CMP, CTX, 1, 1, recipient, X509_NAME) | |
751 | DEFINE_PUSH_TEST(0, 0, geninfo_ITAVs, geninfo_ITAV, OSSL_CMP_ITAV) | |
752 | DEFINE_SET_SK_TEST(OSSL_CMP, CTX, 1, extraCertsOut, X509) | |
235595c4 | 753 | DEFINE_SET_GET_ARG_FN(set0, get0, newPkey, 1, EVP_PKEY *) /* priv == 1 */ |
7960dbec | 754 | DEFINE_SET_GET_TEST(OSSL_CMP, CTX, 0, 0, 0, newPkey_1, EVP_PKEY) |
235595c4 | 755 | DEFINE_SET_GET_ARG_FN(set0, get0, newPkey, 0, EVP_PKEY *) /* priv == 0 */ |
7960dbec DDO |
756 | DEFINE_SET_GET_TEST(OSSL_CMP, CTX, 0, 0, 0, newPkey_0, EVP_PKEY) |
757 | DEFINE_SET_GET1_STR_FN(set1, referenceValue) | |
3dbc5156 DDO |
758 | DEFINE_SET_GET_TEST_DEFAULT(OSSL_CMP, CTX, 1, 1, 1, referenceValue_str, char, |
759 | IS_0) | |
7960dbec | 760 | DEFINE_SET_GET1_STR_FN(set1, secretValue) |
3dbc5156 | 761 | DEFINE_SET_GET_TEST_DEFAULT(OSSL_CMP, CTX, 1, 1, 1, secretValue_str, char, IS_0) |
7960dbec DDO |
762 | DEFINE_SET_TEST(OSSL_CMP, CTX, 1, 1, issuer, X509_NAME) |
763 | DEFINE_SET_TEST(OSSL_CMP, CTX, 1, 1, subjectName, X509_NAME) | |
764 | #ifdef ISSUE_9504_RESOLVED | |
765 | DEFINE_PUSH_TEST(1, 1, subjectAltNames, subjectAltName, GENERAL_NAME) | |
766 | #endif | |
767 | DEFINE_SET_SK_TEST(OSSL_CMP, CTX, 0, reqExtensions, X509_EXTENSION) | |
768 | DEFINE_PUSH_TEST(0, 0, policies, policy, POLICYINFO) | |
769 | DEFINE_SET_TEST(OSSL_CMP, CTX, 1, 0, oldCert, X509) | |
770 | #ifdef ISSUE_9504_RESOLVED | |
771 | DEFINE_SET_TEST(OSSL_CMP, CTX, 1, 1, p10CSR, X509_REQ) | |
772 | #endif | |
773 | DEFINE_PUSH_TEST(0, 0, genm_ITAVs, genm_ITAV, OSSL_CMP_ITAV) | |
774 | DEFINE_SET_CB_TEST(certConf_cb) | |
775 | DEFINE_SET_GET_P_VOID_TEST(certConf_cb_arg) | |
776 | ||
777 | DEFINE_SET_GET_INT_TEST(ossl_cmp, ctx, status) | |
778 | DEFINE_SET_GET_SK_TEST(ossl_cmp, ctx, 0, 0, statusString, ASN1_UTF8STRING) | |
779 | DEFINE_SET_GET_INT_TEST(ossl_cmp, ctx, failInfoCode) | |
780 | DEFINE_SET_GET_TEST(ossl_cmp, ctx, 0, 0, 0, newCert, X509) | |
39082af2 | 781 | DEFINE_SET_GET_SK_X509_TEST(ossl_cmp, ctx, 1, 1, newChain) |
7960dbec DDO |
782 | DEFINE_SET_GET_SK_X509_TEST(ossl_cmp, ctx, 1, 1, caPubs) |
783 | DEFINE_SET_GET_SK_X509_TEST(ossl_cmp, ctx, 1, 1, extraCertsIn) | |
784 | ||
3dbc5156 DDO |
785 | DEFINE_SET_TEST_DEFAULT(OSSL_CMP, CTX, 1, 1, transactionID, ASN1_OCTET_STRING, |
786 | IS_0) | |
7960dbec DDO |
787 | DEFINE_SET_TEST(OSSL_CMP, CTX, 1, 1, senderNonce, ASN1_OCTET_STRING) |
788 | DEFINE_SET_TEST(ossl_cmp, ctx, 1, 1, recipNonce, ASN1_OCTET_STRING) | |
789 | ||
790 | int setup_tests(void) | |
791 | { | |
792 | /* OSSL_CMP_CTX_new() is tested by set_up() */ | |
793 | /* OSSL_CMP_CTX_free() is tested by tear_down() */ | |
794 | ADD_TEST(test_CTX_reinit); | |
795 | ||
3dbc5156 | 796 | /* various CMP options: */ |
7960dbec | 797 | ADD_TEST(test_CTX_set_get_option_16); |
3dbc5156 | 798 | /* CMP-specific callback for logging and outputting the error queue: */ |
7960dbec | 799 | ADD_TEST(test_CTX_set_get_log_cb); |
7960dbec DDO |
800 | /* |
801 | * also tests OSSL_CMP_log_open(), OSSL_CMP_CTX_set_log_verbosity(), | |
ebf30069 DDO |
802 | * ossl_cmp_err(), ossl_cmp_warn(), * ossl_cmp_debug(), |
803 | * ossl_cmp_log2(), ossl_cmp_log_parse_metadata(), and OSSL_CMP_log_close() | |
7960dbec DDO |
804 | * with OSSL_CMP_severity OSSL_CMP_LOG_ERR/WARNING/DEBUG/INFO: |
805 | */ | |
806 | ADD_TEST(test_cmp_ctx_log_cb); | |
8e1a1582 | 807 | #if !defined(OPENSSL_NO_ERR) && !defined(OPENSSL_NO_AUTOERRINIT) |
3dbc5156 DDO |
808 | /* |
809 | * also tests OSSL_CMP_CTX_set_log_cb(), OSSL_CMP_print_errors_cb(), | |
31b28ad9 | 810 | * and the macros ossl_cmp_add_error_data and ossl_cmp_add_error_line: |
3dbc5156 | 811 | */ |
7960dbec | 812 | ADD_TEST(test_CTX_print_errors); |
85870311 | 813 | #endif |
3dbc5156 | 814 | /* message transfer: */ |
7960dbec | 815 | ADD_TEST(test_CTX_set1_get0_serverPath); |
4b1fe471 | 816 | ADD_TEST(test_CTX_set1_get0_server); |
7960dbec | 817 | ADD_TEST(test_CTX_set_get_serverPort); |
afe554c2 DDO |
818 | ADD_TEST(test_CTX_set1_get0_proxy); |
819 | ADD_TEST(test_CTX_set1_get0_no_proxy); | |
7960dbec DDO |
820 | ADD_TEST(test_CTX_set_get_http_cb); |
821 | ADD_TEST(test_CTX_set_get_http_cb_arg); | |
822 | ADD_TEST(test_CTX_set_get_transfer_cb); | |
823 | ADD_TEST(test_CTX_set_get_transfer_cb_arg); | |
3dbc5156 | 824 | /* server authentication: */ |
7960dbec DDO |
825 | ADD_TEST(test_CTX_set1_get0_srvCert); |
826 | ADD_TEST(test_CTX_set0_get0_validatedSrvCert); | |
827 | ADD_TEST(test_CTX_set1_get0_expected_sender); | |
828 | ADD_TEST(test_CTX_set0_get0_trustedStore); | |
0b86eefd | 829 | ADD_TEST(test_CTX_set1_get0_untrusted); |
3dbc5156 | 830 | /* client authentication: */ |
63f1883d | 831 | ADD_TEST(test_CTX_set1_get0_cert); |
7960dbec DDO |
832 | ADD_TEST(test_CTX_set1_get0_pkey); |
833 | /* the following two also test ossl_cmp_asn1_octet_string_set1_bytes(): */ | |
834 | ADD_TEST(test_CTX_set1_get1_referenceValue_str); | |
835 | ADD_TEST(test_CTX_set1_get1_secretValue_str); | |
3dbc5156 | 836 | /* CMP message header and extra certificates: */ |
7960dbec DDO |
837 | ADD_TEST(test_CTX_set1_get0_recipient); |
838 | ADD_TEST(test_CTX_push0_geninfo_ITAV); | |
839 | ADD_TEST(test_CTX_set1_get0_extraCertsOut); | |
3dbc5156 | 840 | /* certificate template: */ |
7960dbec DDO |
841 | ADD_TEST(test_CTX_set0_get0_newPkey_1); |
842 | ADD_TEST(test_CTX_set0_get0_newPkey_0); | |
843 | ADD_TEST(test_CTX_set1_get0_issuer); | |
844 | ADD_TEST(test_CTX_set1_get0_subjectName); | |
845 | #ifdef ISSUE_9504_RESOLVED | |
3dbc5156 DDO |
846 | /* |
847 | * test currently fails, see https://github.com/openssl/openssl/issues/9504 | |
848 | */ | |
7960dbec DDO |
849 | ADD_TEST(test_CTX_push1_subjectAltName); |
850 | #endif | |
851 | ADD_TEST(test_CTX_set0_get0_reqExtensions); | |
852 | ADD_TEST(test_CTX_reqExtensions_have_SAN); | |
853 | ADD_TEST(test_CTX_push0_policy); | |
854 | ADD_TEST(test_CTX_set1_get0_oldCert); | |
855 | #ifdef ISSUE_9504_RESOLVED | |
3dbc5156 DDO |
856 | /* |
857 | * test currently fails, see https://github.com/openssl/openssl/issues/9504 | |
858 | */ | |
7960dbec DDO |
859 | ADD_TEST(test_CTX_set1_get0_p10CSR); |
860 | #endif | |
3dbc5156 | 861 | /* misc body contents: */ |
7960dbec | 862 | ADD_TEST(test_CTX_push0_genm_ITAV); |
3dbc5156 | 863 | /* certificate confirmation: */ |
7960dbec DDO |
864 | ADD_TEST(test_CTX_set_get_certConf_cb); |
865 | ADD_TEST(test_CTX_set_get_certConf_cb_arg); | |
3dbc5156 | 866 | /* result fetching: */ |
7960dbec DDO |
867 | ADD_TEST(test_CTX_set_get_status); |
868 | ADD_TEST(test_CTX_set0_get0_statusString); | |
869 | ADD_TEST(test_CTX_set_get_failInfoCode); | |
870 | ADD_TEST(test_CTX_set0_get0_newCert); | |
39082af2 | 871 | ADD_TEST(test_CTX_set1_get1_newChain); |
7960dbec DDO |
872 | ADD_TEST(test_CTX_set1_get1_caPubs); |
873 | ADD_TEST(test_CTX_set1_get1_extraCertsIn); | |
3dbc5156 | 874 | /* exported for testing and debugging purposes: */ |
7960dbec DDO |
875 | /* the following three also test ossl_cmp_asn1_octet_string_set1(): */ |
876 | ADD_TEST(test_CTX_set1_get0_transactionID); | |
877 | ADD_TEST(test_CTX_set1_get0_senderNonce); | |
878 | ADD_TEST(test_CTX_set1_get0_recipNonce); | |
3dbc5156 | 879 | /* ossl_cmp_build_cert_chain() is tested in cmp_protect.c */ |
7960dbec DDO |
880 | return 1; |
881 | } |