From 748a2967ffd52cf86696582fb1074d513493f469 Mon Sep 17 00:00:00 2001 From: Richard Levitte Date: Sun, 28 Nov 2021 18:03:40 +0100 Subject: TEST: Add addition OSSL_PARAM tests for signed BIGNUMs Reviewed-by: Paul Dale (Merged from https://github.com/openssl/openssl/pull/17162) --- test/param_build_test.c | 66 ++++++++++++++++++-------- test/params_api_test.c | 120 ++++++++++++++++++++++++++++++++---------------- 2 files changed, 128 insertions(+), 58 deletions(-) (limited to 'test') diff --git a/test/param_build_test.c b/test/param_build_test.c index f802b90dfc..8a83fa869d 100644 --- a/test/param_build_test.c +++ b/test/param_build_test.c @@ -20,7 +20,8 @@ static int template_public_test(int tstid) { OSSL_PARAM_BLD *bld = OSSL_PARAM_BLD_new(); OSSL_PARAM *params = NULL, *params_blt = NULL, *p1 = NULL, *p; - BIGNUM *bn = NULL, *bn_res = NULL; + BIGNUM *pbn = NULL, *pbn_res = NULL; + BIGNUM *nbn = NULL, *nbn_res = NULL; int i; long int l; int32_t i32; @@ -37,9 +38,13 @@ static int template_public_test(int tstid) || !TEST_true(OSSL_PARAM_BLD_push_int64(bld, "i64", -9999999)) || !TEST_true(OSSL_PARAM_BLD_push_time_t(bld, "t", 11224)) || !TEST_true(OSSL_PARAM_BLD_push_double(bld, "d", 1.61803398875)) - || !TEST_ptr(bn = BN_new()) - || !TEST_true(BN_set_word(bn, 1729)) - || !TEST_true(OSSL_PARAM_BLD_push_BN(bld, "bignumber", bn)) + || !TEST_ptr(pbn = BN_new()) + || !TEST_true(BN_set_word(pbn, 1729)) + || !TEST_true(OSSL_PARAM_BLD_push_BN(bld, "bignumber", pbn)) + || !TEST_ptr(nbn = BN_secure_new()) + || !TEST_true(BN_set_word(nbn, 1733)) + || !TEST_true((BN_set_negative(nbn, 1), 1)) + || !TEST_true(OSSL_PARAM_BLD_push_BN(bld, "negativebignumber", nbn)) || !TEST_true(OSSL_PARAM_BLD_push_utf8_string(bld, "utf8_s", "foo", sizeof("foo"))) || !TEST_true(OSSL_PARAM_BLD_push_utf8_ptr(bld, "utf8_p", "bar-boom", @@ -118,12 +123,18 @@ static int template_public_test(int tstid) || !TEST_ptr(p = OSSL_PARAM_locate(params, "utf8_p")) || !TEST_true(OSSL_PARAM_get_utf8_ptr(p, &cutf)) || !TEST_str_eq(cutf, "bar-boom") - /* Check BN */ + /* Check BN (positive BN becomes unsigned integer) */ || !TEST_ptr(p = OSSL_PARAM_locate(params, "bignumber")) || !TEST_str_eq(p->key, "bignumber") || !TEST_uint_eq(p->data_type, OSSL_PARAM_UNSIGNED_INTEGER) - || !TEST_true(OSSL_PARAM_get_BN(p, &bn_res)) - || !TEST_int_eq(BN_cmp(bn_res, bn), 0)) + || !TEST_true(OSSL_PARAM_get_BN(p, &pbn_res)) + || !TEST_BN_eq(pbn_res, pbn) + /* Check BN (negative BN becomes signed integer) */ + || !TEST_ptr(p = OSSL_PARAM_locate(params, "negativebignumber")) + || !TEST_str_eq(p->key, "negativebignumber") + || !TEST_uint_eq(p->data_type, OSSL_PARAM_INTEGER) + || !TEST_true(OSSL_PARAM_get_BN(p, &nbn_res)) + || !TEST_BN_eq(nbn_res, nbn)) goto err; res = 1; err: @@ -133,8 +144,10 @@ err: OSSL_PARAM_free(params_blt); OSSL_PARAM_BLD_free(bld); OPENSSL_free(utf); - BN_free(bn); - BN_free(bn_res); + BN_free(pbn); + BN_free(pbn_res); + BN_free(nbn); + BN_free(nbn_res); return res; } @@ -152,7 +165,8 @@ static int template_private_test(int tstid) uint32_t i32; uint64_t i64; size_t st; - BIGNUM *bn = NULL, *bn_res = NULL; + BIGNUM *pbn = NULL, *pbn_res = NULL; + BIGNUM *nbn = NULL, *nbn_res = NULL; int res = 0; if (!TEST_ptr(data1 = OPENSSL_secure_malloc(data1_size)) @@ -170,9 +184,13 @@ static int template_private_test(int tstid) || !TEST_true(OSSL_PARAM_BLD_push_uint32(bld, "i32", 1532)) || !TEST_true(OSSL_PARAM_BLD_push_uint64(bld, "i64", 9999999)) || !TEST_true(OSSL_PARAM_BLD_push_size_t(bld, "st", 65537)) - || !TEST_ptr(bn = BN_secure_new()) - || !TEST_true(BN_set_word(bn, 1729)) - || !TEST_true(OSSL_PARAM_BLD_push_BN(bld, "bignumber", bn)) + || !TEST_ptr(pbn = BN_secure_new()) + || !TEST_true(BN_set_word(pbn, 1729)) + || !TEST_true(OSSL_PARAM_BLD_push_BN(bld, "bignumber", pbn)) + || !TEST_ptr(nbn = BN_secure_new()) + || !TEST_true(BN_set_word(nbn, 1733)) + || !TEST_true((BN_set_negative(nbn, 1), 1)) + || !TEST_true(OSSL_PARAM_BLD_push_BN(bld, "negativebignumber", nbn)) || !TEST_true(OSSL_PARAM_BLD_push_octet_string(bld, "oct_s", data1, data1_size)) || !TEST_true(OSSL_PARAM_BLD_push_octet_ptr(bld, "oct_p", data2, @@ -251,14 +269,22 @@ static int template_private_test(int tstid) || !TEST_str_eq(p->key, "oct_p") || !TEST_uint_eq(p->data_type, OSSL_PARAM_OCTET_PTR) || !TEST_mem_eq(*(void **)p->data, p->data_size, data2, data2_size) - /* Check BN */ + /* Check BN (positive BN becomes unsigned integer) */ || !TEST_ptr(p = OSSL_PARAM_locate(params, "bignumber")) || !TEST_true(CRYPTO_secure_allocated(p->data)) || !TEST_str_eq(p->key, "bignumber") || !TEST_uint_eq(p->data_type, OSSL_PARAM_UNSIGNED_INTEGER) - || !TEST_true(OSSL_PARAM_get_BN(p, &bn_res)) - || !TEST_int_eq(BN_get_flags(bn, BN_FLG_SECURE), BN_FLG_SECURE) - || !TEST_int_eq(BN_cmp(bn_res, bn), 0)) + || !TEST_true(OSSL_PARAM_get_BN(p, &pbn_res)) + || !TEST_int_eq(BN_get_flags(pbn, BN_FLG_SECURE), BN_FLG_SECURE) + || !TEST_BN_eq(pbn_res, pbn) + /* Check BN (negative BN becomes signed integer) */ + || !TEST_ptr(p = OSSL_PARAM_locate(params, "negativebignumber")) + || !TEST_true(CRYPTO_secure_allocated(p->data)) + || !TEST_str_eq(p->key, "negativebignumber") + || !TEST_uint_eq(p->data_type, OSSL_PARAM_INTEGER) + || !TEST_true(OSSL_PARAM_get_BN(p, &nbn_res)) + || !TEST_int_eq(BN_get_flags(nbn, BN_FLG_SECURE), BN_FLG_SECURE) + || !TEST_BN_eq(nbn_res, nbn)) goto err; res = 1; err: @@ -269,8 +295,10 @@ err: OSSL_PARAM_BLD_free(bld); OPENSSL_secure_free(data1); OPENSSL_secure_free(data2); - BN_free(bn); - BN_free(bn_res); + BN_free(pbn); + BN_free(pbn_res); + BN_free(nbn); + BN_free(nbn_res); return res; } diff --git a/test/params_api_test.c b/test/params_api_test.c index 62e458c993..d073477d5a 100644 --- a/test/params_api_test.c +++ b/test/params_api_test.c @@ -34,14 +34,18 @@ static void swap_copy(unsigned char *out, const void *in, size_t len) * big endian machine copying from native to or from little endian involves * byte reversal. */ -static void le_copy(unsigned char *out, const void *in, size_t len) +static void le_copy(unsigned char *out, size_t outlen, + const void *in, size_t inlen) { DECLARE_IS_ENDIAN; - if (IS_LITTLE_ENDIAN) - memcpy(out, in, len); - else - swap_copy(out, in, len); + if (IS_LITTLE_ENDIAN) { + memcpy(out, in, outlen); + } else { + if (outlen < inlen) + in = (const char *)in + inlen - outlen; + swap_copy(out, in, outlen); + } } static const struct { @@ -98,17 +102,17 @@ static int test_param_type_extra(OSSL_PARAM *param, const unsigned char *cmp, /* Check signed types */ if (bit32) { - le_copy(buf, &i32, sizeof(i32)); + le_copy(buf, sizeof(i32), &i32, sizeof(i32)); sz = sizeof(i32) < width ? sizeof(i32) : width; if (!TEST_mem_eq(buf, sz, cmp, sz)) return 0; } - le_copy(buf, &i64, sizeof(i64)); + le_copy(buf, sizeof(i64), &i64, sizeof(i64)); sz = sizeof(i64) < width ? sizeof(i64) : width; if (!TEST_mem_eq(buf, sz, cmp, sz)) return 0; if (sizet && !signd) { - le_copy(buf, &s, sizeof(s)); + le_copy(buf, sizeof(s), &s, sizeof(s)); sz = sizeof(s) < width ? sizeof(s) : width; if (!TEST_mem_eq(buf, sz, cmp, sz)) return 0; @@ -154,18 +158,18 @@ static int test_param_int(int n) OSSL_PARAM param = OSSL_PARAM_int("a", NULL); memset(buf, 0, sizeof(buf)); - le_copy(buf, raw_values[n].value, sizeof(in)); + le_copy(buf, sizeof(in), raw_values[n].value, sizeof(in)); memcpy(&in, buf, sizeof(in)); param.data = &out; if (!TEST_true(OSSL_PARAM_set_int(¶m, in))) return 0; - le_copy(cmp, &out, sizeof(out)); + le_copy(cmp, sizeof(out), &out, sizeof(out)); if (!TEST_mem_eq(cmp, len, raw_values[n].value, len)) return 0; in = 0; if (!TEST_true(OSSL_PARAM_get_int(¶m, &in))) return 0; - le_copy(cmp, &in, sizeof(in)); + le_copy(cmp, sizeof(in), &in, sizeof(in)); if (!TEST_mem_eq(cmp, sizeof(in), raw_values[n].value, sizeof(in))) return 0; param.data = &out; @@ -181,18 +185,18 @@ static int test_param_long(int n) OSSL_PARAM param = OSSL_PARAM_long("a", NULL); memset(buf, 0, sizeof(buf)); - le_copy(buf, raw_values[n].value, sizeof(in)); + le_copy(buf, sizeof(in), raw_values[n].value, sizeof(in)); memcpy(&in, buf, sizeof(in)); param.data = &out; if (!TEST_true(OSSL_PARAM_set_long(¶m, in))) return 0; - le_copy(cmp, &out, sizeof(out)); + le_copy(cmp, sizeof(out), &out, sizeof(out)); if (!TEST_mem_eq(cmp, len, raw_values[n].value, len)) return 0; in = 0; if (!TEST_true(OSSL_PARAM_get_long(¶m, &in))) return 0; - le_copy(cmp, &in, sizeof(in)); + le_copy(cmp, sizeof(in), &in, sizeof(in)); if (!TEST_mem_eq(cmp, sizeof(in), raw_values[n].value, sizeof(in))) return 0; param.data = &out; @@ -207,18 +211,18 @@ static int test_param_uint(int n) OSSL_PARAM param = OSSL_PARAM_uint("a", NULL); memset(buf, 0, sizeof(buf)); - le_copy(buf, raw_values[n].value, sizeof(in)); + le_copy(buf, sizeof(in), raw_values[n].value, sizeof(in)); memcpy(&in, buf, sizeof(in)); param.data = &out; if (!TEST_true(OSSL_PARAM_set_uint(¶m, in))) return 0; - le_copy(cmp, &out, sizeof(out)); + le_copy(cmp, sizeof(out), &out, sizeof(out)); if (!TEST_mem_eq(cmp, len, raw_values[n].value, len)) return 0; in = 0; if (!TEST_true(OSSL_PARAM_get_uint(¶m, &in))) return 0; - le_copy(cmp, &in, sizeof(in)); + le_copy(cmp, sizeof(in), &in, sizeof(in)); if (!TEST_mem_eq(cmp, sizeof(in), raw_values[n].value, sizeof(in))) return 0; param.data = &out; @@ -234,18 +238,18 @@ static int test_param_ulong(int n) OSSL_PARAM param = OSSL_PARAM_ulong("a", NULL); memset(buf, 0, sizeof(buf)); - le_copy(buf, raw_values[n].value, sizeof(in)); + le_copy(buf, sizeof(in), raw_values[n].value, sizeof(in)); memcpy(&in, buf, sizeof(in)); param.data = &out; if (!TEST_true(OSSL_PARAM_set_ulong(¶m, in))) return 0; - le_copy(cmp, &out, sizeof(out)); + le_copy(cmp, sizeof(out), &out, sizeof(out)); if (!TEST_mem_eq(cmp, len, raw_values[n].value, len)) return 0; in = 0; if (!TEST_true(OSSL_PARAM_get_ulong(¶m, &in))) return 0; - le_copy(cmp, &in, sizeof(in)); + le_copy(cmp, sizeof(in), &in, sizeof(in)); if (!TEST_mem_eq(cmp, sizeof(in), raw_values[n].value, sizeof(in))) return 0; param.data = &out; @@ -261,18 +265,18 @@ static int test_param_int32(int n) OSSL_PARAM param = OSSL_PARAM_int32("a", NULL); memset(buf, 0, sizeof(buf)); - le_copy(buf, raw_values[n].value, sizeof(in)); + le_copy(buf, sizeof(in), raw_values[n].value, sizeof(in)); memcpy(&in, buf, sizeof(in)); param.data = &out; if (!TEST_true(OSSL_PARAM_set_int32(¶m, in))) return 0; - le_copy(cmp, &out, sizeof(out)); + le_copy(cmp, sizeof(out), &out, sizeof(out)); if (!TEST_mem_eq(cmp, len, raw_values[n].value, len)) return 0; in = 0; if (!TEST_true(OSSL_PARAM_get_int32(¶m, &in))) return 0; - le_copy(cmp, &in, sizeof(in)); + le_copy(cmp, sizeof(in), &in, sizeof(in)); if (!TEST_mem_eq(cmp, sizeof(in), raw_values[n].value, sizeof(in))) return 0; param.data = &out; @@ -288,18 +292,18 @@ static int test_param_uint32(int n) OSSL_PARAM param = OSSL_PARAM_uint32("a", NULL); memset(buf, 0, sizeof(buf)); - le_copy(buf, raw_values[n].value, sizeof(in)); + le_copy(buf, sizeof(in), raw_values[n].value, sizeof(in)); memcpy(&in, buf, sizeof(in)); param.data = &out; if (!TEST_true(OSSL_PARAM_set_uint32(¶m, in))) return 0; - le_copy(cmp, &out, sizeof(out)); + le_copy(cmp, sizeof(out), &out, sizeof(out)); if (!TEST_mem_eq(cmp, len, raw_values[n].value, len)) return 0; in = 0; if (!TEST_true(OSSL_PARAM_get_uint32(¶m, &in))) return 0; - le_copy(cmp, &in, sizeof(in)); + le_copy(cmp, sizeof(in), &in, sizeof(in)); if (!TEST_mem_eq(cmp, sizeof(in), raw_values[n].value, sizeof(in))) return 0; param.data = &out; @@ -315,18 +319,18 @@ static int test_param_int64(int n) OSSL_PARAM param = OSSL_PARAM_int64("a", NULL); memset(buf, 0, sizeof(buf)); - le_copy(buf, raw_values[n].value, sizeof(in)); + le_copy(buf, sizeof(in), raw_values[n].value, sizeof(in)); memcpy(&in, buf, sizeof(in)); param.data = &out; if (!TEST_true(OSSL_PARAM_set_int64(¶m, in))) return 0; - le_copy(cmp, &out, sizeof(out)); + le_copy(cmp, sizeof(out), &out, sizeof(out)); if (!TEST_mem_eq(cmp, len, raw_values[n].value, len)) return 0; in = 0; if (!TEST_true(OSSL_PARAM_get_int64(¶m, &in))) return 0; - le_copy(cmp, &in, sizeof(in)); + le_copy(cmp, sizeof(in), &in, sizeof(in)); if (!TEST_mem_eq(cmp, sizeof(in), raw_values[n].value, sizeof(in))) return 0; param.data = &out; @@ -342,18 +346,18 @@ static int test_param_uint64(int n) OSSL_PARAM param = OSSL_PARAM_uint64("a", NULL); memset(buf, 0, sizeof(buf)); - le_copy(buf, raw_values[n].value, sizeof(in)); + le_copy(buf, sizeof(in), raw_values[n].value, sizeof(in)); memcpy(&in, buf, sizeof(in)); param.data = &out; if (!TEST_true(OSSL_PARAM_set_uint64(¶m, in))) return 0; - le_copy(cmp, &out, sizeof(out)); + le_copy(cmp, sizeof(out), &out, sizeof(out)); if (!TEST_mem_eq(cmp, len, raw_values[n].value, len)) return 0; in = 0; if (!TEST_true(OSSL_PARAM_get_uint64(¶m, &in))) return 0; - le_copy(cmp, &in, sizeof(in)); + le_copy(cmp, sizeof(in), &in, sizeof(in)); if (!TEST_mem_eq(cmp, sizeof(in), raw_values[n].value, sizeof(in))) return 0; param.data = &out; @@ -369,18 +373,18 @@ static int test_param_size_t(int n) OSSL_PARAM param = OSSL_PARAM_size_t("a", NULL); memset(buf, 0, sizeof(buf)); - le_copy(buf, raw_values[n].value, sizeof(in)); + le_copy(buf, sizeof(in), raw_values[n].value, sizeof(in)); memcpy(&in, buf, sizeof(in)); param.data = &out; if (!TEST_true(OSSL_PARAM_set_size_t(¶m, in))) return 0; - le_copy(cmp, &out, sizeof(out)); + le_copy(cmp, sizeof(out), &out, sizeof(out)); if (!TEST_mem_eq(cmp, len, raw_values[n].value, len)) return 0; in = 0; if (!TEST_true(OSSL_PARAM_get_size_t(¶m, &in))) return 0; - le_copy(cmp, &in, sizeof(in)); + le_copy(cmp, sizeof(in), &in, sizeof(in)); if (!TEST_mem_eq(cmp, sizeof(in), raw_values[n].value, sizeof(in))) return 0; param.data = &out; @@ -396,18 +400,18 @@ static int test_param_time_t(int n) OSSL_PARAM param = OSSL_PARAM_time_t("a", NULL); memset(buf, 0, sizeof(buf)); - le_copy(buf, raw_values[n].value, sizeof(in)); + le_copy(buf, sizeof(in), raw_values[n].value, sizeof(in)); memcpy(&in, buf, sizeof(in)); param.data = &out; if (!TEST_true(OSSL_PARAM_set_time_t(¶m, in))) return 0; - le_copy(cmp, &out, sizeof(out)); + le_copy(cmp, sizeof(out), &out, sizeof(out)); if (!TEST_mem_eq(cmp, len, raw_values[n].value, len)) return 0; in = 0; if (!TEST_true(OSSL_PARAM_get_time_t(¶m, &in))) return 0; - le_copy(cmp, &in, sizeof(in)); + le_copy(cmp, sizeof(in), &in, sizeof(in)); if (!TEST_mem_eq(cmp, sizeof(in), raw_values[n].value, sizeof(in))) return 0; param.data = &out; @@ -426,7 +430,7 @@ static int test_param_bignum(int n) param.data = bnbuf; param.data_size = len; - le_copy(buf, raw_values[n].value, len); + le_copy(buf, len, raw_values[n].value, len); if (!TEST_ptr(b = BN_lebin2bn(raw_values[n].value, (int)len, NULL))) goto err; @@ -445,6 +449,43 @@ err: return ret; } +static int test_param_signed_bignum(int n) +{ + unsigned char buf1[MAX_LEN], buf2[MAX_LEN], bnbuf[MAX_LEN]; + const size_t len = raw_values[n].len; + BIGNUM *b = NULL, *c = NULL; + OSSL_PARAM param = OSSL_PARAM_DEFN("bn", OSSL_PARAM_INTEGER, NULL, 0); + int ret = 0; + + param.data = bnbuf; + param.data_size = sizeof(bnbuf); + + le_copy(buf1, len, raw_values[n].value, len); + if (!TEST_ptr(b = BN_signed_lebin2bn(raw_values[n].value, (int)len, NULL))) + goto err; + + /* raw_values are little endian */ + if (!TEST_false(!!(raw_values[n].value[len - 1] & 0x80) ^ BN_is_negative(b))) + goto err; + if (!TEST_true(OSSL_PARAM_set_BN(¶m, b))) + goto err; + le_copy(buf2, len, bnbuf, sizeof(bnbuf)); + if (!TEST_mem_eq(buf1, len, buf2, len)) + goto err; + param.data_size = param.return_size; + if (!TEST_true(OSSL_PARAM_get_BN(¶m, &c)) + || !TEST_BN_eq(b, c)) { + BN_print_fp(stderr, c); + goto err; + } + + ret = 1; +err: + BN_free(b); + BN_free(c); + return ret; +} + static int test_param_real(void) { double p; @@ -706,6 +747,7 @@ int setup_tests(void) ADD_ALL_TESTS(test_param_int64, OSSL_NELEM(raw_values)); ADD_ALL_TESTS(test_param_uint64, OSSL_NELEM(raw_values)); ADD_ALL_TESTS(test_param_bignum, OSSL_NELEM(raw_values)); + ADD_ALL_TESTS(test_param_signed_bignum, OSSL_NELEM(raw_values)); ADD_TEST(test_param_real); ADD_ALL_TESTS(test_param_construct, 4); ADD_TEST(test_param_modified); -- cgit v1.2.3