2 * Copyright 2019-2022 The OpenSSL Project Authors. All Rights Reserved.
3 * Copyright (c) 2019, Oracle and/or its affiliates. All rights reserved.
5 * Licensed under the Apache License 2.0 (the "License"). You may not use
6 * this file except in compliance with the License. You can obtain a copy
7 * in the file LICENSE in the source distribution or at
8 * https://www.openssl.org/source/license.html
12 #include <openssl/params.h>
13 #include <openssl/param_build.h>
14 #include "internal/nelem.h"
17 static const OSSL_PARAM params_empty[] = { OSSL_PARAM_END };
19 static int template_public_single_zero_test(int idx)
21 OSSL_PARAM_BLD *bld = NULL;
22 OSSL_PARAM *params = NULL, *params_blt = NULL, *p;
23 BIGNUM *zbn = NULL, *zbn_res = NULL;
26 if (!TEST_ptr(bld = OSSL_PARAM_BLD_new())
27 || !TEST_ptr(zbn = BN_new())
28 || !TEST_true(OSSL_PARAM_BLD_push_BN(bld, "zeronumber",
29 idx == 0 ? zbn : NULL))
30 || !TEST_ptr(params_blt = OSSL_PARAM_BLD_to_param(bld)))
34 /* Check BN (zero BN becomes unsigned integer) */
35 if (!TEST_ptr(p = OSSL_PARAM_locate(params, "zeronumber"))
36 || !TEST_str_eq(p->key, "zeronumber")
37 || !TEST_uint_eq(p->data_type, OSSL_PARAM_UNSIGNED_INTEGER)
38 || !TEST_true(OSSL_PARAM_get_BN(p, &zbn_res))
39 || !TEST_BN_eq(zbn_res, zbn))
43 if (params != params_blt)
45 OSSL_PARAM_free(params_blt);
46 OSSL_PARAM_BLD_free(bld);
52 static int template_private_single_zero_test(void)
54 OSSL_PARAM_BLD *bld = NULL;
55 OSSL_PARAM *params = NULL, *params_blt = NULL, *p;
56 BIGNUM *zbn = NULL, *zbn_res = NULL;
59 if (!TEST_ptr(bld = OSSL_PARAM_BLD_new())
60 || !TEST_ptr(zbn = BN_secure_new())
61 || !TEST_true(OSSL_PARAM_BLD_push_BN(bld, "zeronumber", zbn))
62 || !TEST_ptr(params_blt = OSSL_PARAM_BLD_to_param(bld)))
66 /* Check BN (zero BN becomes unsigned integer) */
67 if (!TEST_ptr(p = OSSL_PARAM_locate(params, "zeronumber"))
68 || !TEST_true(CRYPTO_secure_allocated(p->data))
69 || !TEST_str_eq(p->key, "zeronumber")
70 || !TEST_uint_eq(p->data_type, OSSL_PARAM_UNSIGNED_INTEGER)
71 || !TEST_true(OSSL_PARAM_get_BN(p, &zbn_res))
72 || !TEST_int_eq(BN_get_flags(zbn, BN_FLG_SECURE), BN_FLG_SECURE)
73 || !TEST_BN_eq(zbn_res, zbn))
77 if (params != params_blt)
79 OSSL_PARAM_free(params_blt);
80 OSSL_PARAM_BLD_free(bld);
86 static int template_public_test(int tstid)
88 OSSL_PARAM_BLD *bld = OSSL_PARAM_BLD_new();
89 OSSL_PARAM *params = NULL, *params_blt = NULL, *p1 = NULL, *p;
90 BIGNUM *zbn = NULL, *zbn_res = NULL;
91 BIGNUM *pbn = NULL, *pbn_res = NULL;
92 BIGNUM *nbn = NULL, *nbn_res = NULL;
104 || !TEST_true(OSSL_PARAM_BLD_push_long(bld, "l", 42))
105 || !TEST_true(OSSL_PARAM_BLD_push_int32(bld, "i32", 1532))
106 || !TEST_true(OSSL_PARAM_BLD_push_int64(bld, "i64", -9999999))
107 || !TEST_true(OSSL_PARAM_BLD_push_time_t(bld, "t", 11224))
108 || !TEST_true(OSSL_PARAM_BLD_push_double(bld, "d", 1.61803398875))
109 || !TEST_ptr(zbn = BN_new())
110 || !TEST_true(OSSL_PARAM_BLD_push_BN(bld, "zeronumber", zbn))
111 || !TEST_ptr(pbn = BN_new())
112 || !TEST_true(BN_set_word(pbn, 1729))
113 || !TEST_true(OSSL_PARAM_BLD_push_BN(bld, "bignumber", pbn))
114 || !TEST_ptr(nbn = BN_secure_new())
115 || !TEST_true(BN_set_word(nbn, 1733))
116 || !TEST_true((BN_set_negative(nbn, 1), 1))
117 || !TEST_true(OSSL_PARAM_BLD_push_BN(bld, "negativebignumber", nbn))
118 || !TEST_true(OSSL_PARAM_BLD_push_utf8_string(bld, "utf8_s", "foo",
120 || !TEST_true(OSSL_PARAM_BLD_push_utf8_ptr(bld, "utf8_p", "bar-boom",
122 || !TEST_true(OSSL_PARAM_BLD_push_int(bld, "i", -6))
123 || !TEST_ptr(params_blt = OSSL_PARAM_BLD_to_param(bld)))
131 params = OSSL_PARAM_merge(params_blt, params_empty);
134 params = OSSL_PARAM_dup(params_blt);
137 p1 = OSSL_PARAM_merge(params_blt, params_empty);
138 params = OSSL_PARAM_dup(p1);
141 p1 = OSSL_PARAM_dup(params_blt);
142 params = OSSL_PARAM_merge(p1, params_empty);
146 if (!TEST_ptr(p = OSSL_PARAM_locate(params, "i"))
147 || !TEST_true(OSSL_PARAM_get_int(p, &i))
148 || !TEST_str_eq(p->key, "i")
149 || !TEST_uint_eq(p->data_type, OSSL_PARAM_INTEGER)
150 || !TEST_size_t_eq(p->data_size, sizeof(int))
151 || !TEST_int_eq(i, -6)
153 || !TEST_ptr(p = OSSL_PARAM_locate(params, "i32"))
154 || !TEST_true(OSSL_PARAM_get_int32(p, &i32))
155 || !TEST_str_eq(p->key, "i32")
156 || !TEST_uint_eq(p->data_type, OSSL_PARAM_INTEGER)
157 || !TEST_size_t_eq(p->data_size, sizeof(int32_t))
158 || !TEST_int_eq((int)i32, 1532)
160 || !TEST_ptr(p = OSSL_PARAM_locate(params, "i64"))
161 || !TEST_str_eq(p->key, "i64")
162 || !TEST_uint_eq(p->data_type, OSSL_PARAM_INTEGER)
163 || !TEST_size_t_eq(p->data_size, sizeof(int64_t))
164 || !TEST_true(OSSL_PARAM_get_int64(p, &i64))
165 || !TEST_long_eq((long)i64, -9999999)
167 || !TEST_ptr(p = OSSL_PARAM_locate(params, "l"))
168 || !TEST_str_eq(p->key, "l")
169 || !TEST_uint_eq(p->data_type, OSSL_PARAM_INTEGER)
170 || !TEST_size_t_eq(p->data_size, sizeof(long int))
171 || !TEST_true(OSSL_PARAM_get_long(p, &l))
172 || !TEST_long_eq(l, 42)
174 || !TEST_ptr(p = OSSL_PARAM_locate(params, "t"))
175 || !TEST_str_eq(p->key, "t")
176 || !TEST_uint_eq(p->data_type, OSSL_PARAM_INTEGER)
177 || !TEST_size_t_eq(p->data_size, sizeof(time_t))
178 || !TEST_true(OSSL_PARAM_get_time_t(p, &t))
179 || !TEST_time_t_eq(t, 11224)
181 || !TEST_ptr(p = OSSL_PARAM_locate(params, "d"))
182 || !TEST_true(OSSL_PARAM_get_double(p, &d))
183 || !TEST_str_eq(p->key, "d")
184 || !TEST_uint_eq(p->data_type, OSSL_PARAM_REAL)
185 || !TEST_size_t_eq(p->data_size, sizeof(double))
186 || !TEST_double_eq(d, 1.61803398875)
187 /* Check UTF8 string */
188 || !TEST_ptr(p = OSSL_PARAM_locate(params, "utf8_s"))
189 || !TEST_str_eq(p->data, "foo")
190 || !TEST_true(OSSL_PARAM_get_utf8_string(p, &utf, 0))
191 || !TEST_str_eq(utf, "foo")
192 /* Check UTF8 pointer */
193 || !TEST_ptr(p = OSSL_PARAM_locate(params, "utf8_p"))
194 || !TEST_true(OSSL_PARAM_get_utf8_ptr(p, &cutf))
195 || !TEST_str_eq(cutf, "bar-boom")
196 /* Check BN (zero BN becomes unsigned integer) */
197 || !TEST_ptr(p = OSSL_PARAM_locate(params, "zeronumber"))
198 || !TEST_str_eq(p->key, "zeronumber")
199 || !TEST_uint_eq(p->data_type, OSSL_PARAM_UNSIGNED_INTEGER)
200 || !TEST_true(OSSL_PARAM_get_BN(p, &zbn_res))
201 || !TEST_BN_eq(zbn_res, zbn)
202 /* Check BN (positive BN becomes unsigned integer) */
203 || !TEST_ptr(p = OSSL_PARAM_locate(params, "bignumber"))
204 || !TEST_str_eq(p->key, "bignumber")
205 || !TEST_uint_eq(p->data_type, OSSL_PARAM_UNSIGNED_INTEGER)
206 || !TEST_true(OSSL_PARAM_get_BN(p, &pbn_res))
207 || !TEST_BN_eq(pbn_res, pbn)
208 /* Check BN (negative BN becomes signed integer) */
209 || !TEST_ptr(p = OSSL_PARAM_locate(params, "negativebignumber"))
210 || !TEST_str_eq(p->key, "negativebignumber")
211 || !TEST_uint_eq(p->data_type, OSSL_PARAM_INTEGER)
212 || !TEST_true(OSSL_PARAM_get_BN(p, &nbn_res))
213 || !TEST_BN_eq(nbn_res, nbn))
218 if (params != params_blt)
219 OPENSSL_free(params);
220 OSSL_PARAM_free(params_blt);
221 OSSL_PARAM_BLD_free(bld);
232 static int template_private_test(int tstid)
234 int *data1 = NULL, *data2 = NULL, j;
235 const int data1_num = 12;
236 const int data1_size = data1_num * sizeof(int);
237 const int data2_num = 5;
238 const int data2_size = data2_num * sizeof(int);
239 OSSL_PARAM_BLD *bld = NULL;
240 OSSL_PARAM *params = NULL, *params_blt = NULL, *p1 = NULL, *p;
246 BIGNUM *zbn = NULL, *zbn_res = NULL;
247 BIGNUM *pbn = NULL, *pbn_res = NULL;
248 BIGNUM *nbn = NULL, *nbn_res = NULL;
251 if (!TEST_ptr(data1 = OPENSSL_secure_malloc(data1_size))
252 || !TEST_ptr(data2 = OPENSSL_secure_malloc(data2_size))
253 || !TEST_ptr(bld = OSSL_PARAM_BLD_new()))
256 for (j = 0; j < data1_num; j++)
258 for (j = 0; j < data2_num; j++)
261 if (!TEST_true(OSSL_PARAM_BLD_push_uint(bld, "i", 6))
262 || !TEST_true(OSSL_PARAM_BLD_push_ulong(bld, "l", 42))
263 || !TEST_true(OSSL_PARAM_BLD_push_uint32(bld, "i32", 1532))
264 || !TEST_true(OSSL_PARAM_BLD_push_uint64(bld, "i64", 9999999))
265 || !TEST_true(OSSL_PARAM_BLD_push_size_t(bld, "st", 65537))
266 || !TEST_ptr(zbn = BN_secure_new())
267 || !TEST_true(OSSL_PARAM_BLD_push_BN(bld, "zeronumber", zbn))
268 || !TEST_ptr(pbn = BN_secure_new())
269 || !TEST_true(BN_set_word(pbn, 1729))
270 || !TEST_true(OSSL_PARAM_BLD_push_BN(bld, "bignumber", pbn))
271 || !TEST_ptr(nbn = BN_secure_new())
272 || !TEST_true(BN_set_word(nbn, 1733))
273 || !TEST_true((BN_set_negative(nbn, 1), 1))
274 || !TEST_true(OSSL_PARAM_BLD_push_BN(bld, "negativebignumber", nbn))
275 || !TEST_true(OSSL_PARAM_BLD_push_octet_string(bld, "oct_s", data1,
277 || !TEST_true(OSSL_PARAM_BLD_push_octet_ptr(bld, "oct_p", data2,
279 || !TEST_ptr(params_blt = OSSL_PARAM_BLD_to_param(bld)))
286 params = OSSL_PARAM_merge(params_blt, params_empty);
289 params = OSSL_PARAM_dup(params_blt);
292 p1 = OSSL_PARAM_merge(params_blt, params_empty);
293 params = OSSL_PARAM_dup(p1);
296 p1 = OSSL_PARAM_dup(params_blt);
297 params = OSSL_PARAM_merge(p1, params_empty);
300 /* Check unsigned int */
301 if (!TEST_ptr(p = OSSL_PARAM_locate(params, "i"))
302 || !TEST_false(CRYPTO_secure_allocated(p->data))
303 || !TEST_true(OSSL_PARAM_get_uint(p, &i))
304 || !TEST_str_eq(p->key, "i")
305 || !TEST_uint_eq(p->data_type, OSSL_PARAM_UNSIGNED_INTEGER)
306 || !TEST_size_t_eq(p->data_size, sizeof(int))
307 || !TEST_uint_eq(i, 6)
308 /* Check unsigned int32 */
309 || !TEST_ptr(p = OSSL_PARAM_locate(params, "i32"))
310 || !TEST_false(CRYPTO_secure_allocated(p->data))
311 || !TEST_true(OSSL_PARAM_get_uint32(p, &i32))
312 || !TEST_str_eq(p->key, "i32")
313 || !TEST_uint_eq(p->data_type, OSSL_PARAM_UNSIGNED_INTEGER)
314 || !TEST_size_t_eq(p->data_size, sizeof(int32_t))
315 || !TEST_uint_eq((unsigned int)i32, 1532)
316 /* Check unsigned int64 */
317 || !TEST_ptr(p = OSSL_PARAM_locate(params, "i64"))
318 || !TEST_false(CRYPTO_secure_allocated(p->data))
319 || !TEST_str_eq(p->key, "i64")
320 || !TEST_uint_eq(p->data_type, OSSL_PARAM_UNSIGNED_INTEGER)
321 || !TEST_size_t_eq(p->data_size, sizeof(int64_t))
322 || !TEST_true(OSSL_PARAM_get_uint64(p, &i64))
323 || !TEST_ulong_eq((unsigned long)i64, 9999999)
324 /* Check unsigned long int */
325 || !TEST_ptr(p = OSSL_PARAM_locate(params, "l"))
326 || !TEST_false(CRYPTO_secure_allocated(p->data))
327 || !TEST_str_eq(p->key, "l")
328 || !TEST_uint_eq(p->data_type, OSSL_PARAM_UNSIGNED_INTEGER)
329 || !TEST_size_t_eq(p->data_size, sizeof(unsigned long int))
330 || !TEST_true(OSSL_PARAM_get_ulong(p, &l))
331 || !TEST_ulong_eq(l, 42)
333 || !TEST_ptr(p = OSSL_PARAM_locate(params, "st"))
334 || !TEST_false(CRYPTO_secure_allocated(p->data))
335 || !TEST_str_eq(p->key, "st")
336 || !TEST_uint_eq(p->data_type, OSSL_PARAM_UNSIGNED_INTEGER)
337 || !TEST_size_t_eq(p->data_size, sizeof(size_t))
338 || !TEST_true(OSSL_PARAM_get_size_t(p, &st))
339 || !TEST_size_t_eq(st, 65537)
340 /* Check octet string */
341 || !TEST_ptr(p = OSSL_PARAM_locate(params, "oct_s"))
342 || !TEST_true(CRYPTO_secure_allocated(p->data))
343 || !TEST_str_eq(p->key, "oct_s")
344 || !TEST_uint_eq(p->data_type, OSSL_PARAM_OCTET_STRING)
345 || !TEST_mem_eq(p->data, p->data_size, data1, data1_size)
346 /* Check octet pointer */
347 || !TEST_ptr(p = OSSL_PARAM_locate(params, "oct_p"))
348 || !TEST_false(CRYPTO_secure_allocated(p->data))
349 || !TEST_true(CRYPTO_secure_allocated(*(void **)p->data))
350 || !TEST_str_eq(p->key, "oct_p")
351 || !TEST_uint_eq(p->data_type, OSSL_PARAM_OCTET_PTR)
352 || !TEST_mem_eq(*(void **)p->data, p->data_size, data2, data2_size)
353 /* Check BN (zero BN becomes unsigned integer) */
354 || !TEST_ptr(p = OSSL_PARAM_locate(params, "zeronumber"))
355 || !TEST_true(CRYPTO_secure_allocated(p->data))
356 || !TEST_str_eq(p->key, "zeronumber")
357 || !TEST_uint_eq(p->data_type, OSSL_PARAM_UNSIGNED_INTEGER)
358 || !TEST_true(OSSL_PARAM_get_BN(p, &zbn_res))
359 || !TEST_int_eq(BN_get_flags(pbn, BN_FLG_SECURE), BN_FLG_SECURE)
360 || !TEST_BN_eq(zbn_res, zbn)
361 /* Check BN (positive BN becomes unsigned integer) */
362 || !TEST_ptr(p = OSSL_PARAM_locate(params, "bignumber"))
363 || !TEST_true(CRYPTO_secure_allocated(p->data))
364 || !TEST_str_eq(p->key, "bignumber")
365 || !TEST_uint_eq(p->data_type, OSSL_PARAM_UNSIGNED_INTEGER)
366 || !TEST_true(OSSL_PARAM_get_BN(p, &pbn_res))
367 || !TEST_int_eq(BN_get_flags(pbn, BN_FLG_SECURE), BN_FLG_SECURE)
368 || !TEST_BN_eq(pbn_res, pbn)
369 /* Check BN (negative BN becomes signed integer) */
370 || !TEST_ptr(p = OSSL_PARAM_locate(params, "negativebignumber"))
371 || !TEST_true(CRYPTO_secure_allocated(p->data))
372 || !TEST_str_eq(p->key, "negativebignumber")
373 || !TEST_uint_eq(p->data_type, OSSL_PARAM_INTEGER)
374 || !TEST_true(OSSL_PARAM_get_BN(p, &nbn_res))
375 || !TEST_int_eq(BN_get_flags(nbn, BN_FLG_SECURE), BN_FLG_SECURE)
376 || !TEST_BN_eq(nbn_res, nbn))
381 if (params != params_blt)
382 OSSL_PARAM_free(params);
383 OSSL_PARAM_free(params_blt);
384 OSSL_PARAM_BLD_free(bld);
385 OPENSSL_secure_free(data1);
386 OPENSSL_secure_free(data2);
396 static int builder_limit_test(void)
400 OSSL_PARAM_BLD *bld = OSSL_PARAM_BLD_new();
401 OSSL_PARAM *params = NULL;
407 for (i = 0; i < n; i++) {
408 names[i][0] = 'A' + (i / 26) - 1;
409 names[i][1] = 'a' + (i % 26) - 1;
411 if (!TEST_true(OSSL_PARAM_BLD_push_int(bld, names[i], 3 * i + 1)))
414 if (!TEST_ptr(params = OSSL_PARAM_BLD_to_param(bld)))
416 /* Count the elements in the params array, expecting n */
417 for (i = 0; params[i].key != NULL; i++);
418 if (!TEST_int_eq(i, n))
421 /* Verify that the build, cleared the builder structure */
422 OSSL_PARAM_free(params);
425 if (!TEST_true(OSSL_PARAM_BLD_push_int(bld, "g", 2))
426 || !TEST_ptr(params = OSSL_PARAM_BLD_to_param(bld)))
428 /* Count the elements in the params array, expecting 1 */
429 for (i = 0; params[i].key != NULL; i++);
430 if (!TEST_int_eq(i, 1))
434 OSSL_PARAM_free(params);
435 OSSL_PARAM_BLD_free(bld);
439 static int builder_merge_test(void)
441 static int data1[] = { 2, 3, 5, 7, 11, 15, 17 };
442 static unsigned char data2[] = { 2, 4, 6, 8, 10 };
443 OSSL_PARAM_BLD *bld = OSSL_PARAM_BLD_new();
444 OSSL_PARAM_BLD *bld2 = OSSL_PARAM_BLD_new();
445 OSSL_PARAM *params = NULL, *params_blt = NULL, *params2_blt = NULL, *p;
451 BIGNUM *bn_priv = NULL, *bn_priv_res = NULL;
452 BIGNUM *bn_pub = NULL, *bn_pub_res = NULL;
456 || !TEST_true(OSSL_PARAM_BLD_push_uint(bld, "i", 6))
457 || !TEST_true(OSSL_PARAM_BLD_push_ulong(bld, "l", 42))
458 || !TEST_true(OSSL_PARAM_BLD_push_uint32(bld, "i32", 1532))
459 || !TEST_true(OSSL_PARAM_BLD_push_uint64(bld, "i64", 9999999))
460 || !TEST_true(OSSL_PARAM_BLD_push_size_t(bld, "st", 65537))
461 || !TEST_ptr(bn_priv = BN_secure_new())
462 || !TEST_true(BN_set_word(bn_priv, 1729))
463 || !TEST_true(OSSL_PARAM_BLD_push_BN(bld, "bignumber_priv", bn_priv))
464 || !TEST_ptr(params_blt = OSSL_PARAM_BLD_to_param(bld)))
468 || !TEST_true(OSSL_PARAM_BLD_push_octet_string(bld2, "oct_s", data1,
470 || !TEST_true(OSSL_PARAM_BLD_push_octet_ptr(bld2, "oct_p", data2,
472 || !TEST_true(OSSL_PARAM_BLD_push_uint32(bld2, "i32", 99))
473 || !TEST_ptr(bn_pub = BN_new())
474 || !TEST_true(BN_set_word(bn_pub, 0x42))
475 || !TEST_true(OSSL_PARAM_BLD_push_BN(bld2, "bignumber_pub", bn_pub))
476 || !TEST_ptr(params2_blt = OSSL_PARAM_BLD_to_param(bld2)))
479 if (!TEST_ptr(params = OSSL_PARAM_merge(params_blt, params2_blt)))
482 if (!TEST_ptr(p = OSSL_PARAM_locate(params, "i"))
483 || !TEST_true(OSSL_PARAM_get_uint(p, &i))
484 || !TEST_str_eq(p->key, "i")
485 || !TEST_uint_eq(p->data_type, OSSL_PARAM_UNSIGNED_INTEGER)
486 || !TEST_size_t_eq(p->data_size, sizeof(int))
487 || !TEST_uint_eq(i, 6)
488 /* Check unsigned int32 */
489 || !TEST_ptr(p = OSSL_PARAM_locate(params, "i32"))
490 || !TEST_true(OSSL_PARAM_get_uint32(p, &i32))
491 || !TEST_str_eq(p->key, "i32")
492 || !TEST_uint_eq(p->data_type, OSSL_PARAM_UNSIGNED_INTEGER)
493 || !TEST_size_t_eq(p->data_size, sizeof(int32_t))
494 || !TEST_uint_eq((unsigned int)i32, 99)
495 /* Check unsigned int64 */
496 || !TEST_ptr(p = OSSL_PARAM_locate(params, "i64"))
497 || !TEST_str_eq(p->key, "i64")
498 || !TEST_uint_eq(p->data_type, OSSL_PARAM_UNSIGNED_INTEGER)
499 || !TEST_size_t_eq(p->data_size, sizeof(int64_t))
500 || !TEST_true(OSSL_PARAM_get_uint64(p, &i64))
501 || !TEST_ulong_eq((unsigned long)i64, 9999999)
502 /* Check unsigned long int */
503 || !TEST_ptr(p = OSSL_PARAM_locate(params, "l"))
504 || !TEST_str_eq(p->key, "l")
505 || !TEST_uint_eq(p->data_type, OSSL_PARAM_UNSIGNED_INTEGER)
506 || !TEST_size_t_eq(p->data_size, sizeof(unsigned long int))
507 || !TEST_true(OSSL_PARAM_get_ulong(p, &l))
508 || !TEST_ulong_eq(l, 42)
510 || !TEST_ptr(p = OSSL_PARAM_locate(params, "st"))
511 || !TEST_str_eq(p->key, "st")
512 || !TEST_uint_eq(p->data_type, OSSL_PARAM_UNSIGNED_INTEGER)
513 || !TEST_size_t_eq(p->data_size, sizeof(size_t))
514 || !TEST_true(OSSL_PARAM_get_size_t(p, &st))
515 || !TEST_size_t_eq(st, 65537)
516 /* Check octet string */
517 || !TEST_ptr(p = OSSL_PARAM_locate(params, "oct_s"))
518 || !TEST_str_eq(p->key, "oct_s")
519 || !TEST_uint_eq(p->data_type, OSSL_PARAM_OCTET_STRING)
520 || !TEST_mem_eq(p->data, p->data_size, data1, sizeof(data1))
521 /* Check octet pointer */
522 || !TEST_ptr(p = OSSL_PARAM_locate(params, "oct_p"))
523 || !TEST_str_eq(p->key, "oct_p")
524 || !TEST_uint_eq(p->data_type, OSSL_PARAM_OCTET_PTR)
525 || !TEST_mem_eq(*(void **)p->data, p->data_size, data2, sizeof(data2))
527 || !TEST_ptr(p = OSSL_PARAM_locate(params, "bignumber_pub"))
528 || !TEST_str_eq(p->key, "bignumber_pub")
529 || !TEST_uint_eq(p->data_type, OSSL_PARAM_UNSIGNED_INTEGER)
530 || !TEST_true(OSSL_PARAM_get_BN(p, &bn_pub_res))
531 || !TEST_int_eq(BN_cmp(bn_pub_res, bn_pub), 0)
532 || !TEST_ptr(p = OSSL_PARAM_locate(params, "bignumber_priv"))
533 || !TEST_str_eq(p->key, "bignumber_priv")
534 || !TEST_uint_eq(p->data_type, OSSL_PARAM_UNSIGNED_INTEGER)
535 || !TEST_true(OSSL_PARAM_get_BN(p, &bn_priv_res))
536 || !TEST_int_eq(BN_cmp(bn_priv_res, bn_priv), 0))
540 OSSL_PARAM_free(params);
541 OSSL_PARAM_free(params_blt);
542 OSSL_PARAM_free(params2_blt);
543 OSSL_PARAM_BLD_free(bld);
544 OSSL_PARAM_BLD_free(bld2);
546 BN_free(bn_priv_res);
552 int setup_tests(void)
554 ADD_ALL_TESTS(template_public_single_zero_test, 2);
555 ADD_ALL_TESTS(template_public_test, 5);
556 /* Only run the secure memory testing if we have secure memory available */
557 if (CRYPTO_secure_malloc_init(1<<16, 16)) {
558 ADD_TEST(template_private_single_zero_test);
559 ADD_ALL_TESTS(template_private_test, 5);
561 ADD_TEST(builder_limit_test);
562 ADD_TEST(builder_merge_test);