1/* 2 * Copyright 2019-2021 The OpenSSL Project Authors. All Rights Reserved. 3 * Copyright (c) 2019, Oracle and/or its affiliates. All rights reserved. 4 * 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 9 */ 10 11#include <string.h> 12#include "testutil.h" 13#include "internal/nelem.h" 14#include "internal/endian.h" 15#include <openssl/params.h> 16#include <openssl/bn.h> 17 18/* The maximum size of the static buffers used to test most things */ 19#define MAX_LEN 20 20 21static void swap_copy(unsigned char *out, const void *in, size_t len) 22{ 23 size_t j; 24 25 for (j = 0; j < len; j++) 26 out[j] = ((unsigned char *)in)[len - j - 1]; 27} 28 29/* 30 * A memory copy that converts the native byte ordering either to or from 31 * little endian format. 32 * 33 * On a little endian machine copying either is just a memcpy(3), on a 34 * big endian machine copying from native to or from little endian involves 35 * byte reversal. 36 */ 37static void le_copy(unsigned char *out, const void *in, size_t len) 38{ 39 DECLARE_IS_ENDIAN; 40 41 if (IS_LITTLE_ENDIAN) 42 memcpy(out, in, len); 43 else 44 swap_copy(out, in, len); 45} 46 47static const struct { 48 size_t len; 49 unsigned char value[MAX_LEN]; 50} raw_values[] = { 51 { 1, { 0x47 } }, 52 { 1, { 0xd0 } }, 53 { 2, { 0x01, 0xe9 } }, 54 { 2, { 0xff, 0x53 } }, 55 { 3, { 0x16, 0xff, 0x7c } }, 56 { 3, { 0xa8, 0x9c, 0x0e } }, 57 { 4, { 0x38, 0x27, 0xbf, 0x3b } }, 58 { 4, { 0x9f, 0x26, 0x48, 0x22 } }, 59 { 5, { 0x30, 0x65, 0xfa, 0xe4, 0x81 } }, 60 { 5, { 0xd1, 0x76, 0x01, 0x1b, 0xcd } }, 61 { 8, { 0x59, 0xb2, 0x1a, 0xe9, 0x2a, 0xd8, 0x46, 0x40 } }, 62 { 8, { 0xb4, 0xae, 0xbd, 0xb4, 0xdd, 0x04, 0xb1, 0x4c } }, 63 { 16, { 0x61, 0xe8, 0x7e, 0x31, 0xe9, 0x33, 0x83, 0x3d, 64 0x87, 0x99, 0xc7, 0xd8, 0x5d, 0xa9, 0x8b, 0x42 } }, 65 { 16, { 0xee, 0x6e, 0x8b, 0xc3, 0xec, 0xcf, 0x37, 0xcc, 66 0x89, 0x67, 0xf2, 0x68, 0x33, 0xa0, 0x14, 0xb0 } }, 67}; 68 69static int test_param_type_extra(OSSL_PARAM *param, const unsigned char *cmp, 70 size_t width) 71{ 72 int32_t i32; 73 int64_t i64; 74 size_t s, sz; 75 unsigned char buf[MAX_LEN]; 76 const int bit32 = param->data_size <= sizeof(int32_t); 77 const int sizet = param->data_size <= sizeof(size_t); 78 const int signd = param->data_type == OSSL_PARAM_INTEGER; 79 80 /* 81 * Set the unmodified sentinal directly because there is no param array 82 * for these tests. 83 */ 84 param->return_size = OSSL_PARAM_UNMODIFIED; 85 if (signd) { 86 if ((bit32 && !TEST_true(OSSL_PARAM_get_int32(param, &i32))) 87 || !TEST_true(OSSL_PARAM_get_int64(param, &i64))) 88 return 0; 89 } else { 90 if ((bit32 91 && !TEST_true(OSSL_PARAM_get_uint32(param, (uint32_t *)&i32))) 92 || !TEST_true(OSSL_PARAM_get_uint64(param, (uint64_t *)&i64)) 93 || (sizet && !TEST_true(OSSL_PARAM_get_size_t(param, &s)))) 94 return 0; 95 } 96 if (!TEST_false(OSSL_PARAM_modified(param))) 97 return 0; 98 99 /* Check signed types */ 100 if (bit32) { 101 le_copy(buf, &i32, sizeof(i32)); 102 sz = sizeof(i32) < width ? sizeof(i32) : width; 103 if (!TEST_mem_eq(buf, sz, cmp, sz)) 104 return 0; 105 } 106 le_copy(buf, &i64, sizeof(i64)); 107 sz = sizeof(i64) < width ? sizeof(i64) : width; 108 if (!TEST_mem_eq(buf, sz, cmp, sz)) 109 return 0; 110 if (sizet && !signd) { 111 le_copy(buf, &s, sizeof(s)); 112 sz = sizeof(s) < width ? sizeof(s) : width; 113 if (!TEST_mem_eq(buf, sz, cmp, sz)) 114 return 0; 115 } 116 117 /* Check a widening write if possible */ 118 if (sizeof(size_t) > width) { 119 if (signd) { 120 if (!TEST_true(OSSL_PARAM_set_int32(param, 12345)) 121 || !TEST_true(OSSL_PARAM_get_int64(param, &i64)) 122 || !TEST_size_t_eq((size_t)i64, 12345)) 123 return 0; 124 } else { 125 if (!TEST_true(OSSL_PARAM_set_uint32(param, 12345)) 126 || !TEST_true(OSSL_PARAM_get_uint64(param, (uint64_t *)&i64)) 127 || !TEST_size_t_eq((size_t)i64, 12345)) 128 return 0; 129 } 130 if (!TEST_true(OSSL_PARAM_modified(param))) 131 return 0; 132 } 133 return 1; 134} 135 136/* 137 * The test cases for each of the bastic integral types are similar. 138 * For each type, a param of that type is set and an attempt to read it 139 * get is made. Finally, the above function is called to verify that 140 * the params can be read as other types. 141 * 142 * All the real work is done via byte buffers which are converted to machine 143 * byte order and to little endian for comparisons. Narrower values are best 144 * compared using little endian because their values and positions don't 145 * change. 146 */ 147 148static int test_param_int(int n) 149{ 150 int in, out; 151 unsigned char buf[MAX_LEN], cmp[sizeof(int)]; 152 const size_t len = raw_values[n].len >= sizeof(int) ? 153 sizeof(int) : raw_values[n].len; 154 OSSL_PARAM param = OSSL_PARAM_int("a", NULL); 155 156 memset(buf, 0, sizeof(buf)); 157 le_copy(buf, raw_values[n].value, sizeof(in)); 158 memcpy(&in, buf, sizeof(in)); 159 param.data = &out; 160 if (!TEST_true(OSSL_PARAM_set_int(¶m, in))) 161 return 0; 162 le_copy(cmp, &out, sizeof(out)); 163 if (!TEST_mem_eq(cmp, len, raw_values[n].value, len)) 164 return 0; 165 in = 0; 166 if (!TEST_true(OSSL_PARAM_get_int(¶m, &in))) 167 return 0; 168 le_copy(cmp, &in, sizeof(in)); 169 if (!TEST_mem_eq(cmp, sizeof(in), raw_values[n].value, sizeof(in))) 170 return 0; 171 param.data = &out; 172 return test_param_type_extra(¶m, raw_values[n].value, sizeof(int)); 173} 174 175static int test_param_long(int n) 176{ 177 long int in, out; 178 unsigned char buf[MAX_LEN], cmp[sizeof(long int)]; 179 const size_t len = raw_values[n].len >= sizeof(long int) 180 ? sizeof(long int) : raw_values[n].len; 181 OSSL_PARAM param = OSSL_PARAM_long("a", NULL); 182 183 memset(buf, 0, sizeof(buf)); 184 le_copy(buf, raw_values[n].value, sizeof(in)); 185 memcpy(&in, buf, sizeof(in)); 186 param.data = &out; 187 if (!TEST_true(OSSL_PARAM_set_long(¶m, in))) 188 return 0; 189 le_copy(cmp, &out, sizeof(out)); 190 if (!TEST_mem_eq(cmp, len, raw_values[n].value, len)) 191 return 0; 192 in = 0; 193 if (!TEST_true(OSSL_PARAM_get_long(¶m, &in))) 194 return 0; 195 le_copy(cmp, &in, sizeof(in)); 196 if (!TEST_mem_eq(cmp, sizeof(in), raw_values[n].value, sizeof(in))) 197 return 0; 198 param.data = &out; 199 return test_param_type_extra(¶m, raw_values[n].value, sizeof(long int)); 200} 201 202static int test_param_uint(int n) 203{ 204 unsigned int in, out; 205 unsigned char buf[MAX_LEN], cmp[sizeof(unsigned int)]; 206 const size_t len = raw_values[n].len >= sizeof(unsigned int) ? sizeof(unsigned int) : raw_values[n].len; 207 OSSL_PARAM param = OSSL_PARAM_uint("a", NULL); 208 209 memset(buf, 0, sizeof(buf)); 210 le_copy(buf, raw_values[n].value, sizeof(in)); 211 memcpy(&in, buf, sizeof(in)); 212 param.data = &out; 213 if (!TEST_true(OSSL_PARAM_set_uint(¶m, in))) 214 return 0; 215 le_copy(cmp, &out, sizeof(out)); 216 if (!TEST_mem_eq(cmp, len, raw_values[n].value, len)) 217 return 0; 218 in = 0; 219 if (!TEST_true(OSSL_PARAM_get_uint(¶m, &in))) 220 return 0; 221 le_copy(cmp, &in, sizeof(in)); 222 if (!TEST_mem_eq(cmp, sizeof(in), raw_values[n].value, sizeof(in))) 223 return 0; 224 param.data = &out; 225 return test_param_type_extra(¶m, raw_values[n].value, sizeof(unsigned int)); 226} 227 228static int test_param_ulong(int n) 229{ 230 unsigned long int in, out; 231 unsigned char buf[MAX_LEN], cmp[sizeof(unsigned long int)]; 232 const size_t len = raw_values[n].len >= sizeof(unsigned long int) 233 ? sizeof(unsigned long int) : raw_values[n].len; 234 OSSL_PARAM param = OSSL_PARAM_ulong("a", NULL); 235 236 memset(buf, 0, sizeof(buf)); 237 le_copy(buf, raw_values[n].value, sizeof(in)); 238 memcpy(&in, buf, sizeof(in)); 239 param.data = &out; 240 if (!TEST_true(OSSL_PARAM_set_ulong(¶m, in))) 241 return 0; 242 le_copy(cmp, &out, sizeof(out)); 243 if (!TEST_mem_eq(cmp, len, raw_values[n].value, len)) 244 return 0; 245 in = 0; 246 if (!TEST_true(OSSL_PARAM_get_ulong(¶m, &in))) 247 return 0; 248 le_copy(cmp, &in, sizeof(in)); 249 if (!TEST_mem_eq(cmp, sizeof(in), raw_values[n].value, sizeof(in))) 250 return 0; 251 param.data = &out; 252 return test_param_type_extra(¶m, raw_values[n].value, sizeof(unsigned long int)); 253} 254 255static int test_param_int32(int n) 256{ 257 int32_t in, out; 258 unsigned char buf[MAX_LEN], cmp[sizeof(int32_t)]; 259 const size_t len = raw_values[n].len >= sizeof(int32_t) 260 ? sizeof(int32_t) : raw_values[n].len; 261 OSSL_PARAM param = OSSL_PARAM_int32("a", NULL); 262 263 memset(buf, 0, sizeof(buf)); 264 le_copy(buf, raw_values[n].value, sizeof(in)); 265 memcpy(&in, buf, sizeof(in)); 266 param.data = &out; 267 if (!TEST_true(OSSL_PARAM_set_int32(¶m, in))) 268 return 0; 269 le_copy(cmp, &out, sizeof(out)); 270 if (!TEST_mem_eq(cmp, len, raw_values[n].value, len)) 271 return 0; 272 in = 0; 273 if (!TEST_true(OSSL_PARAM_get_int32(¶m, &in))) 274 return 0; 275 le_copy(cmp, &in, sizeof(in)); 276 if (!TEST_mem_eq(cmp, sizeof(in), raw_values[n].value, sizeof(in))) 277 return 0; 278 param.data = &out; 279 return test_param_type_extra(¶m, raw_values[n].value, sizeof(int32_t)); 280} 281 282static int test_param_uint32(int n) 283{ 284 uint32_t in, out; 285 unsigned char buf[MAX_LEN], cmp[sizeof(uint32_t)]; 286 const size_t len = raw_values[n].len >= sizeof(uint32_t) 287 ? sizeof(uint32_t) : raw_values[n].len; 288 OSSL_PARAM param = OSSL_PARAM_uint32("a", NULL); 289 290 memset(buf, 0, sizeof(buf)); 291 le_copy(buf, raw_values[n].value, sizeof(in)); 292 memcpy(&in, buf, sizeof(in)); 293 param.data = &out; 294 if (!TEST_true(OSSL_PARAM_set_uint32(¶m, in))) 295 return 0; 296 le_copy(cmp, &out, sizeof(out)); 297 if (!TEST_mem_eq(cmp, len, raw_values[n].value, len)) 298 return 0; 299 in = 0; 300 if (!TEST_true(OSSL_PARAM_get_uint32(¶m, &in))) 301 return 0; 302 le_copy(cmp, &in, sizeof(in)); 303 if (!TEST_mem_eq(cmp, sizeof(in), raw_values[n].value, sizeof(in))) 304 return 0; 305 param.data = &out; 306 return test_param_type_extra(¶m, raw_values[n].value, sizeof(uint32_t)); 307} 308 309static int test_param_int64(int n) 310{ 311 int64_t in, out; 312 unsigned char buf[MAX_LEN], cmp[sizeof(int64_t)]; 313 const size_t len = raw_values[n].len >= sizeof(int64_t) 314 ? sizeof(int64_t) : raw_values[n].len; 315 OSSL_PARAM param = OSSL_PARAM_int64("a", NULL); 316 317 memset(buf, 0, sizeof(buf)); 318 le_copy(buf, raw_values[n].value, sizeof(in)); 319 memcpy(&in, buf, sizeof(in)); 320 param.data = &out; 321 if (!TEST_true(OSSL_PARAM_set_int64(¶m, in))) 322 return 0; 323 le_copy(cmp, &out, sizeof(out)); 324 if (!TEST_mem_eq(cmp, len, raw_values[n].value, len)) 325 return 0; 326 in = 0; 327 if (!TEST_true(OSSL_PARAM_get_int64(¶m, &in))) 328 return 0; 329 le_copy(cmp, &in, sizeof(in)); 330 if (!TEST_mem_eq(cmp, sizeof(in), raw_values[n].value, sizeof(in))) 331 return 0; 332 param.data = &out; 333 return test_param_type_extra(¶m, raw_values[n].value, sizeof(int64_t)); 334} 335 336static int test_param_uint64(int n) 337{ 338 uint64_t in, out; 339 unsigned char buf[MAX_LEN], cmp[sizeof(uint64_t)]; 340 const size_t len = raw_values[n].len >= sizeof(uint64_t) 341 ? sizeof(uint64_t) : raw_values[n].len; 342 OSSL_PARAM param = OSSL_PARAM_uint64("a", NULL); 343 344 memset(buf, 0, sizeof(buf)); 345 le_copy(buf, raw_values[n].value, sizeof(in)); 346 memcpy(&in, buf, sizeof(in)); 347 param.data = &out; 348 if (!TEST_true(OSSL_PARAM_set_uint64(¶m, in))) 349 return 0; 350 le_copy(cmp, &out, sizeof(out)); 351 if (!TEST_mem_eq(cmp, len, raw_values[n].value, len)) 352 return 0; 353 in = 0; 354 if (!TEST_true(OSSL_PARAM_get_uint64(¶m, &in))) 355 return 0; 356 le_copy(cmp, &in, sizeof(in)); 357 if (!TEST_mem_eq(cmp, sizeof(in), raw_values[n].value, sizeof(in))) 358 return 0; 359 param.data = &out; 360 return test_param_type_extra(¶m, raw_values[n].value, sizeof(uint64_t)); 361} 362 363static int test_param_size_t(int n) 364{ 365 size_t in, out; 366 unsigned char buf[MAX_LEN], cmp[sizeof(size_t)]; 367 const size_t len = raw_values[n].len >= sizeof(size_t) 368 ? sizeof(size_t) : raw_values[n].len; 369 OSSL_PARAM param = OSSL_PARAM_size_t("a", NULL); 370 371 memset(buf, 0, sizeof(buf)); 372 le_copy(buf, raw_values[n].value, sizeof(in)); 373 memcpy(&in, buf, sizeof(in)); 374 param.data = &out; 375 if (!TEST_true(OSSL_PARAM_set_size_t(¶m, in))) 376 return 0; 377 le_copy(cmp, &out, sizeof(out)); 378 if (!TEST_mem_eq(cmp, len, raw_values[n].value, len)) 379 return 0; 380 in = 0; 381 if (!TEST_true(OSSL_PARAM_get_size_t(¶m, &in))) 382 return 0; 383 le_copy(cmp, &in, sizeof(in)); 384 if (!TEST_mem_eq(cmp, sizeof(in), raw_values[n].value, sizeof(in))) 385 return 0; 386 param.data = &out; 387 return test_param_type_extra(¶m, raw_values[n].value, sizeof(size_t)); 388} 389 390static int test_param_time_t(int n) 391{ 392 time_t in, out; 393 unsigned char buf[MAX_LEN], cmp[sizeof(time_t)]; 394 const size_t len = raw_values[n].len >= sizeof(time_t) 395 ? sizeof(time_t) : raw_values[n].len; 396 OSSL_PARAM param = OSSL_PARAM_time_t("a", NULL); 397 398 memset(buf, 0, sizeof(buf)); 399 le_copy(buf, raw_values[n].value, sizeof(in)); 400 memcpy(&in, buf, sizeof(in)); 401 param.data = &out; 402 if (!TEST_true(OSSL_PARAM_set_time_t(¶m, in))) 403 return 0; 404 le_copy(cmp, &out, sizeof(out)); 405 if (!TEST_mem_eq(cmp, len, raw_values[n].value, len)) 406 return 0; 407 in = 0; 408 if (!TEST_true(OSSL_PARAM_get_time_t(¶m, &in))) 409 return 0; 410 le_copy(cmp, &in, sizeof(in)); 411 if (!TEST_mem_eq(cmp, sizeof(in), raw_values[n].value, sizeof(in))) 412 return 0; 413 param.data = &out; 414 return test_param_type_extra(¶m, raw_values[n].value, sizeof(size_t)); 415} 416 417static int test_param_bignum(int n) 418{ 419 unsigned char buf[MAX_LEN], bnbuf[MAX_LEN]; 420 const size_t len = raw_values[n].len; 421 BIGNUM *b = NULL, *c = NULL; 422 OSSL_PARAM param = OSSL_PARAM_DEFN("bn", OSSL_PARAM_UNSIGNED_INTEGER, 423 NULL, 0); 424 int ret = 0; 425 426 param.data = bnbuf; 427 param.data_size = len; 428 429 le_copy(buf, raw_values[n].value, len); 430 if (!TEST_ptr(b = BN_lebin2bn(raw_values[n].value, (int)len, NULL))) 431 goto err; 432 433 if (!TEST_true(OSSL_PARAM_set_BN(¶m, b)) 434 || !TEST_mem_eq(bnbuf, param.return_size, buf, param.return_size)) 435 goto err; 436 param.data_size = param.return_size; 437 if (!TEST_true(OSSL_PARAM_get_BN(¶m, &c)) 438 || !TEST_BN_eq(b, c)) 439 goto err; 440 441 ret = 1; 442err: 443 BN_free(b); 444 BN_free(c); 445 return ret; 446} 447 448static int test_param_real(void) 449{ 450 double p; 451 OSSL_PARAM param = OSSL_PARAM_double("r", NULL); 452 453 param.data = &p; 454 return TEST_true(OSSL_PARAM_set_double(¶m, 3.14159)) 455 && TEST_double_eq(p, 3.14159); 456} 457 458static int test_param_construct(int tstid) 459{ 460 static const char *int_names[] = { 461 "int", "long", "int32", "int64" 462 }; 463 static const char *uint_names[] = { 464 "uint", "ulong", "uint32", "uint64", "size_t" 465 }; 466 static const unsigned char bn_val[16] = { 467 0xac, 0x75, 0x22, 0x7d, 0x81, 0x06, 0x7a, 0x23, 468 0xa6, 0xed, 0x87, 0xc7, 0xab, 0xf4, 0x73, 0x22 469 }; 470 OSSL_PARAM *p = NULL, *p1 = NULL; 471 static const OSSL_PARAM params_empty[] = { 472 OSSL_PARAM_END 473 }; 474 OSSL_PARAM params[20]; 475 char buf[100], buf2[100], *bufp, *bufp2; 476 unsigned char ubuf[100]; 477 void *vp, *vpn = NULL, *vp2; 478 OSSL_PARAM *cp; 479 int i, n = 0, ret = 0; 480 unsigned int u; 481 long int l; 482 unsigned long int ul; 483 int32_t i32; 484 uint32_t u32; 485 int64_t i64; 486 uint64_t u64; 487 size_t j, k, s; 488 double d, d2; 489 BIGNUM *bn = NULL, *bn2 = NULL; 490 491 params[n++] = OSSL_PARAM_construct_int("int", &i); 492 params[n++] = OSSL_PARAM_construct_uint("uint", &u); 493 params[n++] = OSSL_PARAM_construct_long("long", &l); 494 params[n++] = OSSL_PARAM_construct_ulong("ulong", &ul); 495 params[n++] = OSSL_PARAM_construct_int32("int32", &i32); 496 params[n++] = OSSL_PARAM_construct_int64("int64", &i64); 497 params[n++] = OSSL_PARAM_construct_uint32("uint32", &u32); 498 params[n++] = OSSL_PARAM_construct_uint64("uint64", &u64); 499 params[n++] = OSSL_PARAM_construct_size_t("size_t", &s); 500 params[n++] = OSSL_PARAM_construct_double("double", &d); 501 params[n++] = OSSL_PARAM_construct_BN("bignum", ubuf, sizeof(ubuf)); 502 params[n++] = OSSL_PARAM_construct_utf8_string("utf8str", buf, sizeof(buf)); 503 params[n++] = OSSL_PARAM_construct_octet_string("octstr", buf, sizeof(buf)); 504 params[n++] = OSSL_PARAM_construct_utf8_ptr("utf8ptr", &bufp, 0); 505 params[n++] = OSSL_PARAM_construct_octet_ptr("octptr", &vp, 0); 506 params[n] = OSSL_PARAM_construct_end(); 507 508 switch(tstid) { 509 case 0: 510 p = params; 511 break; 512 case 1: 513 p = OSSL_PARAM_merge(params, params_empty); 514 break; 515 case 2: 516 p = OSSL_PARAM_dup(params); 517 break; 518 default: 519 p1 = OSSL_PARAM_dup(params); 520 p = OSSL_PARAM_merge(p1, params_empty); 521 break; 522 } 523 524 /* Search failure */ 525 if (!TEST_ptr_null(OSSL_PARAM_locate(p, "fnord"))) 526 goto err; 527 528 /* All signed integral types */ 529 for (j = 0; j < OSSL_NELEM(int_names); j++) { 530 if (!TEST_ptr(cp = OSSL_PARAM_locate(p, int_names[j])) 531 || !TEST_true(OSSL_PARAM_set_int32(cp, (int32_t)(3 + j))) 532 || !TEST_true(OSSL_PARAM_get_int64(cp, &i64)) 533 || !TEST_size_t_eq(cp->data_size, cp->return_size) 534 || !TEST_size_t_eq((size_t)i64, 3 + j)) { 535 TEST_note("iteration %zu var %s", j + 1, int_names[j]); 536 goto err; 537 } 538 } 539 /* All unsigned integral types */ 540 for (j = 0; j < OSSL_NELEM(uint_names); j++) { 541 if (!TEST_ptr(cp = OSSL_PARAM_locate(p, uint_names[j])) 542 || !TEST_true(OSSL_PARAM_set_uint32(cp, (uint32_t)(3 + j))) 543 || !TEST_true(OSSL_PARAM_get_uint64(cp, &u64)) 544 || !TEST_size_t_eq(cp->data_size, cp->return_size) 545 || !TEST_size_t_eq((size_t)u64, 3 + j)) { 546 TEST_note("iteration %zu var %s", j + 1, uint_names[j]); 547 goto err; 548 } 549 } 550 /* Real */ 551 if (!TEST_ptr(cp = OSSL_PARAM_locate(p, "double")) 552 || !TEST_true(OSSL_PARAM_set_double(cp, 3.14)) 553 || !TEST_true(OSSL_PARAM_get_double(cp, &d2)) 554 || !TEST_size_t_eq(cp->return_size, sizeof(double)) 555 || !TEST_double_eq(d2, 3.14) 556 || (tstid <= 1 && !TEST_double_eq(d, d2))) 557 goto err; 558 /* UTF8 string */ 559 bufp = NULL; 560 if (!TEST_ptr(cp = OSSL_PARAM_locate(p, "utf8str")) 561 || !TEST_true(OSSL_PARAM_set_utf8_string(cp, "abcdef")) 562 || !TEST_size_t_eq(cp->return_size, sizeof("abcdef") - 1) 563 || !TEST_true(OSSL_PARAM_get_utf8_string(cp, &bufp, 0)) 564 || !TEST_str_eq(bufp, "abcdef")) { 565 OPENSSL_free(bufp); 566 goto err; 567 } 568 OPENSSL_free(bufp); 569 bufp = buf2; 570 if (!TEST_true(OSSL_PARAM_get_utf8_string(cp, &bufp, sizeof(buf2))) 571 || !TEST_str_eq(buf2, "abcdef")) 572 goto err; 573 /* UTF8 pointer */ 574 /* Note that the size of a UTF8 string does *NOT* include the NUL byte */ 575 bufp = buf; 576 if (!TEST_ptr(cp = OSSL_PARAM_locate(p, "utf8ptr")) 577 || !TEST_true(OSSL_PARAM_set_utf8_ptr(cp, "tuvwxyz")) 578 || !TEST_size_t_eq(cp->return_size, sizeof("tuvwxyz") - 1) 579 || !TEST_true(OSSL_PARAM_get_utf8_ptr(cp, (const char **)&bufp2)) 580 || !TEST_str_eq(bufp2, "tuvwxyz") 581 || (tstid <= 1 && !TEST_ptr_eq(bufp2, bufp))) 582 goto err; 583 /* OCTET string */ 584 if (!TEST_ptr(cp = OSSL_PARAM_locate(p, "octstr")) 585 || !TEST_true(OSSL_PARAM_set_octet_string(cp, "abcdefghi", 586 sizeof("abcdefghi"))) 587 || !TEST_size_t_eq(cp->return_size, sizeof("abcdefghi"))) 588 goto err; 589 /* Match the return size to avoid trailing garbage bytes */ 590 cp->data_size = cp->return_size; 591 if (!TEST_true(OSSL_PARAM_get_octet_string(cp, &vpn, 0, &s)) 592 || !TEST_size_t_eq(s, sizeof("abcdefghi")) 593 || !TEST_mem_eq(vpn, sizeof("abcdefghi"), 594 "abcdefghi", sizeof("abcdefghi"))) 595 goto err; 596 vp = buf2; 597 if (!TEST_true(OSSL_PARAM_get_octet_string(cp, &vp, sizeof(buf2), &s)) 598 || !TEST_size_t_eq(s, sizeof("abcdefghi")) 599 || !TEST_mem_eq(vp, sizeof("abcdefghi"), 600 "abcdefghi", sizeof("abcdefghi"))) 601 goto err; 602 /* OCTET pointer */ 603 vp = &l; 604 if (!TEST_ptr(cp = OSSL_PARAM_locate(p, "octptr")) 605 || !TEST_true(OSSL_PARAM_set_octet_ptr(cp, &ul, sizeof(ul))) 606 || !TEST_size_t_eq(cp->return_size, sizeof(ul)) 607 || (tstid <= 1 && !TEST_ptr_eq(vp, &ul))) 608 goto err; 609 /* Match the return size to avoid trailing garbage bytes */ 610 cp->data_size = cp->return_size; 611 if (!TEST_true(OSSL_PARAM_get_octet_ptr(cp, (const void **)&vp2, &k)) 612 || !TEST_size_t_eq(k, sizeof(ul)) 613 || (tstid <= 1 && !TEST_ptr_eq(vp2, vp))) 614 goto err; 615 /* BIGNUM */ 616 if (!TEST_ptr(cp = OSSL_PARAM_locate(p, "bignum")) 617 || !TEST_ptr(bn = BN_lebin2bn(bn_val, (int)sizeof(bn_val), NULL)) 618 || !TEST_true(OSSL_PARAM_set_BN(cp, bn)) 619 || !TEST_size_t_eq(cp->data_size, cp->return_size)) 620 goto err; 621 /* Match the return size to avoid trailing garbage bytes */ 622 cp->data_size = cp->return_size; 623 if(!TEST_true(OSSL_PARAM_get_BN(cp, &bn2)) 624 || !TEST_BN_eq(bn, bn2)) 625 goto err; 626 ret = 1; 627err: 628 if (p != params) 629 OPENSSL_free(p); 630 OPENSSL_free(p1); 631 OPENSSL_free(vpn); 632 BN_free(bn); 633 BN_free(bn2); 634 return ret; 635} 636 637static int test_param_modified(void) 638{ 639 OSSL_PARAM param[3] = { OSSL_PARAM_int("a", NULL), 640 OSSL_PARAM_int("b", NULL), 641 OSSL_PARAM_END }; 642 int a, b; 643 644 param->data = &a; 645 param[1].data = &b; 646 if (!TEST_false(OSSL_PARAM_modified(param)) 647 && !TEST_true(OSSL_PARAM_set_int32(param, 1234)) 648 && !TEST_true(OSSL_PARAM_modified(param)) 649 && !TEST_false(OSSL_PARAM_modified(param + 1)) 650 && !TEST_true(OSSL_PARAM_set_int32(param + 1, 1)) 651 && !TEST_true(OSSL_PARAM_modified(param + 1))) 652 return 0; 653 OSSL_PARAM_set_all_unmodified(param); 654 if (!TEST_false(OSSL_PARAM_modified(param)) 655 && !TEST_true(OSSL_PARAM_set_int32(param, 4321)) 656 && !TEST_true(OSSL_PARAM_modified(param)) 657 && !TEST_false(OSSL_PARAM_modified(param + 1)) 658 && !TEST_true(OSSL_PARAM_set_int32(param + 1, 2)) 659 && !TEST_true(OSSL_PARAM_modified(param + 1))) 660 return 0; 661 return 1; 662} 663 664static int test_param_copy_null(void) 665{ 666 int ret, val; 667 int a = 1, b = 2, i = 0; 668 OSSL_PARAM *cp1 = NULL, *cp2 = NULL, *p; 669 OSSL_PARAM param[3]; 670 671 param[i++] = OSSL_PARAM_construct_int("a", &a); 672 param[i++] = OSSL_PARAM_construct_int("b", &b); 673 param[i] = OSSL_PARAM_construct_end(); 674 675 ret = TEST_ptr_null(OSSL_PARAM_dup(NULL)) 676 && TEST_ptr(cp1 = OSSL_PARAM_merge(NULL, param)) 677 && TEST_ptr(p = OSSL_PARAM_locate(cp1, "a")) 678 && TEST_true(OSSL_PARAM_get_int(p, &val)) 679 && TEST_int_eq(val, 1) 680 && TEST_ptr(p = OSSL_PARAM_locate(cp1, "b")) 681 && TEST_true(OSSL_PARAM_get_int(p, &val)) 682 && TEST_int_eq(val, 2) 683 && TEST_ptr(cp2 = OSSL_PARAM_merge(param, NULL)) 684 && TEST_ptr(p = OSSL_PARAM_locate(cp2, "a")) 685 && TEST_true(OSSL_PARAM_get_int(p, &val)) 686 && TEST_int_eq(val, 1) 687 && TEST_ptr(p = OSSL_PARAM_locate(cp2, "b")) 688 && TEST_true(OSSL_PARAM_get_int(p, &val)) 689 && TEST_int_eq(val, 2) 690 && TEST_ptr_null(OSSL_PARAM_merge(NULL, NULL)); 691 OSSL_PARAM_free(cp2); 692 OSSL_PARAM_free(cp1); 693 return ret; 694} 695 696int setup_tests(void) 697{ 698 ADD_ALL_TESTS(test_param_int, OSSL_NELEM(raw_values)); 699 ADD_ALL_TESTS(test_param_long, OSSL_NELEM(raw_values)); 700 ADD_ALL_TESTS(test_param_uint, OSSL_NELEM(raw_values)); 701 ADD_ALL_TESTS(test_param_ulong, OSSL_NELEM(raw_values)); 702 ADD_ALL_TESTS(test_param_int32, OSSL_NELEM(raw_values)); 703 ADD_ALL_TESTS(test_param_uint32, OSSL_NELEM(raw_values)); 704 ADD_ALL_TESTS(test_param_size_t, OSSL_NELEM(raw_values)); 705 ADD_ALL_TESTS(test_param_time_t, OSSL_NELEM(raw_values)); 706 ADD_ALL_TESTS(test_param_int64, OSSL_NELEM(raw_values)); 707 ADD_ALL_TESTS(test_param_uint64, OSSL_NELEM(raw_values)); 708 ADD_ALL_TESTS(test_param_bignum, OSSL_NELEM(raw_values)); 709 ADD_TEST(test_param_real); 710 ADD_ALL_TESTS(test_param_construct, 4); 711 ADD_TEST(test_param_modified); 712 ADD_TEST(test_param_copy_null); 713 return 1; 714} 715