Hakase/openssl-custom
1
0 Fork 0
Code Issues Pull Requests Releases Wiki Activity

Latest update

Browse Source
This commit is contained in:
Hakase
2019-04-01 00:21:15 +09:00
parent c03e0c45f8
commit 48ec086472
209 changed files with 7552 additions and 2495 deletions
Download Patch File Download Diff File Expand all files Collapse all files
test/README
+1 -1
View File
@@ -114,7 +114,7 @@ Generic form of C test executables
int observed;
observed = function(); /* Call the code under test */
if (!TEST_int_equal(observed, 2)) /* Check the result is correct */
if (!TEST_int_eq(observed, 2)) /* Check the result is correct */
goto end; /* Exit on failure - optional */
testresult = 1; /* Mark the test case a success */
test/bn_internal_test.c
+2 -2
View File
@@ -73,8 +73,8 @@ static int test_bn_small_factors(void)
for (i = 1; i < NUMPRIMES; i++) {
prime_t p = primes[i];
if (p > 3 && p <= 751)
BN_mul_word(b, p);
if (p > 3 && p <= 751 && !BN_mul_word(b, p))
goto err;
if (p > 751)
break;
}
test/bntest.c
+212 -174
View File
@@ -160,10 +160,11 @@ static int test_swap(void)
|| !TEST_ptr(d = BN_new()))
goto err;
BN_bntest_rand(a, 1024, 1, 0);
BN_bntest_rand(b, 1024, 1, 0);
BN_copy(c, a);
BN_copy(d, b);
if (!(TEST_true(BN_bntest_rand(a, 1024, 1, 0))
&& TEST_true(BN_bntest_rand(b, 1024, 1, 0))
&& TEST_ptr(BN_copy(c, a))
&& TEST_ptr(BN_copy(d, b))))
goto err;
top = BN_num_bits(a) / BN_BITS2;
/* regular swap */
@@ -233,20 +234,21 @@ static int test_sub(void)
for (i = 0; i < NUM0 + NUM1; i++) {
if (i < NUM1) {
BN_bntest_rand(a, 512, 0, 0);
BN_copy(b, a);
if (!TEST_int_ne(BN_set_bit(a, i), 0))
if (!(TEST_true(BN_bntest_rand(a, 512, 0, 0)))
&& TEST_ptr(BN_copy(b, a))
&& TEST_int_ne(BN_set_bit(a, i), 0)
&& TEST_true(BN_add_word(b, i)))
goto err;
BN_add_word(b, i);
} else {
BN_bntest_rand(b, 400 + i - NUM1, 0, 0);
if (!TEST_true(BN_bntest_rand(b, 400 + i - NUM1, 0, 0)))
goto err;
BN_set_negative(a, rand_neg());
BN_set_negative(b, rand_neg());
}
BN_sub(c, a, b);
BN_add(c, c, b);
BN_sub(c, c, a);
if (!TEST_BN_eq_zero(c))
if (!(TEST_true(BN_sub(c, a, b))
&& TEST_true(BN_add(c, c, b))
&& TEST_true(BN_sub(c, c, a))
&& TEST_BN_eq_zero(c)))
goto err;
}
st = 1;
@@ -273,20 +275,23 @@ static int test_div_recip(void)
for (i = 0; i < NUM0 + NUM1; i++) {
if (i < NUM1) {
BN_bntest_rand(a, 400, 0, 0);
BN_copy(b, a);
BN_lshift(a, a, i);
BN_add_word(a, i);
} else
BN_bntest_rand(b, 50 + 3 * (i - NUM1), 0, 0);
if (!(TEST_true(BN_bntest_rand(a, 400, 0, 0))
&& TEST_ptr(BN_copy(b, a))
&& TEST_true(BN_lshift(a, a, i))
&& TEST_true(BN_add_word(a, i))))
goto err;
} else {
if (!(TEST_true(BN_bntest_rand(b, 50 + 3 * (i - NUM1), 0, 0))))
goto err;
}
BN_set_negative(a, rand_neg());
BN_set_negative(b, rand_neg());
BN_RECP_CTX_set(recp, b, ctx);
BN_div_recp(d, c, a, recp, ctx);
BN_mul(e, d, b, ctx);
BN_add(d, e, c);
BN_sub(d, d, a);
if (!TEST_BN_eq_zero(d))
if (!(TEST_true(BN_RECP_CTX_set(recp, b, ctx))
&& TEST_true(BN_div_recp(d, c, a, recp, ctx))
&& TEST_true(BN_mul(e, d, b, ctx))
&& TEST_true(BN_add(d, e, c))
&& TEST_true(BN_sub(d, d, a))
&& TEST_BN_eq_zero(d)))
goto err;
}
st = 1;
@@ -312,15 +317,17 @@ static int test_mod(void)
|| !TEST_ptr(e = BN_new()))
goto err;
BN_bntest_rand(a, 1024, 0, 0);
if (!(TEST_true(BN_bntest_rand(a, 1024, 0, 0))))
goto err;
for (i = 0; i < NUM0; i++) {
BN_bntest_rand(b, 450 + i * 10, 0, 0);
if (!(TEST_true(BN_bntest_rand(b, 450 + i * 10, 0, 0))))
goto err;
BN_set_negative(a, rand_neg());
BN_set_negative(b, rand_neg());
BN_mod(c, a, b, ctx);
BN_div(d, e, a, b, ctx);
BN_sub(e, e, c);
if (!TEST_BN_eq_zero(e))
if (!(TEST_true(BN_mod(c, a, b, ctx))
&& TEST_true(BN_div(d, e, a, b, ctx))
&& TEST_true(BN_sub(e, e, c))
&& TEST_BN_eq_zero(e)))
goto err;
}
st = 1;
@@ -395,46 +402,52 @@ static int test_modexp_mont5(void)
|| !TEST_ptr(mont = BN_MONT_CTX_new()))
goto err;
BN_bntest_rand(m, 1024, 0, 1); /* must be odd for montgomery */
/* Zero exponent */
BN_bntest_rand(a, 1024, 0, 0);
/* must be odd for montgomery */
if (!(TEST_true(BN_bntest_rand(m, 1024, 0, 1))
/* Zero exponent */
&& TEST_true(BN_bntest_rand(a, 1024, 0, 0))))
goto err;
BN_zero(p);
if (!TEST_true(BN_mod_exp_mont_consttime(d, a, p, m, ctx, NULL)))
goto err;
if (!TEST_BN_eq_one(d))
goto err;
/* Regression test for carry bug in mulx4x_mont */
BN_hex2bn(&a,
if (!(TEST_true(BN_hex2bn(&a,
"7878787878787878787878787878787878787878787878787878787878787878"
"7878787878787878787878787878787878787878787878787878787878787878"
"7878787878787878787878787878787878787878787878787878787878787878"
"7878787878787878787878787878787878787878787878787878787878787878");
BN_hex2bn(&b,
"7878787878787878787878787878787878787878787878787878787878787878"))
&& TEST_true(BN_hex2bn(&b,
"095D72C08C097BA488C5E439C655A192EAFB6380073D8C2664668EDDB4060744"
"E16E57FB4EDB9AE10A0CEFCDC28A894F689A128379DB279D48A2E20849D68593"
"9B7803BCF46CEBF5C533FB0DD35B080593DE5472E3FE5DB951B8BFF9B4CB8F03"
"9CC638A5EE8CDD703719F8000E6A9F63BEED5F2FCD52FF293EA05A251BB4AB81");
BN_hex2bn(&n,
"9CC638A5EE8CDD703719F8000E6A9F63BEED5F2FCD52FF293EA05A251BB4AB81"))
&& TEST_true(BN_hex2bn(&n,
"D78AF684E71DB0C39CFF4E64FB9DB567132CB9C50CC98009FEB820B26F2DED9B"
"91B9B5E2B83AE0AE4EB4E0523CA726BFBE969B89FD754F674CE99118C3F2D1C5"
"D81FDC7C54E02B60262B241D53C040E99E45826ECA37A804668E690E1AFC1CA4"
"2C9A15D84D4954425F0B7642FC0BD9D7B24E2618D2DCC9B729D944BADACFDDAF");
BN_MONT_CTX_set(mont, n, ctx);
BN_mod_mul_montgomery(c, a, b, mont, ctx);
BN_mod_mul_montgomery(d, b, a, mont, ctx);
if (!TEST_BN_eq(c, d))
"2C9A15D84D4954425F0B7642FC0BD9D7B24E2618D2DCC9B729D944BADACFDDAF"))))
goto err;
if (!(TEST_true(BN_MONT_CTX_set(mont, n, ctx))
&& TEST_true(BN_mod_mul_montgomery(c, a, b, mont, ctx))
&& TEST_true(BN_mod_mul_montgomery(d, b, a, mont, ctx))
&& TEST_BN_eq(c, d)))
goto err;
/* Regression test for carry bug in sqr[x]8x_mont */
parse_bigBN(&n, bn1strings);
parse_bigBN(&a, bn2strings);
if (!(TEST_true(parse_bigBN(&n, bn1strings))
&& TEST_true(parse_bigBN(&a, bn2strings))))
goto err;
BN_free(b);
b = BN_dup(a);
BN_MONT_CTX_set(mont, n, ctx);
BN_mod_mul_montgomery(c, a, a, mont, ctx);
BN_mod_mul_montgomery(d, a, b, mont, ctx);
if (!TEST_BN_eq(c, d))
if (!(TEST_ptr(b = BN_dup(a))
&& TEST_true(BN_MONT_CTX_set(mont, n, ctx))
&& TEST_true(BN_mod_mul_montgomery(c, a, a, mont, ctx))
&& TEST_true(BN_mod_mul_montgomery(d, a, b, mont, ctx))
&& TEST_BN_eq(c, d)))
goto err;
/* Regression test for carry bug in bn_sqrx8x_internal */
@@ -470,78 +483,83 @@ static int test_modexp_mont5(void)
NULL
};
parse_bigBN(&a, ahex);
parse_bigBN(&n, nhex);
if (!(TEST_true(parse_bigBN(&a, ahex))
&& TEST_true(parse_bigBN(&n, nhex))))
goto err;
}
BN_free(b);
b = BN_dup(a);
BN_MONT_CTX_set(mont, n, ctx);
if (!(TEST_ptr(b = BN_dup(a))
&& TEST_true(BN_MONT_CTX_set(mont, n, ctx))))
goto err;
if (!TEST_true(BN_mod_mul_montgomery(c, a, a, mont, ctx))
|| !TEST_true(BN_mod_mul_montgomery(d, a, b, mont, ctx))
|| !TEST_BN_eq(c, d))
goto err;
/* Regression test for bug in BN_from_montgomery_word */
BN_hex2bn(&a,
if (!(TEST_true(BN_hex2bn(&a,
"FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF"
"FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF"
"FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF");
BN_hex2bn(&n,
"FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF"))
&& TEST_true(BN_hex2bn(&n,
"FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF"
"FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF");
BN_MONT_CTX_set(mont, n, ctx);
if (!TEST_false(BN_mod_mul_montgomery(d, a, a, mont, ctx)))
"FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF"))
&& TEST_true(BN_MONT_CTX_set(mont, n, ctx))
&& TEST_false(BN_mod_mul_montgomery(d, a, a, mont, ctx))))
goto err;
/* Regression test for bug in rsaz_1024_mul_avx2 */
BN_hex2bn(&a,
if (!(TEST_true(BN_hex2bn(&a,
"FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF"
"FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF"
"FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF"
"FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF2020202020DF");
BN_hex2bn(&b,
"FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF2020202020DF"))
&& TEST_true(BN_hex2bn(&b,
"2020202020202020202020202020202020202020202020202020202020202020"
"2020202020202020202020202020202020202020202020202020202020202020"
"20202020202020FF202020202020202020202020202020202020202020202020"
"2020202020202020202020202020202020202020202020202020202020202020");
BN_hex2bn(&n,
"2020202020202020202020202020202020202020202020202020202020202020"))
&& TEST_true(BN_hex2bn(&n,
"FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF"
"FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF"
"FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF"
"FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF2020202020FF");
BN_MONT_CTX_set(mont, n, ctx);
BN_mod_exp_mont_consttime(c, a, b, n, ctx, mont);
BN_mod_exp_mont(d, a, b, n, ctx, mont);
if (!TEST_BN_eq(c, d))
"FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF2020202020FF"))
&& TEST_true(BN_MONT_CTX_set(mont, n, ctx))
&& TEST_true(BN_mod_exp_mont_consttime(c, a, b, n, ctx, mont))
&& TEST_true(BN_mod_exp_mont(d, a, b, n, ctx, mont))
&& TEST_BN_eq(c, d)))
goto err;
/*
* rsaz_1024_mul_avx2 expects fully-reduced inputs.
* BN_mod_exp_mont_consttime should reduce the input first.
*/
BN_hex2bn(&a,
if (!(TEST_true(BN_hex2bn(&a,
"FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF"
"FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF"
"FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF"
"FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF2020202020DF");
BN_hex2bn(&b,
"FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF2020202020DF"))
&& TEST_true(BN_hex2bn(&b,
"1FA53F26F8811C58BE0357897AA5E165693230BC9DF5F01DFA6A2D59229EC69D"
"9DE6A89C36E3B6957B22D6FAAD5A3C73AE587B710DBE92E83D3A9A3339A085CB"
"B58F508CA4F837924BB52CC1698B7FDC2FD74362456A595A5B58E38E38E38E38"
"E38E38E38E38E38E38E38E38E38E38E38E38E38E38E38E38E38E38E38E38E38E");
BN_hex2bn(&n,
"E38E38E38E38E38E38E38E38E38E38E38E38E38E38E38E38E38E38E38E38E38E"))
&& TEST_true(BN_hex2bn(&n,
"FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF"
"FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF"
"FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF"
"FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF2020202020DF");
BN_MONT_CTX_set(mont, n, ctx);
BN_mod_exp_mont_consttime(c, a, b, n, ctx, mont);
"FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF2020202020DF"))
&& TEST_true(BN_MONT_CTX_set(mont, n, ctx))
&& TEST_true(BN_mod_exp_mont_consttime(c, a, b, n, ctx, mont))))
goto err;
BN_zero(d);
if (!TEST_BN_eq(c, d))
goto err;
/* Zero input */
BN_bntest_rand(p, 1024, 0, 0);
if (!TEST_true(BN_bntest_rand(p, 1024, 0, 0)))
goto err;
BN_zero(a);
if (!TEST_true(BN_mod_exp_mont_consttime(d, a, p, m, ctx, NULL))
|| !TEST_BN_eq_zero(d))
@@ -552,8 +570,9 @@ static int test_modexp_mont5(void)
* than the modulus m, in order to test the const time precomputation
* scattering/gathering.
*/
BN_one(a);
BN_MONT_CTX_set(mont, m, ctx);
if (!(TEST_true(BN_one(a))
&& TEST_true(BN_MONT_CTX_set(mont, m, ctx))))
goto err;
if (!TEST_true(BN_from_montgomery(e, a, mont, ctx))
|| !TEST_true(BN_mod_exp_mont_consttime(d, e, p, m, ctx, NULL))
|| !TEST_true(BN_mod_exp_simple(a, e, p, m, ctx))
@@ -561,10 +580,10 @@ static int test_modexp_mont5(void)
goto err;
/* Finally, some regular test vectors. */
BN_bntest_rand(e, 1024, 0, 0);
if (!TEST_true(BN_mod_exp_mont_consttime(d, e, p, m, ctx, NULL))
|| !TEST_true(BN_mod_exp_simple(a, e, p, m, ctx))
|| !TEST_BN_eq(a, d))
if (!(TEST_true(BN_bntest_rand(e, 1024, 0, 0))
&& TEST_true(BN_mod_exp_mont_consttime(d, e, p, m, ctx, NULL))
&& TEST_true(BN_mod_exp_simple(a, e, p, m, ctx))
&& TEST_BN_eq(a, d)))
goto err;
st = 1;
@@ -594,18 +613,19 @@ static int test_gf2m_add(void)
goto err;
for (i = 0; i < NUM0; i++) {
BN_rand(a, 512, 0, 0);
BN_copy(b, BN_value_one());
if (!(TEST_true(BN_rand(a, 512, 0, 0))
&& TEST_ptr(BN_copy(b, BN_value_one()))))
goto err;
BN_set_negative(a, rand_neg());
BN_set_negative(b, rand_neg());
BN_GF2m_add(c, a, b);
/* Test that two added values have the correct parity. */
if (!TEST_false((BN_is_odd(a) && BN_is_odd(c))
|| (!BN_is_odd(a) && !BN_is_odd(c))))
if (!(TEST_true(BN_GF2m_add(c, a, b))
/* Test that two added values have the correct parity. */
&& TEST_false((BN_is_odd(a) && BN_is_odd(c))
|| (!BN_is_odd(a) && !BN_is_odd(c)))))
goto err;
BN_GF2m_add(c, c, c);
/* Test that c + c = 0. */
if (!TEST_BN_eq_zero(c))
if (!(TEST_true(BN_GF2m_add(c, c, c))
/* Test that c + c = 0. */
&& TEST_BN_eq_zero(c)))
goto err;
}
st = 1;
@@ -629,17 +649,19 @@ static int test_gf2m_mod(void)
|| !TEST_ptr(e = BN_new()))
goto err;
BN_GF2m_arr2poly(p0, b[0]);
BN_GF2m_arr2poly(p1, b[1]);
if (!(TEST_true(BN_GF2m_arr2poly(p0, b[0]))
&& TEST_true(BN_GF2m_arr2poly(p1, b[1]))))
goto err;
for (i = 0; i < NUM0; i++) {
BN_bntest_rand(a, 1024, 0, 0);
if (!TEST_true(BN_bntest_rand(a, 1024, 0, 0)))
goto err;
for (j = 0; j < 2; j++) {
BN_GF2m_mod(c, a, b[j]);
BN_GF2m_add(d, a, c);
BN_GF2m_mod(e, d, b[j]);
/* Test that a + (a mod p) mod p == 0. */
if (!TEST_BN_eq_zero(e))
if (!(TEST_true(BN_GF2m_mod(c, a, b[j]))
&& TEST_true(BN_GF2m_add(d, a, c))
&& TEST_true(BN_GF2m_mod(e, d, b[j]))
/* Test that a + (a mod p) mod p == 0. */
&& TEST_BN_eq_zero(e)))
goto err;
}
}
@@ -671,22 +693,24 @@ static int test_gf2m_mul(void)
|| !TEST_ptr(h = BN_new()))
goto err;
BN_GF2m_arr2poly(p0, b[0]);
BN_GF2m_arr2poly(p1, b[1]);
if (!(TEST_true(BN_GF2m_arr2poly(p0, b[0]))
&& TEST_true(BN_GF2m_arr2poly(p1, b[1]))))
goto err;
for (i = 0; i < NUM0; i++) {
BN_bntest_rand(a, 1024, 0, 0);
BN_bntest_rand(c, 1024, 0, 0);
BN_bntest_rand(d, 1024, 0, 0);
if (!(TEST_true(BN_bntest_rand(a, 1024, 0, 0))
&& TEST_true(BN_bntest_rand(c, 1024, 0, 0))
&& TEST_true(BN_bntest_rand(d, 1024, 0, 0))))
goto err;
for (j = 0; j < 2; j++) {
BN_GF2m_mod_mul(e, a, c, b[j], ctx);
BN_GF2m_add(f, a, d);
BN_GF2m_mod_mul(g, f, c, b[j], ctx);
BN_GF2m_mod_mul(h, d, c, b[j], ctx);
BN_GF2m_add(f, e, g);
BN_GF2m_add(f, f, h);
/* Test that (a+d)*c = a*c + d*c. */
if (!TEST_BN_eq_zero(f))
if (!(TEST_true(BN_GF2m_mod_mul(e, a, c, b[j], ctx))
&& TEST_true(BN_GF2m_add(f, a, d))
&& TEST_true(BN_GF2m_mod_mul(g, f, c, b[j], ctx))
&& TEST_true(BN_GF2m_mod_mul(h, d, c, b[j], ctx))
&& TEST_true(BN_GF2m_add(f, e, g))
&& TEST_true(BN_GF2m_add(f, f, h))
/* Test that (a+d)*c = a*c + d*c. */
&& TEST_BN_eq_zero(f)))
goto err;
}
}
@@ -717,18 +741,20 @@ static int test_gf2m_sqr(void)
|| !TEST_ptr(d = BN_new()))
goto err;
BN_GF2m_arr2poly(p0, b[0]);
BN_GF2m_arr2poly(p1, b[1]);
if (!(TEST_true(BN_GF2m_arr2poly(p0, b[0]))
&& TEST_true(BN_GF2m_arr2poly(p1, b[1]))))
goto err;
for (i = 0; i < NUM0; i++) {
BN_bntest_rand(a, 1024, 0, 0);
if (!TEST_true(BN_bntest_rand(a, 1024, 0, 0)))
goto err;
for (j = 0; j < 2; j++) {
BN_GF2m_mod_sqr(c, a, b[j], ctx);
BN_copy(d, a);
BN_GF2m_mod_mul(d, a, d, b[j], ctx);
BN_GF2m_add(d, c, d);
/* Test that a*a = a^2. */
if (!TEST_BN_eq_zero(d))
if (!(TEST_true(BN_GF2m_mod_sqr(c, a, b[j], ctx))
&& TEST_true(BN_copy(d, a))
&& TEST_true(BN_GF2m_mod_mul(d, a, d, b[j], ctx))
&& TEST_true(BN_GF2m_add(d, c, d))
/* Test that a*a = a^2. */
&& TEST_BN_eq_zero(d)))
goto err;
}
}
@@ -754,16 +780,18 @@ static int test_gf2m_modinv(void)
|| !TEST_ptr(d = BN_new()))
goto err;
BN_GF2m_arr2poly(p0, b[0]);
BN_GF2m_arr2poly(p1, b[1]);
if (!(TEST_true(BN_GF2m_arr2poly(p0, b[0]))
&& TEST_true(BN_GF2m_arr2poly(p1, b[1]))))
goto err;
for (i = 0; i < NUM0; i++) {
BN_bntest_rand(a, 512, 0, 0);
if (!TEST_true(BN_bntest_rand(a, 512, 0, 0)))
goto err;
for (j = 0; j < 2; j++) {
BN_GF2m_mod_inv(c, a, b[j], ctx);
BN_GF2m_mod_mul(d, a, c, b[j], ctx);
/* Test that ((1/a)*a) = 1. */
if (!TEST_BN_eq_one(d))
if (!(TEST_true(BN_GF2m_mod_inv(c, a, b[j], ctx))
&& TEST_true(BN_GF2m_mod_mul(d, a, c, b[j], ctx))
/* Test that ((1/a)*a) = 1. */
&& TEST_BN_eq_one(d)))
goto err;
}
}
@@ -792,18 +820,20 @@ static int test_gf2m_moddiv(void)
|| !TEST_ptr(f = BN_new()))
goto err;
BN_GF2m_arr2poly(p0, b[0]);
BN_GF2m_arr2poly(p1, b[1]);
if (!(TEST_true(BN_GF2m_arr2poly(p0, b[0]))
&& TEST_true(BN_GF2m_arr2poly(p1, b[1]))))
goto err;
for (i = 0; i < NUM0; i++) {
BN_bntest_rand(a, 512, 0, 0);
BN_bntest_rand(c, 512, 0, 0);
if (!(TEST_true(BN_bntest_rand(a, 512, 0, 0))
&& TEST_true(BN_bntest_rand(c, 512, 0, 0))))
goto err;
for (j = 0; j < 2; j++) {
BN_GF2m_mod_div(d, a, c, b[j], ctx);
BN_GF2m_mod_mul(e, d, c, b[j], ctx);
BN_GF2m_mod_div(f, a, e, b[j], ctx);
/* Test that ((a/c)*c)/a = 1. */
if (!TEST_BN_eq_one(f))
if (!(TEST_true(BN_GF2m_mod_div(d, a, c, b[j], ctx))
&& TEST_true(BN_GF2m_mod_mul(e, d, c, b[j], ctx))
&& TEST_true(BN_GF2m_mod_div(f, a, e, b[j], ctx))
/* Test that ((a/c)*c)/a = 1. */
&& TEST_BN_eq_one(f)))
goto err;
}
}
@@ -834,22 +864,24 @@ static int test_gf2m_modexp(void)
|| !TEST_ptr(f = BN_new()))
goto err;
BN_GF2m_arr2poly(p0, b[0]);
BN_GF2m_arr2poly(p1, b[1]);
if (!(TEST_true(BN_GF2m_arr2poly(p0, b[0]))
&& TEST_true(BN_GF2m_arr2poly(p1, b[1]))))
goto err;
for (i = 0; i < NUM0; i++) {
BN_bntest_rand(a, 512, 0, 0);
BN_bntest_rand(c, 512, 0, 0);
BN_bntest_rand(d, 512, 0, 0);
if (!(TEST_true(BN_bntest_rand(a, 512, 0, 0))
&& TEST_true(BN_bntest_rand(c, 512, 0, 0))
&& TEST_true(BN_bntest_rand(d, 512, 0, 0))))
goto err;
for (j = 0; j < 2; j++) {
BN_GF2m_mod_exp(e, a, c, b[j], ctx);
BN_GF2m_mod_exp(f, a, d, b[j], ctx);
BN_GF2m_mod_mul(e, e, f, b[j], ctx);
BN_add(f, c, d);
BN_GF2m_mod_exp(f, a, f, b[j], ctx);
BN_GF2m_add(f, e, f);
/* Test that a^(c+d)=a^c*a^d. */
if (!TEST_BN_eq_zero(f))
if (!(TEST_true(BN_GF2m_mod_exp(e, a, c, b[j], ctx))
&& TEST_true(BN_GF2m_mod_exp(f, a, d, b[j], ctx))
&& TEST_true(BN_GF2m_mod_mul(e, e, f, b[j], ctx))
&& TEST_true(BN_add(f, c, d))
&& TEST_true(BN_GF2m_mod_exp(f, a, f, b[j], ctx))
&& TEST_true(BN_GF2m_add(f, e, f))
/* Test that a^(c+d)=a^c*a^d. */
&& TEST_BN_eq_zero(f)))
goto err;
}
}
@@ -880,18 +912,21 @@ static int test_gf2m_modsqrt(void)
|| !TEST_ptr(f = BN_new()))
goto err;
BN_GF2m_arr2poly(p0, b[0]);
BN_GF2m_arr2poly(p1, b[1]);
if (!(TEST_true(BN_GF2m_arr2poly(p0, b[0]))
&& TEST_true(BN_GF2m_arr2poly(p1, b[1]))))
goto err;
for (i = 0; i < NUM0; i++) {
BN_bntest_rand(a, 512, 0, 0);
if (!TEST_true(BN_bntest_rand(a, 512, 0, 0)))
goto err;
for (j = 0; j < 2; j++) {
BN_GF2m_mod(c, a, b[j]);
BN_GF2m_mod_sqrt(d, a, b[j], ctx);
BN_GF2m_mod_sqr(e, d, b[j], ctx);
BN_GF2m_add(f, c, e);
/* Test that d^2 = a, where d = sqrt(a). */
if (!TEST_BN_eq_zero(f))
if (!(TEST_true(BN_GF2m_mod(c, a, b[j]))
&& TEST_true(BN_GF2m_mod_sqrt(d, a, b[j], ctx))
&& TEST_true(BN_GF2m_mod_sqr(e, d, b[j], ctx))
&& TEST_true(BN_GF2m_add(f, c, e))
/* Test that d^2 = a, where d = sqrt(a). */
&& TEST_BN_eq_zero(f)))
goto err;
}
}
@@ -921,23 +956,26 @@ static int test_gf2m_modsolvequad(void)
|| !TEST_ptr(e = BN_new()))
goto err;
BN_GF2m_arr2poly(p0, b[0]);
BN_GF2m_arr2poly(p1, b[1]);
if (!(TEST_true(BN_GF2m_arr2poly(p0, b[0]))
&& TEST_true(BN_GF2m_arr2poly(p1, b[1]))))
goto err;
for (i = 0; i < NUM0; i++) {
BN_bntest_rand(a, 512, 0, 0);
if (!TEST_true(BN_bntest_rand(a, 512, 0, 0)))
goto err;
for (j = 0; j < 2; j++) {
t = BN_GF2m_mod_solve_quad(c, a, b[j], ctx);
if (t) {
s++;
BN_GF2m_mod_sqr(d, c, b[j], ctx);
BN_GF2m_add(d, c, d);
BN_GF2m_mod(e, a, b[j]);
BN_GF2m_add(e, e, d);
/*
* Test that solution of quadratic c satisfies c^2 + c = a.
*/
if (!TEST_BN_eq_zero(e))
if (!(TEST_true(BN_GF2m_mod_sqr(d, c, b[j], ctx))
&& TEST_true(BN_GF2m_add(d, c, d))
&& TEST_true(BN_GF2m_mod(e, a, b[j]))
&& TEST_true(BN_GF2m_add(e, e, d))
/*
* Test that solution of quadratic c
* satisfies c^2 + c = a.
*/
&& TEST_BN_eq_zero(e)))
goto err;
}
}
test/certs/cyrillic.msb
+17 -17
View File
@@ -36,26 +36,26 @@ Certificate:
X509v3 Subject Key Identifier:
11:49:46:19:2A:4E:4D:D1:C8:FB:79:55:3D:81:99:22:EE:34:4F:22
X509v3 Authority Key Identifier:
keyid:11:49:46:19:2A:4E:4D:D1:C8:FB:79:55:3D:81:99:22:EE:34:4F:22
11:49:46:19:2A:4E:4D:D1:C8:FB:79:55:3D:81:99:22:EE:34:4F:22
X509v3 Basic Constraints:
CA:TRUE
Signature Algorithm: sha256WithRSAEncryption
04:8f:c3:77:48:06:29:c0:8d:66:2e:6b:48:a3:b3:e0:dd:5b:
0a:e7:a4:0b:7e:72:91:fc:37:29:7f:81:1e:60:66:7b:ba:94:
30:f8:c0:79:56:bc:ed:87:88:d9:bd:d8:7b:dc:1b:87:bb:ef:
15:d0:77:74:59:d7:3f:30:09:71:86:da:d7:d7:50:cb:ef:8f:
34:26:76:b5:0a:de:d0:ce:ca:40:57:86:ce:13:24:2a:9e:97:
db:5d:3e:73:8c:24:cc:89:84:42:04:45:62:f9:fd:4b:79:b2:
1b:a0:01:d7:4c:1f:4d:d1:4c:5b:99:0a:27:5e:c9:79:3c:0f:
b7:3c:09:db:32:d6:ca:56:91:32:0d:7f:79:94:bc:bc:a8:ba:
54:4b:39:6e:2d:9a:21:77:13:f8:b5:62:5d:a8:8c:c8:8d:ec:
67:6c:14:2d:f6:ce:e6:d3:a6:fa:37:36:5b:31:7a:80:66:83:
02:64:82:c1:ec:bf:38:8e:49:b0:e5:ec:09:9b:80:16:e4:32:
91:4e:72:c4:5f:2d:b3:e9:57:b1:00:36:2d:1a:e9:9f:4a:b1:
1c:d1:ae:fb:15:79:02:0b:14:97:81:ee:42:01:ed:00:58:38:
b2:30:89:f2:89:11:b7:03:7c:16:95:30:eb:32:9c:9f:00:e5:
22:12:db:7a
Signature Value:
04:8f:c3:77:48:06:29:c0:8d:66:2e:6b:48:a3:b3:e0:dd:5b:
0a:e7:a4:0b:7e:72:91:fc:37:29:7f:81:1e:60:66:7b:ba:94:
30:f8:c0:79:56:bc:ed:87:88:d9:bd:d8:7b:dc:1b:87:bb:ef:
15:d0:77:74:59:d7:3f:30:09:71:86:da:d7:d7:50:cb:ef:8f:
34:26:76:b5:0a:de:d0:ce:ca:40:57:86:ce:13:24:2a:9e:97:
db:5d:3e:73:8c:24:cc:89:84:42:04:45:62:f9:fd:4b:79:b2:
1b:a0:01:d7:4c:1f:4d:d1:4c:5b:99:0a:27:5e:c9:79:3c:0f:
b7:3c:09:db:32:d6:ca:56:91:32:0d:7f:79:94:bc:bc:a8:ba:
54:4b:39:6e:2d:9a:21:77:13:f8:b5:62:5d:a8:8c:c8:8d:ec:
67:6c:14:2d:f6:ce:e6:d3:a6:fa:37:36:5b:31:7a:80:66:83:
02:64:82:c1:ec:bf:38:8e:49:b0:e5:ec:09:9b:80:16:e4:32:
91:4e:72:c4:5f:2d:b3:e9:57:b1:00:36:2d:1a:e9:9f:4a:b1:
1c:d1:ae:fb:15:79:02:0b:14:97:81:ee:42:01:ed:00:58:38:
b2:30:89:f2:89:11:b7:03:7c:16:95:30:eb:32:9c:9f:00:e5:
22:12:db:7a
-----BEGIN CERTIFICATE-----
MIIEPTCCAyWgAwIBAgIJAL5HPFOmKsA6MA0GCSqGSIb3DQEBCwUAMIG0MQswCQYD
VQQGEwJSVTEVMBMGA1UECAwM0JzQvtGB0LrQstCwMRUwEwYDVQQHDAzQnNC+0YHQ
test/certs/cyrillic.utf8
+17 -17
View File
@@ -36,26 +36,26 @@ Certificate:
X509v3 Subject Key Identifier:
11:49:46:19:2A:4E:4D:D1:C8:FB:79:55:3D:81:99:22:EE:34:4F:22
X509v3 Authority Key Identifier:
keyid:11:49:46:19:2A:4E:4D:D1:C8:FB:79:55:3D:81:99:22:EE:34:4F:22
11:49:46:19:2A:4E:4D:D1:C8:FB:79:55:3D:81:99:22:EE:34:4F:22
X509v3 Basic Constraints:
CA:TRUE
Signature Algorithm: sha256WithRSAEncryption
04:8f:c3:77:48:06:29:c0:8d:66:2e:6b:48:a3:b3:e0:dd:5b:
0a:e7:a4:0b:7e:72:91:fc:37:29:7f:81:1e:60:66:7b:ba:94:
30:f8:c0:79:56:bc:ed:87:88:d9:bd:d8:7b:dc:1b:87:bb:ef:
15:d0:77:74:59:d7:3f:30:09:71:86:da:d7:d7:50:cb:ef:8f:
34:26:76:b5:0a:de:d0:ce:ca:40:57:86:ce:13:24:2a:9e:97:
db:5d:3e:73:8c:24:cc:89:84:42:04:45:62:f9:fd:4b:79:b2:
1b:a0:01:d7:4c:1f:4d:d1:4c:5b:99:0a:27:5e:c9:79:3c:0f:
b7:3c:09:db:32:d6:ca:56:91:32:0d:7f:79:94:bc:bc:a8:ba:
54:4b:39:6e:2d:9a:21:77:13:f8:b5:62:5d:a8:8c:c8:8d:ec:
67:6c:14:2d:f6:ce:e6:d3:a6:fa:37:36:5b:31:7a:80:66:83:
02:64:82:c1:ec:bf:38:8e:49:b0:e5:ec:09:9b:80:16:e4:32:
91:4e:72:c4:5f:2d:b3:e9:57:b1:00:36:2d:1a:e9:9f:4a:b1:
1c:d1:ae:fb:15:79:02:0b:14:97:81:ee:42:01:ed:00:58:38:
b2:30:89:f2:89:11:b7:03:7c:16:95:30:eb:32:9c:9f:00:e5:
22:12:db:7a
Signature Value:
04:8f:c3:77:48:06:29:c0:8d:66:2e:6b:48:a3:b3:e0:dd:5b:
0a:e7:a4:0b:7e:72:91:fc:37:29:7f:81:1e:60:66:7b:ba:94:
30:f8:c0:79:56:bc:ed:87:88:d9:bd:d8:7b:dc:1b:87:bb:ef:
15:d0:77:74:59:d7:3f:30:09:71:86:da:d7:d7:50:cb:ef:8f:
34:26:76:b5:0a:de:d0:ce:ca:40:57:86:ce:13:24:2a:9e:97:
db:5d:3e:73:8c:24:cc:89:84:42:04:45:62:f9:fd:4b:79:b2:
1b:a0:01:d7:4c:1f:4d:d1:4c:5b:99:0a:27:5e:c9:79:3c:0f:
b7:3c:09:db:32:d6:ca:56:91:32:0d:7f:79:94:bc:bc:a8:ba:
54:4b:39:6e:2d:9a:21:77:13:f8:b5:62:5d:a8:8c:c8:8d:ec:
67:6c:14:2d:f6:ce:e6:d3:a6:fa:37:36:5b:31:7a:80:66:83:
02:64:82:c1:ec:bf:38:8e:49:b0:e5:ec:09:9b:80:16:e4:32:
91:4e:72:c4:5f:2d:b3:e9:57:b1:00:36:2d:1a:e9:9f:4a:b1:
1c:d1:ae:fb:15:79:02:0b:14:97:81:ee:42:01:ed:00:58:38:
b2:30:89:f2:89:11:b7:03:7c:16:95:30:eb:32:9c:9f:00:e5:
22:12:db:7a
-----BEGIN CERTIFICATE-----
MIIEPTCCAyWgAwIBAgIJAL5HPFOmKsA6MA0GCSqGSIb3DQEBCwUAMIG0MQswCQYD
VQQGEwJSVTEVMBMGA1UECAwM0JzQvtGB0LrQstCwMRUwEwYDVQQHDAzQnNC+0YHQ
test/certs/cyrillic_crl.utf8
+16 -15
View File
@@ -9,21 +9,22 @@ Certificate Revocation List (CRL):
1
No Revoked Certificates.
Signature Algorithm: sha256WithRSAEncryption
85:e5:e5:fe:d4:13:3f:07:1a:07:53:6f:f7:a5:01:c9:80:f4:
8a:7a:f3:74:fc:af:dd:6a:21:47:88:99:7b:29:bf:46:0b:02:
98:d7:80:75:46:f6:cd:da:b5:0f:ff:9f:0c:b7:e6:aa:8e:f6:
ae:7f:5c:81:ce:56:89:41:e2:4a:65:cb:02:98:6f:69:e9:3a:
f5:cb:40:49:5e:1a:ea:e6:40:b4:48:bc:8d:0e:c7:c6:51:37:
ee:c6:7c:26:a3:e7:25:1d:74:54:fa:02:ae:93:e8:74:5a:42:
4b:d3:6d:99:61:b2:77:f3:0e:7c:f2:4e:0d:4f:70:96:54:77:
84:db:71:03:0b:6e:b8:a7:de:36:9a:50:c4:ed:e9:fa:33:22:
f5:e7:63:de:2d:df:58:ad:68:aa:e6:23:88:3a:b2:1b:40:b1:
2b:ab:41:23:c3:1b:c7:1b:db:0c:89:81:54:6b:a5:6b:c2:64:
5f:db:a9:f2:67:bb:bd:44:a2:43:3f:ea:36:76:5b:70:76:20:
5a:49:70:b7:42:dd:e9:67:c0:48:7e:ff:e5:f3:59:70:a7:c0:
eb:eb:74:b0:08:82:36:a4:84:69:97:22:02:75:0a:a6:5f:f6:
be:d6:af:24:4e:15:c8:3f:62:b1:f9:7e:3c:83:b5:44:da:8d:
97:e1:c7:f2
Signature Value:
85:e5:e5:fe:d4:13:3f:07:1a:07:53:6f:f7:a5:01:c9:80:f4:
8a:7a:f3:74:fc:af:dd:6a:21:47:88:99:7b:29:bf:46:0b:02:
98:d7:80:75:46:f6:cd:da:b5:0f:ff:9f:0c:b7:e6:aa:8e:f6:
ae:7f:5c:81:ce:56:89:41:e2:4a:65:cb:02:98:6f:69:e9:3a:
f5:cb:40:49:5e:1a:ea:e6:40:b4:48:bc:8d:0e:c7:c6:51:37:
ee:c6:7c:26:a3:e7:25:1d:74:54:fa:02:ae:93:e8:74:5a:42:
4b:d3:6d:99:61:b2:77:f3:0e:7c:f2:4e:0d:4f:70:96:54:77:
84:db:71:03:0b:6e:b8:a7:de:36:9a:50:c4:ed:e9:fa:33:22:
f5:e7:63:de:2d:df:58:ad:68:aa:e6:23:88:3a:b2:1b:40:b1:
2b:ab:41:23:c3:1b:c7:1b:db:0c:89:81:54:6b:a5:6b:c2:64:
5f:db:a9:f2:67:bb:bd:44:a2:43:3f:ea:36:76:5b:70:76:20:
5a:49:70:b7:42:dd:e9:67:c0:48:7e:ff:e5:f3:59:70:a7:c0:
eb:eb:74:b0:08:82:36:a4:84:69:97:22:02:75:0a:a6:5f:f6:
be:d6:af:24:4e:15:c8:3f:62:b1:f9:7e:3c:83:b5:44:da:8d:
97:e1:c7:f2
-----BEGIN X509 CRL-----
MIIB6DCB0QIBATANBgkqhkiG9w0BAQsFADCBjjELMAkGA1UEBhMCUlUxFTATBgNV
BAgMDNCc0L7RgdC60LLQsDELMAkGA1UECgwC0K8xCzAJBgNVBAsMAtCvMSowKAYD
test/certs/sm2-ca-cert.pem
+14
View File
@@ -0,0 +1,14 @@
-----BEGIN CERTIFICATE-----
MIICJDCCAcqgAwIBAgIJAOlkpDpSrmVbMAoGCCqBHM9VAYN1MGgxCzAJBgNVBAYT
AkNOMQswCQYDVQQIDAJMTjERMA8GA1UEBwwIU2hlbnlhbmcxETAPBgNVBAoMCFRl
c3QgT3JnMRAwDgYDVQQLDAdUZXN0IE9VMRQwEgYDVQQDDAtUZXN0IFNNMiBDQTAe
Fw0xOTAyMTkwNzA1NDhaFw0yMzAzMzAwNzA1NDhaMGgxCzAJBgNVBAYTAkNOMQsw
CQYDVQQIDAJMTjERMA8GA1UEBwwIU2hlbnlhbmcxETAPBgNVBAoMCFRlc3QgT3Jn
MRAwDgYDVQQLDAdUZXN0IE9VMRQwEgYDVQQDDAtUZXN0IFNNMiBDQTBZMBMGByqG
SM49AgEGCCqBHM9VAYItA0IABHRYnqErofBdXPptvvO7+BSVJxcpHuTGnZ+UPrbU
5kVEUMaUnNOeMJZl/vRGimZCm/AkReJmRfnb15ESHR+ssp6jXTBbMB0GA1UdDgQW
BBTFjcWu/zJgSZ5SKUlU5Vx4/0W5dDAfBgNVHSMEGDAWgBTFjcWu/zJgSZ5SKUlU
5Vx4/0W5dDAMBgNVHRMEBTADAQH/MAsGA1UdDwQEAwIBBjAKBggqgRzPVQGDdQNI
ADBFAiEAs6byi1nSQtFELOw/2tQIv5AEsZFR5MJ/oB2ztXzs2LYCIEfIw4xlUH6X
YFhs4RnIa0K9Ng1ebsGPrifYkudwBIk3
-----END CERTIFICATE-----
test/certs/sm2.crt → test/certs/sm2.pem
View File
test/clienthellotest.c
+5 -1
View File
@@ -58,7 +58,7 @@ static int test_client_hello(int currtest)
BIO *wbio;
long len;
unsigned char *data;
PACKET pkt = {0}, pkt2 = {0}, pkt3 = {0};
PACKET pkt, pkt2, pkt3;
char *dummytick = "Hello World!";
unsigned int type = 0;
int testresult = 0;
@@ -71,6 +71,10 @@ static int test_client_hello(int currtest)
return 1;
#endif
memset(&pkt, 0, sizeof(pkt));
memset(&pkt2, 0, sizeof(pkt2));
memset(&pkt3, 0, sizeof(pkt3));
/*
* For each test set up an SSL_CTX and SSL and see what ClientHello gets
* produced when we try to connect
test/drbgtest.c
+150 -4
View File
@@ -152,6 +152,31 @@ static size_t kat_nonce(RAND_DRBG *drbg, unsigned char **pout,
return t->noncelen;
}
/*
* Disable CRNG testing if it is enabled.
* If the DRBG is ready or in an error state, this means an instantiate cycle
* for which the default personalisation string is used.
*/
static int disable_crngt(RAND_DRBG *drbg)
{
static const char pers[] = DRBG_DEFAULT_PERS_STRING;
const int instantiate = drbg->state != DRBG_UNINITIALISED;
if (drbg->get_entropy != rand_crngt_get_entropy)
return 1;
if ((instantiate && !RAND_DRBG_uninstantiate(drbg))
|| !TEST_true(RAND_DRBG_set_callbacks(drbg, &rand_drbg_get_entropy,
&rand_drbg_cleanup_entropy,
&rand_drbg_get_nonce,
&rand_drbg_cleanup_nonce))
|| (instantiate
&& !RAND_DRBG_instantiate(drbg, (const unsigned char *)pers,
sizeof(pers) - 1)))
return 0;
return 1;
}
static int uninstantiate(RAND_DRBG *drbg)
{
int ret = drbg == NULL ? 1 : RAND_DRBG_uninstantiate(drbg);
@@ -177,7 +202,8 @@ static int single_kat(DRBG_SELFTEST_DATA *td)
if (!TEST_ptr(drbg = RAND_DRBG_new(td->nid, td->flags, NULL)))
return 0;
if (!TEST_true(RAND_DRBG_set_callbacks(drbg, kat_entropy, NULL,
kat_nonce, NULL))) {
kat_nonce, NULL))
|| !TEST_true(disable_crngt(drbg))) {
failures++;
goto err;
}
@@ -295,7 +321,8 @@ static int error_check(DRBG_SELFTEST_DATA *td)
unsigned int reseed_counter_tmp;
int ret = 0;
if (!TEST_ptr(drbg = RAND_DRBG_new(td->nid, td->flags, NULL)))
if (!TEST_ptr(drbg = RAND_DRBG_new(td->nid, td->flags, NULL))
|| !TEST_true(disable_crngt(drbg)))
goto err;
/*
@@ -708,6 +735,10 @@ static int test_rand_drbg_reseed(void)
|| !TEST_ptr_eq(private->parent, master))
return 0;
/* Disable CRNG testing for the master DRBG */
if (!TEST_true(disable_crngt(master)))
return 0;
/* uninstantiate the three global DRBGs */
RAND_DRBG_uninstantiate(private);
RAND_DRBG_uninstantiate(public);
@@ -928,7 +959,8 @@ static int test_rand_seed(void)
size_t rand_buflen;
size_t required_seed_buflen = 0;
if (!TEST_ptr(master = RAND_DRBG_get0_master()))
if (!TEST_ptr(master = RAND_DRBG_get0_master())
|| !TEST_true(disable_crngt(master)))
return 0;
#ifdef OPENSSL_RAND_SEED_NONE
@@ -983,7 +1015,8 @@ static int test_multi_set(void)
RAND_DRBG *drbg = NULL;
/* init drbg with default CTR initializer */
if (!TEST_ptr(drbg = RAND_DRBG_new(0, 0, NULL)))
if (!TEST_ptr(drbg = RAND_DRBG_new(0, 0, NULL))
|| !TEST_true(disable_crngt(drbg)))
goto err;
/* change it to use hmac */
if (!TEST_true(RAND_DRBG_set(drbg, NID_sha1, RAND_DRBG_FLAG_HMAC)))
@@ -1093,6 +1126,118 @@ static int test_set_defaults(void)
&& TEST_true(RAND_DRBG_uninstantiate(private));
}
/*
* A list of the FIPS DRGB types.
* Because of the way HMAC DRGBs are implemented, both the NID and flags
* are required.
*/
static const struct s_drgb_types {
int nid;
int flags;
} drgb_types[] = {
{ NID_aes_128_ctr, 0 },
{ NID_aes_192_ctr, 0 },
{ NID_aes_256_ctr, 0 },
{ NID_sha1, 0 },
{ NID_sha224, 0 },
{ NID_sha256, 0 },
{ NID_sha384, 0 },
{ NID_sha512, 0 },
{ NID_sha512_224, 0 },
{ NID_sha512_256, 0 },
{ NID_sha3_224, 0 },
{ NID_sha3_256, 0 },
{ NID_sha3_384, 0 },
{ NID_sha3_512, 0 },
{ NID_sha1, RAND_DRBG_FLAG_HMAC },
{ NID_sha224, RAND_DRBG_FLAG_HMAC },
{ NID_sha256, RAND_DRBG_FLAG_HMAC },
{ NID_sha384, RAND_DRBG_FLAG_HMAC },
{ NID_sha512, RAND_DRBG_FLAG_HMAC },
{ NID_sha512_224, RAND_DRBG_FLAG_HMAC },
{ NID_sha512_256, RAND_DRBG_FLAG_HMAC },
{ NID_sha3_224, RAND_DRBG_FLAG_HMAC },
{ NID_sha3_256, RAND_DRBG_FLAG_HMAC },
{ NID_sha3_384, RAND_DRBG_FLAG_HMAC },
{ NID_sha3_512, RAND_DRBG_FLAG_HMAC },
};
/* Six cases for each covers seed sizes up to 32 bytes */
static const size_t crngt_num_cases = 6;
static size_t crngt_case, crngt_idx;
static int crngt_entropy_cb(unsigned char *buf)
{
size_t i, z;
if (!TEST_int_lt(crngt_idx, crngt_num_cases))
return 0;
/* Generate a block of unique data unless this is the duplication point */
z = crngt_idx++;
if (z > 0 && crngt_case == z)
z--;
for (i = 0; i < CRNGT_BUFSIZ; i++)
buf[i] = (unsigned char)(i + 'A' + z);
return 1;
}
static int test_crngt(int n)
{
const struct s_drgb_types *dt = drgb_types + n / crngt_num_cases;
RAND_DRBG *drbg = NULL;
unsigned char buff[100];
size_t ent;
int res = 0;
int expect;
if (!TEST_true(rand_crngt_single_init()))
return 0;
rand_crngt_cleanup();
if (!TEST_ptr(drbg = RAND_DRBG_new(dt->nid, dt->flags, NULL)))
return 0;
ent = (drbg->min_entropylen + CRNGT_BUFSIZ - 1) / CRNGT_BUFSIZ;
crngt_case = n % crngt_num_cases;
crngt_idx = 0;
crngt_get_entropy = &crngt_entropy_cb;
if (!TEST_true(rand_crngt_init()))
goto err;
#ifndef FIPS_MODE
if (!TEST_true(RAND_DRBG_set_callbacks(drbg, &rand_crngt_get_entropy,
&rand_crngt_cleanup_entropy,
&rand_drbg_get_nonce,
&rand_drbg_cleanup_nonce)))
goto err;
#endif
expect = crngt_case == 0 || crngt_case > ent;
if (!TEST_int_eq(RAND_DRBG_instantiate(drbg, NULL, 0), expect))
goto err;
if (!expect)
goto fin;
if (!TEST_true(RAND_DRBG_generate(drbg, buff, sizeof(buff), 0, NULL, 0)))
goto err;
expect = crngt_case == 0 || crngt_case > 2 * ent;
if (!TEST_int_eq(RAND_DRBG_reseed(drbg, NULL, 0, 0), expect))
goto err;
if (!expect)
goto fin;
if (!TEST_true(RAND_DRBG_generate(drbg, buff, sizeof(buff), 0, NULL, 0)))
goto err;
fin:
res = 1;
err:
if (!res)
TEST_note("DRBG %zd case %zd block %zd", n / crngt_num_cases,
crngt_case, crngt_idx);
uninstantiate(drbg);
RAND_DRBG_free(drbg);
crngt_get_entropy = &rand_crngt_get_entropy_cb;
return res;
}
int setup_tests(void)
{
app_data_index = RAND_DRBG_get_ex_new_index(0L, NULL, NULL, NULL, NULL);
@@ -1107,5 +1252,6 @@ int setup_tests(void)
#if defined(OPENSSL_THREADS)
ADD_TEST(test_multi_thread);
#endif
ADD_ALL_TESTS(test_crngt, crngt_num_cases * OSSL_NELEM(drgb_types));
return 1;
}
test/evp_extra_test.c
+164
View File
@@ -18,6 +18,7 @@
#include <openssl/x509.h>
#include <openssl/pem.h>
#include <openssl/kdf.h>
#include <openssl/provider.h>
#include "testutil.h"
#include "internal/nelem.h"
#include "internal/evp_int.h"
@@ -509,6 +510,66 @@ static int test_d2i_AutoPrivateKey(int i)
}
#ifndef OPENSSL_NO_EC
static const unsigned char ec_public_sect163k1_validxy[] = {
0x30, 0x40, 0x30, 0x10, 0x06, 0x07, 0x2a, 0x86, 0x48, 0xce, 0x3d, 0x02,
0x01, 0x06, 0x05, 0x2b, 0x81, 0x04, 0x00, 0x01, 0x03, 0x2c, 0x00, 0x04,
0x02, 0x84, 0x58, 0xa6, 0xd4, 0xa0, 0x35, 0x2b, 0xae, 0xf0, 0xc0, 0x69,
0x05, 0xcf, 0x2a, 0x50, 0x33, 0xf9, 0xe3, 0x92, 0x79, 0x02, 0xd1, 0x7b,
0x9f, 0x22, 0x00, 0xf0, 0x3b, 0x0e, 0x5d, 0x2e, 0xb7, 0x23, 0x24, 0xf3,
0x6a, 0xd8, 0x17, 0x65, 0x41, 0x2f
};
static const unsigned char ec_public_sect163k1_badx[] = {
0x30, 0x40, 0x30, 0x10, 0x06, 0x07, 0x2a, 0x86, 0x48, 0xce, 0x3d, 0x02,
0x01, 0x06, 0x05, 0x2b, 0x81, 0x04, 0x00, 0x01, 0x03, 0x2c, 0x00, 0x04,
0x0a, 0x84, 0x58, 0xa6, 0xd4, 0xa0, 0x35, 0x2b, 0xae, 0xf0, 0xc0, 0x69,
0x05, 0xcf, 0x2a, 0x50, 0x33, 0xf9, 0xe3, 0x92, 0xb0, 0x02, 0xd1, 0x7b,
0x9f, 0x22, 0x00, 0xf0, 0x3b, 0x0e, 0x5d, 0x2e, 0xb7, 0x23, 0x24, 0xf3,
0x6a, 0xd8, 0x17, 0x65, 0x41, 0x2f
};
static const unsigned char ec_public_sect163k1_bady[] = {
0x30, 0x40, 0x30, 0x10, 0x06, 0x07, 0x2a, 0x86, 0x48, 0xce, 0x3d, 0x02,
0x01, 0x06, 0x05, 0x2b, 0x81, 0x04, 0x00, 0x01, 0x03, 0x2c, 0x00, 0x04,
0x02, 0x84, 0x58, 0xa6, 0xd4, 0xa0, 0x35, 0x2b, 0xae, 0xf0, 0xc0, 0x69,
0x05, 0xcf, 0x2a, 0x50, 0x33, 0xf9, 0xe3, 0x92, 0x79, 0x0a, 0xd1, 0x7b,
0x9f, 0x22, 0x00, 0xf0, 0x3b, 0x0e, 0x5d, 0x2e, 0xb7, 0x23, 0x24, 0xf3,
0x6a, 0xd8, 0x17, 0x65, 0x41, 0xe6
};
static struct ec_der_pub_keys_st {
const unsigned char *der;
size_t len;
int valid;
} ec_der_pub_keys[] = {
{ ec_public_sect163k1_validxy, sizeof(ec_public_sect163k1_validxy), 1 },
{ ec_public_sect163k1_badx, sizeof(ec_public_sect163k1_badx), 0 },
{ ec_public_sect163k1_bady, sizeof(ec_public_sect163k1_bady), 0 },
};
/*
* Tests the range of the decoded EC char2 public point.
* See ec_GF2m_simple_oct2point().
*/
static int test_invalide_ec_char2_pub_range_decode(int id)
{
int ret = 0;
BIO *bio = NULL;
EC_KEY *eckey = NULL;
if (!TEST_ptr(bio = BIO_new_mem_buf(ec_der_pub_keys[id].der,
ec_der_pub_keys[id].len)))
goto err;
eckey = d2i_EC_PUBKEY_bio(bio, NULL);
ret = (ec_der_pub_keys[id].valid && TEST_ptr(eckey))
|| TEST_ptr_null(eckey);
err:
EC_KEY_free(eckey);
BIO_free(bio);
return ret;
}
/* Tests loading a bad key in PKCS8 format */
static int test_EVP_PKCS82PKEY(void)
{
@@ -1009,6 +1070,106 @@ done:
}
#endif
static int calculate_digest(const EVP_MD *md, const char *msg, size_t len,
const unsigned char *exptd)
{
unsigned char out[SHA256_DIGEST_LENGTH];
EVP_MD_CTX *ctx;
int ret = 0;
if (!TEST_ptr(ctx = EVP_MD_CTX_new())
|| !TEST_true(EVP_DigestInit_ex(ctx, md, NULL))
|| !TEST_true(EVP_DigestUpdate(ctx, msg, len))
|| !TEST_true(EVP_DigestFinal_ex(ctx, out, NULL))
|| !TEST_mem_eq(out, SHA256_DIGEST_LENGTH, exptd,
SHA256_DIGEST_LENGTH))
goto err;
ret = 1;
err:
EVP_MD_CTX_free(ctx);
return ret;
}
/*
* Test EVP_MD_fetch()
*
* Test 0: Test with the default OPENSSL_CTX
* Test 1: Test with an explicit OPENSSL_CTX
* Test 2: Explicit OPENSSL_CTX with explicit load of default provider
*/
static int test_EVP_MD_fetch(int tst)
{
OPENSSL_CTX *ctx = NULL;
EVP_MD *md = NULL;
OSSL_PROVIDER *prov = NULL;
int ret = 0;
const char testmsg[] = "Hello world";
const unsigned char exptd[] = {
0x27, 0x51, 0x8b, 0xa9, 0x68, 0x30, 0x11, 0xf6, 0xb3, 0x96, 0x07, 0x2c,
0x05, 0xf6, 0x65, 0x6d, 0x04, 0xf5, 0xfb, 0xc3, 0x78, 0x7c, 0xf9, 0x24,
0x90, 0xec, 0x60, 0x6e, 0x50, 0x92, 0xe3, 0x26
};
if (tst > 0) {
ctx = OPENSSL_CTX_new();
if (!TEST_ptr(ctx))
goto err;
if (tst == 2) {
prov = OSSL_PROVIDER_load(ctx, "default");
if (!TEST_ptr(prov))
goto err;
}
}
/* Implicit fetching of the MD should produce the expected result */
if (!TEST_true(calculate_digest(EVP_sha256(), testmsg, sizeof(testmsg),
exptd)))
goto err;
/*
* Test that without loading any providers or specifying any properties we
* can get a sha256 md from the default provider.
*/
if (!TEST_ptr(md = EVP_MD_fetch(ctx, "SHA256", NULL))
|| !TEST_ptr(md)
|| !TEST_int_eq(EVP_MD_nid(md), NID_sha256)
|| !TEST_true(calculate_digest(md, testmsg, sizeof(testmsg), exptd)))
goto err;
/* Also test EVP_MD_upref() while we're doing this */
if (!TEST_true(EVP_MD_upref(md)))
goto err;
/* Ref count should now be 2. Release both */
EVP_MD_meth_free(md);
EVP_MD_meth_free(md);
md = NULL;
/*
* We've only loaded the default provider so explicitly asking for a
* non-default implementation should fail.
*/
if (!TEST_ptr_null(md = EVP_MD_fetch(ctx, "SHA256", "default=no")))
goto err;
/* Explicitly asking for the default implementation should succeeed */
if (!TEST_ptr(md = EVP_MD_fetch(ctx, "SHA256", "default=yes"))
|| !TEST_int_eq(EVP_MD_nid(md), NID_sha256)
|| !TEST_true(calculate_digest(md, testmsg, sizeof(testmsg), exptd)))
goto err;
EVP_MD_meth_free(md);
md = NULL;
ret = 1;
err:
EVP_MD_meth_free(md);
OSSL_PROVIDER_unload(prov);
OPENSSL_CTX_free(ctx);
return ret;
}
int setup_tests(void)
{
ADD_TEST(test_EVP_DigestSignInit);
@@ -1035,6 +1196,9 @@ int setup_tests(void)
ADD_TEST(test_HKDF);
#ifndef OPENSSL_NO_EC
ADD_TEST(test_X509_PUBKEY_inplace);
ADD_ALL_TESTS(test_invalide_ec_char2_pub_range_decode,
OSSL_NELEM(ec_der_pub_keys));
#endif
ADD_ALL_TESTS(test_EVP_MD_fetch, 3);
return 1;
}
test/evp_kdf_test.c
+198 -167
View File
@@ -19,137 +19,76 @@
static int test_kdf_tls1_prf(void)
{
int ret = 0;
int ret;
EVP_KDF_CTX *kctx;
unsigned char out[16];
const unsigned char expected[sizeof(out)] = {
0x8e, 0x4d, 0x93, 0x25, 0x30, 0xd7, 0x65, 0xa0,
0xaa, 0xe9, 0x74, 0xc3, 0x04, 0x73, 0x5e, 0xcc
};
if ((kctx = EVP_KDF_CTX_new_id(EVP_KDF_TLS1_PRF)) == NULL) {
TEST_error("EVP_KDF_TLS1_PRF");
goto err;
}
if (EVP_KDF_ctrl(kctx, EVP_KDF_CTRL_SET_MD, EVP_sha256()) <= 0) {
TEST_error("EVP_KDF_CTRL_SET_MD");
goto err;
}
if (EVP_KDF_ctrl(kctx, EVP_KDF_CTRL_SET_TLS_SECRET,
"secret", (size_t)6) <= 0) {
TEST_error("EVP_KDF_CTRL_SET_TLS_SECRET");
goto err;
}
if (EVP_KDF_ctrl(kctx, EVP_KDF_CTRL_ADD_TLS_SEED, "seed", (size_t)4) <= 0) {
TEST_error("EVP_KDF_CTRL_ADD_TLS_SEED");
goto err;
}
if (EVP_KDF_derive(kctx, out, sizeof(out)) <= 0) {
TEST_error("EVP_KDF_derive");
goto err;
}
ret = TEST_ptr(kctx = EVP_KDF_CTX_new_id(EVP_KDF_TLS1_PRF))
&& TEST_int_gt(EVP_KDF_ctrl(kctx, EVP_KDF_CTRL_SET_MD, EVP_sha256()),
0)
&& TEST_int_gt(EVP_KDF_ctrl(kctx, EVP_KDF_CTRL_SET_TLS_SECRET,
"secret", (size_t)6), 0)
&& TEST_int_gt(EVP_KDF_ctrl(kctx, EVP_KDF_CTRL_ADD_TLS_SEED, "seed",
(size_t)4), 0)
&& TEST_int_gt(EVP_KDF_derive(kctx, out, sizeof(out)), 0)
&& TEST_mem_eq(out, sizeof(out), expected, sizeof(expected));
{
const unsigned char expected[sizeof(out)] = {
0x8e, 0x4d, 0x93, 0x25, 0x30, 0xd7, 0x65, 0xa0,
0xaa, 0xe9, 0x74, 0xc3, 0x04, 0x73, 0x5e, 0xcc
};
if (!TEST_mem_eq(out, sizeof(out), expected, sizeof(expected))) {
goto err;
}
}
ret = 1;
err:
EVP_KDF_CTX_free(kctx);
return ret;
}
static int test_kdf_hkdf(void)
{
int ret = 0;
int ret;
EVP_KDF_CTX *kctx;
unsigned char out[10];
const unsigned char expected[sizeof(out)] = {
0x2a, 0xc4, 0x36, 0x9f, 0x52, 0x59, 0x96, 0xf8, 0xde, 0x13
};
if ((kctx = EVP_KDF_CTX_new_id(EVP_KDF_HKDF)) == NULL) {
TEST_error("EVP_KDF_HKDF");
goto err;
}
if (EVP_KDF_ctrl(kctx, EVP_KDF_CTRL_SET_MD, EVP_sha256()) <= 0) {
TEST_error("EVP_KDF_CTRL_SET_MD");
goto err;
}
if (EVP_KDF_ctrl(kctx, EVP_KDF_CTRL_SET_SALT, "salt", (size_t)4) <= 0) {
TEST_error("EVP_KDF_CTRL_SET_SALT");
goto err;
}
if (EVP_KDF_ctrl(kctx, EVP_KDF_CTRL_SET_KEY, "secret", (size_t)6) <= 0) {
TEST_error("EVP_KDF_CTRL_SET_KEY");
goto err;
}
if (EVP_KDF_ctrl(kctx, EVP_KDF_CTRL_ADD_HKDF_INFO,
"label", (size_t)5) <= 0) {
TEST_error("EVP_KDF_CTRL_ADD_HKDF_INFO");
goto err;
}
if (EVP_KDF_derive(kctx, out, sizeof(out)) <= 0) {
TEST_error("EVP_KDF_derive");
goto err;
}
ret = TEST_ptr(kctx = EVP_KDF_CTX_new_id(EVP_KDF_HKDF))
&& TEST_int_gt(EVP_KDF_ctrl(kctx, EVP_KDF_CTRL_SET_MD, EVP_sha256()),
0)
&& TEST_int_gt(EVP_KDF_ctrl(kctx, EVP_KDF_CTRL_SET_SALT, "salt",
(size_t)4), 0)
&& TEST_int_gt(EVP_KDF_ctrl(kctx, EVP_KDF_CTRL_SET_KEY, "secret",
(size_t)6), 0)
&& TEST_int_gt(EVP_KDF_ctrl(kctx, EVP_KDF_CTRL_ADD_HKDF_INFO,
"label", (size_t)5), 0)
&& TEST_int_gt(EVP_KDF_derive(kctx, out, sizeof(out)), 0)
&& TEST_mem_eq(out, sizeof(out), expected, sizeof(expected));
{
const unsigned char expected[sizeof(out)] = {
0x2a, 0xc4, 0x36, 0x9f, 0x52, 0x59, 0x96, 0xf8, 0xde, 0x13
};
if (!TEST_mem_eq(out, sizeof(out), expected, sizeof(expected))) {
goto err;
}
}
ret = 1;
err:
EVP_KDF_CTX_free(kctx);
return ret;
}
static int test_kdf_pbkdf2(void)
{
int ret = 0;
int ret;
EVP_KDF_CTX *kctx;
unsigned char out[32];
const unsigned char expected[sizeof(out)] = {
0xae, 0x4d, 0x0c, 0x95, 0xaf, 0x6b, 0x46, 0xd3,
0x2d, 0x0a, 0xdf, 0xf9, 0x28, 0xf0, 0x6d, 0xd0,
0x2a, 0x30, 0x3f, 0x8e, 0xf3, 0xc2, 0x51, 0xdf,
0xd6, 0xe2, 0xd8, 0x5a, 0x95, 0x47, 0x4c, 0x43
};
if ((kctx = EVP_KDF_CTX_new_id(EVP_KDF_PBKDF2)) == NULL) {
TEST_error("EVP_KDF_PBKDF2");
goto err;
}
if (EVP_KDF_ctrl(kctx, EVP_KDF_CTRL_SET_PASS, "password", (size_t)8) <= 0) {
TEST_error("EVP_KDF_CTRL_SET_PASS");
goto err;
}
if (EVP_KDF_ctrl(kctx, EVP_KDF_CTRL_SET_SALT, "salt", (size_t)4) <= 0) {
TEST_error("EVP_KDF_CTRL_SET_SALT");
goto err;
}
if (EVP_KDF_ctrl(kctx, EVP_KDF_CTRL_SET_ITER, 2) <= 0) {
TEST_error("EVP_KDF_CTRL_SET_ITER");
goto err;
}
if (EVP_KDF_ctrl(kctx, EVP_KDF_CTRL_SET_MD, EVP_sha256()) <= 0) {
TEST_error("EVP_KDF_CTRL_SET_MD");
goto err;
}
if (EVP_KDF_derive(kctx, out, sizeof(out)) <= 0) {
TEST_error("EVP_KDF_derive");
goto err;
}
ret = TEST_ptr(kctx = EVP_KDF_CTX_new_id(EVP_KDF_PBKDF2))
&& TEST_int_gt(EVP_KDF_ctrl(kctx, EVP_KDF_CTRL_SET_PASS, "password",
(size_t)8), 0)
&& TEST_int_gt(EVP_KDF_ctrl(kctx, EVP_KDF_CTRL_SET_SALT, "salt",
(size_t)4), 0)
&& TEST_int_gt(EVP_KDF_ctrl(kctx, EVP_KDF_CTRL_SET_ITER, 2), 0)
&& TEST_int_gt(EVP_KDF_ctrl(kctx, EVP_KDF_CTRL_SET_MD, EVP_sha256()),
0)
&& TEST_int_gt(EVP_KDF_derive(kctx, out, sizeof(out)), 0)
&& TEST_mem_eq(out, sizeof(out), expected, sizeof(expected));
{
const unsigned char expected[sizeof(out)] = {
0xae, 0x4d, 0x0c, 0x95, 0xaf, 0x6b, 0x46, 0xd3,
0x2d, 0x0a, 0xdf, 0xf9, 0x28, 0xf0, 0x6d, 0xd0,
0x2a, 0x30, 0x3f, 0x8e, 0xf3, 0xc2, 0x51, 0xdf,
0xd6, 0xe2, 0xd8, 0x5a, 0x95, 0x47, 0x4c, 0x43
};
if (!TEST_mem_eq(out, sizeof(out), expected, sizeof(expected))) {
goto err;
}
}
ret = 1;
err:
EVP_KDF_CTX_free(kctx);
return ret;
}
@@ -157,73 +96,162 @@ err:
#ifndef OPENSSL_NO_SCRYPT
static int test_kdf_scrypt(void)
{
int ret = 0;
int ret;
EVP_KDF_CTX *kctx;
unsigned char out[64];
const unsigned char expected[sizeof(out)] = {
0xfd, 0xba, 0xbe, 0x1c, 0x9d, 0x34, 0x72, 0x00,
0x78, 0x56, 0xe7, 0x19, 0x0d, 0x01, 0xe9, 0xfe,
0x7c, 0x6a, 0xd7, 0xcb, 0xc8, 0x23, 0x78, 0x30,
0xe7, 0x73, 0x76, 0x63, 0x4b, 0x37, 0x31, 0x62,
0x2e, 0xaf, 0x30, 0xd9, 0x2e, 0x22, 0xa3, 0x88,
0x6f, 0xf1, 0x09, 0x27, 0x9d, 0x98, 0x30, 0xda,
0xc7, 0x27, 0xaf, 0xb9, 0x4a, 0x83, 0xee, 0x6d,
0x83, 0x60, 0xcb, 0xdf, 0xa2, 0xcc, 0x06, 0x40
};
if ((kctx = EVP_KDF_CTX_new_id(EVP_KDF_SCRYPT)) == NULL) {
TEST_error("EVP_KDF_SCRYPT");
goto err;
}
if (EVP_KDF_ctrl(kctx, EVP_KDF_CTRL_SET_PASS, "password", (size_t)8) <= 0) {
TEST_error("EVP_KDF_CTRL_SET_PASS");
goto err;
}
if (EVP_KDF_ctrl(kctx, EVP_KDF_CTRL_SET_SALT, "NaCl", (size_t)4) <= 0) {
TEST_error("EVP_KDF_CTRL_SET_SALT");
goto err;
}
if (EVP_KDF_ctrl(kctx, EVP_KDF_CTRL_SET_SCRYPT_N, (uint64_t)1024) <= 0) {
TEST_error("EVP_KDF_CTRL_SET_SCRYPT_N");
goto err;
}
if (EVP_KDF_ctrl(kctx, EVP_KDF_CTRL_SET_SCRYPT_R, (uint32_t)8) <= 0) {
TEST_error("EVP_KDF_CTRL_SET_SCRYPT_R");
goto err;
}
if (EVP_KDF_ctrl(kctx, EVP_KDF_CTRL_SET_SCRYPT_P, (uint32_t)16) <= 0) {
TEST_error("EVP_KDF_CTRL_SET_SCRYPT_P");
goto err;
}
if (EVP_KDF_ctrl(kctx, EVP_KDF_CTRL_SET_MAXMEM_BYTES, (uint64_t)16) <= 0) {
TEST_error("EVP_KDF_CTRL_SET_MAXMEM_BYTES");
goto err;
}
if (EVP_KDF_derive(kctx, out, sizeof(out)) > 0) {
TEST_error("EVP_KDF_derive should have failed");
goto err;
}
if (EVP_KDF_ctrl(kctx, EVP_KDF_CTRL_SET_MAXMEM_BYTES,
(uint64_t)(10 * 1024 * 1024)) <= 0) {
TEST_error("EVP_KDF_CTRL_SET_MAXMEM_BYTES");
goto err;
}
if (EVP_KDF_derive(kctx, out, sizeof(out)) <= 0) {
TEST_error("EVP_KDF_derive");
goto err;
}
ret = TEST_ptr(kctx = EVP_KDF_CTX_new_id(EVP_KDF_SCRYPT))
&& TEST_int_gt(EVP_KDF_ctrl(kctx, EVP_KDF_CTRL_SET_PASS, "password",
(size_t)8), 0)
&& TEST_int_gt(EVP_KDF_ctrl(kctx, EVP_KDF_CTRL_SET_SALT, "NaCl",
(size_t)4), 0)
&& TEST_int_gt(EVP_KDF_ctrl(kctx, EVP_KDF_CTRL_SET_SCRYPT_N,
(uint64_t)1024), 0)
&& TEST_int_gt(EVP_KDF_ctrl(kctx, EVP_KDF_CTRL_SET_SCRYPT_R,
(uint32_t)8), 0)
&& TEST_int_gt(EVP_KDF_ctrl(kctx, EVP_KDF_CTRL_SET_SCRYPT_P,
(uint32_t)16), 0)
&& TEST_int_gt(EVP_KDF_ctrl(kctx, EVP_KDF_CTRL_SET_MAXMEM_BYTES,
(uint64_t)16), 0)
/* failure test */
&& TEST_int_le(EVP_KDF_derive(kctx, out, sizeof(out)), 0)
&& TEST_int_gt(EVP_KDF_ctrl(kctx, EVP_KDF_CTRL_SET_MAXMEM_BYTES,
(uint64_t)(10 * 1024 * 1024)), 0)
&& TEST_int_gt(EVP_KDF_derive(kctx, out, sizeof(out)), 0)
&& TEST_mem_eq(out, sizeof(out), expected, sizeof(expected));
EVP_KDF_CTX_free(kctx);
return ret;
}
#endif /* OPENSSL_NO_SCRYPT */
static int test_kdf_ss_hash(void)
{
int ret;
EVP_KDF_CTX *kctx = NULL;
const unsigned char z[] = {
0x6d,0xbd,0xc2,0x3f,0x04,0x54,0x88,0xe4,0x06,0x27,0x57,0xb0,0x6b,0x9e,
0xba,0xe1,0x83,0xfc,0x5a,0x59,0x46,0xd8,0x0d,0xb9,0x3f,0xec,0x6f,0x62,
0xec,0x07,0xe3,0x72,0x7f,0x01,0x26,0xae,0xd1,0x2c,0xe4,0xb2,0x62,0xf4,
0x7d,0x48,0xd5,0x42,0x87,0xf8,0x1d,0x47,0x4c,0x7c,0x3b,0x18,0x50,0xe9
};
const unsigned char other[] = {
0xa1,0xb2,0xc3,0xd4,0xe5,0x43,0x41,0x56,0x53,0x69,0x64,0x3c,0x83,0x2e,
0x98,0x49,0xdc,0xdb,0xa7,0x1e,0x9a,0x31,0x39,0xe6,0x06,0xe0,0x95,0xde,
0x3c,0x26,0x4a,0x66,0xe9,0x8a,0x16,0x58,0x54,0xcd,0x07,0x98,0x9b,0x1e,
0xe0,0xec,0x3f,0x8d,0xbe
};
const unsigned char expected[] = {
0xa4,0x62,0xde,0x16,0xa8,0x9d,0xe8,0x46,0x6e,0xf5,0x46,0x0b,0x47,0xb8
};
unsigned char out[14];
ret = TEST_ptr(kctx = EVP_KDF_CTX_new_id(EVP_KDF_SS))
&& TEST_int_gt(EVP_KDF_ctrl(kctx, EVP_KDF_CTRL_SET_MD, EVP_sha224()),
0)
&& TEST_int_gt(EVP_KDF_ctrl(kctx, EVP_KDF_CTRL_SET_KEY, z, sizeof(z)),
0)
&& TEST_int_gt(EVP_KDF_ctrl(kctx, EVP_KDF_CTRL_SET_SSKDF_INFO, other,
sizeof(other)), 0)
&& TEST_int_gt(EVP_KDF_derive(kctx, out, sizeof(out)), 0)
&& TEST_mem_eq(out, sizeof(out), expected, sizeof(expected));
EVP_KDF_CTX_free(kctx);
return ret;
}
static int test_kdf_ss_hmac(void)
{
int ret;
EVP_KDF_CTX *kctx;
const EVP_MAC *mac;
const unsigned char z[] = {
0xb7,0x4a,0x14,0x9a,0x16,0x15,0x46,0xf8,0xc2,0x0b,0x06,0xac,0x4e,0xd4
};
const unsigned char other[] = {
0x34,0x8a,0x37,0xa2,0x7e,0xf1,0x28,0x2f,0x5f,0x02,0x0d,0xcc
};
const unsigned char salt[] = {
0x36,0x38,0x27,0x1c,0xcd,0x68,0xa2,0x5d,0xc2,0x4e,0xcd,0xdd,0x39,0xef,
0x3f,0x89
};
const unsigned char expected[] = {
0x44,0xf6,0x76,0xe8,0x5c,0x1b,0x1a,0x8b,0xbc,0x3d,0x31,0x92,0x18,0x63,
0x1c,0xa3
};
unsigned char out[16];
ret = TEST_ptr(kctx = EVP_KDF_CTX_new_id(EVP_KDF_SS))
&& TEST_ptr(mac = EVP_get_macbyname("HMAC"))
&& TEST_int_gt(EVP_KDF_ctrl(kctx, EVP_KDF_CTRL_SET_MAC, mac), 0)
&& TEST_int_gt(EVP_KDF_ctrl(kctx, EVP_KDF_CTRL_SET_MD, EVP_sha256()),
0)
&& TEST_int_gt(EVP_KDF_ctrl(kctx, EVP_KDF_CTRL_SET_KEY, z, sizeof(z)),
0)
&& TEST_int_gt(EVP_KDF_ctrl(kctx, EVP_KDF_CTRL_SET_SSKDF_INFO, other,
sizeof(other)), 0)
&& TEST_int_gt(EVP_KDF_ctrl(kctx, EVP_KDF_CTRL_SET_SALT, salt,
sizeof(salt)), 0)
&& TEST_int_gt(EVP_KDF_derive(kctx, out, sizeof(out)), 0)
&& TEST_mem_eq(out, sizeof(out), expected, sizeof(expected));
EVP_KDF_CTX_free(kctx);
return ret;
}
static int test_kdf_ss_kmac(void)
{
int ret;
EVP_KDF_CTX *kctx;
unsigned char out[64];
const EVP_MAC *mac;
const unsigned char z[] = {
0xb7,0x4a,0x14,0x9a,0x16,0x15,0x46,0xf8,0xc2,0x0b,0x06,0xac,0x4e,0xd4
};
const unsigned char other[] = {
0x34,0x8a,0x37,0xa2,0x7e,0xf1,0x28,0x2f,0x5f,0x02,0x0d,0xcc
};
const unsigned char salt[] = {
0x36,0x38,0x27,0x1c,0xcd,0x68,0xa2,0x5d,0xc2,0x4e,0xcd,0xdd,0x39,0xef,
0x3f,0x89
};
const unsigned char expected[] = {
0xe9,0xc1,0x84,0x53,0xa0,0x62,0xb5,0x3b,0xdb,0xfc,0xbb,0x5a,0x34,0xbd,
0xb8,0xe5,0xe7,0x07,0xee,0xbb,0x5d,0xd1,0x34,0x42,0x43,0xd8,0xcf,0xc2,
0xc2,0xe6,0x33,0x2f,0x91,0xbd,0xa5,0x86,0xf3,0x7d,0xe4,0x8a,0x65,0xd4,
0xc5,0x14,0xfd,0xef,0xaa,0x1e,0x67,0x54,0xf3,0x73,0xd2,0x38,0xe1,0x95,
0xae,0x15,0x7e,0x1d,0xe8,0x14,0x98,0x03
};
ret = TEST_ptr(kctx = EVP_KDF_CTX_new_id(EVP_KDF_SS))
&& TEST_ptr(mac = EVP_get_macbyname("KMAC128"))
&& TEST_int_gt(EVP_KDF_ctrl(kctx, EVP_KDF_CTRL_SET_MAC, mac), 0)
&& TEST_int_gt(EVP_KDF_ctrl(kctx, EVP_KDF_CTRL_SET_KEY, z,
sizeof(z)), 0)
&& TEST_int_gt(EVP_KDF_ctrl(kctx, EVP_KDF_CTRL_SET_SSKDF_INFO, other,
sizeof(other)), 0)
&& TEST_int_gt(EVP_KDF_ctrl(kctx, EVP_KDF_CTRL_SET_SALT, salt,
sizeof(salt)), 0)
&& TEST_int_gt(EVP_KDF_ctrl(kctx, EVP_KDF_CTRL_SET_MAC_SIZE,
(size_t)20), 0)
&& TEST_int_gt(EVP_KDF_derive(kctx, out, sizeof(out)), 0)
&& TEST_mem_eq(out, sizeof(out), expected, sizeof(expected));
{
const unsigned char expected[sizeof(out)] = {
0xfd, 0xba, 0xbe, 0x1c, 0x9d, 0x34, 0x72, 0x00,
0x78, 0x56, 0xe7, 0x19, 0x0d, 0x01, 0xe9, 0xfe,
0x7c, 0x6a, 0xd7, 0xcb, 0xc8, 0x23, 0x78, 0x30,
0xe7, 0x73, 0x76, 0x63, 0x4b, 0x37, 0x31, 0x62,
0x2e, 0xaf, 0x30, 0xd9, 0x2e, 0x22, 0xa3, 0x88,
0x6f, 0xf1, 0x09, 0x27, 0x9d, 0x98, 0x30, 0xda,
0xc7, 0x27, 0xaf, 0xb9, 0x4a, 0x83, 0xee, 0x6d,
0x83, 0x60, 0xcb, 0xdf, 0xa2, 0xcc, 0x06, 0x40
};
if (!TEST_mem_eq(out, sizeof(out), expected, sizeof(expected))) {
goto err;
}
}
ret = 1;
err:
EVP_KDF_CTX_free(kctx);
return ret;
}
#endif
int setup_tests(void)
{
@@ -233,5 +261,8 @@ int setup_tests(void)
#ifndef OPENSSL_NO_SCRYPT
ADD_TEST(test_kdf_scrypt);
#endif
ADD_TEST(test_kdf_ss_hash);
ADD_TEST(test_kdf_ss_hmac);
ADD_TEST(test_kdf_ss_kmac);
return 1;
}
test/ossl_test_endian.h
+22
View File
@@ -0,0 +1,22 @@
/*
* Copyright 2019 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 can obtain a copy
* in the file LICENSE in the source distribution or at
* https://www.openssl.org/source/license.html
*/
#ifndef HEADER_INTERNAL_ENDIAN_H
# define HEADER_INTERNAL_ENDIAN_H
# define DECLARE_IS_ENDIAN \
const union { \
long one; \
char little; \
} ossl_is_endian = { 1 }
# define IS_LITTLE_ENDIAN (ossl_is_endian.little != 0)
# define IS_BIG_ENDIAN (ossl_is_endian.little == 0)
#endif
test/packettest.c
+10 -5
View File
@@ -350,8 +350,9 @@ static int test_PACKET_get_length_prefixed_1(void)
unsigned char buf1[BUF_LEN];
const size_t len = 16;
unsigned int i;
PACKET pkt, short_pkt, subpkt = {0};
PACKET pkt, short_pkt, subpkt;
memset(&subpkt, 0, sizeof(subpkt));
buf1[0] = (unsigned char)len;
for (i = 1; i < BUF_LEN; i++)
buf1[i] = (i * 2) & 0xff;
@@ -374,8 +375,9 @@ static int test_PACKET_get_length_prefixed_2(void)
unsigned char buf1[1024];
const size_t len = 516; /* 0x0204 */
unsigned int i;
PACKET pkt, short_pkt, subpkt = {0};
PACKET pkt, short_pkt, subpkt;
memset(&subpkt, 0, sizeof(subpkt));
for (i = 1; i <= 1024; i++)
buf1[i - 1] = (i * 2) & 0xff;
@@ -397,8 +399,9 @@ static int test_PACKET_get_length_prefixed_3(void)
unsigned char buf1[1024];
const size_t len = 516; /* 0x000204 */
unsigned int i;
PACKET pkt, short_pkt, subpkt = {0};
PACKET pkt, short_pkt, subpkt;
memset(&subpkt, 0, sizeof(subpkt));
for (i = 0; i < 1024; i++)
buf1[i] = (i * 2) & 0xff;
@@ -420,8 +423,9 @@ static int test_PACKET_as_length_prefixed_1(void)
unsigned char buf1[BUF_LEN];
const size_t len = 16;
unsigned int i;
PACKET pkt, exact_pkt, subpkt = {0};
PACKET pkt, exact_pkt, subpkt;
memset(&subpkt, 0, sizeof(subpkt));
buf1[0] = (unsigned char)len;
for (i = 1; i < BUF_LEN; i++)
buf1[i] = (i * 2) & 0xff;
@@ -443,8 +447,9 @@ static int test_PACKET_as_length_prefixed_2(void)
unsigned char buf[1024];
const size_t len = 516; /* 0x0204 */
unsigned int i;
PACKET pkt, exact_pkt, subpkt = {0};
PACKET pkt, exact_pkt, subpkt;
memset(&subpkt, 0, sizeof(subpkt));
for (i = 1; i <= 1024; i++)
buf[i-1] = (i * 2) & 0xff;
test/params_api_test.c
+19 -17
View File
@@ -11,6 +11,7 @@
#include <string.h>
#include "testutil.h"
#include "internal/nelem.h"
#include "ossl_test_endian.h"
#include <openssl/params.h>
#include <openssl/bn.h>
@@ -27,20 +28,22 @@ static void swap_copy(unsigned char *out, const void *in, size_t len)
static void copy_to_le(unsigned char *out, const void *in, size_t len)
{
#ifdef B_ENDIAN
swap_copy(out, in, len);
#else
memcpy(out, in, len);
#endif
DECLARE_IS_ENDIAN;
if (IS_LITTLE_ENDIAN)
memcpy(out, in, len);
else
swap_copy(out, in, len);
}
static void copy_be_to_native(unsigned char *out, const void *in, size_t len)
{
#ifdef B_ENDIAN
memcpy(out, in, len);
#else
swap_copy(out, in, len);
#endif
DECLARE_IS_ENDIAN;
if (IS_LITTLE_ENDIAN)
swap_copy(out, in, len);
else
memcpy(out, in, len);
}
static const struct {
@@ -103,12 +106,12 @@ static int test_param_type_extra(const OSSL_PARAM *param, unsigned char *cmp,
if (signd) {
if (!TEST_true(OSSL_PARAM_set_int32(param, 12345))
|| !TEST_true(OSSL_PARAM_get_int64(param, &i64))
|| !TEST_size_t_eq(i64, 12345))
|| !TEST_size_t_eq((size_t)i64, 12345))
return 0;
} else {
if (!TEST_true(OSSL_PARAM_set_uint32(param, 12345))
|| !TEST_true(OSSL_PARAM_get_uint64(param, (uint64_t *)&i64))
|| !TEST_size_t_eq(i64, 12345))
|| !TEST_size_t_eq((size_t)i64, 12345))
return 0;
}
}
@@ -465,7 +468,7 @@ static int test_param_construct(void)
OSSL_PARAM params[20];
char buf[100], buf2[100], *bufp, *bufp2;
unsigned char ubuf[100];
void *vp, *vp2;
void *vp, *vpn = NULL, *vp2;
OSSL_PARAM *p;
const OSSL_PARAM *cp;
static const OSSL_PARAM pend = OSSL_PARAM_END;
@@ -557,7 +560,6 @@ static int test_param_construct(void)
|| !TEST_ptr_eq(bufp2, bufp))
goto err;
/* OCTET string */
vp = NULL;
if (!TEST_ptr(p = locate(params, "octstr"))
|| !TEST_true(OSSL_PARAM_set_octet_string(p, "abcdefghi",
sizeof("abcdefghi")))
@@ -565,12 +567,11 @@ static int test_param_construct(void)
goto err;
/* Match the return size to avoid trailing garbage bytes */
p->data_size = *p->return_size;
if (!TEST_true(OSSL_PARAM_get_octet_string(p, &vp, 0, &s))
if (!TEST_true(OSSL_PARAM_get_octet_string(p, &vpn, 0, &s))
|| !TEST_size_t_eq(s, sizeof("abcdefghi"))
|| !TEST_mem_eq(vp, sizeof("abcdefghi"),
|| !TEST_mem_eq(vpn, sizeof("abcdefghi"),
"abcdefghi", sizeof("abcdefghi")))
goto err;
OPENSSL_free(vp);
vp = buf2;
if (!TEST_true(OSSL_PARAM_get_octet_string(p, &vp, sizeof(buf2), &s))
|| !TEST_size_t_eq(s, sizeof("abcdefghi"))
@@ -604,6 +605,7 @@ static int test_param_construct(void)
goto err;
ret = 1;
err:
OPENSSL_free(vpn);
BN_free(bn);
BN_free(bn2);
return ret;
test/provider_internal_test.c
+3 -3
View File
@@ -35,9 +35,9 @@ static int test_provider(OSSL_PROVIDER *prov)
if (!TEST_ptr(name = ossl_provider_name(prov)))
return 0;
snprintf(expected_greeting, sizeof(expected_greeting),
"Hello OpenSSL %.20s, greetings from %s!",
OPENSSL_VERSION_STR, name);
BIO_snprintf(expected_greeting, sizeof(expected_greeting),
"Hello OpenSSL %.20s, greetings from %s!",
OPENSSL_VERSION_STR, name);
ret =
TEST_true(ossl_provider_activate(prov))
test/provider_test.c
+3 -3
View File
@@ -32,9 +32,9 @@ static int test_provider(const char *name)
const char *greeting = NULL;
char expected_greeting[256];
snprintf(expected_greeting, sizeof(expected_greeting),
"Hello OpenSSL %.20s, greetings from %s!",
OPENSSL_VERSION_STR, name);
BIO_snprintf(expected_greeting, sizeof(expected_greeting),
"Hello OpenSSL %.20s, greetings from %s!",
OPENSSL_VERSION_STR, name);
return
TEST_ptr(prov = OSSL_PROVIDER_load(NULL, name))
test/recipes/20-test_pkeyutl.t
+3 -3
View File
@@ -25,14 +25,14 @@ SKIP: {
# SM2
ok(run(app(([ 'openssl', 'pkeyutl', '-sign',
'-in', srctop_file('test', 'certs', 'sm2.crt'),
'-in', srctop_file('test', 'certs', 'sm2.pem'),
'-inkey', srctop_file('test', 'certs', 'sm2.key'),
'-out', 'signature.dat', '-rawin',
'-digest', 'sm3', '-pkeyopt', 'sm2_id:someid']))),
"Sign a piece of data using SM2");
ok(run(app(([ 'openssl', 'pkeyutl', '-verify', '-certin',
'-in', srctop_file('test', 'certs', 'sm2.crt'),
'-inkey', srctop_file('test', 'certs', 'sm2.crt'),
'-in', srctop_file('test', 'certs', 'sm2.pem'),
'-inkey', srctop_file('test', 'certs', 'sm2.pem'),
'-sigfile', 'signature.dat', '-rawin',
'-digest', 'sm3', '-pkeyopt', 'sm2_id:someid']))),
"Verify an SM2 signature against a piece of data");
test/recipes/25-test_verify.t
+13 -1
View File
@@ -27,7 +27,7 @@ sub verify {
run(app([@args]));
}
plan tests => 135;
plan tests => 137;
# Canonical success
ok(verify("ee-cert", "sslserver", ["root-cert"], ["ca-cert"]),
@@ -373,3 +373,15 @@ SKIP: {
"ED25519 signature");
}
SKIP: {
skip "SM2 is not supported by this OpenSSL build", 1
if disabled("sm2");
# Test '-sm2-id' and '-sm2-hex-id' option
ok(verify("sm2", "any", ["sm2-ca-cert"], [], "-sm2-id", "1234567812345678"),
"SM2 ID test");
ok(verify("sm2", "any", ["sm2-ca-cert"], [], "-sm2-hex-id",
"31323334353637383132333435363738"),
"SM2 hex ID test");
}
test/recipes/25-test_x509.t
+25 -1
View File
@@ -11,11 +11,12 @@ use strict;
use warnings;
use File::Spec;
use OpenSSL::Test::Utils;
use OpenSSL::Test qw/:DEFAULT srctop_file/;
setup("test_x509");
plan tests => 9;
plan tests => 10;
require_ok(srctop_file('test','recipes','tconversion.pl'));
@@ -34,6 +35,29 @@ is(cmp_text($out, srctop_file("test/certs", "cyrillic.utf8")),
0, 'Comparing utf8 output');
unlink $out;
SKIP: {
skip "EC disabled", 1 if disabled("ec");
# producing and checking self-issued (but not self-signed) cert
my @path = qw(test certs);
my $subj = "/CN=CA"; # using same DN as in issuer of ee-cert.pem
my $pkey = srctop_file(@path, "ca-key.pem"); # issuer private key
my $pubkey = "ca-pubkey.pem"; # the corresponding issuer public key
# use any (different) key for signing our self-issued cert:
my $signkey = srctop_file(@path, "ee-ecdsa-key.pem");
my $selfout = "self-issued.out";
my $testcert = srctop_file(@path, "ee-cert.pem");
ok(run(app(["openssl", "pkey", "-in", $pkey, "-pubout", "-out", $pubkey]))
&&
run(app(["openssl", "x509", "-new", "-force_pubkey", $pubkey,
"-subj", $subj, "-signkey", $signkey, "-out", $selfout]))
&&
run(app(["openssl", "verify", "-no_check_time",
"-trusted", $selfout, $testcert])));
unlink $pubkey;
unlink $selfout;
}
subtest 'x509 -- x.509 v1 certificate' => sub {
tconversion("x509", srctop_file("test","testx509.pem"));
};
test/recipes/30-test_evp_data/evpciph.txt
+31 -1
View File
@@ -2233,7 +2233,7 @@ IV = 00000000000000000000000000000000
Plaintext = 11111111aaaaaaaa11111111bbbbbbbb11111111cccccccc11111111dddddddd22222222aaaaaaaa22222222bbbbbbbb22222222cccccccc22222222dddddddd33333333aaaaaaaa33333333bbbbbbbb33333333cccccccc33333333dddddddd44444444aaaaaaaa44444444bbbbbbbb44444444cccccccc44444444dddddddd55555555aaaaaaaa55555555bbbbbbbb55555555cccccccc55555555dddddddd
Ciphertext = 30026c329666141721178b99c0a1f1b2f06940253f7b3089e2a30ea86aa3c88f5940f05ad7ee41d71347bb7261e348f18360473fdf7d4e7723bffb4411cc13f6cdd89f3bc7b9c768145022c7a74f14d7c305cd012a10f16050c23f1ae5c23f45998d13fbaa041e51619577e0772764896a5d4516d8ffceb3bf7e05f613edd9a60cdcedaff9cfcaf4e00d445a54334f73ab2cad944e51d266548e61c6eb0aa1cd
Title = ARIA GCM test vectors from IETF draft-ietf-avtcore-aria-srtp-10
Title = ARIA GCM test vectors from RFC8269
Cipher = ARIA-128-GCM
Key = e91e5e75da65554a48181f3846349562
@@ -2251,6 +2251,36 @@ Tag = e210d6ced2cf430ff841472915e7ef48
Plaintext = f57af5fd4ae19562976ec57a5a7ad55a5af5c5e5c5fdf5c55ad57a4a7272d57262e9729566ed66e97ac54a4a5a7ad5e15ae5fdd5fd5ac5d56ae56ad5c572d54ae54ac55a956afd6aed5a4ac562957a9516991691d572fd14e97ae962ed7a9f4a955af572e162f57a956666e17ae1f54a95f566d54a66e16e4afd6a9f7ae1c5c55ae5d56afde916c5e94a6ec56695e14afde1148416e94ad57ac5146ed59d1cc5
Ciphertext = 6f9e4bcbc8c85fc0128fb1e4a0a20cb9932ff74581f54fc013dd054b19f99371425b352d97d3f337b90b63d1b082adeeea9d2d7391897d591b985e55fb50cb5350cf7d38dc27dda127c078a149c8eb98083d66363a46e3726af217d3a00275ad5bf772c7610ea4c23006878f0ee69a8397703169a419303f40b72e4573714d19e2697df61e7c7252e5abc6bade876ac4961bfac4d5e867afca351a48aed52822
Title = ARIA GCM self-generated test vectors
Cipher = ARIA-128-GCM
Key = e91e5e75da65554a48181f3846349562
# Shorter than default IV
IV = 0001020304
AAD = 8008315ebf2e6fe020e8f5eb
Tag = ebaa2645bb154542117ee46031aa176e
Plaintext = f57af5fd4ae19562976ec57a5a7ad55a5af5c5e5c5fdf5c55ad57a4a7272d57262e9729566ed66e97ac54a4a5a7ad5e15ae5fdd5fd5ac5d56ae56ad5c572d54ae54ac55a956afd6aed5a4ac562957a9516991691d572fd14e97ae962ed7a9f4a955af572e162f57a956666e17ae1f54a95f566d54a66e16e4afd6a9f7ae1c5c55ae5d56afde916c5e94a6ec56695e14afde1148416e94ad57ac5146ed59d1cc5
Ciphertext = 1723ccfc0ed44a12520473cfeb63bc933cd450a943f5f1cba78e19d72f80cc102acc51f2459a06cf6435182b8ddd451f83e13479efe5ec7dfbf16229f4017920fb41457a9b6fe1a401b30b2f332d827ae2f86e962326927c1ed8bfedac1f7a00ddde63bd392a8f28a488ba5974689f8d15b9b1739fb50aae0ff244026ec72064003c621b33ffc8086b0a97eefb70604a2826f6499f6eb12d67a0da03fc8e1482
Cipher = ARIA-128-GCM
Key = e91e5e75da65554a48181f3846349562
# Longer than default IV
IV = 000102030405060708090a0b0c0d0e0f
AAD = 8008315ebf2e6fe020e8f5eb
Tag = 61f7f44c7da3c60195b29ae0b46051a4
Plaintext = f57af5fd4ae19562976ec57a5a7ad55a5af5c5e5c5fdf5c55ad57a4a7272d57262e9729566ed66e97ac54a4a5a7ad5e15ae5fdd5fd5ac5d56ae56ad5c572d54ae54ac55a956afd6aed5a4ac562957a9516991691d572fd14e97ae962ed7a9f4a955af572e162f57a956666e17ae1f54a95f566d54a66e16e4afd6a9f7ae1c5c55ae5d56afde916c5e94a6ec56695e14afde1148416e94ad57ac5146ed59d1cc5
Ciphertext = 0d3e98fcaf7a2c4fe9198d66add90d113e5e0ff47598c40a4bf501960d935a4156c9a4d46c9358a608e10a16479a4247c9ab9bb4a02809e3eac3571b832590fe2ca3e2d545741e36282d96c041fc7d39a46ed60214c2c0ec70f27768dfea4f9563b5d5c2ac33b1368a78f2908f5daf942433fec6ab588f09e908e95cc8dfa85d1a0dfd5835dc14e148323230c63eedc99a9ce942214cb3768b97b821d613629f
Cipher = ARIA-128-GCM
Key = e91e5e75da65554a48181f3846349562
# Extra long IV
IV = 000102030405060708090a0b0c0d0e0f1011
AAD = 8008315ebf2e6fe020e8f5eb
Tag = c8b31ab6c2ddccab06b76af4e56e664e
Plaintext = f57af5fd4ae19562976ec57a5a7ad55a5af5c5e5c5fdf5c55ad57a4a7272d57262e9729566ed66e97ac54a4a5a7ad5e15ae5fdd5fd5ac5d56ae56ad5c572d54ae54ac55a956afd6aed5a4ac562957a9516991691d572fd14e97ae962ed7a9f4a955af572e162f57a956666e17ae1f54a95f566d54a66e16e4afd6a9f7ae1c5c55ae5d56afde916c5e94a6ec56695e14afde1148416e94ad57ac5146ed59d1cc5
Ciphertext = 616a7bce24206501082cef7267c09a4affa54f8f82eb7fb2cdebdcaab4b6ab05c37e891c2d0fc90d15c5fb684247625c8bc0befad86896ae1c8f5a8506954caba4e13df0a0eb23853d4474e7f3b2c57bb398456a24d198e14566bce8a5f8d3bcdb12994d2fdc0f5cf19aeff990c1fe119e01f9fcc86757b1d43a9accf7b2f913c2208a46c1967f403867f89b46ffe96864c63f042265806ea5270e0dddd0e8dd
Title = ARIA CCM test vectors from IETF draft-ietf-avtcore-aria-srtp-02
# 16-byte Tag
test/recipes/30-test_evp_data/evpkdf.txt
+1089 -1
View File
@@ -1,5 +1,5 @@
#
# Copyright 2001-2018 The OpenSSL Project Authors. All Rights Reserved.
# Copyright 2001-2019 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 can obtain a copy
@@ -5286,3 +5286,1091 @@ Ctrl.hexsession_id = hexsession_id:a4ebd45934f56792b5112dcd75a1075fdc889245
Ctrl.type = type:A
Output = FF
Result = KDF_MISMATCH
#There are currently no official test vectors for Single Step KDF
#https://github.com/patrickfav/singlestep-kdf/wiki/NIST-SP-800-56C-Rev1:-Non-Official-Test-Vectors
Title = Single Step KDF tests
KDF = SSKDF
Ctrl.digest = digest:SHA1
Ctrl.hexsecret = hexsecret:d09a6b1a472f930db4f5e6b967900744
Ctrl.hexinfo = hexinfo:b117255ab5f1b6b96fc434b0
Output = b5a3c52e97ae6e8c5069954354eab3c7
KDF = SSKDF
Ctrl.digest = digest:SHA1
Ctrl.hexsecret = hexsecret:343666c0dd34b756e70f759f14c304f5
Ctrl.hexinfo = hexinfo:722b28448d7eab85491bce09
Output = 1003b650ddd3f0891a15166db5ec881d
KDF = SSKDF
Ctrl.digest = digest:SHA1
Ctrl.hexsecret = hexsecret:b84acf03ab08652dd7f82fa956933261
Ctrl.hexinfo = hexinfo:3d8773ec068c86053a918565
Output = 1635dcd1ce698f736831b4badb68ab2b
KDF = SSKDF
Ctrl.digest = digest:SHA1
Ctrl.hexsecret = hexsecret:8cc24ca3f1d1a8b34783780b79890430
Ctrl.hexinfo = hexinfo:f08d4f2d9a8e6d7105c0bc16
Output = b8e716fb84a420aed4812cd76d9700ee
KDF = SSKDF
Ctrl.digest = digest:SHA1
Ctrl.hexsecret = hexsecret:b616905a6f7562cd2689142ce21e42a3
Ctrl.hexinfo = hexinfo:ead310159a909da87e7b4b40
Output = 1b9201358c50fe5d5d42907c4a9fce78
KDF = SSKDF
Ctrl.digest = digest:SHA1
Ctrl.hexsecret = hexsecret:3f57fd3fd56199b3eb33890f7ee28180
Ctrl.hexinfo = hexinfo:7a5056ba4fdb034c7cb6c4fe
Output = e51ebd30a8c4b8449b0fb29d9adc11af
KDF = SSKDF
Ctrl.digest = digest:SHA1
Ctrl.hexsecret = hexsecret:fb9fb108d104e9f662d6593fc84cde69
Ctrl.hexinfo = hexinfo:5faf29211c1bdbf1b2696a7c
Output = 7a3a7e670656e48c390cdd7c51e167e0
KDF = SSKDF
Ctrl.digest = digest:SHA1
Ctrl.hexsecret = hexsecret:237a39981794f4516dccffc3dda28396
Ctrl.hexinfo = hexinfo:62ed9528d104c241e0f66275
Output = 0c26fc9e90e1c5c5f943428301682045
KDF = SSKDF
Ctrl.digest = digest:SHA1
Ctrl.hexsecret = hexsecret:b9b6c45f7279218fa09894e06366a3a1
Ctrl.hexinfo = hexinfo:0f384339670aaed4b89ecb7e
Output = ee5fad414e32fad5d52a2bf61a7f6c72
KDF = SSKDF
Ctrl.digest = digest:SHA1
Ctrl.hexsecret = hexsecret:08b7140e2cd0a4abd79171e4d5a71cad
Ctrl.hexinfo = hexinfo:099211f0d8a2e02dbb5958c0
Output = 6162f5142e057efafd2c4f2bad5985a1
KDF = SSKDF
Ctrl.digest = digest:SHA1
Ctrl.hexsecret = hexsecret:ebe28edbae5a410b87a479243db3f690
Ctrl.hexinfo = hexinfo:e60dd8b28228ce5b9be74d3b
Output = b4a2
KDF = SSKDF
Ctrl.digest = digest:SHA1
Ctrl.hexsecret = hexsecret:ebe28edbae5a410b87a479243db3f690
Ctrl.hexinfo = hexinfo:e60dd8b28228ce5b9be74d3b
Output = b4a23963
KDF = SSKDF
Ctrl.digest = digest:SHA1
Ctrl.hexsecret = hexsecret:ebe28edbae5a410b87a479243db3f690
Ctrl.hexinfo = hexinfo:e60dd8b28228ce5b9be74d3b
Output = b4a23963e07f
KDF = SSKDF
Ctrl.digest = digest:SHA1
Ctrl.hexsecret = hexsecret:ebe28edbae5a410b87a479243db3f690
Ctrl.hexinfo = hexinfo:e60dd8b28228ce5b9be74d3b
Output = b4a23963e07f4853
KDF = SSKDF
Ctrl.digest = digest:SHA1
Ctrl.hexsecret = hexsecret:ebe28edbae5a410b87a479243db3f690
Ctrl.hexinfo = hexinfo:e60dd8b28228ce5b9be74d3b
Output = b4a23963e07f485382cb
KDF = SSKDF
Ctrl.digest = digest:SHA1
Ctrl.hexsecret = hexsecret:ebe28edbae5a410b87a479243db3f690
Ctrl.hexinfo = hexinfo:e60dd8b28228ce5b9be74d3b
Output = b4a23963e07f485382cb358a
KDF = SSKDF
Ctrl.digest = digest:SHA1
Ctrl.hexsecret = hexsecret:ebe28edbae5a410b87a479243db3f690
Ctrl.hexinfo = hexinfo:e60dd8b28228ce5b9be74d3b
Output = b4a23963e07f485382cb358a493d
KDF = SSKDF
Ctrl.digest = digest:SHA1
Ctrl.hexsecret = hexsecret:ebe28edbae5a410b87a479243db3f690
Ctrl.hexinfo = hexinfo:e60dd8b28228ce5b9be74d3b
Output = b4a23963e07f485382cb358a493daec1
KDF = SSKDF
Ctrl.digest = digest:SHA1
Ctrl.hexsecret = hexsecret:ebe28edbae5a410b87a479243db3f690
Ctrl.hexinfo = hexinfo:e60dd8b28228ce5b9be74d3b
Output = b4a23963e07f485382cb358a493daec1759a
KDF = SSKDF
Ctrl.digest = digest:SHA1
Ctrl.hexsecret = hexsecret:ebe28edbae5a410b87a479243db3f690
Ctrl.hexinfo = hexinfo:e60dd8b28228ce5b9be74d3b
Output = b4a23963e07f485382cb358a493daec1759ac704
KDF = SSKDF
Ctrl.digest = digest:SHA1
Ctrl.hexsecret = hexsecret:ebe28edbae5a410b87a479243db3f690
Ctrl.hexinfo = hexinfo:e60dd8b28228ce5b9be74d3b
Output = b4a23963e07f485382cb358a493daec1759ac7043dbe
KDF = SSKDF
Ctrl.digest = digest:SHA1
Ctrl.hexsecret = hexsecret:ebe28edbae5a410b87a479243db3f690
Ctrl.hexinfo = hexinfo:e60dd8b28228ce5b9be74d3b
Output = b4a23963e07f485382cb358a493daec1759ac7043dbeac37
KDF = SSKDF
Ctrl.digest = digest:SHA1
Ctrl.hexsecret = hexsecret:ebe28edbae5a410b87a479243db3f690
Ctrl.hexinfo = hexinfo:e60dd8b28228ce5b9be74d3b
Output = b4a23963e07f485382cb358a493daec1759ac7043dbeac37152c
KDF = SSKDF
Ctrl.digest = digest:SHA1
Ctrl.hexsecret = hexsecret:ebe28edbae5a410b87a479243db3f690
Ctrl.hexinfo = hexinfo:e60dd8b28228ce5b9be74d3b
Output = b4a23963e07f485382cb358a493daec1759ac7043dbeac37152c6ddf
KDF = SSKDF
Ctrl.digest = digest:SHA1
Ctrl.hexsecret = hexsecret:ebe28edbae5a410b87a479243db3f690
Ctrl.hexinfo = hexinfo:e60dd8b28228ce5b9be74d3b
Output = b4a23963e07f485382cb358a493daec1759ac7043dbeac37152c6ddf1050
KDF = SSKDF
Ctrl.digest = digest:SHA1
Ctrl.hexsecret = hexsecret:ebe28edbae5a410b87a479243db3f690
Ctrl.hexinfo = hexinfo:e60dd8b28228ce5b9be74d3b
Output = b4a23963e07f485382cb358a493daec1759ac7043dbeac37152c6ddf105031f0
KDF = SSKDF
Ctrl.digest = digest:SHA1
Ctrl.hexsecret = hexsecret:ebe28edbae5a410b87a479243db3f690
Ctrl.hexinfo = hexinfo:e60dd8b28228ce5b9be74d3b
Output = b4a23963e07f485382cb358a493daec1759ac7043dbeac37152c6ddf105031f0f239
KDF = SSKDF
Ctrl.digest = digest:SHA1
Ctrl.hexsecret = hexsecret:ebe28edbae5a410b87a479243db3f690
Ctrl.hexinfo = hexinfo:e60dd8b28228ce5b9be74d3b
Output = b4a23963e07f485382cb358a493daec1759ac7043dbeac37152c6ddf105031f0f239f270
KDF = SSKDF
Ctrl.digest = digest:SHA1
Ctrl.hexsecret = hexsecret:ebe28edbae5a410b87a479243db3f690
Ctrl.hexinfo = hexinfo:e60dd8b28228ce5b9be74d3b
Output = b4a23963e07f485382cb358a493daec1759ac7043dbeac37152c6ddf105031f0f239f270b7f3
KDF = SSKDF
Ctrl.digest = digest:SHA1
Ctrl.hexsecret = hexsecret:ebe28edbae5a410b87a479243db3f690
Ctrl.hexinfo = hexinfo:e60dd8b28228ce5b9be74d3b
Output = b4a23963e07f485382cb358a493daec1759ac7043dbeac37152c6ddf105031f0f239f270b7f30616
KDF = SSKDF
Ctrl.digest = digest:SHA1
Ctrl.hexsecret = hexsecret:ebe28edbae5a410b87a479243db3f690
Ctrl.hexinfo = hexinfo:e60dd8b28228ce5b9be74d3b
Output = b4a23963e07f485382cb358a493daec1759ac7043dbeac37152c6ddf105031f0f239f270b7f30616166f
KDF = SSKDF
Ctrl.digest = digest:SHA1
Ctrl.hexsecret = hexsecret:ebe28edbae5a410b87a479243db3f690
Ctrl.hexinfo = hexinfo:e60dd8b28228ce5b9be74d3b
Output = b4a23963e07f485382cb358a493daec1759ac7043dbeac37152c6ddf105031f0f239f270b7f30616166f10e5
KDF = SSKDF
Ctrl.digest = digest:SHA1
Ctrl.hexsecret = hexsecret:ebe28edbae5a410b87a479243db3f690
Ctrl.hexinfo = hexinfo:e60dd8b28228ce5b9be74d3b
Output = b4a23963e07f485382cb358a493daec1759ac7043dbeac37152c6ddf105031f0f239f270b7f30616166f10e5d2b4
KDF = SSKDF
Ctrl.digest = digest:SHA1
Ctrl.hexsecret = hexsecret:ebe28edbae5a410b87a479243db3f690
Ctrl.hexinfo = hexinfo:e60dd8b28228ce5b9be74d3b
Output = b4a23963e07f485382cb358a493daec1759ac7043dbeac37152c6ddf105031f0f239f270b7f30616166f10e5d2b4cb11
KDF = SSKDF
Ctrl.digest = digest:SHA1
Ctrl.hexsecret = hexsecret:ebe28edbae5a410b87a479243db3f690
Ctrl.hexinfo = hexinfo:e60dd8b28228ce5b9be74d3b
Output = b4a23963e07f485382cb358a493daec1759ac7043dbeac37152c6ddf105031f0f239f270b7f30616166f10e5d2b4cb11ba8b
KDF = SSKDF
Ctrl.digest = digest:SHA1
Ctrl.hexsecret = hexsecret:ebe28edbae5a410b87a479243db3f690
Ctrl.hexinfo = hexinfo:e60dd8b28228ce5b9be74d3b
Output = b4a23963e07f485382cb358a493daec1759ac7043dbeac37152c6ddf105031f0f239f270b7f30616166f10e5d2b4cb11ba8bf4ba
KDF = SSKDF
Ctrl.digest = digest:SHA1
Ctrl.hexsecret = hexsecret:ebe28edbae5a410b87a479243db3f690
Ctrl.hexinfo = hexinfo:e60dd8b28228ce5b9be74d3b
Output = b4a23963e07f485382cb358a493daec1759ac7043dbeac37152c6ddf105031f0f239f270b7f30616166f10e5d2b4cb11ba8bf4ba3f22
KDF = SSKDF
Ctrl.digest = digest:SHA1
Ctrl.hexsecret = hexsecret:ebe28edbae5a410b87a479243db3f690
Ctrl.hexinfo = hexinfo:e60dd8b28228ce5b9be74d3b
Output = b4a23963e07f485382cb358a493daec1759ac7043dbeac37152c6ddf105031f0f239f270b7f30616166f10e5d2b4cb11ba8bf4ba3f227688
KDF = SSKDF
Ctrl.digest = digest:SHA1
Ctrl.hexsecret = hexsecret:ebe28edbae5a410b87a479243db3f690
Ctrl.hexinfo = hexinfo:e60dd8b28228ce5b9be74d3b
Output = b4a23963e07f485382cb358a493daec1759ac7043dbeac37152c6ddf105031f0f239f270b7f30616166f10e5d2b4cb11ba8bf4ba3f2276885abf
KDF = SSKDF
Ctrl.digest = digest:SHA1
Ctrl.hexsecret = hexsecret:ebe28edbae5a410b87a479243db3f690
Ctrl.hexinfo = hexinfo:e60dd8b28228ce5b9be74d3b
Output = b4a23963e07f485382cb358a493daec1759ac7043dbeac37152c6ddf105031f0f239f270b7f30616166f10e5d2b4cb11ba8bf4ba3f2276885abfbc3e
KDF = SSKDF
Ctrl.digest = digest:SHA1
Ctrl.hexsecret = hexsecret:ebe28edbae5a410b87a479243db3f690
Ctrl.hexinfo = hexinfo:e60dd8b28228ce5b9be74d3b
Output = b4a23963e07f485382cb358a493daec1759ac7043dbeac37152c6ddf105031f0f239f270b7f30616166f10e5d2b4cb11ba8bf4ba3f2276885abfbc3e811a
KDF = SSKDF
Ctrl.digest = digest:SHA1
Ctrl.hexsecret = hexsecret:ebe28edbae5a410b87a479243db3f690
Ctrl.hexinfo = hexinfo:e60dd8b28228ce5b9be74d3b
Output = b4a23963e07f485382cb358a493daec1759ac7043dbeac37152c6ddf105031f0f239f270b7f30616166f10e5d2b4cb11ba8bf4ba3f2276885abfbc3e811a568d
KDF = SSKDF
Ctrl.digest = digest:SHA1
Ctrl.hexsecret = hexsecret:ebe28edbae5a410b87a479243db3f690
Ctrl.hexinfo = hexinfo:e60dd8b28228ce5b9be74d3b
Output = b4a23963e07f485382cb358a493daec1759ac7043dbeac37152c6ddf105031f0f239f270b7f30616166f10e5d2b4cb11ba8bf4ba3f2276885abfbc3e811a568d480d
KDF = SSKDF
Ctrl.digest = digest:SHA1
Ctrl.hexsecret = hexsecret:ebe28edbae5a410b87a479243db3f690
Ctrl.hexinfo = hexinfo:e60dd8b28228ce5b9be74d3b
Output = b4a23963e07f485382cb358a493daec1759ac7043dbeac37152c6ddf105031f0f239f270b7f30616166f10e5d2b4cb11ba8bf4ba3f2276885abfbc3e811a568d480d9192
KDF = SSKDF
Ctrl.digest = digest:SHA1
Ctrl.hexsecret = hexsecret:d7e6
Ctrl.hexinfo = hexinfo:0bbe1fa8722023d7c3da4fff
Output = 31e798e9931b612a3ad1b9b1008faa8c
KDF = SSKDF
Ctrl.digest = digest:SHA1
Ctrl.hexsecret = hexsecret:4646779d
Ctrl.hexinfo = hexinfo:0bbe1fa8722023d7c3da4fff
Output = 139f68bcca879b490e268e569087d04d
KDF = SSKDF
Ctrl.digest = digest:SHA1
Ctrl.hexsecret = hexsecret:d9811c81d4c6
Ctrl.hexinfo = hexinfo:0bbe1fa8722023d7c3da4fff
Output = 914dc4f09cb633a76e6c389e04c64485
KDF = SSKDF
Ctrl.digest = digest:SHA1
Ctrl.hexsecret = hexsecret:8838f9d99ec46f09
Ctrl.hexinfo = hexinfo:0bbe1fa8722023d7c3da4fff
Output = 4f07dfb6f7a5bf348689e08b2e29c948
KDF = SSKDF
Ctrl.digest = digest:SHA1
Ctrl.hexsecret = hexsecret:3e0939b33f34e779f30e
Ctrl.hexinfo = hexinfo:0bbe1fa8722023d7c3da4fff
Output = b42c7a98c23be19d1187ff960e87557f
KDF = SSKDF
Ctrl.digest = digest:SHA1
Ctrl.hexsecret = hexsecret:f36230cacca4d245d303058c
Ctrl.hexinfo = hexinfo:0bbe1fa8722023d7c3da4fff
Output = 50f2068d8010d355d56c5e34aaffbc67
KDF = SSKDF
Ctrl.digest = digest:SHA1
Ctrl.hexsecret = hexsecret:7005d32c3d4284c73c3aefc70438
Ctrl.hexinfo = hexinfo:0bbe1fa8722023d7c3da4fff
Output = 66fd712ccf5462bbd41e89041ea7ea26
KDF = SSKDF
Ctrl.digest = digest:SHA1
Ctrl.hexsecret = hexsecret:c01c83150b7734f8dbd6efd6f54d7365
Ctrl.hexinfo = hexinfo:0bbe1fa8722023d7c3da4fff
Output = 5c5edb0ceda9cd0c7f1f3d9e239c67d5
KDF = SSKDF
Ctrl.digest = digest:SHA1
Ctrl.hexsecret = hexsecret:da69f1dbbebc837480af692e7e9ee6b9
Ctrl.hexinfo = hexinfo:9949
Output = 33c83f54ed00fb1bccd2113e88550941
KDF = SSKDF
Ctrl.digest = digest:SHA1
Ctrl.hexsecret = hexsecret:da69f1dbbebc837480af692e7e9ee6b9
Ctrl.hexinfo = hexinfo:17144da6
Output = a999c28961424cab35ec06015e8c376a
KDF = SSKDF
Ctrl.digest = digest:SHA1
Ctrl.hexsecret = hexsecret:da69f1dbbebc837480af692e7e9ee6b9
Ctrl.hexinfo = hexinfo:dffdee1062eb
Output = 4101ad50e626ed6f957bff926dfbb7db
KDF = SSKDF
Ctrl.digest = digest:SHA1
Ctrl.hexsecret = hexsecret:da69f1dbbebc837480af692e7e9ee6b9
Ctrl.hexinfo = hexinfo:9f365043e23b4648
Output = 4d3e4b971b88771f229df9f564984832
KDF = SSKDF
Ctrl.digest = digest:SHA1
Ctrl.hexsecret = hexsecret:da69f1dbbebc837480af692e7e9ee6b9
Ctrl.hexinfo = hexinfo:a885a0c4567ddc4f96da
Output = bebbc30f5a83df5e9c9b57db33c0c879
KDF = SSKDF
Ctrl.digest = digest:SHA1
Ctrl.hexsecret = hexsecret:da69f1dbbebc837480af692e7e9ee6b9
Ctrl.hexinfo = hexinfo:c9d86183295bfe4c3d85f0fd
Output = 87c947e45407db63eb94cbaa02d14e94
KDF = SSKDF
Ctrl.digest = digest:SHA1
Ctrl.hexsecret = hexsecret:da69f1dbbebc837480af692e7e9ee6b9
Ctrl.hexinfo = hexinfo:825fadce46964236a486732c5dad
Output = 192370a85ff78e3c0245129d9b398558
KDF = SSKDF
Ctrl.digest = digest:SHA1
Ctrl.hexsecret = hexsecret:da69f1dbbebc837480af692e7e9ee6b9
Ctrl.hexinfo = hexinfo:5c0b5eb3ac9f342347d73d7a521723aa
Output = c7b7634fd809383e87c4b1b3e728be56
KDF = SSKDF
Ctrl.digest = digest:SHA1
Ctrl.hexsecret = hexsecret:8d7a4e7d5cf34b3f74873b862aeb33b7
Output = 6a5594f402f74f69
KDF = SSKDF
Ctrl.digest = digest:SHA1
Ctrl.hexsecret = hexsecret:9b208e7ee1e641fac1dff48fc1beb2d2
Output = 556ed67e24ac0c7c46cc432da8bdb23c
KDF = SSKDF
Ctrl.digest = digest:SHA1
Ctrl.hexsecret = hexsecret:4d2572539fed433211da28c8a0eebac3
Output = 5a4054c59c5b92814025578f43c1b79fe84968fc284e240b
KDF = SSKDF
Ctrl.digest = digest:SHA1
Ctrl.hexsecret = hexsecret:4e1e70c9886819a31bc29a537911add9
Output = ddbfc440449aab4131c6d8aec08ce1496f2702241d0e27cc155c5c7c3cda75b5
KDF = SSKDF
Ctrl.digest = digest:SHA1
Ctrl.hexsecret = hexsecret:68f144c952528e540c686dc353b766f2
Output = 59ed66bb6f54a9688a0b891d0b2ea6743621d9e1b5cc098cf3a55e6f864f9af8a95e4d945d2f987f
KDF = SSKDF
Ctrl.digest = digest:SHA1
Ctrl.hexsecret = hexsecret:b66c9d507c9f837fbe60b6675fdbf38b
Output = c282787ddf421a72fc88811be81b08d0d6ab66c92d1011974aa58335a6bbbd62e9e982bfae5929865ea1d517247089d2
KDF = SSKDF
Ctrl.digest = digest:SHA1
Ctrl.hexsecret = hexsecret:34e730b49e46c7ed2fb25975a4cccd2d
Output = 39e76e6571cb00740260b9070accbdcc4a492c295cbef33d9e37dac21e5e9d07e0f12dc7063d2172641475d4e08b8e3712fb26a10c8376b8
KDF = SSKDF
Ctrl.digest = digest:SHA1
Ctrl.hexsecret = hexsecret:e340d87e2d7adbc1b95ec2dbdc3b82be
Output = a660c0037a53f76f1e7667043f5869348ad07ac0e272e615ce31f16d4ab90d4b35fe5c370c0010ce79aff45682c6fb8b97f9a05b7d40b5af3c62999a10df9c6d
KDF = SSKDF
Ctrl.digest = digest:SHA256
Ctrl.hexsecret = hexsecret:afc4e154498d4770aa8365f6903dc83b
Ctrl.hexinfo = hexinfo:662af20379b29d5ef813e655
Output = f0b80d6ae4c1e19e2105a37024e35dc6
KDF = SSKDF
Ctrl.digest = digest:SHA512
Ctrl.hexsecret = hexsecret:108cf63318555c787fa578731dd4f037
Ctrl.hexinfo = hexinfo:53191b1dd3f94d83084d61d6
Output = 0ad475c1826da3007637970c8b92b993
KDF = SSKDF
Ctrl.mac = mac:HMAC
Ctrl.digest = digest:SHA256
Ctrl.hexsecret = hexsecret:6ee6c00d70a6cd14bd5a4e8fcfec8386
Ctrl.hexsalt = hexsalt:532f5131e0a2fecc722f87e5aa2062cb
Ctrl.hexinfo = hexinfo:861aa2886798231259bd0314
Output = 13479e9a91dd20fdd757d68ffe8869fb
KDF = SSKDF
Ctrl.mac = mac:HMAC
Ctrl.digest = digest:SHA256
Ctrl.hexsecret = hexsecret:cb09b565de1ac27a50289b3704b93afd
Ctrl.hexsalt = hexsalt:d504c1c41a499481ce88695d18ae2e8f
Ctrl.hexinfo = hexinfo:5ed3768c2c7835943a789324
Output = f081c0255b0cae16edc6ce1d6c9d12bc
KDF = SSKDF
Ctrl.mac = mac:HMAC
Ctrl.digest = digest:SHA256
Ctrl.hexsecret = hexsecret:98f50345fd970639a1b7935f501e1d7c
Ctrl.hexsalt = hexsalt:3691939461247e9f74382ae4ef629b17
Ctrl.hexinfo = hexinfo:6ddbdb1314663152c3ccc192
Output = 56f42183ed3e287298dbbecf143f51ac
KDF = SSKDF
Ctrl.mac = mac:HMAC
Ctrl.digest = digest:SHA256
Ctrl.hexsecret = hexsecret:a72b0076221727eca4d3ef8f4d88ac96
Ctrl.hexsalt = hexsalt:397dc6807de2c1d5ba52e03c4e6c7a19
Ctrl.hexinfo = hexinfo:12379bd7873a7dbabe894ac8
Output = 26c0f937e8ca337a859b6c092fe22b9a
KDF = SSKDF
Ctrl.mac = mac:HMAC
Ctrl.digest = digest:SHA256
Ctrl.hexsecret = hexsecret:0b09bf8ebe1e85a049174c521e35be64
Ctrl.hexsalt = hexsalt:313d29bbeaa5ac9e52278f7619d29d93
Ctrl.hexinfo = hexinfo:e2ac98de1486959bfc6363c0
Output = 4bfdf78782a45e2a5858edb851c5783c
KDF = SSKDF
Ctrl.mac = mac:HMAC
Ctrl.digest = digest:SHA256
Ctrl.hexsecret = hexsecret:e907ad4fe811ee047af77e0c4418226a
Ctrl.hexsalt = hexsalt:5000ef57104ca2e86a5fec5883ea4ea8
Ctrl.hexinfo = hexinfo:c4ee443920f2b7542eee2a24
Output = 06bfbd9571462c920a5a1b589c765383
KDF = SSKDF
Ctrl.mac = mac:HMAC
Ctrl.digest = digest:SHA256
Ctrl.hexsecret = hexsecret:608dae15fe8b906d2dc649815bdee148
Ctrl.hexsalt = hexsalt:742cc5a02a24d09c66fd9da0d0c571f6
Ctrl.hexinfo = hexinfo:ba60ff781e2756cba07f6524
Output = 7f7f9e5d8f89a8edd10289f1d690f629
KDF = SSKDF
Ctrl.mac = mac:HMAC
Ctrl.digest = digest:SHA256
Ctrl.hexsecret = hexsecret:eb39e8dc7c40b906216108e2592bb6cd
Ctrl.hexsalt = hexsalt:af9f612da575c1afc8c4afff4ced34e1
Ctrl.hexinfo = hexinfo:84b7f0628df0cb22baaa279a
Output = 5202576c69c6276daedf4916de250d19
KDF = SSKDF
Ctrl.mac = mac:HMAC
Ctrl.digest = digest:SHA256
Ctrl.hexsecret = hexsecret:4bac0c1a963b8cf6933beb2ad191a31e
Ctrl.hexsalt = hexsalt:debd24d71a1a7ae77f7e3aa24d939635
Ctrl.hexinfo = hexinfo:9e51c8593cec92c89e82439a
Output = ecb9889f9004f80716b56c44910f160c
KDF = SSKDF
Ctrl.mac = mac:HMAC
Ctrl.digest = digest:SHA256
Ctrl.hexsecret = hexsecret:8aa41e3c8076ea01ca6789dd18709a68
Ctrl.hexsalt = hexsalt:7c9dacc409cde7b05efdae07bd9973db
Ctrl.hexinfo = hexinfo:52651f0f2e858bbfbacb2533
Output = b8683c9a982e0826d659a1ab77a603d7
KDF = SSKDF
Ctrl.mac = mac:HMAC
Ctrl.digest = digest:SHA256
Ctrl.hexsecret = hexsecret:02b40d33e3f685aeae677ac344eeaf77
Ctrl.hexsalt = hexsalt:0ad52c9357c85e4781296a36ca72039c
Ctrl.hexinfo = hexinfo:c67c389580128f18f6cf8592
Output = be32
KDF = SSKDF
Ctrl.mac = mac:HMAC
Ctrl.digest = digest:SHA256
Ctrl.hexsecret = hexsecret:02b40d33e3f685aeae677ac344eeaf77
Ctrl.hexsalt = hexsalt:0ad52c9357c85e4781296a36ca72039c
Ctrl.hexinfo = hexinfo:c67c389580128f18f6cf8592
Output = be32e7d3
KDF = SSKDF
Ctrl.mac = mac:HMAC
Ctrl.digest = digest:SHA256
Ctrl.hexsecret = hexsecret:02b40d33e3f685aeae677ac344eeaf77
Ctrl.hexsalt = hexsalt:0ad52c9357c85e4781296a36ca72039c
Ctrl.hexinfo = hexinfo:c67c389580128f18f6cf8592
Output = be32e7d306d8
KDF = SSKDF
Ctrl.mac = mac:HMAC
Ctrl.digest = digest:SHA256
Ctrl.hexsecret = hexsecret:02b40d33e3f685aeae677ac344eeaf77
Ctrl.hexsalt = hexsalt:0ad52c9357c85e4781296a36ca72039c
Ctrl.hexinfo = hexinfo:c67c389580128f18f6cf8592
Output = be32e7d306d89102
KDF = SSKDF
Ctrl.mac = mac:HMAC
Ctrl.digest = digest:SHA256
Ctrl.hexsecret = hexsecret:02b40d33e3f685aeae677ac344eeaf77
Ctrl.hexsalt = hexsalt:0ad52c9357c85e4781296a36ca72039c
Ctrl.hexinfo = hexinfo:c67c389580128f18f6cf8592
Output = be32e7d306d891028be0
KDF = SSKDF
Ctrl.mac = mac:HMAC
Ctrl.digest = digest:SHA256
Ctrl.hexsecret = hexsecret:02b40d33e3f685aeae677ac344eeaf77
Ctrl.hexsalt = hexsalt:0ad52c9357c85e4781296a36ca72039c
Ctrl.hexinfo = hexinfo:c67c389580128f18f6cf8592
Output = be32e7d306d891028be088f2
KDF = SSKDF
Ctrl.mac = mac:HMAC
Ctrl.digest = digest:SHA256
Ctrl.hexsecret = hexsecret:02b40d33e3f685aeae677ac344eeaf77
Ctrl.hexsalt = hexsalt:0ad52c9357c85e4781296a36ca72039c
Ctrl.hexinfo = hexinfo:c67c389580128f18f6cf8592
Output = be32e7d306d891028be088f213f9
KDF = SSKDF
Ctrl.mac = mac:HMAC
Ctrl.digest = digest:SHA256
Ctrl.hexsecret = hexsecret:02b40d33e3f685aeae677ac344eeaf77
Ctrl.hexsalt = hexsalt:0ad52c9357c85e4781296a36ca72039c
Ctrl.hexinfo = hexinfo:c67c389580128f18f6cf8592
Output = be32e7d306d891028be088f213f9f947
KDF = SSKDF
Ctrl.mac = mac:HMAC
Ctrl.digest = digest:SHA256
Ctrl.hexsecret = hexsecret:02b40d33e3f685aeae677ac344eeaf77
Ctrl.hexsalt = hexsalt:0ad52c9357c85e4781296a36ca72039c
Ctrl.hexinfo = hexinfo:c67c389580128f18f6cf8592
Output = be32e7d306d891028be088f213f9f947c504
KDF = SSKDF
Ctrl.mac = mac:HMAC
Ctrl.digest = digest:SHA256
Ctrl.hexsecret = hexsecret:02b40d33e3f685aeae677ac344eeaf77
Ctrl.hexsalt = hexsalt:0ad52c9357c85e4781296a36ca72039c
Ctrl.hexinfo = hexinfo:c67c389580128f18f6cf8592
Output = be32e7d306d891028be088f213f9f947c50420d9
KDF = SSKDF
Ctrl.mac = mac:HMAC
Ctrl.digest = digest:SHA256
Ctrl.hexsecret = hexsecret:02b40d33e3f685aeae677ac344eeaf77
Ctrl.hexsalt = hexsalt:0ad52c9357c85e4781296a36ca72039c
Ctrl.hexinfo = hexinfo:c67c389580128f18f6cf8592
Output = be32e7d306d891028be088f213f9f947c50420d9b5a1
KDF = SSKDF
Ctrl.mac = mac:HMAC
Ctrl.digest = digest:SHA256
Ctrl.hexsecret = hexsecret:02b40d33e3f685aeae677ac344eeaf77
Ctrl.hexsalt = hexsalt:0ad52c9357c85e4781296a36ca72039c
Ctrl.hexinfo = hexinfo:c67c389580128f18f6cf8592
Output = be32e7d306d891028be088f213f9f947c50420d9b5a12ca6
KDF = SSKDF
Ctrl.mac = mac:HMAC
Ctrl.digest = digest:SHA256
Ctrl.hexsecret = hexsecret:02b40d33e3f685aeae677ac344eeaf77
Ctrl.hexsalt = hexsalt:0ad52c9357c85e4781296a36ca72039c
Ctrl.hexinfo = hexinfo:c67c389580128f18f6cf8592
Output = be32e7d306d891028be088f213f9f947c50420d9b5a12ca69818
KDF = SSKDF
Ctrl.mac = mac:HMAC
Ctrl.digest = digest:SHA256
Ctrl.hexsecret = hexsecret:02b40d33e3f685aeae677ac344eeaf77
Ctrl.hexsalt = hexsalt:0ad52c9357c85e4781296a36ca72039c
Ctrl.hexinfo = hexinfo:c67c389580128f18f6cf8592
Output = be32e7d306d891028be088f213f9f947c50420d9b5a12ca69818dd99
KDF = SSKDF
Ctrl.mac = mac:HMAC
Ctrl.digest = digest:SHA256
Ctrl.hexsecret = hexsecret:02b40d33e3f685aeae677ac344eeaf77
Ctrl.hexsalt = hexsalt:0ad52c9357c85e4781296a36ca72039c
Ctrl.hexinfo = hexinfo:c67c389580128f18f6cf8592
Output = be32e7d306d891028be088f213f9f947c50420d9b5a12ca69818dd9995de
KDF = SSKDF
Ctrl.mac = mac:HMAC
Ctrl.digest = digest:SHA256
Ctrl.hexsecret = hexsecret:02b40d33e3f685aeae677ac344eeaf77
Ctrl.hexsalt = hexsalt:0ad52c9357c85e4781296a36ca72039c
Ctrl.hexinfo = hexinfo:c67c389580128f18f6cf8592
Output = be32e7d306d891028be088f213f9f947c50420d9b5a12ca69818dd9995dedd8e
KDF = SSKDF
Ctrl.mac = mac:HMAC
Ctrl.digest = digest:SHA256
Ctrl.hexsecret = hexsecret:02b40d33e3f685aeae677ac344eeaf77
Ctrl.hexsalt = hexsalt:0ad52c9357c85e4781296a36ca72039c
Ctrl.hexinfo = hexinfo:c67c389580128f18f6cf8592
Output = be32e7d306d891028be088f213f9f947c50420d9b5a12ca69818dd9995dedd8e6137
KDF = SSKDF
Ctrl.mac = mac:HMAC
Ctrl.digest = digest:SHA256
Ctrl.hexsecret = hexsecret:02b40d33e3f685aeae677ac344eeaf77
Ctrl.hexsalt = hexsalt:0ad52c9357c85e4781296a36ca72039c
Ctrl.hexinfo = hexinfo:c67c389580128f18f6cf8592
Output = be32e7d306d891028be088f213f9f947c50420d9b5a12ca69818dd9995dedd8e6137c710
KDF = SSKDF
Ctrl.mac = mac:HMAC
Ctrl.digest = digest:SHA256
Ctrl.hexsecret = hexsecret:02b40d33e3f685aeae677ac344eeaf77
Ctrl.hexsalt = hexsalt:0ad52c9357c85e4781296a36ca72039c
Ctrl.hexinfo = hexinfo:c67c389580128f18f6cf8592
Output = be32e7d306d891028be088f213f9f947c50420d9b5a12ca69818dd9995dedd8e6137c7104d67
KDF = SSKDF
Ctrl.mac = mac:HMAC
Ctrl.digest = digest:SHA256
Ctrl.hexsecret = hexsecret:02b40d33e3f685aeae677ac344eeaf77
Ctrl.hexsalt = hexsalt:0ad52c9357c85e4781296a36ca72039c
Ctrl.hexinfo = hexinfo:c67c389580128f18f6cf8592
Output = be32e7d306d891028be088f213f9f947c50420d9b5a12ca69818dd9995dedd8e6137c7104d67f2ca
KDF = SSKDF
Ctrl.mac = mac:HMAC
Ctrl.digest = digest:SHA256
Ctrl.hexsecret = hexsecret:02b40d33e3f685aeae677ac344eeaf77
Ctrl.hexsalt = hexsalt:0ad52c9357c85e4781296a36ca72039c
Ctrl.hexinfo = hexinfo:c67c389580128f18f6cf8592
Output = be32e7d306d891028be088f213f9f947c50420d9b5a12ca69818dd9995dedd8e6137c7104d67f2ca9091
KDF = SSKDF
Ctrl.mac = mac:HMAC
Ctrl.digest = digest:SHA256
Ctrl.hexsecret = hexsecret:02b40d33e3f685aeae677ac344eeaf77
Ctrl.hexsalt = hexsalt:0ad52c9357c85e4781296a36ca72039c
Ctrl.hexinfo = hexinfo:c67c389580128f18f6cf8592
Output = be32e7d306d891028be088f213f9f947c50420d9b5a12ca69818dd9995dedd8e6137c7104d67f2ca90915dda
KDF = SSKDF
Ctrl.mac = mac:HMAC
Ctrl.digest = digest:SHA256
Ctrl.hexsecret = hexsecret:02b40d33e3f685aeae677ac344eeaf77
Ctrl.hexsalt = hexsalt:0ad52c9357c85e4781296a36ca72039c
Ctrl.hexinfo = hexinfo:c67c389580128f18f6cf8592
Output = be32e7d306d891028be088f213f9f947c50420d9b5a12ca69818dd9995dedd8e6137c7104d67f2ca90915dda0ab6
KDF = SSKDF
Ctrl.mac = mac:HMAC
Ctrl.digest = digest:SHA256
Ctrl.hexsecret = hexsecret:02b40d33e3f685aeae677ac344eeaf77
Ctrl.hexsalt = hexsalt:0ad52c9357c85e4781296a36ca72039c
Ctrl.hexinfo = hexinfo:c67c389580128f18f6cf8592
Output = be32e7d306d891028be088f213f9f947c50420d9b5a12ca69818dd9995dedd8e6137c7104d67f2ca90915dda0ab68af2
KDF = SSKDF
Ctrl.mac = mac:HMAC
Ctrl.digest = digest:SHA256
Ctrl.hexsecret = hexsecret:02b40d33e3f685aeae677ac344eeaf77
Ctrl.hexsalt = hexsalt:0ad52c9357c85e4781296a36ca72039c
Ctrl.hexinfo = hexinfo:c67c389580128f18f6cf8592
Output = be32e7d306d891028be088f213f9f947c50420d9b5a12ca69818dd9995dedd8e6137c7104d67f2ca90915dda0ab68af2f355
KDF = SSKDF
Ctrl.mac = mac:HMAC
Ctrl.digest = digest:SHA256
Ctrl.hexsecret = hexsecret:02b40d33e3f685aeae677ac344eeaf77
Ctrl.hexsalt = hexsalt:0ad52c9357c85e4781296a36ca72039c
Ctrl.hexinfo = hexinfo:c67c389580128f18f6cf8592
Output = be32e7d306d891028be088f213f9f947c50420d9b5a12ca69818dd9995dedd8e6137c7104d67f2ca90915dda0ab68af2f355b904
KDF = SSKDF
Ctrl.mac = mac:HMAC
Ctrl.digest = digest:SHA256
Ctrl.hexsecret = hexsecret:02b40d33e3f685aeae677ac344eeaf77
Ctrl.hexsalt = hexsalt:0ad52c9357c85e4781296a36ca72039c
Ctrl.hexinfo = hexinfo:c67c389580128f18f6cf8592
Output = be32e7d306d891028be088f213f9f947c50420d9b5a12ca69818dd9995dedd8e6137c7104d67f2ca90915dda0ab68af2f355b904f9eb
KDF = SSKDF
Ctrl.mac = mac:HMAC
Ctrl.digest = digest:SHA256
Ctrl.hexsecret = hexsecret:02b40d33e3f685aeae677ac344eeaf77
Ctrl.hexsalt = hexsalt:0ad52c9357c85e4781296a36ca72039c
Ctrl.hexinfo = hexinfo:c67c389580128f18f6cf8592
Output = be32e7d306d891028be088f213f9f947c50420d9b5a12ca69818dd9995dedd8e6137c7104d67f2ca90915dda0ab68af2f355b904f9eb0388
KDF = SSKDF
Ctrl.mac = mac:HMAC
Ctrl.digest = digest:SHA256
Ctrl.hexsecret = hexsecret:02b40d33e3f685aeae677ac344eeaf77
Ctrl.hexsalt = hexsalt:0ad52c9357c85e4781296a36ca72039c
Ctrl.hexinfo = hexinfo:c67c389580128f18f6cf8592
Output = be32e7d306d891028be088f213f9f947c50420d9b5a12ca69818dd9995dedd8e6137c7104d67f2ca90915dda0ab68af2f355b904f9eb0388b5b7
KDF = SSKDF
Ctrl.mac = mac:HMAC
Ctrl.digest = digest:SHA256
Ctrl.hexsecret = hexsecret:02b40d33e3f685aeae677ac344eeaf77
Ctrl.hexsalt = hexsalt:0ad52c9357c85e4781296a36ca72039c
Ctrl.hexinfo = hexinfo:c67c389580128f18f6cf8592
Output = be32e7d306d891028be088f213f9f947c50420d9b5a12ca69818dd9995dedd8e6137c7104d67f2ca90915dda0ab68af2f355b904f9eb0388b5b7fe19
KDF = SSKDF
Ctrl.mac = mac:HMAC
Ctrl.digest = digest:SHA256
Ctrl.hexsecret = hexsecret:02b40d33e3f685aeae677ac344eeaf77
Ctrl.hexsalt = hexsalt:0ad52c9357c85e4781296a36ca72039c
Ctrl.hexinfo = hexinfo:c67c389580128f18f6cf8592
Output = be32e7d306d891028be088f213f9f947c50420d9b5a12ca69818dd9995dedd8e6137c7104d67f2ca90915dda0ab68af2f355b904f9eb0388b5b7fe193c95
KDF = SSKDF
Ctrl.mac = mac:HMAC
Ctrl.digest = digest:SHA256
Ctrl.hexsecret = hexsecret:02b40d33e3f685aeae677ac344eeaf77
Ctrl.hexsalt = hexsalt:0ad52c9357c85e4781296a36ca72039c
Ctrl.hexinfo = hexinfo:c67c389580128f18f6cf8592
Output = be32e7d306d891028be088f213f9f947c50420d9b5a12ca69818dd9995dedd8e6137c7104d67f2ca90915dda0ab68af2f355b904f9eb0388b5b7fe193c9546d4
KDF = SSKDF
Ctrl.mac = mac:HMAC
Ctrl.digest = digest:SHA256
Ctrl.hexsecret = hexsecret:02b40d33e3f685aeae677ac344eeaf77
Ctrl.hexsalt = hexsalt:0ad52c9357c85e4781296a36ca72039c
Ctrl.hexinfo = hexinfo:c67c389580128f18f6cf8592
Output = be32e7d306d891028be088f213f9f947c50420d9b5a12ca69818dd9995dedd8e6137c7104d67f2ca90915dda0ab68af2f355b904f9eb0388b5b7fe193c9546d45849
KDF = SSKDF
Ctrl.mac = mac:HMAC
Ctrl.digest = digest:SHA256
Ctrl.hexsecret = hexsecret:02b40d33e3f685aeae677ac344eeaf77
Ctrl.hexsalt = hexsalt:0ad52c9357c85e4781296a36ca72039c
Ctrl.hexinfo = hexinfo:c67c389580128f18f6cf8592
Output = be32e7d306d891028be088f213f9f947c50420d9b5a12ca69818dd9995dedd8e6137c7104d67f2ca90915dda0ab68af2f355b904f9eb0388b5b7fe193c9546d45849133d
KDF = SSKDF
Ctrl.mac = mac:HMAC
Ctrl.digest = digest:SHA256
Ctrl.hexsecret = hexsecret:f4e1
Ctrl.hexsalt = hexsalt:3638271ccd68a25dc24ecddd39ef3f89
Ctrl.hexinfo = hexinfo:348a37a27ef1282f5f020dcc
Output = 3f661ec46fcc1e110b88f33ee7dbc308
KDF = SSKDF
Ctrl.mac = mac:HMAC
Ctrl.digest = digest:SHA256
Ctrl.hexsecret = hexsecret:253554e5
Ctrl.hexsalt = hexsalt:3638271ccd68a25dc24ecddd39ef3f89
Ctrl.hexinfo = hexinfo:348a37a27ef1282f5f020dcc
Output = 73ccb357554ca44967d507518262e38d
KDF = SSKDF
Ctrl.mac = mac:HMAC
Ctrl.digest = digest:SHA256
Ctrl.hexsecret = hexsecret:e10d0e0bc95b
Ctrl.hexsalt = hexsalt:3638271ccd68a25dc24ecddd39ef3f89
Ctrl.hexinfo = hexinfo:348a37a27ef1282f5f020dcc
Output = c4f1cf190980b6777bb35107654b25f9
KDF = SSKDF
Ctrl.mac = mac:HMAC
Ctrl.digest = digest:SHA256
Ctrl.hexsecret = hexsecret:451f7f2c23c51326
Ctrl.hexsalt = hexsalt:3638271ccd68a25dc24ecddd39ef3f89
Ctrl.hexinfo = hexinfo:348a37a27ef1282f5f020dcc
Output = ddb2d7475d00cc65bff6904b4f0b54ba
KDF = SSKDF
Ctrl.mac = mac:HMAC
Ctrl.digest = digest:SHA256
Ctrl.hexsecret = hexsecret:0f27277ee800d6cc5425
Ctrl.hexsalt = hexsalt:3638271ccd68a25dc24ecddd39ef3f89
Ctrl.hexinfo = hexinfo:348a37a27ef1282f5f020dcc
Output = 1100a6049ae9d8be01ab3829754cecc2
KDF = SSKDF
Ctrl.mac = mac:HMAC
Ctrl.digest = digest:SHA256
Ctrl.hexsecret = hexsecret:20438ff1f26390dbc3a1a6d0
Ctrl.hexsalt = hexsalt:3638271ccd68a25dc24ecddd39ef3f89
Ctrl.hexinfo = hexinfo:348a37a27ef1282f5f020dcc
Output = 5180382f740444ada597197f98e73e1e
KDF = SSKDF
Ctrl.mac = mac:HMAC
Ctrl.digest = digest:SHA256
Ctrl.hexsecret = hexsecret:b74a149a161546f8c20b06ac4ed4
Ctrl.hexsalt = hexsalt:3638271ccd68a25dc24ecddd39ef3f89
Ctrl.hexinfo = hexinfo:348a37a27ef1282f5f020dcc
Output = 44f676e85c1b1a8bbc3d319218631ca3
KDF = SSKDF
Ctrl.mac = mac:HMAC
Ctrl.digest = digest:SHA256
Ctrl.hexsecret = hexsecret:8aa7df46b8cb3fe47228494f4e116b2c
Ctrl.hexsalt = hexsalt:3638271ccd68a25dc24ecddd39ef3f89
Ctrl.hexinfo = hexinfo:348a37a27ef1282f5f020dcc
Output = ebb24413855a0a3249960d0de0f4750d
KDF = SSKDF
Ctrl.mac = mac:HMAC
Ctrl.digest = digest:SHA256
Ctrl.hexsecret = hexsecret:a678236b6ac82077b23f73a510c1d0e2
Ctrl.hexsalt = hexsalt:46ee4f36a4167a09cde5a33b130c6e1c
Ctrl.hexinfo = hexinfo:d851
Output = 5dbe10ead8f81a81a29072eca4501658
KDF = SSKDF
Ctrl.mac = mac:HMAC
Ctrl.digest = digest:SHA256
Ctrl.hexsecret = hexsecret:a678236b6ac82077b23f73a510c1d0e2
Ctrl.hexsalt = hexsalt:46ee4f36a4167a09cde5a33b130c6e1c
Ctrl.hexinfo = hexinfo:b04da03c
Output = 0a08d7616dcbec25a36f1936b82992ca
KDF = SSKDF
Ctrl.mac = mac:HMAC
Ctrl.digest = digest:SHA256
Ctrl.hexsecret = hexsecret:a678236b6ac82077b23f73a510c1d0e2
Ctrl.hexsalt = hexsalt:46ee4f36a4167a09cde5a33b130c6e1c
Ctrl.hexinfo = hexinfo:f9e8b47eade3
Output = 84a29697445179b662d85dbc59bf8042
KDF = SSKDF
Ctrl.mac = mac:HMAC
Ctrl.digest = digest:SHA256
Ctrl.hexsecret = hexsecret:a678236b6ac82077b23f73a510c1d0e2
Ctrl.hexsalt = hexsalt:46ee4f36a4167a09cde5a33b130c6e1c
Ctrl.hexinfo = hexinfo:5b141bfa54fcf824
Output = be7660c840644cec84d67d95ba7ebf2d
KDF = SSKDF
Ctrl.mac = mac:HMAC
Ctrl.digest = digest:SHA256
Ctrl.hexsecret = hexsecret:a678236b6ac82077b23f73a510c1d0e2
Ctrl.hexsalt = hexsalt:46ee4f36a4167a09cde5a33b130c6e1c
Ctrl.hexinfo = hexinfo:736e7ddb856f0ba14744
Output = e3010b1fbcb02fd8baa8449ac71d0c62
KDF = SSKDF
Ctrl.mac = mac:HMAC
Ctrl.digest = digest:SHA256
Ctrl.hexsecret = hexsecret:a678236b6ac82077b23f73a510c1d0e2
Ctrl.hexsalt = hexsalt:46ee4f36a4167a09cde5a33b130c6e1c
Ctrl.hexinfo = hexinfo:c54320ff6e7d1a3b0b3aea00
Output = df0ac84982999cda676e4cbf707c42f0
KDF = SSKDF
Ctrl.mac = mac:HMAC
Ctrl.digest = digest:SHA256
Ctrl.hexsecret = hexsecret:a678236b6ac82077b23f73a510c1d0e2
Ctrl.hexsalt = hexsalt:46ee4f36a4167a09cde5a33b130c6e1c
Ctrl.hexinfo = hexinfo:37ab143e1b4ab61d0294ea8afbc7
Output = 93eec7f4dda18b7e710dbbd7570ebd13
KDF = SSKDF
Ctrl.mac = mac:HMAC
Ctrl.digest = digest:SHA256
Ctrl.hexsecret = hexsecret:a678236b6ac82077b23f73a510c1d0e2
Ctrl.hexsalt = hexsalt:46ee4f36a4167a09cde5a33b130c6e1c
Ctrl.hexinfo = hexinfo:c3146575d2c60981511e700902fc2ac1
Output = e9125f77d699faa53d5bc48f3fc2f7d0
KDF = SSKDF
Ctrl.mac = mac:HMAC
Ctrl.digest = digest:SHA256
Ctrl.hexsecret = hexsecret:0031558fddb96e3db2e0496026302055
Ctrl.hexsalt = hexsalt:1ae1
Ctrl.hexinfo = hexinfo:97ed3540c7466ab27395fe79
Output = ddf7eedcd997eca3943d4519aaf414f4
KDF = SSKDF
Ctrl.mac = mac:HMAC
Ctrl.digest = digest:SHA256
Ctrl.hexsecret = hexsecret:0031558fddb96e3db2e0496026302055
Ctrl.hexsalt = hexsalt:3bda13b6
Ctrl.hexinfo = hexinfo:97ed3540c7466ab27395fe79
Output = ec783ca20501df3cacac5ab4adbc6427
KDF = SSKDF
Ctrl.mac = mac:HMAC
Ctrl.digest = digest:SHA256
Ctrl.hexsecret = hexsecret:0031558fddb96e3db2e0496026302055
Ctrl.hexsalt = hexsalt:c792f52e5876
Ctrl.hexinfo = hexinfo:97ed3540c7466ab27395fe79
Output = 9303a2562e6f8c418e3fcc081b94bdcf
KDF = SSKDF
Ctrl.mac = mac:HMAC
Ctrl.digest = digest:SHA256
Ctrl.hexsecret = hexsecret:0031558fddb96e3db2e0496026302055
Ctrl.hexsalt = hexsalt:a9b7a64840d52633
Ctrl.hexinfo = hexinfo:97ed3540c7466ab27395fe79
Output = aab6b0dc19bae0dd7fa02391ac3d6ef1
KDF = SSKDF
Ctrl.mac = mac:HMAC
Ctrl.digest = digest:SHA256
Ctrl.hexsecret = hexsecret:0031558fddb96e3db2e0496026302055
Ctrl.hexsalt = hexsalt:8f62a3ec15cdf9b3522f
Ctrl.hexinfo = hexinfo:97ed3540c7466ab27395fe79
Output = 1516d5ed7f46474d250408b0864647cf
KDF = SSKDF
Ctrl.mac = mac:HMAC
Ctrl.digest = digest:SHA256
Ctrl.hexsecret = hexsecret:0031558fddb96e3db2e0496026302055
Ctrl.hexsalt = hexsalt:55ed67cbdc98ed8e45214704
Ctrl.hexinfo = hexinfo:97ed3540c7466ab27395fe79
Output = 38bf96a3d737a84dc10a835d340b6866
KDF = SSKDF
Ctrl.mac = mac:HMAC
Ctrl.digest = digest:SHA256
Ctrl.hexsecret = hexsecret:0031558fddb96e3db2e0496026302055
Ctrl.hexsalt = hexsalt:e4946aff3b2ab891b311234c77bc
Ctrl.hexinfo = hexinfo:97ed3540c7466ab27395fe79
Output = 3ddd870471ff028a63c5f1bacc7e5b5c
KDF = SSKDF
Ctrl.mac = mac:HMAC
Ctrl.digest = digest:SHA256
Ctrl.hexsecret = hexsecret:0031558fddb96e3db2e0496026302055
Ctrl.hexsalt = hexsalt:91e8378de5348cea41f84c41e8546e34
Ctrl.hexinfo = hexinfo:97ed3540c7466ab27395fe79
Output = bf1eb0eab488b2393ad6a1c2eb804381
KDF = SSKDF
Ctrl.mac = mac:HMAC
Ctrl.digest = digest:SHA256
Ctrl.hexsecret = hexsecret:4ce16564db9615f75d46c6a9837af7ca
Ctrl.hexsalt = hexsalt:6199187690823def2037e0632577c6b1
Output = 0a102289b16cbf4b
KDF = SSKDF
Ctrl.mac = mac:HMAC
Ctrl.digest = digest:SHA256
Ctrl.hexsecret = hexsecret:2578fe1116e27e3a5e8e935e892e12eb
Ctrl.hexsalt = hexsalt:6199187690823def2037e0632577c6b1
Output = dd5773998893ad5a93f9819c8e798aab
KDF = SSKDF
Ctrl.mac = mac:HMAC
Ctrl.digest = digest:SHA256
Ctrl.hexsecret = hexsecret:e9dd8bd75f29661e61703346bbf2df47
Ctrl.hexsalt = hexsalt:6199187690823def2037e0632577c6b1
Output = 32136643daa64aaac0e2886364f157ba923d7b36ada761eb
KDF = SSKDF
Ctrl.mac = mac:HMAC
Ctrl.digest = digest:SHA256
Ctrl.hexsecret = hexsecret:e4640d3752cf48186a8ad2d7d4a81210
Ctrl.hexsalt = hexsalt:6199187690823def2037e0632577c6b1
Output = 6379d59efbe02576663af5efaccb9d063f596a22c8e1fed12cde7cdd7f327e88
KDF = SSKDF
Ctrl.mac = mac:HMAC
Ctrl.digest = digest:SHA256
Ctrl.hexsecret = hexsecret:3bd9a074a219d62273c3f639659a3ecd
Ctrl.hexsalt = hexsalt:6199187690823def2037e0632577c6b1
Output = cc45eb2ab80272c1e082b4f167ee4e086f12af3fbd0c812dda5568fea702928999cde3899cffc8a8
KDF = SSKDF
Ctrl.mac = mac:HMAC
Ctrl.digest = digest:SHA256
Ctrl.hexsecret = hexsecret:2147c0fb1c7587b22fa44ce3bf3d8f5b
Ctrl.hexsalt = hexsalt:6199187690823def2037e0632577c6b1
Output = 4e3a8827fcdb214686b35bfcc497ca69dccb78d3464aa4af0704ec0fba03c7bb10b9a4e31e27b1b2379a32e46935309c
KDF = SSKDF
Ctrl.mac = mac:HMAC
Ctrl.digest = digest:SHA256
Ctrl.hexsecret = hexsecret:2c2438b6321fed7a9eac200b91b3ac30
Ctrl.hexsalt = hexsalt:6199187690823def2037e0632577c6b1
Output = b402fda16e1c2719263be82158972c9080a7bafcbe0a3a6ede3504a3d5c8c0c0e00fe7e5f6bb3afdfa4d661b8fbe4bd7b950cfe0b2443bbd
KDF = SSKDF
Ctrl.mac = mac:HMAC
Ctrl.digest = digest:SHA256
Ctrl.hexsecret = hexsecret:0ffa4c40a822f6e3d86053aefe738eac
Ctrl.hexsalt = hexsalt:6199187690823def2037e0632577c6b1
Output = 0486d589aa71a603c09120fb76eeab3293eee2dc36a91b23eb954d6703ade8a7b660d920c5a6f7bf3898d0e81fbad3a680b74b33680e0cc6a16aa616d078b256
KDF = SSKDF
Ctrl.mac = mac:HMAC
Ctrl.digest = digest:SHA256
Ctrl.hexsecret = hexsecret:a801d997ed539ae9aa05d17871eb7fab
Ctrl.hexinfo = hexinfo:03697296e42a6fdbdb24b3ec
Output = 1a5efa3aca87c1f4
KDF = SSKDF
Ctrl.mac = mac:HMAC
Ctrl.digest = digest:SHA256
Ctrl.hexsecret = hexsecret:e9624e112f9e90e7bf8a749cf37d920c
Ctrl.hexinfo = hexinfo:03697296e42a6fdbdb24b3ec
Output = ee93ca3986cc43516ae4e29fd7a90ef1
KDF = SSKDF
Ctrl.mac = mac:HMAC
Ctrl.digest = digest:SHA256
Ctrl.hexsecret = hexsecret:a92acdee54a84a4564d4782d47801ec0
Ctrl.hexinfo = hexinfo:03697296e42a6fdbdb24b3ec
Output = 3116b87eaffaa0cc48a72e6c1574df335d706f7c860b44e9
KDF = SSKDF
Ctrl.mac = mac:HMAC
Ctrl.digest = digest:SHA256
Ctrl.hexsecret = hexsecret:e60d902e63b1a2bf5dab733cadb47b10
Ctrl.hexinfo = hexinfo:03697296e42a6fdbdb24b3ec
Output = 3fde6c078dd6dc65aacf62beafa39398d2b3d7cfb4b0ee4807bfc98a15330eef
KDF = SSKDF
Ctrl.mac = mac:HMAC
Ctrl.digest = digest:SHA256
Ctrl.hexsecret = hexsecret:d3b747a1d1584a0fc5aefcd4dd8ef9c3
Ctrl.hexinfo = hexinfo:03697296e42a6fdbdb24b3ec
Output = 2c4363597d42f9f8736e8050b4a6dd033d7ddac6f7211c4810ef74aff01f101d885767d7ae6f1d7f
KDF = SSKDF
Ctrl.mac = mac:HMAC
Ctrl.digest = digest:SHA256
Ctrl.hexsecret = hexsecret:119559a2c0a8888e9c95b9989a460d97
Ctrl.hexinfo = hexinfo:03697296e42a6fdbdb24b3ec
Output = 97922585f69adf484930cf22b8378c797694438502fa47e2f19f0fee97ca11451f3bc81a20c1d74964c63ab2d5df1985
KDF = SSKDF
Ctrl.mac = mac:HMAC
Ctrl.digest = digest:SHA256
Ctrl.hexsecret = hexsecret:807f375266988df5d0ae878efac424fa
Ctrl.hexinfo = hexinfo:03697296e42a6fdbdb24b3ec
Output = ba78ef8ab720fc583bb64581917634fca230876cc344e46b44fe61f3bdab556ee753743b78db4b16c0fcd8f987aebad15d0b7b13a10f6819
KDF = SSKDF
Ctrl.mac = mac:HMAC
Ctrl.digest = digest:SHA256
Ctrl.hexsecret = hexsecret:f7906f870b256753b5bc3ef408e47e9b
Ctrl.hexinfo = hexinfo:03697296e42a6fdbdb24b3ec
Output = 96bee2ae234f98c285aa970bd54c2e2891febf734bad58a91dc7a97490b6b05fe539f2156ae3acd2e661eced0d59084fda340cd1ba3daa7ca2a550d7b1c19462
KDF = SSKDF
Ctrl.mac = mac:HMAC
Ctrl.digest = digest:SHA512
Ctrl.hexsecret = hexsecret:73b6e2ede34aae5680e2289e611ffc3a
Ctrl.hexsalt = hexsalt:28df8439747d5a9b502e0838ca6999b2
Ctrl.hexinfo = hexinfo:232941631fc04dd82f727a51
Output = b0d36cd7d6b23b48ca6f89901bb784ec
KDF = SSKDF
Ctrl.mac = mac:HMAC
Ctrl.digest = digest:SHA512
Ctrl.hexsecret = hexsecret:abb7d7554c0de41cada5826a1f79d76f
Ctrl.hexinfo = hexinfo:a80b9061879365b1669c87a8
Output = 71e29fff69198eca92f5180bcb281fbdaf409ec7c99ca704b1f56e782d3c4db10cb4158e6634d793a46c13bffb6bdb71a01101936ea9b20f7dbe302558b1356c
test/recipes/30-test_evp_data/evpmac.txt
+8
View File
@@ -589,6 +589,14 @@ Input = "Sample message for keylen>blocklen"
Key = 000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f8081828384858687
Output = 5f464f5e5b7848e3885e49b2c385f0694985d0e38966242dc4a5fe3fea4b37d46b65ceced5dcf59438dd840bab22269f0ba7febdb9fcf74602a35666b2a32915
Title = HMAC self generated tests
MAC = HMAC
Algorithm = SHAKE128
Input = "Test that SHAKE128 fails"
Key = 000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f
Result = MAC_CTRL_ERROR
Title = CMAC tests (from FIPS module)
test/rsa_sp800_56b_test.c
+64 -25
View File
@@ -290,19 +290,31 @@ static int test_check_private_exponent(void)
&& TEST_ptr(ctx = BN_CTX_new())
&& TEST_ptr(p = BN_new())
&& TEST_ptr(q = BN_new())
&& TEST_ptr(e = BN_new())
&& TEST_ptr(d = BN_new())
&& TEST_ptr(n = BN_new())
/* lcm(15-1,17-1) = 14*16 / 2 = 112 */
&& TEST_true(BN_set_word(p, 15))
&& TEST_true(BN_set_word(q, 17))
&& TEST_true(RSA_set0_factors(key, p, q));
if (!ret) {
BN_free(p);
BN_free(q);
goto end;
}
ret = TEST_ptr(e = BN_new())
&& TEST_ptr(d = BN_new())
&& TEST_ptr(n = BN_new())
&& TEST_true(BN_set_word(e, 5))
&& TEST_true(BN_set_word(d, 157))
&& TEST_true(BN_set_word(n, 15*17))
&& TEST_true(RSA_set0_factors(key, p, q))
&& TEST_true(RSA_set0_key(key, n, e, d))
/* fails since d >= lcm(p-1, q-1) */
&& TEST_false(rsa_check_private_exponent(key, 8, ctx))
&& TEST_true(RSA_set0_key(key, n, e, d));
if (!ret) {
BN_free(e);
BN_free(d);
BN_free(n);
goto end;
}
/* fails since d >= lcm(p-1, q-1) */
ret = TEST_false(rsa_check_private_exponent(key, 8, ctx))
&& TEST_true(BN_set_word(d, 45))
/* d is correct size and 1 = e.d mod lcm(p-1, q-1) */
&& TEST_true(rsa_check_private_exponent(key, 8, ctx))
@@ -314,7 +326,7 @@ static int test_check_private_exponent(void)
/* fail if 1 != e.d mod lcm(p-1, q-1) */
&& TEST_true(BN_set_word(d, 46))
&& TEST_false(rsa_check_private_exponent(key, 8, ctx));
end:
RSA_free(key);
BN_CTX_free(ctx);
return ret;
@@ -343,8 +355,13 @@ static int test_check_crt_components(void)
&& TEST_true(BN_set_word(p, P))
&& TEST_true(BN_set_word(q, Q))
&& TEST_true(BN_set_word(e, E))
&& TEST_true(RSA_set0_factors(key, p, q))
&& TEST_true(rsa_sp800_56b_derive_params_from_pq(key, 8, e, ctx))
&& TEST_true(RSA_set0_factors(key, p, q));
if (!ret) {
BN_free(p);
BN_free(q);
goto end;
}
ret = TEST_true(rsa_sp800_56b_derive_params_from_pq(key, 8, e, ctx))
&& TEST_BN_eq_word(key->n, N)
&& TEST_BN_eq_word(key->dmp1, DP)
&& TEST_BN_eq_word(key->dmq1, DQ)
@@ -382,7 +399,7 @@ static int test_check_crt_components(void)
&& TEST_true(BN_set_word(key->iqmp, QINV))
/* check defaults are still valid */
&& TEST_true(rsa_check_crt_components(key, ctx));
end:
BN_free(e);
RSA_free(key);
BN_CTX_free(ctx);
@@ -427,14 +444,25 @@ static int test_invalid_keypair(void)
/* load key */
&& TEST_ptr(p = bn_load_new(cav_p, sizeof(cav_p)))
&& TEST_ptr(q = bn_load_new(cav_q, sizeof(cav_q)))
&& TEST_ptr(e = bn_load_new(cav_e, sizeof(cav_e)))
&& TEST_true(RSA_set0_factors(key, p, q));
if (!ret) {
BN_free(p);
BN_free(q);
goto end;
}
ret = TEST_ptr(e = bn_load_new(cav_e, sizeof(cav_e)))
&& TEST_ptr(n = bn_load_new(cav_n, sizeof(cav_n)))
&& TEST_ptr(d = bn_load_new(cav_d, sizeof(cav_d)))
&& TEST_true(RSA_set0_key(key, n, e, d))
&& TEST_true(RSA_set0_factors(key, p, q))
&& TEST_true(RSA_set0_key(key, n, e, d));
if (!ret) {
BN_free(e);
BN_free(n);
BN_free(d);
goto end;
}
/* bad strength/key size */
&& TEST_false(rsa_sp800_56b_check_keypair(key, NULL, 100, 2048))
ret = TEST_false(rsa_sp800_56b_check_keypair(key, NULL, 100, 2048))
&& TEST_false(rsa_sp800_56b_check_keypair(key, NULL, 112, 1024))
&& TEST_false(rsa_sp800_56b_check_keypair(key, NULL, 128, 2048))
&& TEST_false(rsa_sp800_56b_check_keypair(key, NULL, 140, 3072))
@@ -466,7 +494,7 @@ static int test_invalid_keypair(void)
&& TEST_false(rsa_sp800_56b_check_keypair(key, NULL, -1, 2048))
&& TEST_true(BN_add_word(q, 2))
&& TEST_true(BN_mul(n, p, q, ctx));
end:
RSA_free(key);
BN_CTX_free(ctx);
return ret;
@@ -567,16 +595,22 @@ static int test_check_private_key(void)
&& TEST_ptr(n = bn_load_new(cav_n, sizeof(cav_n)))
&& TEST_ptr(d = bn_load_new(cav_d, sizeof(cav_d)))
&& TEST_ptr(e = bn_load_new(cav_e, sizeof(cav_e)))
&& TEST_true(RSA_set0_key(key, n, e, d))
/* check d is in range */
&& TEST_true(rsa_sp800_56b_check_private(key))
&& TEST_true(RSA_set0_key(key, n, e, d));
if (!ret) {
BN_free(n);
BN_free(e);
BN_free(d);
goto end;
}
/* check d is in range */
ret = TEST_true(rsa_sp800_56b_check_private(key))
/* check d is too low */
&& TEST_true(BN_set_word(d, 0))
&& TEST_false(rsa_sp800_56b_check_private(key))
/* check d is too high */
&& TEST_ptr(BN_copy(d, n))
&& TEST_false(rsa_sp800_56b_check_private(key));
end:
RSA_free(key);
return ret;
}
@@ -593,9 +627,14 @@ static int test_check_public_key(void)
/* load public key */
&& TEST_ptr(e = bn_load_new(cav_e, sizeof(cav_e)))
&& TEST_ptr(n = bn_load_new(cav_n, sizeof(cav_n)))
&& TEST_true(RSA_set0_key(key, n, e, NULL))
/* check public key is valid */
&& TEST_true(rsa_sp800_56b_check_public(key))
&& TEST_true(RSA_set0_key(key, n, e, NULL));
if (!ret) {
BN_free(e);
BN_free(n);
goto end;
}
/* check public key is valid */
ret = TEST_true(rsa_sp800_56b_check_public(key))
/* check fail if n is even */
&& TEST_true(BN_add_word(n, 1))
&& TEST_false(rsa_sp800_56b_check_public(key))
@@ -611,7 +650,7 @@ static int test_check_public_key(void)
/* modulus fails composite check */
&& TEST_true(BN_add_word(n, 2))
&& TEST_false(rsa_sp800_56b_check_public(key));
end:
RSA_free(key);
return ret;
}
test/servername_test.c
+7 -1
View File
@@ -35,10 +35,16 @@ static int get_sni_from_client_hello(BIO *bio, char **sni)
{
long len;
unsigned char *data;
PACKET pkt = {0}, pkt2 = {0}, pkt3 = {0}, pkt4 = {0}, pkt5 = {0};
PACKET pkt, pkt2, pkt3, pkt4, pkt5;
unsigned int servname_type = 0, type = 0;
int ret = 0;
memset(&pkt, 0, sizeof(pkt));
memset(&pkt2, 0, sizeof(pkt2));
memset(&pkt3, 0, sizeof(pkt3));
memset(&pkt4, 0, sizeof(pkt4));
memset(&pkt5, 0, sizeof(pkt5));
len = BIO_get_mem_data(bio, (char **)&data);
if (!TEST_true(PACKET_buf_init(&pkt, data, len))
/* Skip the record header */
test/sslapitest.c
+9 -3
View File
@@ -306,9 +306,10 @@ static int test_keylog(void)
SSL_CTX *cctx = NULL, *sctx = NULL;
SSL *clientssl = NULL, *serverssl = NULL;
int testresult = 0;
struct sslapitest_log_counts expected = {0};
struct sslapitest_log_counts expected;
/* Clean up logging space */
memset(&expected, 0, sizeof(expected));
memset(client_log_buffer, 0, sizeof(client_log_buffer));
memset(server_log_buffer, 0, sizeof(server_log_buffer));
client_log_buffer_index = 0;
@@ -387,11 +388,12 @@ static int test_keylog_no_master_key(void)
SSL *clientssl = NULL, *serverssl = NULL;
SSL_SESSION *sess = NULL;
int testresult = 0;
struct sslapitest_log_counts expected = {0};
struct sslapitest_log_counts expected;
unsigned char buf[1];
size_t readbytes, written;
/* Clean up logging space */
memset(&expected, 0, sizeof(expected));
memset(client_log_buffer, 0, sizeof(client_log_buffer));
memset(server_log_buffer, 0, sizeof(server_log_buffer));
client_log_buffer_index = 0;
@@ -4593,12 +4595,16 @@ static int get_MFL_from_client_hello(BIO *bio, int *mfl_codemfl_code)
{
long len;
unsigned char *data;
PACKET pkt = {0}, pkt2 = {0}, pkt3 = {0};
PACKET pkt, pkt2, pkt3;
unsigned int MFL_code = 0, type = 0;
if (!TEST_uint_gt( len = BIO_get_mem_data( bio, (char **) &data ), 0 ) )
goto end;
memset(&pkt, 0, sizeof(pkt));
memset(&pkt2, 0, sizeof(pkt2));
memset(&pkt3, 0, sizeof(pkt3));
if (!TEST_true( PACKET_buf_init( &pkt, data, len ) )
/* Skip the record header */
|| !PACKET_forward(&pkt, SSL3_RT_HEADER_LENGTH)