test/params_test.c

   1 /*
   2  * Copyright 2019-2022 The OpenSSL Project Authors. All Rights Reserved.
   3  *
   4  * Licensed under the Apache License 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  * https://www.openssl.org/source/license.html
   8  * or in the file LICENSE in the source distribution.
   9  */
  10
  11 /*
  12  * This program tests the use of OSSL_PARAM, currently in raw form.
  13  */
  14
  15 #include <string.h>
  16 #include <openssl/bn.h>
  17 #include <openssl/core.h>
  18 #include <openssl/params.h>
  19 #include "internal/numbers.h"
  20 #include "internal/nelem.h"
  21 #include "testutil.h"
  22
  23 /*-
  24  * PROVIDER SECTION
  25  * ================
  26  *
  27  * Even though it's not necessarily ONLY providers doing this part,
  28  * they are naturally going to be the most common users of
  29  * set_params and get_params functions.
  30  */
  31
  32 /*
  33  * In real use cases, setters and getters would take an object with
  34  * which the parameters are associated.  This structure is a cheap
  35  * simulation.
  36  */
  37 struct object_st {
  38     /*
  39      * Documented as a native integer, of the size given by sizeof(int).
  40      * Assumed data type OSSL_PARAM_INTEGER
  41      */
  42     int p1;
  43     /*
  44      * Documented as a native double, of the size given by sizeof(double).
  45      * Assumed data type OSSL_PARAM_REAL
  46      */
  47     double p2;
  48     /*
  49      * Documented as an arbitrarily large unsigned integer.
  50      * The data size must be large enough to accommodate.
  51      * Assumed data type OSSL_PARAM_UNSIGNED_INTEGER
  52      */
  53     BIGNUM *p3;
  54     /*
  55      * Documented as a C string.
  56      * The data size must be large enough to accommodate.
  57      * Assumed data type OSSL_PARAM_UTF8_STRING
  58      */
  59     char *p4;
  60     size_t p4_l;
  61     /*
  62      * Documented as a C string.
  63      * Assumed data type OSSL_PARAM_UTF8_STRING
  64      */
  65     char p5[256];
  66     size_t p5_l;
  67     /*
  68      * Documented as a pointer to a constant C string.
  69      * Assumed data type OSSL_PARAM_UTF8_PTR
  70      */
  71     const char *p6;
  72     size_t p6_l;
  73 };
  74
  75 #define p1_init 42                              /* The ultimate answer */
  76 #define p2_init 6.283                           /* Magic number */
  77 /* Stolen from evp_data, BLAKE2s256 test */
  78 #define p3_init                                 \
  79     "4142434445464748494a4b4c4d4e4f50"          \
  80     "5152535455565758595a616263646566"          \
  81     "6768696a6b6c6d6e6f70717273747576"          \
  82     "7778797a30313233343536373839"
  83 #define p4_init "BLAKE2s256"                    /* Random string */
  84 #define p5_init "Hellow World"                  /* Random string */
  85 #define p6_init OPENSSL_FULL_VERSION_STR        /* Static string */
  86
  87 static void cleanup_object(void *vobj)
  88 {
  89     struct object_st *obj = vobj;
  90
  91     BN_free(obj->p3);
  92     obj->p3 = NULL;
  93     OPENSSL_free(obj->p4);
  94     obj->p4 = NULL;
  95     OPENSSL_free(obj);
  96 }
  97
  98 static void *init_object(void)
  99 {
 100     struct object_st *obj;
 101
 102     if (!TEST_ptr(obj = OPENSSL_zalloc(sizeof(*obj))))
 103         return NULL;
 104
 105     obj->p1 = p1_init;
 106     obj->p2 = p2_init;
 107     if (!TEST_true(BN_hex2bn(&obj->p3, p3_init)))
 108         goto fail;
 109     if (!TEST_ptr(obj->p4 = OPENSSL_strdup(p4_init)))
 110         goto fail;
 111     strcpy(obj->p5, p5_init);
 112     obj->p6 = p6_init;
 113
 114     return obj;
 115  fail:
 116     cleanup_object(obj);
 117     obj = NULL;
 118
 119     return NULL;
 120 }
 121
 122 /*
 123  * RAW provider, which handles the parameters in a very raw manner,
 124  * with no fancy API and very minimal checking.  The application that
 125  * calls these to set or request parameters MUST get its OSSL_PARAM
 126  * array right.
 127  */
 128
 129 static int raw_set_params(void *vobj, const OSSL_PARAM *params)
 130 {
 131     struct object_st *obj = vobj;
 132
 133     for (; params->key != NULL; params++)
 134         if (strcmp(params->key, "p1") == 0) {
 135             obj->p1 = *(int *)params->data;
 136         } else if (strcmp(params->key, "p2") == 0) {
 137             obj->p2 = *(double *)params->data;
 138         } else if (strcmp(params->key, "p3") == 0) {
 139             BN_free(obj->p3);
 140             if (!TEST_ptr(obj->p3 = BN_native2bn(params->data,
 141                                                  params->data_size, NULL)))
 142                 return 0;
 143         } else if (strcmp(params->key, "p4") == 0) {
 144             OPENSSL_free(obj->p4);
 145             if (!TEST_ptr(obj->p4 = OPENSSL_strndup(params->data,
 146                                                     params->data_size)))
 147                 return 0;
 148             obj->p4_l = strlen(obj->p4);
 149         } else if (strcmp(params->key, "p5") == 0) {
 150             /*
 151              * Protect obj->p5 against too much data.  This should not
 152              * happen, we don't use that long strings.
 153              */
 154             size_t data_length =
 155                 OPENSSL_strnlen(params->data, params->data_size);
 156
 157             if (!TEST_size_t_lt(data_length, sizeof(obj->p5)))
 158                 return 0;
 159             strncpy(obj->p5, params->data, data_length);
 160             obj->p5[data_length] = '\0';
 161             obj->p5_l = strlen(obj->p5);
 162         } else if (strcmp(params->key, "p6") == 0) {
 163             obj->p6 = *(const char **)params->data;
 164             obj->p6_l = params->data_size;
 165         }
 166
 167     return 1;
 168 }
 169
 170 static int raw_get_params(void *vobj, OSSL_PARAM *params)
 171 {
 172     struct object_st *obj = vobj;
 173
 174     for (; params->key != NULL; params++)
 175         if (strcmp(params->key, "p1") == 0) {
 176             params->return_size = sizeof(obj->p1);
 177             *(int *)params->data = obj->p1;
 178         } else if (strcmp(params->key, "p2") == 0) {
 179             params->return_size = sizeof(obj->p2);
 180             *(double *)params->data = obj->p2;
 181         } else if (strcmp(params->key, "p3") == 0) {
 182             params->return_size = BN_num_bytes(obj->p3);
 183             if (!TEST_size_t_ge(params->data_size, params->return_size))
 184                 return 0;
 185             BN_bn2nativepad(obj->p3, params->data, params->return_size);
 186         } else if (strcmp(params->key, "p4") == 0) {
 187             params->return_size = strlen(obj->p4);
 188             if (!TEST_size_t_gt(params->data_size, params->return_size))
 189                 return 0;
 190             strcpy(params->data, obj->p4);
 191         } else if (strcmp(params->key, "p5") == 0) {
 192             params->return_size = strlen(obj->p5);
 193             if (!TEST_size_t_gt(params->data_size, params->return_size))
 194                 return 0;
 195             strcpy(params->data, obj->p5);
 196         } else if (strcmp(params->key, "p6") == 0) {
 197             params->return_size = strlen(obj->p6);
 198             *(const char **)params->data = obj->p6;
 199         }
 200
 201     return 1;
 202 }
 203
 204 /*
 205  * API provider, which handles the parameters using the API from params.h
 206  */
 207
 208 static int api_set_params(void *vobj, const OSSL_PARAM *params)
 209 {
 210     struct object_st *obj = vobj;
 211     const OSSL_PARAM *p = NULL;
 212
 213     if ((p = OSSL_PARAM_locate_const(params, "p1")) != NULL
 214         && !TEST_true(OSSL_PARAM_get_int(p, &obj->p1)))
 215         return 0;
 216     if ((p = OSSL_PARAM_locate_const(params, "p2")) != NULL
 217         && !TEST_true(OSSL_PARAM_get_double(p, &obj->p2)))
 218         return 0;
 219     if ((p = OSSL_PARAM_locate_const(params, "p3")) != NULL
 220         && !TEST_true(OSSL_PARAM_get_BN(p, &obj->p3)))
 221         return 0;
 222     if ((p = OSSL_PARAM_locate_const(params, "p4")) != NULL) {
 223         OPENSSL_free(obj->p4);
 224         obj->p4 = NULL;
 225         /* If the value pointer is NULL, we get it automatically allocated */
 226         if (!TEST_true(OSSL_PARAM_get_utf8_string(p, &obj->p4, 0)))
 227             return 0;
 228     }
 229     if ((p = OSSL_PARAM_locate_const(params, "p5")) != NULL) {
 230         char *p5_ptr = obj->p5;
 231         if (!TEST_true(OSSL_PARAM_get_utf8_string(p, &p5_ptr, sizeof(obj->p5))))
 232             return 0;
 233         obj->p5_l = strlen(obj->p5);
 234     }
 235     if ((p = OSSL_PARAM_locate_const(params, "p6")) != NULL) {
 236         if (!TEST_true(OSSL_PARAM_get_utf8_ptr(p, &obj->p6)))
 237             return 0;
 238         obj->p6_l = strlen(obj->p6);
 239     }
 240
 241     return 1;
 242 }
 243
 244 static int api_get_params(void *vobj, OSSL_PARAM *params)
 245 {
 246     struct object_st *obj = vobj;
 247     OSSL_PARAM *p = NULL;
 248
 249     if ((p = OSSL_PARAM_locate(params, "p1")) != NULL
 250         && !TEST_true(OSSL_PARAM_set_int(p, obj->p1)))
 251         return 0;
 252     if ((p = OSSL_PARAM_locate(params, "p2")) != NULL
 253         && !TEST_true(OSSL_PARAM_set_double(p, obj->p2)))
 254         return 0;
 255     if ((p = OSSL_PARAM_locate(params, "p3")) != NULL
 256         && !TEST_true(OSSL_PARAM_set_BN(p, obj->p3)))
 257         return 0;
 258     if ((p = OSSL_PARAM_locate(params, "p4")) != NULL
 259         && !TEST_true(OSSL_PARAM_set_utf8_string(p, obj->p4)))
 260         return 0;
 261     if ((p = OSSL_PARAM_locate(params, "p5")) != NULL
 262         && !TEST_true(OSSL_PARAM_set_utf8_string(p, obj->p5)))
 263         return 0;
 264     if ((p = OSSL_PARAM_locate(params, "p6")) != NULL
 265         && !TEST_true(OSSL_PARAM_set_utf8_ptr(p, obj->p6)))
 266         return 0;
 267
 268     return 1;
 269 }
 270
 271 /*
 272  * This structure only simulates a provider dispatch, the real deal is
 273  * a bit more code that's not necessary in these tests.
 274  */
 275 struct provider_dispatch_st {
 276     int (*set_params)(void *obj, const OSSL_PARAM *params);
 277     int (*get_params)(void *obj, OSSL_PARAM *params);
 278 };
 279
 280 /* "raw" provider */
 281 static const struct provider_dispatch_st provider_raw = {
 282     raw_set_params, raw_get_params
 283 };
 284
 285 /* "api" provider */
 286 static const struct provider_dispatch_st provider_api = {
 287     api_set_params, api_get_params
 288 };
 289
 290 /*-
 291  * APPLICATION SECTION
 292  * ===================
 293  */
 294
 295 /* In all our tests, these are variables that get manipulated as parameters
 296  *
 297  * These arrays consistently do nothing with the "p2" parameter, and
 298  * always include a "foo" parameter.  This is to check that the
 299  * set_params and get_params calls ignore the lack of parameters that
 300  * the application isn't interested in, as well as ignore parameters
 301  * they don't understand (the application may have one big bag of
 302  * parameters).
 303  */
 304 static int app_p1;                    /* "p1" */
 305 static double app_p2;                 /* "p2" is ignored */
 306 static BIGNUM *app_p3 = NULL;         /* "p3" */
 307 static unsigned char bignumbin[4096]; /* "p3" */
 308 static char app_p4[256];              /* "p4" */
 309 static char app_p5[256];              /* "p5" */
 310 static const char *app_p6 = NULL;     /* "p6" */
 311 static unsigned char foo[1];          /* "foo" */
 312
 313 #define app_p1_init 17           /* A random number */
 314 #define app_p2_init 47.11        /* Another random number */
 315 #define app_p3_init "deadbeef"   /* Classic */
 316 #define app_p4_init "Hello"
 317 #define app_p5_init "World"
 318 #define app_p6_init "Cookie"
 319 #define app_foo_init 'z'
 320
 321 static int cleanup_app_variables(void)
 322 {
 323     BN_free(app_p3);
 324     app_p3 = NULL;
 325     return 1;
 326 }
 327
 328 static int init_app_variables(void)
 329 {
 330     int l = 0;
 331
 332     cleanup_app_variables();
 333
 334     app_p1 = app_p1_init;
 335     app_p2 = app_p2_init;
 336     if (!BN_hex2bn(&app_p3, app_p3_init)
 337         || (l = BN_bn2nativepad(app_p3, bignumbin, sizeof(bignumbin))) < 0)
 338         return 0;
 339     strcpy(app_p4, app_p4_init);
 340     strcpy(app_p5, app_p5_init);
 341     app_p6 = app_p6_init;
 342     foo[0] = app_foo_init;
 343
 344     return 1;
 345 }
 346
 347 /*
 348  * Here, we define test OSSL_PARAM arrays
 349  */
 350
 351 /* An array of OSSL_PARAM, specific in the most raw manner possible */
 352 static OSSL_PARAM static_raw_params[] = {
 353     { "p1", OSSL_PARAM_INTEGER, &app_p1, sizeof(app_p1), 0 },
 354     { "p3", OSSL_PARAM_UNSIGNED_INTEGER, &bignumbin, sizeof(bignumbin), 0 },
 355     { "p4", OSSL_PARAM_UTF8_STRING, &app_p4, sizeof(app_p4), 0 },
 356     { "p5", OSSL_PARAM_UTF8_STRING, &app_p5, sizeof(app_p5), 0 },
 357     /* sizeof(app_p6_init) - 1, because we know that's what we're using */
 358     { "p6", OSSL_PARAM_UTF8_PTR, &app_p6, sizeof(app_p6_init) - 1, 0 },
 359     { "foo", OSSL_PARAM_OCTET_STRING, &foo, sizeof(foo), 0 },
 360     { NULL, 0, NULL, 0, 0 }
 361 };
 362
 363 /* The same array of OSSL_PARAM, specified with the macros from params.h */
 364 static OSSL_PARAM static_api_params[] = {
 365     OSSL_PARAM_int("p1", &app_p1),
 366     OSSL_PARAM_BN("p3", &bignumbin, sizeof(bignumbin)),
 367     OSSL_PARAM_DEFN("p4", OSSL_PARAM_UTF8_STRING, &app_p4, sizeof(app_p4)),
 368     OSSL_PARAM_DEFN("p5", OSSL_PARAM_UTF8_STRING, &app_p5, sizeof(app_p5)),
 369     /* sizeof(app_p6_init), because we know that's what we're using */
 370     OSSL_PARAM_DEFN("p6", OSSL_PARAM_UTF8_PTR, &app_p6,
 371                     sizeof(app_p6_init) - 1),
 372     OSSL_PARAM_DEFN("foo", OSSL_PARAM_OCTET_STRING, &foo, sizeof(foo)),
 373     OSSL_PARAM_END
 374 };
 375
 376 /*
 377  * The same array again, but constructed at run-time
 378  * This exercises the OSSL_PARAM constructor functions
 379  */
 380 static OSSL_PARAM *construct_api_params(void)
 381 {
 382     size_t n = 0;
 383     static OSSL_PARAM params[10];
 384
 385     params[n++] = OSSL_PARAM_construct_int("p1", &app_p1);
 386     params[n++] = OSSL_PARAM_construct_BN("p3", bignumbin, sizeof(bignumbin));
 387     params[n++] = OSSL_PARAM_construct_utf8_string("p4", app_p4,
 388                                                    sizeof(app_p4));
 389     params[n++] = OSSL_PARAM_construct_utf8_string("p5", app_p5,
 390                                                    sizeof(app_p5));
 391     /* sizeof(app_p6_init), because we know that's what we're using */
 392     params[n++] = OSSL_PARAM_construct_utf8_ptr("p6", (char **)&app_p6,
 393                                                 sizeof(app_p6_init));
 394     params[n++] = OSSL_PARAM_construct_octet_string("foo", &foo, sizeof(foo));
 395     params[n++] = OSSL_PARAM_construct_end();
 396
 397     return params;
 398 }
 399
 400 struct param_owner_st {
 401     OSSL_PARAM *static_params;
 402     OSSL_PARAM *(*constructed_params)(void);
 403 };
 404
 405 static const struct param_owner_st raw_params = {
 406     static_raw_params, NULL
 407 };
 408
 409 static const struct param_owner_st api_params = {
 410     static_api_params, construct_api_params
 411 };
 412
 413 /*-
 414  * TESTING
 415  * =======
 416  */
 417
 418 /*
 419  * Test cases to combine parameters with "provider side" functions
 420  */
 421 static struct {
 422     const struct provider_dispatch_st *prov;
 423     const struct param_owner_st *app;
 424     const char *desc;
 425 } test_cases[] = {
 426     /* Tests within specific methods */
 427     { &provider_raw, &raw_params, "raw provider vs raw params" },
 428     { &provider_api, &api_params, "api provider vs api params" },
 429
 430     /* Mixed methods */
 431     { &provider_raw, &api_params, "raw provider vs api params" },
 432     { &provider_api, &raw_params, "api provider vs raw params" },
 433 };
 434
 435 /* Generic tester of combinations of "providers" and params */
 436 static int test_case_variant(OSSL_PARAM *params, const struct provider_dispatch_st *prov)
 437 {
 438     BIGNUM *verify_p3 = NULL;
 439     void *obj = NULL;
 440     int errcnt = 0;
 441     OSSL_PARAM *p;
 442
 443     /*
 444      * Initialize
 445      */
 446     if (!TEST_ptr(obj = init_object())
 447         || !TEST_true(BN_hex2bn(&verify_p3, p3_init))) {
 448         errcnt++;
 449         goto fin;
 450     }
 451
 452     /*
 453      * Get parameters a first time, just to see that getting works and
 454      * gets us the values we expect.
 455      */
 456     init_app_variables();
 457
 458     if (!TEST_true(prov->get_params(obj, params))
 459         || !TEST_int_eq(app_p1, p1_init)        /* "provider" value */
 460         || !TEST_double_eq(app_p2, app_p2_init) /* Should remain untouched */
 461         || !TEST_ptr(p = OSSL_PARAM_locate(params, "p3"))
 462         || !TEST_ptr(BN_native2bn(bignumbin, p->return_size, app_p3))
 463         || !TEST_BN_eq(app_p3, verify_p3)       /* "provider" value */
 464         || !TEST_str_eq(app_p4, p4_init)        /* "provider" value */
 465         || !TEST_ptr(p = OSSL_PARAM_locate(params, "p5"))
 466         || !TEST_size_t_eq(p->return_size,
 467                            sizeof(p5_init) - 1) /* "provider" value */
 468         || !TEST_str_eq(app_p5, p5_init)        /* "provider" value */
 469         || !TEST_ptr(p = OSSL_PARAM_locate(params, "p6"))
 470         || !TEST_size_t_eq(p->return_size,
 471                            sizeof(p6_init) - 1) /* "provider" value */
 472         || !TEST_str_eq(app_p6, p6_init)        /* "provider" value */
 473         || !TEST_char_eq(foo[0], app_foo_init)  /* Should remain untouched */
 474         || !TEST_ptr(p = OSSL_PARAM_locate(params, "foo")))
 475         errcnt++;
 476
 477     /*
 478      * Set parameters, then sneak into the object itself and check
 479      * that its attributes got set (or ignored) properly.
 480      */
 481     init_app_variables();
 482
 483     if (!TEST_true(prov->set_params(obj, params))) {
 484         errcnt++;
 485     } else {
 486         struct object_st *sneakpeek = obj;
 487
 488         if (!TEST_int_eq(sneakpeek->p1, app_p1)         /* app value set */
 489             || !TEST_double_eq(sneakpeek->p2, p2_init)  /* Should remain untouched */
 490             || !TEST_BN_eq(sneakpeek->p3, app_p3)       /* app value set */
 491             || !TEST_str_eq(sneakpeek->p4, app_p4)      /* app value set */
 492             || !TEST_str_eq(sneakpeek->p5, app_p5)      /* app value set */
 493             || !TEST_str_eq(sneakpeek->p6, app_p6))     /* app value set */
 494             errcnt++;
 495     }
 496
 497     /*
 498      * Get parameters again, checking that we get different values
 499      * than earlier where relevant.
 500      */
 501     BN_free(verify_p3);
 502     verify_p3 = NULL;
 503
 504     if (!TEST_true(BN_hex2bn(&verify_p3, app_p3_init))) {
 505         errcnt++;
 506         goto fin;
 507     }
 508
 509     if (!TEST_true(prov->get_params(obj, params))
 510         || !TEST_int_eq(app_p1, app_p1_init)    /* app value */
 511         || !TEST_double_eq(app_p2, app_p2_init) /* Should remain untouched */
 512         || !TEST_ptr(p = OSSL_PARAM_locate(params, "p3"))
 513         || !TEST_ptr(BN_native2bn(bignumbin, p->return_size, app_p3))
 514         || !TEST_BN_eq(app_p3, verify_p3)       /* app value */
 515         || !TEST_str_eq(app_p4, app_p4_init)    /* app value */
 516         || !TEST_ptr(p = OSSL_PARAM_locate(params, "p5"))
 517         || !TEST_size_t_eq(p->return_size,
 518                            sizeof(app_p5_init) - 1) /* app value */
 519         || !TEST_str_eq(app_p5, app_p5_init)    /* app value */
 520         || !TEST_ptr(p = OSSL_PARAM_locate(params, "p6"))
 521         || !TEST_size_t_eq(p->return_size,
 522                            sizeof(app_p6_init) - 1) /* app value */
 523         || !TEST_str_eq(app_p6, app_p6_init)    /* app value */
 524         || !TEST_char_eq(foo[0], app_foo_init)  /* Should remain untouched */
 525         || !TEST_ptr(p = OSSL_PARAM_locate(params, "foo")))
 526         errcnt++;
 527
 528  fin:
 529     BN_free(verify_p3);
 530     verify_p3 = NULL;
 531     cleanup_app_variables();
 532     cleanup_object(obj);
 533
 534     return errcnt == 0;
 535 }
 536
 537 static int test_case(int i)
 538 {
 539     TEST_info("Case: %s", test_cases[i].desc);
 540
 541     return test_case_variant(test_cases[i].app->static_params,
 542                              test_cases[i].prov)
 543         && (test_cases[i].app->constructed_params == NULL
 544             || test_case_variant(test_cases[i].app->constructed_params(),
 545                                  test_cases[i].prov));
 546 }
 547
 548 /*-
 549  * OSSL_PARAM_allocate_from_text() tests
 550  * =====================================
 551  */
 552
 553 static const OSSL_PARAM params_from_text[] = {
 554     /* Fixed size buffer */
 555     OSSL_PARAM_int32("int", NULL),
 556     OSSL_PARAM_DEFN("short", OSSL_PARAM_INTEGER, NULL, sizeof(int16_t)),
 557     OSSL_PARAM_DEFN("ushort", OSSL_PARAM_UNSIGNED_INTEGER, NULL, sizeof(uint16_t)),
 558     /* Arbitrary size buffer.  Make sure the result fits in a long */
 559     OSSL_PARAM_DEFN("num", OSSL_PARAM_INTEGER, NULL, 0),
 560     OSSL_PARAM_DEFN("unum", OSSL_PARAM_UNSIGNED_INTEGER, NULL, 0),
 561     OSSL_PARAM_END,
 562 };
 563
 564 struct int_from_text_test_st {
 565     const char *argname;
 566     const char *strval;
 567     long int expected_intval;
 568     int expected_res;
 569     size_t expected_bufsize;
 570 };
 571
 572 static struct int_from_text_test_st int_from_text_test_cases[] = {
 573     { "int",               "",          0, 0, 0 },
 574     { "int",              "0",          0, 1, 4 },
 575     { "int",            "101",        101, 1, 4 },
 576     { "int",           "-102",       -102, 1, 4 },
 577     { "int",            "12A",         12, 1, 4 }, /* incomplete */
 578     { "int",          "0x12B",      0x12B, 1, 4 },
 579     { "hexint",         "12C",      0x12C, 1, 4 },
 580     { "hexint",       "0x12D",          0, 1, 4 }, /* zero */
 581     /* test check of the target buffer size */
 582     { "int",     "0x7fffffff",  INT32_MAX, 1, 4 },
 583     { "int",     "2147483647",  INT32_MAX, 1, 4 },
 584     { "int",     "2147483648",          0, 0, 0 }, /* too small buffer */
 585     { "int",    "-2147483648",  INT32_MIN, 1, 4 },
 586     { "int",    "-2147483649",          0, 0, 4 }, /* too small buffer */
 587     { "short",       "0x7fff",  INT16_MAX, 1, 2 },
 588     { "short",        "32767",  INT16_MAX, 1, 2 },
 589     { "short",        "32768",          0, 0, 0 }, /* too small buffer */
 590     { "ushort",      "0xffff", UINT16_MAX, 1, 2 },
 591     { "ushort",       "65535", UINT16_MAX, 1, 2 },
 592     { "ushort",       "65536",          0, 0, 0 }, /* too small buffer */
 593     /* test check of sign extension in arbitrary size results */
 594     { "num",              "0",          0, 1, 1 },
 595     { "num",              "0",          0, 1, 1 },
 596     { "num",           "0xff",       0xff, 1, 2 }, /* sign extension */
 597     { "num",          "-0xff",      -0xff, 1, 2 }, /* sign extension */
 598     { "num",           "0x7f",       0x7f, 1, 1 }, /* no sign extension */
 599     { "num",          "-0x7f",      -0x7f, 1, 1 }, /* no sign extension */
 600     { "num",           "0x80",       0x80, 1, 2 }, /* sign extension */
 601     { "num",          "-0x80",      -0x80, 1, 1 }, /* no sign extension */
 602     { "num",           "0x81",       0x81, 1, 2 }, /* sign extension */
 603     { "num",          "-0x81",      -0x81, 1, 2 }, /* sign extension */
 604     { "unum",          "0xff",       0xff, 1, 1 },
 605     { "unum",         "-0xff",      -0xff, 0, 0 }, /* invalid neg number */
 606     { "unum",          "0x7f",       0x7f, 1, 1 },
 607     { "unum",         "-0x7f",      -0x7f, 0, 0 }, /* invalid neg number */
 608     { "unum",          "0x80",       0x80, 1, 1 },
 609     { "unum",         "-0x80",      -0x80, 0, 0 }, /* invalid neg number */
 610     { "unum",          "0x81",       0x81, 1, 1 },
 611     { "unum",         "-0x81",      -0x81, 0, 0 }, /* invalid neg number */
 612 };
 613
 614 static int check_int_from_text(const struct int_from_text_test_st a)
 615 {
 616     OSSL_PARAM param;
 617     long int val = 0;
 618     int res;
 619
 620     if (!OSSL_PARAM_allocate_from_text(&param, params_from_text,
 621                                        a.argname, a.strval, 0, NULL)) {
 622         if (a.expected_res)
 623             TEST_error("unexpected OSSL_PARAM_allocate_from_text() return for %s \"%s\"",
 624                        a.argname, a.strval);
 625         return !a.expected_res;
 626     }
 627
 628     /* For data size zero, OSSL_PARAM_get_long() may crash */
 629     if (param.data_size == 0) {
 630         OPENSSL_free(param.data);
 631         TEST_error("unexpected zero size for %s \"%s\"",
 632                    a.argname, a.strval);
 633         return 0;
 634     }
 635     res = OSSL_PARAM_get_long(&param, &val);
 636     OPENSSL_free(param.data);
 637
 638     if (res ^ a.expected_res) {
 639         TEST_error("unexpected OSSL_PARAM_get_long() return for %s \"%s\": "
 640                    "%d != %d", a.argname, a.strval, a.expected_res, res);
 641         return 0;
 642     }
 643     if (val != a.expected_intval) {
 644         TEST_error("unexpected result for %s \"%s\":  %li != %li",
 645                    a.argname, a.strval, a.expected_intval, val);
 646         return 0;
 647     }
 648     if (param.data_size != a.expected_bufsize) {
 649         TEST_error("unexpected size for %s \"%s\":  %d != %d",
 650                    a.argname, a.strval,
 651                    (int)a.expected_bufsize, (int)param.data_size);
 652         return 0;
 653     }
 654
 655     return a.expected_res;
 656 }
 657
 658 static int test_allocate_from_text(int i)
 659 {
 660     return check_int_from_text(int_from_text_test_cases[i]);
 661 }
 662
 663 int setup_tests(void)
 664 {
 665     ADD_ALL_TESTS(test_case, OSSL_NELEM(test_cases));
 666     ADD_ALL_TESTS(test_allocate_from_text, OSSL_NELEM(int_from_text_test_cases));
 667     return 1;
 668 }