/* * Copyright 2019-2022 The OpenSSL Project Authors. All Rights Reserved. * * Licensed under the Apache License 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * https://www.openssl.org/source/license.html * or in the file LICENSE in the source distribution. */ /* * This program tests the use of OSSL_PARAM, currently in raw form. */ #include #include #include #include #include "internal/numbers.h" #include "internal/nelem.h" #include "testutil.h" /*- * PROVIDER SECTION * ================ * * Even though it's not necessarily ONLY providers doing this part, * they are naturally going to be the most common users of * set_params and get_params functions. */ /* * In real use cases, setters and getters would take an object with * which the parameters are associated. This structure is a cheap * simulation. */ struct object_st { /* * Documented as a native integer, of the size given by sizeof(int). * Assumed data type OSSL_PARAM_INTEGER */ int p1; /* * Documented as a native double, of the size given by sizeof(double). * Assumed data type OSSL_PARAM_REAL */ double p2; /* * Documented as an arbitrarily large unsigned integer. * The data size must be large enough to accommodate. * Assumed data type OSSL_PARAM_UNSIGNED_INTEGER */ BIGNUM *p3; /* * Documented as a C string. * The data size must be large enough to accommodate. * Assumed data type OSSL_PARAM_UTF8_STRING */ char *p4; size_t p4_l; /* * Documented as a C string. * Assumed data type OSSL_PARAM_UTF8_STRING */ char p5[256]; size_t p5_l; /* * Documented as a pointer to a constant C string. * Assumed data type OSSL_PARAM_UTF8_PTR */ const char *p6; size_t p6_l; }; #define p1_init 42 /* The ultimate answer */ #define p2_init 6.283 /* Magic number */ /* Stolen from evp_data, BLAKE2s256 test */ #define p3_init \ "4142434445464748494a4b4c4d4e4f50" \ "5152535455565758595a616263646566" \ "6768696a6b6c6d6e6f70717273747576" \ "7778797a30313233343536373839" #define p4_init "BLAKE2s256" /* Random string */ #define p5_init "Hellow World" /* Random string */ #define p6_init OPENSSL_FULL_VERSION_STR /* Static string */ static void cleanup_object(void *vobj) { struct object_st *obj = vobj; BN_free(obj->p3); obj->p3 = NULL; OPENSSL_free(obj->p4); obj->p4 = NULL; OPENSSL_free(obj); } static void *init_object(void) { struct object_st *obj; if (!TEST_ptr(obj = OPENSSL_zalloc(sizeof(*obj)))) return NULL; obj->p1 = p1_init; obj->p2 = p2_init; if (!TEST_true(BN_hex2bn(&obj->p3, p3_init))) goto fail; if (!TEST_ptr(obj->p4 = OPENSSL_strdup(p4_init))) goto fail; strcpy(obj->p5, p5_init); obj->p6 = p6_init; return obj; fail: cleanup_object(obj); obj = NULL; return NULL; } /* * RAW provider, which handles the parameters in a very raw manner, * with no fancy API and very minimal checking. The application that * calls these to set or request parameters MUST get its OSSL_PARAM * array right. */ static int raw_set_params(void *vobj, const OSSL_PARAM *params) { struct object_st *obj = vobj; for (; params->key != NULL; params++) if (strcmp(params->key, "p1") == 0) { obj->p1 = *(int *)params->data; } else if (strcmp(params->key, "p2") == 0) { obj->p2 = *(double *)params->data; } else if (strcmp(params->key, "p3") == 0) { BN_free(obj->p3); if (!TEST_ptr(obj->p3 = BN_native2bn(params->data, params->data_size, NULL))) return 0; } else if (strcmp(params->key, "p4") == 0) { OPENSSL_free(obj->p4); if (!TEST_ptr(obj->p4 = OPENSSL_strndup(params->data, params->data_size))) return 0; obj->p4_l = strlen(obj->p4); } else if (strcmp(params->key, "p5") == 0) { /* * Protect obj->p5 against too much data. This should not * happen, we don't use that long strings. */ size_t data_length = OPENSSL_strnlen(params->data, params->data_size); if (!TEST_size_t_lt(data_length, sizeof(obj->p5))) return 0; strncpy(obj->p5, params->data, data_length); obj->p5[data_length] = '\0'; obj->p5_l = strlen(obj->p5); } else if (strcmp(params->key, "p6") == 0) { obj->p6 = *(const char **)params->data; obj->p6_l = params->data_size; } return 1; } static int raw_get_params(void *vobj, OSSL_PARAM *params) { struct object_st *obj = vobj; for (; params->key != NULL; params++) if (strcmp(params->key, "p1") == 0) { params->return_size = sizeof(obj->p1); *(int *)params->data = obj->p1; } else if (strcmp(params->key, "p2") == 0) { params->return_size = sizeof(obj->p2); *(double *)params->data = obj->p2; } else if (strcmp(params->key, "p3") == 0) { params->return_size = BN_num_bytes(obj->p3); if (!TEST_size_t_ge(params->data_size, params->return_size)) return 0; BN_bn2nativepad(obj->p3, params->data, params->return_size); } else if (strcmp(params->key, "p4") == 0) { params->return_size = strlen(obj->p4); if (!TEST_size_t_gt(params->data_size, params->return_size)) return 0; strcpy(params->data, obj->p4); } else if (strcmp(params->key, "p5") == 0) { params->return_size = strlen(obj->p5); if (!TEST_size_t_gt(params->data_size, params->return_size)) return 0; strcpy(params->data, obj->p5); } else if (strcmp(params->key, "p6") == 0) { params->return_size = strlen(obj->p6); *(const char **)params->data = obj->p6; } return 1; } /* * API provider, which handles the parameters using the API from params.h */ static int api_set_params(void *vobj, const OSSL_PARAM *params) { struct object_st *obj = vobj; const OSSL_PARAM *p = NULL; if ((p = OSSL_PARAM_locate_const(params, "p1")) != NULL && !TEST_true(OSSL_PARAM_get_int(p, &obj->p1))) return 0; if ((p = OSSL_PARAM_locate_const(params, "p2")) != NULL && !TEST_true(OSSL_PARAM_get_double(p, &obj->p2))) return 0; if ((p = OSSL_PARAM_locate_const(params, "p3")) != NULL && !TEST_true(OSSL_PARAM_get_BN(p, &obj->p3))) return 0; if ((p = OSSL_PARAM_locate_const(params, "p4")) != NULL) { OPENSSL_free(obj->p4); obj->p4 = NULL; /* If the value pointer is NULL, we get it automatically allocated */ if (!TEST_true(OSSL_PARAM_get_utf8_string(p, &obj->p4, 0))) return 0; } if ((p = OSSL_PARAM_locate_const(params, "p5")) != NULL) { char *p5_ptr = obj->p5; if (!TEST_true(OSSL_PARAM_get_utf8_string(p, &p5_ptr, sizeof(obj->p5)))) return 0; obj->p5_l = strlen(obj->p5); } if ((p = OSSL_PARAM_locate_const(params, "p6")) != NULL) { if (!TEST_true(OSSL_PARAM_get_utf8_ptr(p, &obj->p6))) return 0; obj->p6_l = strlen(obj->p6); } return 1; } static int api_get_params(void *vobj, OSSL_PARAM *params) { struct object_st *obj = vobj; OSSL_PARAM *p = NULL; if ((p = OSSL_PARAM_locate(params, "p1")) != NULL && !TEST_true(OSSL_PARAM_set_int(p, obj->p1))) return 0; if ((p = OSSL_PARAM_locate(params, "p2")) != NULL && !TEST_true(OSSL_PARAM_set_double(p, obj->p2))) return 0; if ((p = OSSL_PARAM_locate(params, "p3")) != NULL && !TEST_true(OSSL_PARAM_set_BN(p, obj->p3))) return 0; if ((p = OSSL_PARAM_locate(params, "p4")) != NULL && !TEST_true(OSSL_PARAM_set_utf8_string(p, obj->p4))) return 0; if ((p = OSSL_PARAM_locate(params, "p5")) != NULL && !TEST_true(OSSL_PARAM_set_utf8_string(p, obj->p5))) return 0; if ((p = OSSL_PARAM_locate(params, "p6")) != NULL && !TEST_true(OSSL_PARAM_set_utf8_ptr(p, obj->p6))) return 0; return 1; } /* * This structure only simulates a provider dispatch, the real deal is * a bit more code that's not necessary in these tests. */ struct provider_dispatch_st { int (*set_params)(void *obj, const OSSL_PARAM *params); int (*get_params)(void *obj, OSSL_PARAM *params); }; /* "raw" provider */ static const struct provider_dispatch_st provider_raw = { raw_set_params, raw_get_params }; /* "api" provider */ static const struct provider_dispatch_st provider_api = { api_set_params, api_get_params }; /*- * APPLICATION SECTION * =================== */ /* In all our tests, these are variables that get manipulated as parameters * * These arrays consistently do nothing with the "p2" parameter, and * always include a "foo" parameter. This is to check that the * set_params and get_params calls ignore the lack of parameters that * the application isn't interested in, as well as ignore parameters * they don't understand (the application may have one big bag of * parameters). */ static int app_p1; /* "p1" */ static double app_p2; /* "p2" is ignored */ static BIGNUM *app_p3 = NULL; /* "p3" */ static unsigned char bignumbin[4096]; /* "p3" */ static char app_p4[256]; /* "p4" */ static char app_p5[256]; /* "p5" */ static const char *app_p6 = NULL; /* "p6" */ static unsigned char foo[1]; /* "foo" */ #define app_p1_init 17 /* A random number */ #define app_p2_init 47.11 /* Another random number */ #define app_p3_init "deadbeef" /* Classic */ #define app_p4_init "Hello" #define app_p5_init "World" #define app_p6_init "Cookie" #define app_foo_init 'z' static int cleanup_app_variables(void) { BN_free(app_p3); app_p3 = NULL; return 1; } static int init_app_variables(void) { int l = 0; cleanup_app_variables(); app_p1 = app_p1_init; app_p2 = app_p2_init; if (!BN_hex2bn(&app_p3, app_p3_init) || (l = BN_bn2nativepad(app_p3, bignumbin, sizeof(bignumbin))) < 0) return 0; strcpy(app_p4, app_p4_init); strcpy(app_p5, app_p5_init); app_p6 = app_p6_init; foo[0] = app_foo_init; return 1; } /* * Here, we define test OSSL_PARAM arrays */ /* An array of OSSL_PARAM, specific in the most raw manner possible */ static OSSL_PARAM static_raw_params[] = { { "p1", OSSL_PARAM_INTEGER, &app_p1, sizeof(app_p1), 0 }, { "p3", OSSL_PARAM_UNSIGNED_INTEGER, &bignumbin, sizeof(bignumbin), 0 }, { "p4", OSSL_PARAM_UTF8_STRING, &app_p4, sizeof(app_p4), 0 }, { "p5", OSSL_PARAM_UTF8_STRING, &app_p5, sizeof(app_p5), 0 }, /* sizeof(app_p6_init) - 1, because we know that's what we're using */ { "p6", OSSL_PARAM_UTF8_PTR, &app_p6, sizeof(app_p6_init) - 1, 0 }, { "foo", OSSL_PARAM_OCTET_STRING, &foo, sizeof(foo), 0 }, { NULL, 0, NULL, 0, 0 } }; /* The same array of OSSL_PARAM, specified with the macros from params.h */ static OSSL_PARAM static_api_params[] = { OSSL_PARAM_int("p1", &app_p1), OSSL_PARAM_BN("p3", &bignumbin, sizeof(bignumbin)), OSSL_PARAM_DEFN("p4", OSSL_PARAM_UTF8_STRING, &app_p4, sizeof(app_p4)), OSSL_PARAM_DEFN("p5", OSSL_PARAM_UTF8_STRING, &app_p5, sizeof(app_p5)), /* sizeof(app_p6_init), because we know that's what we're using */ OSSL_PARAM_DEFN("p6", OSSL_PARAM_UTF8_PTR, &app_p6, sizeof(app_p6_init) - 1), OSSL_PARAM_DEFN("foo", OSSL_PARAM_OCTET_STRING, &foo, sizeof(foo)), OSSL_PARAM_END }; /* * The same array again, but constructed at run-time * This exercises the OSSL_PARAM constructor functions */ static OSSL_PARAM *construct_api_params(void) { size_t n = 0; static OSSL_PARAM params[10]; params[n++] = OSSL_PARAM_construct_int("p1", &app_p1); params[n++] = OSSL_PARAM_construct_BN("p3", bignumbin, sizeof(bignumbin)); params[n++] = OSSL_PARAM_construct_utf8_string("p4", app_p4, sizeof(app_p4)); params[n++] = OSSL_PARAM_construct_utf8_string("p5", app_p5, sizeof(app_p5)); /* sizeof(app_p6_init), because we know that's what we're using */ params[n++] = OSSL_PARAM_construct_utf8_ptr("p6", (char **)&app_p6, sizeof(app_p6_init)); params[n++] = OSSL_PARAM_construct_octet_string("foo", &foo, sizeof(foo)); params[n++] = OSSL_PARAM_construct_end(); return params; } struct param_owner_st { OSSL_PARAM *static_params; OSSL_PARAM *(*constructed_params)(void); }; static const struct param_owner_st raw_params = { static_raw_params, NULL }; static const struct param_owner_st api_params = { static_api_params, construct_api_params }; /*- * TESTING * ======= */ /* * Test cases to combine parameters with "provider side" functions */ static struct { const struct provider_dispatch_st *prov; const struct param_owner_st *app; const char *desc; } test_cases[] = { /* Tests within specific methods */ { &provider_raw, &raw_params, "raw provider vs raw params" }, { &provider_api, &api_params, "api provider vs api params" }, /* Mixed methods */ { &provider_raw, &api_params, "raw provider vs api params" }, { &provider_api, &raw_params, "api provider vs raw params" }, }; /* Generic tester of combinations of "providers" and params */ static int test_case_variant(OSSL_PARAM *params, const struct provider_dispatch_st *prov) { BIGNUM *verify_p3 = NULL; void *obj = NULL; int errcnt = 0; OSSL_PARAM *p; /* * Initialize */ if (!TEST_ptr(obj = init_object()) || !TEST_true(BN_hex2bn(&verify_p3, p3_init))) { errcnt++; goto fin; } /* * Get parameters a first time, just to see that getting works and * gets us the values we expect. */ init_app_variables(); if (!TEST_true(prov->get_params(obj, params)) || !TEST_int_eq(app_p1, p1_init) /* "provider" value */ || !TEST_double_eq(app_p2, app_p2_init) /* Should remain untouched */ || !TEST_ptr(p = OSSL_PARAM_locate(params, "p3")) || !TEST_ptr(BN_native2bn(bignumbin, p->return_size, app_p3)) || !TEST_BN_eq(app_p3, verify_p3) /* "provider" value */ || !TEST_str_eq(app_p4, p4_init) /* "provider" value */ || !TEST_ptr(p = OSSL_PARAM_locate(params, "p5")) || !TEST_size_t_eq(p->return_size, sizeof(p5_init) - 1) /* "provider" value */ || !TEST_str_eq(app_p5, p5_init) /* "provider" value */ || !TEST_ptr(p = OSSL_PARAM_locate(params, "p6")) || !TEST_size_t_eq(p->return_size, sizeof(p6_init) - 1) /* "provider" value */ || !TEST_str_eq(app_p6, p6_init) /* "provider" value */ || !TEST_char_eq(foo[0], app_foo_init) /* Should remain untouched */ || !TEST_ptr(p = OSSL_PARAM_locate(params, "foo"))) errcnt++; /* * Set parameters, then sneak into the object itself and check * that its attributes got set (or ignored) properly. */ init_app_variables(); if (!TEST_true(prov->set_params(obj, params))) { errcnt++; } else { struct object_st *sneakpeek = obj; if (!TEST_int_eq(sneakpeek->p1, app_p1) /* app value set */ || !TEST_double_eq(sneakpeek->p2, p2_init) /* Should remain untouched */ || !TEST_BN_eq(sneakpeek->p3, app_p3) /* app value set */ || !TEST_str_eq(sneakpeek->p4, app_p4) /* app value set */ || !TEST_str_eq(sneakpeek->p5, app_p5) /* app value set */ || !TEST_str_eq(sneakpeek->p6, app_p6)) /* app value set */ errcnt++; } /* * Get parameters again, checking that we get different values * than earlier where relevant. */ BN_free(verify_p3); verify_p3 = NULL; if (!TEST_true(BN_hex2bn(&verify_p3, app_p3_init))) { errcnt++; goto fin; } if (!TEST_true(prov->get_params(obj, params)) || !TEST_int_eq(app_p1, app_p1_init) /* app value */ || !TEST_double_eq(app_p2, app_p2_init) /* Should remain untouched */ || !TEST_ptr(p = OSSL_PARAM_locate(params, "p3")) || !TEST_ptr(BN_native2bn(bignumbin, p->return_size, app_p3)) || !TEST_BN_eq(app_p3, verify_p3) /* app value */ || !TEST_str_eq(app_p4, app_p4_init) /* app value */ || !TEST_ptr(p = OSSL_PARAM_locate(params, "p5")) || !TEST_size_t_eq(p->return_size, sizeof(app_p5_init) - 1) /* app value */ || !TEST_str_eq(app_p5, app_p5_init) /* app value */ || !TEST_ptr(p = OSSL_PARAM_locate(params, "p6")) || !TEST_size_t_eq(p->return_size, sizeof(app_p6_init) - 1) /* app value */ || !TEST_str_eq(app_p6, app_p6_init) /* app value */ || !TEST_char_eq(foo[0], app_foo_init) /* Should remain untouched */ || !TEST_ptr(p = OSSL_PARAM_locate(params, "foo"))) errcnt++; fin: BN_free(verify_p3); verify_p3 = NULL; cleanup_app_variables(); cleanup_object(obj); return errcnt == 0; } static int test_case(int i) { TEST_info("Case: %s", test_cases[i].desc); return test_case_variant(test_cases[i].app->static_params, test_cases[i].prov) && (test_cases[i].app->constructed_params == NULL || test_case_variant(test_cases[i].app->constructed_params(), test_cases[i].prov)); } /*- * OSSL_PARAM_allocate_from_text() tests * ===================================== */ static const OSSL_PARAM params_from_text[] = { /* Fixed size buffer */ OSSL_PARAM_int32("int", NULL), OSSL_PARAM_DEFN("short", OSSL_PARAM_INTEGER, NULL, sizeof(int16_t)), OSSL_PARAM_DEFN("ushort", OSSL_PARAM_UNSIGNED_INTEGER, NULL, sizeof(uint16_t)), /* Arbitrary size buffer. Make sure the result fits in a long */ OSSL_PARAM_DEFN("num", OSSL_PARAM_INTEGER, NULL, 0), OSSL_PARAM_DEFN("unum", OSSL_PARAM_UNSIGNED_INTEGER, NULL, 0), OSSL_PARAM_END, }; struct int_from_text_test_st { const char *argname; const char *strval; long int expected_intval; int expected_res; size_t expected_bufsize; }; static struct int_from_text_test_st int_from_text_test_cases[] = { { "int", "", 0, 0, 0 }, { "int", "0", 0, 1, 4 }, { "int", "101", 101, 1, 4 }, { "int", "-102", -102, 1, 4 }, { "int", "12A", 12, 1, 4 }, /* incomplete */ { "int", "0x12B", 0x12B, 1, 4 }, { "hexint", "12C", 0x12C, 1, 4 }, { "hexint", "0x12D", 0, 1, 4 }, /* zero */ /* test check of the target buffer size */ { "int", "0x7fffffff", INT32_MAX, 1, 4 }, { "int", "2147483647", INT32_MAX, 1, 4 }, { "int", "2147483648", 0, 0, 0 }, /* too small buffer */ { "int", "-2147483648", INT32_MIN, 1, 4 }, { "int", "-2147483649", 0, 0, 4 }, /* too small buffer */ { "short", "0x7fff", INT16_MAX, 1, 2 }, { "short", "32767", INT16_MAX, 1, 2 }, { "short", "32768", 0, 0, 0 }, /* too small buffer */ { "ushort", "0xffff", UINT16_MAX, 1, 2 }, { "ushort", "65535", UINT16_MAX, 1, 2 }, { "ushort", "65536", 0, 0, 0 }, /* too small buffer */ /* test check of sign extension in arbitrary size results */ { "num", "0", 0, 1, 1 }, { "num", "0", 0, 1, 1 }, { "num", "0xff", 0xff, 1, 2 }, /* sign extension */ { "num", "-0xff", -0xff, 1, 2 }, /* sign extension */ { "num", "0x7f", 0x7f, 1, 1 }, /* no sign extension */ { "num", "-0x7f", -0x7f, 1, 1 }, /* no sign extension */ { "num", "0x80", 0x80, 1, 2 }, /* sign extension */ { "num", "-0x80", -0x80, 1, 1 }, /* no sign extension */ { "num", "0x81", 0x81, 1, 2 }, /* sign extension */ { "num", "-0x81", -0x81, 1, 2 }, /* sign extension */ { "unum", "0xff", 0xff, 1, 1 }, { "unum", "-0xff", -0xff, 0, 0 }, /* invalid neg number */ { "unum", "0x7f", 0x7f, 1, 1 }, { "unum", "-0x7f", -0x7f, 0, 0 }, /* invalid neg number */ { "unum", "0x80", 0x80, 1, 1 }, { "unum", "-0x80", -0x80, 0, 0 }, /* invalid neg number */ { "unum", "0x81", 0x81, 1, 1 }, { "unum", "-0x81", -0x81, 0, 0 }, /* invalid neg number */ }; static int check_int_from_text(const struct int_from_text_test_st a) { OSSL_PARAM param; long int val = 0; int res; if (!OSSL_PARAM_allocate_from_text(¶m, params_from_text, a.argname, a.strval, 0, NULL)) { if (a.expected_res) TEST_error("unexpected OSSL_PARAM_allocate_from_text() return for %s \"%s\"", a.argname, a.strval); return !a.expected_res; } /* For data size zero, OSSL_PARAM_get_long() may crash */ if (param.data_size == 0) { OPENSSL_free(param.data); TEST_error("unexpected zero size for %s \"%s\"", a.argname, a.strval); return 0; } res = OSSL_PARAM_get_long(¶m, &val); OPENSSL_free(param.data); if (res ^ a.expected_res) { TEST_error("unexpected OSSL_PARAM_get_long() return for %s \"%s\": " "%d != %d", a.argname, a.strval, a.expected_res, res); return 0; } if (val != a.expected_intval) { TEST_error("unexpected result for %s \"%s\": %li != %li", a.argname, a.strval, a.expected_intval, val); return 0; } if (param.data_size != a.expected_bufsize) { TEST_error("unexpected size for %s \"%s\": %d != %d", a.argname, a.strval, (int)a.expected_bufsize, (int)param.data_size); return 0; } return a.expected_res; } static int test_allocate_from_text(int i) { return check_int_from_text(int_from_text_test_cases[i]); } int setup_tests(void) { ADD_ALL_TESTS(test_case, OSSL_NELEM(test_cases)); ADD_ALL_TESTS(test_allocate_from_text, OSSL_NELEM(int_from_text_test_cases)); return 1; }