{
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;
|| !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",
|| !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:
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;
}
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))
|| !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,
|| !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:
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;
}
* 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 {
/* 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;
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;
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;
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;
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;
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;
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;
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;
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;
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;
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;
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;
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;
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);