xref: /third_party/openssl/test/params_test.c (revision e1051a39)
1/*
2 * Copyright 2019-2021 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 */
37struct 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 arbitrarly 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
87static 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
98static 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
129static 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
170static 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
208static 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
244static 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 */
275struct 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 */
281static const struct provider_dispatch_st provider_raw = {
282    raw_set_params, raw_get_params
283};
284
285/* "api" provider */
286static 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 */
304static int app_p1;                    /* "p1" */
305static double app_p2;                 /* "p2" is ignored */
306static BIGNUM *app_p3 = NULL;         /* "p3" */
307static unsigned char bignumbin[4096]; /* "p3" */
308static char app_p4[256];              /* "p4" */
309static char app_p5[256];              /* "p5" */
310static const char *app_p6 = NULL;     /* "p6" */
311static 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
321static int cleanup_app_variables(void)
322{
323    BN_free(app_p3);
324    app_p3 = NULL;
325    return 1;
326}
327
328static 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 */
352static 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 */
364static 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 */
380static 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
400struct param_owner_st {
401    OSSL_PARAM *static_params;
402    OSSL_PARAM *(*constructed_params)(void);
403};
404
405static const struct param_owner_st raw_params = {
406    static_raw_params, NULL
407};
408
409static 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 */
421static 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 */
436static 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
537static 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
553static 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
564struct 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
572static 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
614static 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
658static int test_allocate_from_text(int i)
659{
660    return check_int_from_text(int_from_text_test_cases[i]);
661}
662
663int 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}
669