1234353Sdim/* 2193323Sed * Copyright 2019-2021 The OpenSSL Project Authors. All Rights Reserved. 3353358Sdim * Copyright (c) 2019, Oracle and/or its affiliates. All rights reserved. 4353358Sdim * 5353358Sdim * Licensed under the Apache License 2.0 (the "License"). You may not use 6193323Sed * this file except in compliance with the License. You can obtain a copy 7193323Sed * in the file LICENSE in the source distribution or at 8193323Sed * https://www.openssl.org/source/license.html 9193323Sed */ 10193323Sed 11193323Sed#include <string.h> 12193323Sed#include "testutil.h" 13193323Sed#include "internal/nelem.h" 14249423Sdim#include "internal/endian.h" 15276479Sdim#include <openssl/params.h> 16193323Sed#include <openssl/bn.h> 17280031Sdim 18249423Sdim/* The maximum size of the static buffers used to test most things */ 19249423Sdim#define MAX_LEN 20 20249423Sdim 21249423Sdimstatic void swap_copy(unsigned char *out, const void *in, size_t len) 22193323Sed{ 23193323Sed size_t j; 24193323Sed 25193323Sed for (j = 0; j < len; j++) 26249423Sdim out[j] = ((unsigned char *)in)[len - j - 1]; 27249423Sdim} 28249423Sdim 29249423Sdim/* 30276479Sdim * A memory copy that converts the native byte ordering either to or from 31249423Sdim * little endian format. 32327952Sdim * 33193323Sed * On a little endian machine copying either is just a memcpy(3), on a 34193323Sed * big endian machine copying from native to or from little endian involves 35193323Sed * byte reversal. 36276479Sdim */ 37276479Sdimstatic void le_copy(unsigned char *out, const void *in, size_t len) 38276479Sdim{ 39276479Sdim DECLARE_IS_ENDIAN; 40224145Sdim 41224145Sdim if (IS_LITTLE_ENDIAN) 42224145Sdim memcpy(out, in, len); 43261991Sdim else 44261991Sdim swap_copy(out, in, len); 45193323Sed} 46193323Sed 47193323Sedstatic const struct { 48193323Sed size_t len; 49193323Sed unsigned char value[MAX_LEN]; 50193323Sed} raw_values[] = { 51193323Sed { 1, { 0x47 } }, 52193323Sed { 1, { 0xd0 } }, 53193323Sed { 2, { 0x01, 0xe9 } }, 54193323Sed { 2, { 0xff, 0x53 } }, 55193323Sed { 3, { 0x16, 0xff, 0x7c } }, 56193323Sed { 3, { 0xa8, 0x9c, 0x0e } }, 57193323Sed { 4, { 0x38, 0x27, 0xbf, 0x3b } }, 58193323Sed { 4, { 0x9f, 0x26, 0x48, 0x22 } }, 59193323Sed { 5, { 0x30, 0x65, 0xfa, 0xe4, 0x81 } }, 60276479Sdim { 5, { 0xd1, 0x76, 0x01, 0x1b, 0xcd } }, 61276479Sdim { 8, { 0x59, 0xb2, 0x1a, 0xe9, 0x2a, 0xd8, 0x46, 0x40 } }, 62276479Sdim { 8, { 0xb4, 0xae, 0xbd, 0xb4, 0xdd, 0x04, 0xb1, 0x4c } }, 63276479Sdim { 16, { 0x61, 0xe8, 0x7e, 0x31, 0xe9, 0x33, 0x83, 0x3d, 64276479Sdim 0x87, 0x99, 0xc7, 0xd8, 0x5d, 0xa9, 0x8b, 0x42 } }, 65276479Sdim { 16, { 0xee, 0x6e, 0x8b, 0xc3, 0xec, 0xcf, 0x37, 0xcc, 66276479Sdim 0x89, 0x67, 0xf2, 0x68, 0x33, 0xa0, 0x14, 0xb0 } }, 67276479Sdim}; 68276479Sdim 69276479Sdimstatic int test_param_type_extra(OSSL_PARAM *param, const unsigned char *cmp, 70276479Sdim size_t width) 71276479Sdim{ 72276479Sdim int32_t i32; 73276479Sdim int64_t i64; 74276479Sdim size_t s, sz; 75276479Sdim unsigned char buf[MAX_LEN]; 76276479Sdim const int bit32 = param->data_size <= sizeof(int32_t); 77276479Sdim const int sizet = param->data_size <= sizeof(size_t); 78276479Sdim const int signd = param->data_type == OSSL_PARAM_INTEGER; 79276479Sdim 80276479Sdim /* 81276479Sdim * Set the unmodified sentinal directly because there is no param array 82276479Sdim * for these tests. 83276479Sdim */ 84276479Sdim param->return_size = OSSL_PARAM_UNMODIFIED; 85276479Sdim if (signd) { 86276479Sdim if ((bit32 && !TEST_true(OSSL_PARAM_get_int32(param, &i32))) 87276479Sdim || !TEST_true(OSSL_PARAM_get_int64(param, &i64))) 88276479Sdim return 0; 89276479Sdim } else { 90276479Sdim if ((bit32 91276479Sdim && !TEST_true(OSSL_PARAM_get_uint32(param, (uint32_t *)&i32))) 92276479Sdim || !TEST_true(OSSL_PARAM_get_uint64(param, (uint64_t *)&i64)) 93276479Sdim || (sizet && !TEST_true(OSSL_PARAM_get_size_t(param, &s)))) 94276479Sdim return 0; 95276479Sdim } 96276479Sdim if (!TEST_false(OSSL_PARAM_modified(param))) 97276479Sdim return 0; 98276479Sdim 99276479Sdim /* Check signed types */ 100276479Sdim if (bit32) { 101280031Sdim le_copy(buf, &i32, sizeof(i32)); 102276479Sdim sz = sizeof(i32) < width ? sizeof(i32) : width; 103276479Sdim if (!TEST_mem_eq(buf, sz, cmp, sz)) 104276479Sdim return 0; 105276479Sdim } 106276479Sdim le_copy(buf, &i64, sizeof(i64)); 107276479Sdim sz = sizeof(i64) < width ? sizeof(i64) : width; 108276479Sdim if (!TEST_mem_eq(buf, sz, cmp, sz)) 109276479Sdim return 0; 110276479Sdim if (sizet && !signd) { 111276479Sdim le_copy(buf, &s, sizeof(s)); 112276479Sdim sz = sizeof(s) < width ? sizeof(s) : width; 113276479Sdim if (!TEST_mem_eq(buf, sz, cmp, sz)) 114276479Sdim return 0; 115276479Sdim } 116276479Sdim 117276479Sdim /* Check a widening write if possible */ 118276479Sdim if (sizeof(size_t) > width) { 119276479Sdim if (signd) { 120276479Sdim if (!TEST_true(OSSL_PARAM_set_int32(param, 12345)) 121276479Sdim || !TEST_true(OSSL_PARAM_get_int64(param, &i64)) 122276479Sdim || !TEST_size_t_eq((size_t)i64, 12345)) 123276479Sdim return 0; 124276479Sdim } else { 125276479Sdim if (!TEST_true(OSSL_PARAM_set_uint32(param, 12345)) 126276479Sdim || !TEST_true(OSSL_PARAM_get_uint64(param, (uint64_t *)&i64)) 127276479Sdim || !TEST_size_t_eq((size_t)i64, 12345)) 128276479Sdim return 0; 129276479Sdim } 130276479Sdim if (!TEST_true(OSSL_PARAM_modified(param))) 131276479Sdim return 0; 132276479Sdim } 133276479Sdim return 1; 134276479Sdim} 135276479Sdim 136276479Sdim/* 137276479Sdim * The test cases for each of the bastic integral types are similar. 138276479Sdim * For each type, a param of that type is set and an attempt to read it 139276479Sdim * get is made. Finally, the above function is called to verify that 140276479Sdim * the params can be read as other types. 141276479Sdim * 142276479Sdim * All the real work is done via byte buffers which are converted to machine 143276479Sdim * byte order and to little endian for comparisons. Narrower values are best 144276479Sdim * compared using little endian because their values and positions don't 145276479Sdim * change. 146276479Sdim */ 147276479Sdim 148276479Sdimstatic int test_param_int(int n) 149276479Sdim{ 150276479Sdim int in, out; 151276479Sdim unsigned char buf[MAX_LEN], cmp[sizeof(int)]; 152276479Sdim const size_t len = raw_values[n].len >= sizeof(int) ? 153276479Sdim sizeof(int) : raw_values[n].len; 154276479Sdim OSSL_PARAM param = OSSL_PARAM_int("a", NULL); 155276479Sdim 156276479Sdim memset(buf, 0, sizeof(buf)); 157276479Sdim le_copy(buf, raw_values[n].value, sizeof(in)); 158276479Sdim memcpy(&in, buf, sizeof(in)); 159276479Sdim param.data = &out; 160276479Sdim if (!TEST_true(OSSL_PARAM_set_int(¶m, in))) 161276479Sdim return 0; 162276479Sdim le_copy(cmp, &out, sizeof(out)); 163276479Sdim if (!TEST_mem_eq(cmp, len, raw_values[n].value, len)) 164276479Sdim return 0; 165276479Sdim in = 0; 166276479Sdim if (!TEST_true(OSSL_PARAM_get_int(¶m, &in))) 167276479Sdim return 0; 168276479Sdim le_copy(cmp, &in, sizeof(in)); 169276479Sdim if (!TEST_mem_eq(cmp, sizeof(in), raw_values[n].value, sizeof(in))) 170276479Sdim return 0; 171276479Sdim param.data = &out; 172276479Sdim return test_param_type_extra(¶m, raw_values[n].value, sizeof(int)); 173280031Sdim} 174276479Sdim 175276479Sdimstatic int test_param_long(int n) 176276479Sdim{ 177276479Sdim long int in, out; 178280031Sdim unsigned char buf[MAX_LEN], cmp[sizeof(long int)]; 179276479Sdim const size_t len = raw_values[n].len >= sizeof(long int) 180276479Sdim ? sizeof(long int) : raw_values[n].len; 181276479Sdim OSSL_PARAM param = OSSL_PARAM_long("a", NULL); 182276479Sdim 183276479Sdim memset(buf, 0, sizeof(buf)); 184276479Sdim le_copy(buf, raw_values[n].value, sizeof(in)); 185276479Sdim memcpy(&in, buf, sizeof(in)); 186276479Sdim param.data = &out; 187276479Sdim if (!TEST_true(OSSL_PARAM_set_long(¶m, in))) 188276479Sdim return 0; 189276479Sdim le_copy(cmp, &out, sizeof(out)); 190276479Sdim if (!TEST_mem_eq(cmp, len, raw_values[n].value, len)) 191276479Sdim return 0; 192276479Sdim in = 0; 193276479Sdim if (!TEST_true(OSSL_PARAM_get_long(¶m, &in))) 194276479Sdim return 0; 195276479Sdim le_copy(cmp, &in, sizeof(in)); 196276479Sdim if (!TEST_mem_eq(cmp, sizeof(in), raw_values[n].value, sizeof(in))) 197276479Sdim return 0; 198276479Sdim param.data = &out; 199276479Sdim return test_param_type_extra(¶m, raw_values[n].value, sizeof(long int)); 200276479Sdim} 201276479Sdim 202276479Sdimstatic int test_param_uint(int n) 203276479Sdim{ 204276479Sdim unsigned int in, out; 205206274Srdivacky unsigned char buf[MAX_LEN], cmp[sizeof(unsigned int)]; 206360784Sdim const size_t len = raw_values[n].len >= sizeof(unsigned int) ? sizeof(unsigned int) : raw_values[n].len; 207193323Sed OSSL_PARAM param = OSSL_PARAM_uint("a", NULL); 208193323Sed 209288943Sdim memset(buf, 0, sizeof(buf)); 210288943Sdim le_copy(buf, raw_values[n].value, sizeof(in)); 211276479Sdim memcpy(&in, buf, sizeof(in)); 212276479Sdim param.data = &out; 213276479Sdim if (!TEST_true(OSSL_PARAM_set_uint(¶m, in))) 214193323Sed return 0; 215276479Sdim le_copy(cmp, &out, sizeof(out)); 216193323Sed if (!TEST_mem_eq(cmp, len, raw_values[n].value, len)) 217193323Sed return 0; 218276479Sdim in = 0; 219276479Sdim if (!TEST_true(OSSL_PARAM_get_uint(¶m, &in))) 220276479Sdim return 0; 221276479Sdim le_copy(cmp, &in, sizeof(in)); 222276479Sdim if (!TEST_mem_eq(cmp, sizeof(in), raw_values[n].value, sizeof(in))) 223288943Sdim return 0; 224276479Sdim param.data = &out; 225276479Sdim return test_param_type_extra(¶m, raw_values[n].value, sizeof(unsigned int)); 226193323Sed} 227193323Sed 228193323Sedstatic int test_param_ulong(int n) 229193323Sed{ 230193323Sed unsigned long int in, out; 231288943Sdim unsigned char buf[MAX_LEN], cmp[sizeof(unsigned long int)]; 232218893Sdim const size_t len = raw_values[n].len >= sizeof(unsigned long int) 233193323Sed ? sizeof(unsigned long int) : raw_values[n].len; 234193323Sed OSSL_PARAM param = OSSL_PARAM_ulong("a", NULL); 235193323Sed 236193323Sed memset(buf, 0, sizeof(buf)); 237218893Sdim le_copy(buf, raw_values[n].value, sizeof(in)); 238193323Sed memcpy(&in, buf, sizeof(in)); 239193323Sed param.data = &out; 240193323Sed if (!TEST_true(OSSL_PARAM_set_ulong(¶m, in))) 241193323Sed return 0; 242193323Sed le_copy(cmp, &out, sizeof(out)); 243193323Sed if (!TEST_mem_eq(cmp, len, raw_values[n].value, len)) 244193323Sed return 0; 245276479Sdim in = 0; 246193323Sed if (!TEST_true(OSSL_PARAM_get_ulong(¶m, &in))) 247193323Sed return 0; 248221345Sdim le_copy(cmp, &in, sizeof(in)); 249239462Sdim if (!TEST_mem_eq(cmp, sizeof(in), raw_values[n].value, sizeof(in))) 250276479Sdim return 0; 251239462Sdim param.data = &out; 252239462Sdim return test_param_type_extra(¶m, raw_values[n].value, sizeof(unsigned long int)); 253239462Sdim} 254221345Sdim 255221345Sdimstatic int test_param_int32(int n) 256221345Sdim{ 257221345Sdim int32_t in, out; 258212904Sdim unsigned char buf[MAX_LEN], cmp[sizeof(int32_t)]; 259198090Srdivacky const size_t len = raw_values[n].len >= sizeof(int32_t) 260249423Sdim ? sizeof(int32_t) : raw_values[n].len; 261249423Sdim OSSL_PARAM param = OSSL_PARAM_int32("a", NULL); 262193323Sed 263193323Sed memset(buf, 0, sizeof(buf)); 264249423Sdim le_copy(buf, raw_values[n].value, sizeof(in)); 265193323Sed memcpy(&in, buf, sizeof(in)); 266193323Sed param.data = &out; 267193323Sed if (!TEST_true(OSSL_PARAM_set_int32(¶m, in))) 268276479Sdim return 0; 269280031Sdim le_copy(cmp, &out, sizeof(out)); 270276479Sdim if (!TEST_mem_eq(cmp, len, raw_values[n].value, len)) 271288943Sdim return 0; 272314564Sdim in = 0; 273314564Sdim if (!TEST_true(OSSL_PARAM_get_int32(¶m, &in))) 274193323Sed return 0; 275193323Sed le_copy(cmp, &in, sizeof(in)); 276341825Sdim if (!TEST_mem_eq(cmp, sizeof(in), raw_values[n].value, sizeof(in))) 277341825Sdim return 0; 278341825Sdim param.data = &out; 279341825Sdim return test_param_type_extra(¶m, raw_values[n].value, sizeof(int32_t)); 280341825Sdim} 281341825Sdim 282341825Sdimstatic int test_param_uint32(int n) 283193323Sed{ 284193323Sed uint32_t in, out; 285224145Sdim unsigned char buf[MAX_LEN], cmp[sizeof(uint32_t)]; 286353358Sdim const size_t len = raw_values[n].len >= sizeof(uint32_t) 287224145Sdim ? sizeof(uint32_t) : raw_values[n].len; 288224145Sdim OSSL_PARAM param = OSSL_PARAM_uint32("a", NULL); 289224145Sdim 290249423Sdim memset(buf, 0, sizeof(buf)); 291249423Sdim le_copy(buf, raw_values[n].value, sizeof(in)); 292224145Sdim memcpy(&in, buf, sizeof(in)); 293224145Sdim param.data = &out; 294224145Sdim if (!TEST_true(OSSL_PARAM_set_uint32(¶m, in))) 295193323Sed return 0; 296249423Sdim le_copy(cmp, &out, sizeof(out)); 297249423Sdim if (!TEST_mem_eq(cmp, len, raw_values[n].value, len)) 298341825Sdim return 0; 299193323Sed in = 0; 300341825Sdim if (!TEST_true(OSSL_PARAM_get_uint32(¶m, &in))) 301341825Sdim return 0; 302193323Sed le_copy(cmp, &in, sizeof(in)); 303341825Sdim if (!TEST_mem_eq(cmp, sizeof(in), raw_values[n].value, sizeof(in))) 304360784Sdim return 0; 305276479Sdim param.data = &out; 306193323Sed return test_param_type_extra(¶m, raw_values[n].value, sizeof(uint32_t)); 307276479Sdim} 308276479Sdim 309276479Sdimstatic int test_param_int64(int n) 310276479Sdim{ 311276479Sdim int64_t in, out; 312193323Sed unsigned char buf[MAX_LEN], cmp[sizeof(int64_t)]; 313276479Sdim const size_t len = raw_values[n].len >= sizeof(int64_t) 314276479Sdim ? sizeof(int64_t) : raw_values[n].len; 315276479Sdim OSSL_PARAM param = OSSL_PARAM_int64("a", NULL); 316276479Sdim 317193323Sed memset(buf, 0, sizeof(buf)); 318193323Sed le_copy(buf, raw_values[n].value, sizeof(in)); 319276479Sdim memcpy(&in, buf, sizeof(in)); 320193323Sed param.data = &out; 321193323Sed if (!TEST_true(OSSL_PARAM_set_int64(¶m, in))) 322193323Sed return 0; 323193323Sed le_copy(cmp, &out, sizeof(out)); 324353358Sdim if (!TEST_mem_eq(cmp, len, raw_values[n].value, len)) 325288943Sdim return 0; 326218893Sdim in = 0; 327218893Sdim if (!TEST_true(OSSL_PARAM_get_int64(¶m, &in))) 328193323Sed 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