wbrawner/openssl
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Convert more tests

Browse source 
recordlentest, srptest, ecdsatest, enginetest, pbelutest

Reviewed-by: Richard Levitte <levitte@openssl.org>
(Merged from https://github.com/openssl/openssl/pull/3237)
This commit is contained in:
Rich Salz 2017-04-18 14:34:43 -04:00
parent 0fef74486e
commit b66411f6cd
6 changed files with 325 additions and 470 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

10
test/build.info
View file

@ -55,7 +55,7 @@ IF[{- !$disabled{tests} -}]
INCLUDE[ectest]=.. ../include
DEPEND[ectest]=../libcrypto
SOURCE[ecdsatest]=ecdsatest.c
SOURCE[ecdsatest]=ecdsatest.c testutil.c test_main.c
INCLUDE[ecdsatest]=../include
DEPEND[ecdsatest]=../libcrypto
@ -63,7 +63,7 @@ IF[{- !$disabled{tests} -}]
INCLUDE[gmdifftest]=../include
DEPEND[gmdifftest]=../libcrypto
SOURCE[pbelutest]=pbelutest.c
SOURCE[pbelutest]=pbelutest.c testutil.c test_main.c
INCLUDE[pbelutest]=../include
DEPEND[pbelutest]=../libcrypto
@ -119,11 +119,11 @@ IF[{- !$disabled{tests} -}]
INCLUDE[dhtest]=../include
DEPEND[dhtest]=../libcrypto
SOURCE[enginetest]=enginetest.c
SOURCE[enginetest]=enginetest.c testutil.c test_main.c
INCLUDE[enginetest]=../include
DEPEND[enginetest]=../libcrypto
SOURCE[casttest]=casttest.c testutil.c test_main.o
SOURCE[casttest]=casttest.c testutil.c test_main.c
INCLUDE[casttest]=.. ../include
DEPEND[casttest]=../libcrypto
@ -203,7 +203,7 @@ IF[{- !$disabled{tests} -}]
INCLUDE[secmemtest]=../include
DEPEND[secmemtest]=../libcrypto
SOURCE[srptest]=srptest.c
SOURCE[srptest]=srptest.c testutil.c test_main.c
INCLUDE[srptest]=../include
DEPEND[srptest]=../libcrypto

320
test/ecdsatest.c
View file

@ -45,48 +45,39 @@ int main(int argc, char *argv[])
# endif
# include <openssl/err.h>
# include <openssl/rand.h>
# include "testutil.h"
# include "test_main.h"
static const char rnd_seed[] = "string to make the random number generator "
"think it has entropy";
/* declaration of the test functions */
int x9_62_tests(BIO *);
int x9_62_test_internal(BIO *out, int nid, const char *r, const char *s);
int test_builtin(BIO *);
/* functions to change the RAND_METHOD */
int change_rand(void);
int restore_rand(void);
int fbytes(unsigned char *buf, int num);
static int fbytes(unsigned char *buf, int num);
static RAND_METHOD fake_rand;
static const RAND_METHOD *old_rand;
int change_rand(void)
static int change_rand(void)
{
/* save old rand method */
if ((old_rand = RAND_get_rand_method()) == NULL)
if (!TEST_ptr(old_rand = RAND_get_rand_method()))
return 0;
fake_rand.seed = old_rand->seed;
fake_rand.cleanup = old_rand->cleanup;
fake_rand.add = old_rand->add;
fake_rand.status = old_rand->status;
fake_rand = *old_rand;
/* use own random function */
fake_rand.bytes = fbytes;
fake_rand.pseudorand = old_rand->bytes;
/* set new RAND_METHOD */
if (!RAND_set_rand_method(&fake_rand))
if (!TEST_true(RAND_set_rand_method(&fake_rand)))
return 0;
return 1;
}
int restore_rand(void)
static int restore_rand(void)
{
if (!RAND_set_rand_method(old_rand))
if (!TEST_true(RAND_set_rand_method(old_rand)))
return 0;
else
return 1;
return 1;
}
static int fbytes_counter = 0, use_fake = 0;
@ -105,9 +96,9 @@ static const char *numbers[8] = {
"40041670216363"
};
int fbytes(unsigned char *buf, int num)
static int fbytes(unsigned char *buf, int num)
{
int ret;
int ret = 0;
BIGNUM *tmp = NULL;
if (use_fake == 0)
@ -117,85 +108,77 @@ int fbytes(unsigned char *buf, int num)
if (fbytes_counter >= 8)
return 0;
tmp = BN_new();
if (!tmp)
if (!TEST_ptr(tmp = BN_new()))
return 0;
if (!BN_dec2bn(&tmp, numbers[fbytes_counter])) {
if (!TEST_true(BN_dec2bn(&tmp, numbers[fbytes_counter]))) {
BN_free(tmp);
return 0;
}
fbytes_counter++;
if (num != BN_num_bytes(tmp) || !BN_bn2bin(tmp, buf))
ret = 0;
else
if (TEST_int_eq(BN_num_bytes(tmp), num)
&& TEST_true(BN_bn2bin(tmp, buf)))
ret = 1;
BN_free(tmp);
return ret;
}
/* some tests from the X9.62 draft */
int x9_62_test_internal(BIO *out, int nid, const char *r_in, const char *s_in)
static int x9_62_test_internal(int nid, const char *r_in, const char *s_in)
{
int ret = 0;
const char message[] = "abc";
unsigned char digest[20];
unsigned int dgst_len = 0;
EVP_MD_CTX *md_ctx = EVP_MD_CTX_new();
EVP_MD_CTX *md_ctx;
EC_KEY *key = NULL;
ECDSA_SIG *signature = NULL;
BIGNUM *r = NULL, *s = NULL;
BIGNUM *kinv = NULL, *rp = NULL;
const BIGNUM *sig_r, *sig_s;
if (md_ctx == NULL)
if (!TEST_ptr(md_ctx = EVP_MD_CTX_new()))
goto x962_int_err;
/* get the message digest */
if (!EVP_DigestInit(md_ctx, EVP_sha1())
|| !EVP_DigestUpdate(md_ctx, (const void *)message, 3)
|| !EVP_DigestFinal(md_ctx, digest, &dgst_len))
if (!TEST_true(EVP_DigestInit(md_ctx, EVP_sha1()))
|| !TEST_true(EVP_DigestUpdate(md_ctx, (const void *)message, 3))
|| !TEST_true(EVP_DigestFinal(md_ctx, digest, &dgst_len)))
goto x962_int_err;
BIO_printf(out, "testing %s: ", OBJ_nid2sn(nid));
TEST_info("testing %s", OBJ_nid2sn(nid));
/* create the key */
if ((key = EC_KEY_new_by_curve_name(nid)) == NULL)
if (!TEST_ptr(key = EC_KEY_new_by_curve_name(nid)))
goto x962_int_err;
use_fake = 1;
if (!EC_KEY_generate_key(key))
if (!TEST_true(EC_KEY_generate_key(key)))
goto x962_int_err;
BIO_printf(out, ".");
(void)BIO_flush(out);
/* create the signature */
use_fake = 1;
/* Use ECDSA_sign_setup to avoid use of ECDSA nonces */
if (!ECDSA_sign_setup(key, NULL, &kinv, &rp))
if (!TEST_true(ECDSA_sign_setup(key, NULL, &kinv, &rp)))
goto x962_int_err;
signature = ECDSA_do_sign_ex(digest, 20, kinv, rp, key);
if (signature == NULL)
if (!TEST_ptr(signature = ECDSA_do_sign_ex(digest, 20, kinv, rp, key)))
goto x962_int_err;
BIO_printf(out, ".");
(void)BIO_flush(out);
/* compare the created signature with the expected signature */
if ((r = BN_new()) == NULL || (s = BN_new()) == NULL)
if (!TEST_ptr(r = BN_new()) || !TEST_ptr(s = BN_new()))
goto x962_int_err;
if (!BN_dec2bn(&r, r_in) || !BN_dec2bn(&s, s_in))
if (!TEST_true(BN_dec2bn(&r, r_in)) || !TEST_true(BN_dec2bn(&s, s_in)))
goto x962_int_err;
ECDSA_SIG_get0(signature, &sig_r, &sig_s);
if (BN_cmp(sig_r, r) || BN_cmp(sig_s, s))
if (!TEST_int_eq(BN_cmp(sig_r, r), 0)
|| !TEST_int_eq(BN_cmp(sig_s, s), 0))
goto x962_int_err;
/* verify the signature */
if (!TEST_int_eq(ECDSA_do_verify(digest, 20, signature, key), 1))
goto x962_int_err;
BIO_printf(out, ".");
(void)BIO_flush(out);
/* verify the signature */
if (ECDSA_do_verify(digest, 20, signature, key) != 1)
goto x962_int_err;
BIO_printf(out, ".");
(void)BIO_flush(out);
BIO_printf(out, " ok\n");
ret = 1;
x962_int_err:
if (!ret)
BIO_printf(out, " failed\n");
EC_KEY_free(key);
ECDSA_SIG_free(signature);
BN_free(r);
@ -206,46 +189,46 @@ int x9_62_test_internal(BIO *out, int nid, const char *r_in, const char *s_in)
return ret;
}
int x9_62_tests(BIO *out)
static int x9_62_tests()
{
int ret = 0;
BIO_printf(out, "some tests from X9.62:\n");
/* set own rand method */
if (!change_rand())
goto x962_err;
if (!x9_62_test_internal(out, NID_X9_62_prime192v1,
"3342403536405981729393488334694600415596881826869351677613",
"5735822328888155254683894997897571951568553642892029982342"))
if (!TEST_true(x9_62_test_internal(NID_X9_62_prime192v1,
"3342403536405981729393488334694600415596881826869351677613",
"5735822328888155254683894997897571951568553642892029982342")))
goto x962_err;
if (!x9_62_test_internal(out, NID_X9_62_prime239v1,
"3086361431751678114926225473006680188549593787585317781474"
if (!TEST_true(x9_62_test_internal(NID_X9_62_prime239v1,
"3086361431751678114926225473006680188549593787585317781474"
"62058306432176",
"3238135532097973577080787768312505059318910517550078427819"
"78505179448783"))
"3238135532097973577080787768312505059318910517550078427819"
"78505179448783")))
goto x962_err;
# ifndef OPENSSL_NO_EC2M
if (!x9_62_test_internal(out, NID_X9_62_c2tnb191v1,
"87194383164871543355722284926904419997237591535066528048",
"308992691965804947361541664549085895292153777025772063598"))
if (!TEST_true(x9_62_test_internal(NID_X9_62_c2tnb191v1,
"87194383164871543355722284926904419997237591535066528048",
"308992691965804947361541664549085895292153777025772063598")))
goto x962_err;
if (!x9_62_test_internal(out, NID_X9_62_c2tnb239v1,
"2159633321041961198501834003903461262881815148684178964245"
if (!TEST_true(x9_62_test_internal(NID_X9_62_c2tnb239v1,
"2159633321041961198501834003903461262881815148684178964245"
"5876922391552",
"1970303740007316867383349976549972270528498040721988191026"
"49413465737174"))
"1970303740007316867383349976549972270528498040721988191026"
"49413465737174")))
goto x962_err;
# endif
ret = 1;
x962_err:
if (!restore_rand())
if (!TEST_true(restore_rand()))
ret = 0;
return ret;
}
int test_builtin(BIO *out)
static int test_builtin(void)
{
EC_builtin_curve *curves = NULL;
size_t crv_len = 0, n = 0;
@ -264,29 +247,16 @@ int test_builtin(BIO *out)
int nid, ret = 0;
/* fill digest values with some random data */
if (RAND_bytes(digest, 20) <= 0 || RAND_bytes(wrong_digest, 20) <= 0) {
BIO_printf(out, "ERROR: unable to get random data\n");
if (!TEST_true(RAND_bytes(digest, 20))
|| !TEST_true(RAND_bytes(wrong_digest, 20)))
goto builtin_err;
}
/*
* create and verify a ecdsa signature with every available curve (with )
*/
BIO_printf(out, "\ntesting ECDSA_sign() and ECDSA_verify() "
"with some internal curves:\n");
/* create and verify a ecdsa signature with every available curve */
/* get a list of all internal curves */
crv_len = EC_get_builtin_curves(NULL, 0);
curves = OPENSSL_malloc(sizeof(*curves) * crv_len);
if (curves == NULL) {
BIO_printf(out, "malloc error\n");
if (!TEST_ptr(curves = OPENSSL_malloc(sizeof(*curves) * crv_len))
|| !TEST_true(EC_get_builtin_curves(curves, crv_len)))
goto builtin_err;
}
if (!EC_get_builtin_curves(curves, crv_len)) {
BIO_printf(out, "unable to get internal curves\n");
goto builtin_err;
}
/* now create and verify a signature for every curve */
for (n = 0; n < crv_len; n++) {
@ -296,12 +266,9 @@ int test_builtin(BIO *out)
if (nid == NID_ipsec4 || nid == NID_X25519)
continue;
/* create new ecdsa key (== EC_KEY) */
if ((eckey = EC_KEY_new()) == NULL)
goto builtin_err;
group = EC_GROUP_new_by_curve_name(nid);
if (group == NULL)
goto builtin_err;
if (EC_KEY_set_group(eckey, group) == 0)
if (!TEST_ptr(eckey = EC_KEY_new())
|| !TEST_ptr(group = EC_GROUP_new_by_curve_name(nid))
|| !TEST_true(EC_KEY_set_group(eckey, group)))
goto builtin_err;
EC_GROUP_free(group);
degree = EC_GROUP_get_degree(EC_KEY_get0_group(eckey));
@ -311,73 +278,50 @@ int test_builtin(BIO *out)
eckey = NULL;
continue;
}
BIO_printf(out, "%s: ", OBJ_nid2sn(nid));
TEST_info("testing %s", OBJ_nid2sn(nid));
/* create key */
if (!EC_KEY_generate_key(eckey)) {
BIO_printf(out, " failed\n");
if (!TEST_true(EC_KEY_generate_key(eckey)))
goto builtin_err;
}
/* create second key */
if ((wrong_eckey = EC_KEY_new()) == NULL)
goto builtin_err;
group = EC_GROUP_new_by_curve_name(nid);
if (group == NULL)
goto builtin_err;
if (EC_KEY_set_group(wrong_eckey, group) == 0)
if (!TEST_ptr(wrong_eckey = EC_KEY_new())
|| !TEST_ptr(group = EC_GROUP_new_by_curve_name(nid))
|| !TEST_true(EC_KEY_set_group(wrong_eckey, group)))
goto builtin_err;
EC_GROUP_free(group);
if (!EC_KEY_generate_key(wrong_eckey)) {
BIO_printf(out, " failed\n");
if (!TEST_true(EC_KEY_generate_key(wrong_eckey)))
goto builtin_err;
}
BIO_printf(out, ".");
(void)BIO_flush(out);
/* check key */
if (!EC_KEY_check_key(eckey)) {
BIO_printf(out, " failed\n");
if (!TEST_true(EC_KEY_check_key(eckey)))
goto builtin_err;
}
BIO_printf(out, ".");
(void)BIO_flush(out);
/* create signature */
sig_len = ECDSA_size(eckey);
if ((signature = OPENSSL_malloc(sig_len)) == NULL)
if (!TEST_ptr(signature = OPENSSL_malloc(sig_len))
|| !TEST_true(ECDSA_sign(0, digest, 20, signature, &sig_len,
eckey)))
goto builtin_err;
if (!ECDSA_sign(0, digest, 20, signature, &sig_len, eckey)) {
BIO_printf(out, " failed\n");
goto builtin_err;
}
BIO_printf(out, ".");
(void)BIO_flush(out);
/* verify signature */
if (ECDSA_verify(0, digest, 20, signature, sig_len, eckey) != 1) {
BIO_printf(out, " failed\n");
if (!TEST_int_eq(ECDSA_verify(0, digest, 20, signature, sig_len,
eckey), 1))
goto builtin_err;
}
BIO_printf(out, ".");
(void)BIO_flush(out);
/* verify signature with the wrong key */
if (ECDSA_verify(0, digest, 20, signature, sig_len, wrong_eckey) == 1) {
BIO_printf(out, " failed\n");
if (!TEST_int_ne(ECDSA_verify(0, digest, 20, signature, sig_len,
wrong_eckey), 1))
goto builtin_err;
}
BIO_printf(out, ".");
(void)BIO_flush(out);
/* wrong digest */
if (ECDSA_verify(0, wrong_digest, 20, signature, sig_len, eckey) == 1) {
BIO_printf(out, " failed\n");
if (!TEST_int_ne(ECDSA_verify(0, wrong_digest, 20, signature,
sig_len, eckey), 1))
goto builtin_err;
}
BIO_printf(out, ".");
(void)BIO_flush(out);
/* wrong length */
if (ECDSA_verify(0, digest, 20, signature, sig_len - 1, eckey) == 1) {
BIO_printf(out, " failed\n");
if (!TEST_int_ne(ECDSA_verify(0, digest, 20, signature,
sig_len - 1, eckey), 1))
goto builtin_err;
}
BIO_printf(out, ".");
(void)BIO_flush(out);
/*
* Modify a single byte of the signature: to ensure we don't garble
@ -385,10 +329,8 @@ int test_builtin(BIO *out)
* one of the bignums directly.
*/
sig_ptr = signature;
if ((ecdsa_sig = d2i_ECDSA_SIG(NULL, &sig_ptr, sig_len)) == NULL) {
BIO_printf(out, " failed\n");
if (!TEST_ptr(ecdsa_sig = d2i_ECDSA_SIG(NULL, &sig_ptr, sig_len)))
goto builtin_err;
}
ECDSA_SIG_get0(ecdsa_sig, &sig_r, &sig_s);
@ -396,12 +338,11 @@ int test_builtin(BIO *out)
r_len = BN_num_bytes(sig_r);
s_len = BN_num_bytes(sig_s);
bn_len = (degree + 7) / 8;
if ((r_len > bn_len) || (s_len > bn_len)) {
BIO_printf(out, " failed\n");
if (!TEST_false(r_len > bn_len)
|| !TEST_false(s_len > bn_len))
goto builtin_err;
}
buf_len = 2 * bn_len;
if ((raw_buf = OPENSSL_zalloc(buf_len)) == NULL)
if (!TEST_ptr(raw_buf = OPENSSL_zalloc(buf_len)))
goto builtin_err;
BN_bn2bin(sig_r, raw_buf + bn_len - r_len);
BN_bn2bin(sig_s, raw_buf + buf_len - s_len);
@ -410,30 +351,31 @@ int test_builtin(BIO *out)
offset = raw_buf[10] % buf_len;
dirt = raw_buf[11] ? raw_buf[11] : 1;
raw_buf[offset] ^= dirt;
/* Now read the BIGNUMs back in from raw_buf. */
modified_sig = ECDSA_SIG_new();
if (modified_sig == NULL)
if (!TEST_ptr(modified_sig = ECDSA_SIG_new()))
goto builtin_err;
if (((modified_r = BN_bin2bn(raw_buf, bn_len, NULL)) == NULL)
|| ((modified_s = BN_bin2bn(raw_buf + bn_len, bn_len, NULL)) == NULL)
|| !ECDSA_SIG_set0(modified_sig, modified_r, modified_s)) {
if (!TEST_ptr(modified_r = BN_bin2bn(raw_buf, bn_len, NULL))
|| !TEST_ptr(modified_s = BN_bin2bn(raw_buf + bn_len,
bn_len, NULL))
|| !TEST_true(ECDSA_SIG_set0(modified_sig,
modified_r, modified_s))) {
BN_free(modified_r);
BN_free(modified_s);
goto builtin_err;
}
sig_ptr2 = signature;
sig_len = i2d_ECDSA_SIG(modified_sig, &sig_ptr2);
if (ECDSA_verify(0, digest, 20, signature, sig_len, eckey) == 1) {
BIO_printf(out, " failed\n");
if (!TEST_false(ECDSA_verify(0, digest, 20, signature, sig_len, eckey)))
goto builtin_err;
}
/*
* Sanity check: undo the modification and verify signature.
*/
/* Sanity check: undo the modification and verify signature. */
raw_buf[offset] ^= dirt;
if (((unmodified_r = BN_bin2bn(raw_buf, bn_len, NULL)) == NULL)
|| ((unmodified_s = BN_bin2bn(raw_buf + bn_len, bn_len, NULL)) == NULL)
|| !ECDSA_SIG_set0(modified_sig, unmodified_r, unmodified_s)) {
if (!TEST_ptr(unmodified_r = BN_bin2bn(raw_buf, bn_len, NULL))
|| !TEST_ptr(unmodified_s = BN_bin2bn(raw_buf + bn_len,
bn_len, NULL))
|| !TEST_true(ECDSA_SIG_set0(modified_sig, unmodified_r,
unmodified_s))) {
BN_free(unmodified_r);
BN_free(unmodified_s);
goto builtin_err;
@ -441,16 +383,10 @@ int test_builtin(BIO *out)
sig_ptr2 = signature;
sig_len = i2d_ECDSA_SIG(modified_sig, &sig_ptr2);
if (ECDSA_verify(0, digest, 20, signature, sig_len, eckey) != 1) {
BIO_printf(out, " failed\n");
if (!TEST_true(ECDSA_verify(0, digest, 20, signature, sig_len, eckey)))
goto builtin_err;
}
BIO_printf(out, ".");
(void)BIO_flush(out);
BIO_printf(out, " ok\n");
/* cleanup */
/* clean bogus errors */
ERR_clear_error();
OPENSSL_free(signature);
signature = NULL;
@ -479,41 +415,11 @@ int test_builtin(BIO *out)
return ret;
}
int main(void)
void register_tests(void)
{
int ret = 1;
BIO *out;
char *p;
out = BIO_new_fp(stdout, BIO_NOCLOSE | BIO_FP_TEXT);
p = getenv("OPENSSL_DEBUG_MEMORY");
if (p != NULL && strcmp(p, "on") == 0)
CRYPTO_set_mem_debug(1);
/* initialize the prng */
RAND_seed(rnd_seed, sizeof(rnd_seed));
/* the tests */
if (!x9_62_tests(out))
goto err;
if (!test_builtin(out))
goto err;
ret = 0;
err:
if (ret)
BIO_printf(out, "\nECDSA test failed\n");
else
BIO_printf(out, "\nECDSA test passed\n");
if (ret)
ERR_print_errors(out);
#ifndef OPENSSL_NO_CRYPTO_MDEBUG
if (CRYPTO_mem_leaks(out) <= 0)
ret = 1;
#endif
BIO_free(out);
return ret;
ADD_TEST(x9_62_tests);
ADD_TEST(test_builtin);
}
#endif

194
test/enginetest.c
View file

@ -22,21 +22,20 @@ int main(int argc, char *argv[])
# include <openssl/crypto.h>
# include <openssl/engine.h>
# include <openssl/err.h>
# include "testutil.h"
# include "test_main.h"
static void display_engine_list(void)
{
ENGINE *h;
int loop;
h = ENGINE_get_first();
loop = 0;
printf("listing available engine types\n");
while (h) {
printf("engine %i, id = \"%s\", name = \"%s\"\n",
for (h = ENGINE_get_first(); h != NULL; h = ENGINE_get_next(h)) {
TEST_info("#%d: id = \"%s\", name = \"%s\"",
loop++, ENGINE_get_id(h), ENGINE_get_name(h));
h = ENGINE_get_next(h);
}
printf("end of list\n");
/*
* ENGINE_get_first() increases the struct_ref counter, so we must call
* ENGINE_free() to decrease it again
@ -44,161 +43,146 @@ static void display_engine_list(void)
ENGINE_free(h);
}
int main(int argc, char *argv[])
#define NUMTOADD 512
static int test_engines(void)
{
ENGINE *block[512];
ENGINE *block[NUMTOADD];
char buf[256];
const char *id, *name, *p;
const char *id, *name;
ENGINE *ptr;
int loop;
int to_return = 1;
int to_return = 0;
ENGINE *new_h1 = NULL;
ENGINE *new_h2 = NULL;
ENGINE *new_h3 = NULL;
ENGINE *new_h4 = NULL;
p = getenv("OPENSSL_DEBUG_MEMORY");
if (p != NULL && strcmp(p, "on") == 0)
CRYPTO_set_mem_debug(1);
memset(block, 0, sizeof(block));
if (((new_h1 = ENGINE_new()) == NULL) ||
!ENGINE_set_id(new_h1, "test_id0") ||
!ENGINE_set_name(new_h1, "First test item") ||
((new_h2 = ENGINE_new()) == NULL) ||
!ENGINE_set_id(new_h2, "test_id1") ||
!ENGINE_set_name(new_h2, "Second test item") ||
((new_h3 = ENGINE_new()) == NULL) ||
!ENGINE_set_id(new_h3, "test_id2") ||
!ENGINE_set_name(new_h3, "Third test item") ||
((new_h4 = ENGINE_new()) == NULL) ||
!ENGINE_set_id(new_h4, "test_id3") ||
!ENGINE_set_name(new_h4, "Fourth test item")) {
printf("Couldn't set up test ENGINE structures\n");
if (!TEST_ptr(new_h1 = ENGINE_new())
|| !TEST_true(ENGINE_set_id(new_h1, "test_id0"))
|| !TEST_true(ENGINE_set_name(new_h1, "First test item"))
|| !TEST_ptr(new_h2 = ENGINE_new())
|| !TEST_true(ENGINE_set_id(new_h2, "test_id1"))
|| !TEST_true(ENGINE_set_name(new_h2, "Second test item"))
|| !TEST_ptr(new_h3 = ENGINE_new())
|| !TEST_true(ENGINE_set_id(new_h3, "test_id2"))
|| !TEST_true(ENGINE_set_name(new_h3, "Third test item"))
|| !TEST_ptr(new_h4 = ENGINE_new())
|| !TEST_true(ENGINE_set_id(new_h4, "test_id3"))
|| !TEST_true(ENGINE_set_name(new_h4, "Fourth test item")))
goto end;
}
printf("\nenginetest beginning\n\n");
TEST_info("Engines:");
display_engine_list();
if (!ENGINE_add(new_h1)) {
printf("Add failed!\n");
if (!TEST_true(ENGINE_add(new_h1)))
goto end;
}
TEST_info("Engines:");
display_engine_list();
ptr = ENGINE_get_first();
if (!ENGINE_remove(ptr)) {
printf("Remove failed!\n");
if (!TEST_true(ENGINE_remove(ptr)))
goto end;
}
ENGINE_free(ptr);
TEST_info("Engines:");
display_engine_list();
if (!ENGINE_add(new_h3) || !ENGINE_add(new_h2)) {
printf("Add failed!\n");
if (!TEST_true(ENGINE_add(new_h3))
|| !TEST_true(ENGINE_add(new_h2)))
goto end;
}
TEST_info("Engines:");
display_engine_list();
if (!ENGINE_remove(new_h2)) {
printf("Remove failed!\n");
if (!TEST_true(ENGINE_remove(new_h2)))
goto end;
}
TEST_info("Engines:");
display_engine_list();
if (!ENGINE_add(new_h4)) {
printf("Add failed!\n");
if (!TEST_true(ENGINE_add(new_h4)))
goto end;
}
TEST_info("Engines:");
display_engine_list();
if (ENGINE_add(new_h3)) {
printf("Add *should* have failed but didn't!\n");
/* Should fail. */
if (!TEST_false(ENGINE_add(new_h3)))
goto end;
} else
printf("Add that should fail did.\n");
ERR_clear_error();
if (ENGINE_remove(new_h2)) {
printf("Remove *should* have failed but didn't!\n");
/* Should fail. */
if (!TEST_false(ENGINE_remove(new_h2)))
goto end;
} else
printf("Remove that should fail did.\n");
ERR_clear_error();
if (!ENGINE_remove(new_h3)) {
printf("Remove failed!\n");
if (!TEST_true(ENGINE_remove(new_h3)))
goto end;
}
TEST_info("Engines:");
display_engine_list();
if (!ENGINE_remove(new_h4)) {
printf("Remove failed!\n");
if (!TEST_true(ENGINE_remove(new_h4)))
goto end;
}
TEST_info("Engines:");
display_engine_list();
/*
* Depending on whether there's any hardware support compiled in, this
* remove may be destined to fail.
*/
ptr = ENGINE_get_first();
if (ptr)
if ((ptr = ENGINE_get_first()) != NULL) {
if (!ENGINE_remove(ptr))
printf("Remove failed!i - probably no hardware "
"support present.\n");
ENGINE_free(ptr);
display_engine_list();
if (!ENGINE_add(new_h1) || !ENGINE_remove(new_h1)) {
printf("Couldn't add and remove to an empty list!\n");
goto end;
} else
printf("Successfully added and removed to an empty list!\n");
printf("About to beef up the engine-type list\n");
for (loop = 0; loop < 512; loop++) {
sprintf(buf, "id%i", loop);
id = OPENSSL_strdup(buf);
sprintf(buf, "Fake engine type %i", loop);
name = OPENSSL_strdup(buf);
if (((block[loop] = ENGINE_new()) == NULL) ||
!ENGINE_set_id(block[loop], id) ||
!ENGINE_set_name(block[loop], name)) {
printf("Couldn't create block of ENGINE structures.\n"
"I'll probably also core-dump now, damn.\n");
goto end;
}
TEST_info("Remove failed - probably no hardware support present");
}
for (loop = 0; loop < 512; loop++) {
if (!ENGINE_add(block[loop])) {
printf("\nAdding stopped at %i, (%s,%s)\n",
ENGINE_free(ptr);
TEST_info("Engines:");
display_engine_list();
if (!TEST_true(ENGINE_add(new_h1))
|| !TEST_true(ENGINE_remove(new_h1)))
goto end;
TEST_info("About to beef up the engine-type list");
for (loop = 0; loop < NUMTOADD; loop++) {
sprintf(buf, "id%d", loop);
id = OPENSSL_strdup(buf);
sprintf(buf, "Fake engine type %d", loop);
name = OPENSSL_strdup(buf);
if (!TEST_ptr(block[loop] = ENGINE_new())
|| !TEST_true(ENGINE_set_id(block[loop], id))
|| !TEST_true(ENGINE_set_name(block[loop], name)))
goto end;
}
for (loop = 0; loop < NUMTOADD; loop++) {
if (!TEST_true(ENGINE_add(block[loop]))) {
printf("Adding stopped at %d, (%s,%s)",
loop, ENGINE_get_id(block[loop]),
ENGINE_get_name(block[loop]));
goto cleanup_loop;
} else
printf(".");
fflush(stdout);
}
}
cleanup_loop:
printf("\nAbout to empty the engine-type list\n");
TEST_info("About to empty the engine-type list");
while ((ptr = ENGINE_get_first()) != NULL) {
if (!ENGINE_remove(ptr)) {
printf("\nRemove failed!\n");
if (!TEST_true(ENGINE_remove(ptr)))
goto end;
}
ENGINE_free(ptr);
printf(".");
fflush(stdout);
}
for (loop = 0; loop < 512; loop++) {
for (loop = 0; loop < NUMTOADD; loop++) {
OPENSSL_free((void *)ENGINE_get_id(block[loop]));
OPENSSL_free((void *)ENGINE_get_name(block[loop]));
}
printf("\nTests completed happily\n");
to_return = 0;
to_return = 1;
end:
if (to_return)
ERR_print_errors_fp(stderr);
ENGINE_free(new_h1);
ENGINE_free(new_h2);
ENGINE_free(new_h3);
ENGINE_free(new_h4);
for (loop = 0; loop < 512; loop++)
for (loop = 0; loop < NUMTOADD; loop++)
ENGINE_free(block[loop]);
#ifndef OPENSSL_NO_CRYPTO_MDEBUG
if (CRYPTO_mem_leaks_fp(stderr) <= 0)
to_return = 1;
#endif
return to_return;
}
void register_tests(void)
{
ADD_TEST(test_engines);
}
#endif

43
test/pbelutest.c
View file

@ -8,40 +8,49 @@
*/
#include <openssl/evp.h>
#include <stdio.h>
#include <string.h>
#include "testutil.h"
#include "test_main.h"
/*
* Password based encryption (PBE) table ordering test.
* Attempt to look up all supported algorithms.
*/
int main(int argc, char **argv)
static int test_pbelu(void)
{
size_t i;
int rv = 0;
int pbe_type, pbe_nid;
int last_type = -1, last_nid = -1;
int i, failed = 0, ok;
int pbe_type, pbe_nid, last_type = -1, last_nid = -1;
for (i = 0; EVP_PBE_get(&pbe_type, &pbe_nid, i) != 0; i++) {
if (EVP_PBE_find(pbe_type, pbe_nid, NULL, NULL, 0) == 0) {
rv = 1;
if (!TEST_true(EVP_PBE_find(pbe_type, pbe_nid, NULL, NULL, 0))) {
TEST_info("i=%d, pbe_type=%d, pbe_nid=%d", i, pbe_type, pbe_nid);
failed = 1;
break;
}
}
if (rv == 0)
return 0;
if (!failed)
return 1;
/* Error: print out whole table */
for (i = 0; EVP_PBE_get(&pbe_type, &pbe_nid, i) != 0; i++) {
if (pbe_type > last_type)
rv = 0;
ok = 0;
else if (pbe_type < last_type || pbe_nid < last_nid)
rv = 1;
ok = 1;
else
rv = 0;
fprintf(stderr, "PBE type=%d %d (%s): %s\n", pbe_type, pbe_nid,
OBJ_nid2sn(pbe_nid), rv ? "ERROR" : "OK");
ok = 0;
if (!ok)
failed = 1;
TEST_info("PBE type=%d %d (%s): %s\n", pbe_type, pbe_nid,
OBJ_nid2sn(pbe_nid), ok ? "ERROR" : "OK");
last_type = pbe_type;
last_nid = pbe_nid;
}
return 1;
return failed ? 0 : 1;
}
void register_tests(void)
{
ADD_TEST(test_pbelu);
}

48
test/recordlentest.c
View file

@ -103,11 +103,9 @@ static int test_record_overflow(int idx)
ERR_clear_error();
if (!create_ssl_ctx_pair(TLS_server_method(), TLS_client_method(), &sctx,
&cctx, cert, privkey)) {
printf("Unable to create SSL_CTX pair\n");
if (!TEST_true(create_ssl_ctx_pair(TLS_server_method(), TLS_client_method(),
&sctx, &cctx, cert, privkey)))
goto end;
}
if (idx == TEST_ENCRYPTED_OVERFLOW_TLS1_2_OK
|| idx == TEST_ENCRYPTED_OVERFLOW_TLS1_2_NOT_OK) {
@ -121,10 +119,9 @@ static int test_record_overflow(int idx)
len = SSL3_RT_MAX_TLS13_ENCRYPTED_LENGTH;
}
if (!create_ssl_objects(sctx, cctx, &serverssl, &clientssl, NULL, NULL)) {
printf("Unable to create SSL objects\n");
if (!TEST_true(create_ssl_objects(sctx, cctx, &serverssl, &clientssl,
NULL, NULL)))
goto end;
}
serverbio = SSL_get_rbio(serverssl);
@ -135,29 +132,23 @@ static int test_record_overflow(int idx)
if (idx == TEST_PLAINTEXT_OVERFLOW_NOT_OK)
len++;
if (!write_record(serverbio, len, SSL3_RT_HANDSHAKE, TLS1_VERSION)) {
printf("Unable to write plaintext record\n");
if (!TEST_true(write_record(serverbio, len,
SSL3_RT_HANDSHAKE, TLS1_VERSION)))
goto end;
}
if (SSL_accept(serverssl) > 0) {
printf("Unexpected success reading plaintext record\n");
if (!TEST_int_le(SSL_accept(serverssl), 0))
goto end;
}
overf_expected = (idx == TEST_PLAINTEXT_OVERFLOW_OK) ? 0 : 1;
if (fail_due_to_record_overflow(0) != overf_expected) {
printf("Unexpected error value received\n");
if (!TEST_int_eq(fail_due_to_record_overflow(0), overf_expected))
goto end;
}
goto success;
}
if (!create_ssl_connection(serverssl, clientssl, SSL_ERROR_NONE)) {
printf("Unable to create SSL connection\n");
if (!TEST_true(create_ssl_connection(serverssl, clientssl,
SSL_ERROR_NONE)))
goto end;
}
if (idx == TEST_ENCRYPTED_OVERFLOW_TLS1_2_NOT_OK
|| idx == TEST_ENCRYPTED_OVERFLOW_TLS1_3_NOT_OK) {
@ -173,32 +164,24 @@ static int test_record_overflow(int idx)
else
recversion = TLS1_2_VERSION;
if (!write_record(serverbio, len, SSL3_RT_APPLICATION_DATA, recversion)) {
printf("Unable to write encrypted record\n");
if (!TEST_true(write_record(serverbio, len, SSL3_RT_APPLICATION_DATA,
recversion)))
goto end;
}
if (SSL_read_ex(serverssl, &buf, sizeof(buf), &written)) {
printf("Unexpected success reading encrypted record\n");
if (!TEST_false(SSL_read_ex(serverssl, &buf, sizeof(buf), &written)))
goto end;
}
if (fail_due_to_record_overflow(1) != overf_expected) {
printf("Unexpected error value received\n");
if (!TEST_int_eq(fail_due_to_record_overflow(1), overf_expected))
goto end;
}
success:
testresult = 1;
end:
if(!testresult)
ERR_print_errors_fp(stdout);
SSL_free(serverssl);
SSL_free(clientssl);
SSL_CTX_free(sctx);
SSL_CTX_free(cctx);
return testresult;
}
@ -207,10 +190,9 @@ int test_main(int argc, char *argv[])
int testresult = 1;
if (argc != 3) {
printf("Invalid argument count\n");
TEST_error("Invalid argument count");
return 1;
}
cert = argv[1];
privkey = argv[2];

180
test/srptest.c
View file

@ -23,13 +23,23 @@ int main(int argc, char *argv[])
# include <openssl/srp.h>
# include <openssl/rand.h>
# include <openssl/err.h>
# include "testutil.h"
# include "test_main.h"
static void showbn(const char *name, const BIGNUM *bn)
{
fputs(name, stdout);
fputs(" = ", stdout);
BN_print_fp(stdout, bn);
putc('\n', stdout);
BIO *b;
const char *text;
if (!TEST_ptr(b = BIO_new(BIO_s_mem())))
return;
BIO_write(b, name, strlen(name));
BIO_write(b, " = ", 3);
BN_print(b, bn);
BIO_write(b, "\0", 1);
BIO_get_mem_data(b, &text);
TEST_info("%s", text);
BIO_free(b);
}
# define RANDOM_SIZE 32 /* use 256 bits on each side */
@ -37,7 +47,7 @@ static void showbn(const char *name, const BIGNUM *bn)
static int run_srp(const char *username, const char *client_pass,
const char *server_pass)
{
int ret = -1;
int ret = 0;
BIGNUM *s = NULL;
BIGNUM *v = NULL;
BIGNUM *a = NULL;
@ -50,17 +60,15 @@ static int run_srp(const char *username, const char *client_pass,
BIGNUM *Kserver = NULL;
unsigned char rand_tmp[RANDOM_SIZE];
/* use builtin 1024-bit params */
const SRP_gN *GN = SRP_get_default_gN("1024");
const SRP_gN *GN;
if (!TEST_ptr(GN = SRP_get_default_gN("1024")))
return 0;
if (GN == NULL) {
fprintf(stderr, "Failed to get SRP parameters\n");
return -1;
}
/* Set up server's password entry */
if (!SRP_create_verifier_BN(username, server_pass, &s, &v, GN->N, GN->g)) {
fprintf(stderr, "Failed to create SRP verifier\n");
return -1;
}
if (!TEST_true(SRP_create_verifier_BN(username, server_pass,
&s, &v, GN->N, GN->g)))
goto end;
showbn("N", GN->N);
showbn("g", GN->g);
@ -70,32 +78,30 @@ static int run_srp(const char *username, const char *client_pass,
/* Server random */
RAND_bytes(rand_tmp, sizeof(rand_tmp));
b = BN_bin2bn(rand_tmp, sizeof(rand_tmp), NULL);
/* TODO - check b != 0 */
if (!TEST_false(BN_is_zero(b)))
goto end;
showbn("b", b);
/* Server's first message */
Bpub = SRP_Calc_B(b, GN->N, GN->g, v);
showbn("B", Bpub);
if (!SRP_Verify_B_mod_N(Bpub, GN->N)) {
fprintf(stderr, "Invalid B\n");
return -1;
}
if (!TEST_true(SRP_Verify_B_mod_N(Bpub, GN->N)))
goto end;
/* Client random */
RAND_bytes(rand_tmp, sizeof(rand_tmp));
a = BN_bin2bn(rand_tmp, sizeof(rand_tmp), NULL);
/* TODO - check a != 0 */
if (!TEST_false(BN_is_zero(a)))
goto end;
showbn("a", a);
/* Client's response */
Apub = SRP_Calc_A(a, GN->N, GN->g);
showbn("A", Apub);
if (!SRP_Verify_A_mod_N(Apub, GN->N)) {
fprintf(stderr, "Invalid A\n");
return -1;
}
if (!TEST_true(SRP_Verify_A_mod_N(Apub, GN->N)))
goto end;
/* Both sides calculate u */
u = SRP_Calc_u(Apub, Bpub, GN->N);
@ -109,13 +115,12 @@ static int run_srp(const char *username, const char *client_pass,
Kserver = SRP_Calc_server_key(Apub, v, u, b, GN->N);
showbn("Server's key", Kserver);
if (BN_cmp(Kclient, Kserver) == 0) {
ret = 0;
} else {
fprintf(stderr, "Keys mismatch\n");
ret = 1;
}
if (!TEST_int_eq(BN_cmp(Kclient, Kserver), 0))
goto end;
ret = 1;
end:
BN_clear_free(Kclient);
BN_clear_free(Kserver);
BN_clear_free(x);
@ -133,25 +138,19 @@ static int run_srp(const char *username, const char *client_pass,
static int check_bn(const char *name, const BIGNUM *bn, const char *hexbn)
{
BIGNUM *tmp = NULL;
int rv;
if (BN_hex2bn(&tmp, hexbn) == 0)
if (!TEST_true(BN_hex2bn(&tmp, hexbn)))
return 0;
rv = BN_cmp(bn, tmp);
if (rv == 0) {
printf("%s = ", name);
BN_print_fp(stdout, bn);
printf("\n");
if (!TEST_int_eq(BN_cmp(bn, tmp), 0)) {
TEST_info("Unexpected %s value", name);
showbn("expecting", tmp);
showbn("received", bn);
BN_free(tmp);
return 1;
return 0;
}
printf("Unexpected %s value\n", name);
printf("Expecting: ");
BN_print_fp(stdout, tmp);
printf("\nReceived: ");
BN_print_fp(stdout, bn);
printf("\n");
BN_free(tmp);
return 0;
return 1;
}
/* SRP test vectors from RFC5054 */
@ -169,26 +168,22 @@ static int run_srp_kat(void)
BIGNUM *Kclient = NULL;
BIGNUM *Kserver = NULL;
/* use builtin 1024-bit params */
const SRP_gN *GN = SRP_get_default_gN("1024");
if (GN == NULL) {
fprintf(stderr, "Failed to get SRP parameters\n");
const SRP_gN *GN;
if (!TEST_ptr(GN = SRP_get_default_gN("1024")))
goto err;
}
BN_hex2bn(&s, "BEB25379D1A8581EB5A727673A2441EE");
/* Set up server's password entry */
if (!SRP_create_verifier_BN("alice", "password123", &s, &v, GN->N,
GN->g)) {
fprintf(stderr, "Failed to create SRP verifier\n");
if (!TEST_true(SRP_create_verifier_BN("alice", "password123", &s, &v, GN->N,
GN->g)))
goto err;
}
if (!check_bn("v", v,
if (!TEST_true(check_bn("v", v,
"7E273DE8696FFC4F4E337D05B4B375BEB0DDE1569E8FA00A9886D812"
"9BADA1F1822223CA1A605B530E379BA4729FDC59F105B4787E5186F5"
"C671085A1447B52A48CF1970B4FB6F8400BBF4CEBFBB168152E08AB5"
"EA53D15C1AFF87B2B9DA6E04E058AD51CC72BFC9033B564E26480D78"
"E955A5E29E7AB245DB2BE315E2099AFB"))
"E955A5E29E7AB245DB2BE315E2099AFB")))
goto err;
/* Server random */
@ -197,18 +192,15 @@ static int run_srp_kat(void)
/* Server's first message */
Bpub = SRP_Calc_B(b, GN->N, GN->g, v);
if (!SRP_Verify_B_mod_N(Bpub, GN->N)) {
fprintf(stderr, "Invalid B\n");
if (!TEST_true(SRP_Verify_B_mod_N(Bpub, GN->N)))
goto err;
}
if (!check_bn("B", Bpub,
if (!TEST_true(check_bn("B", Bpub,
"BD0C61512C692C0CB6D041FA01BB152D4916A1E77AF46AE105393011"
"BAF38964DC46A0670DD125B95A981652236F99D9B681CBF87837EC99"
"6C6DA04453728610D0C6DDB58B318885D7D82C7F8DEB75CE7BD4FBAA"
"37089E6F9C6059F388838E7A00030B331EB76840910440B1B27AAEAE"
"EB4012B7D7665238A8E3FB004B117B58"))
"EB4012B7D7665238A8E3FB004B117B58")))
goto err;
/* Client random */
@ -217,49 +209,48 @@ static int run_srp_kat(void)
/* Client's response */
Apub = SRP_Calc_A(a, GN->N, GN->g);
if (!TEST_true(SRP_Verify_A_mod_N(Apub, GN->N)))
goto err;
if (!SRP_Verify_A_mod_N(Apub, GN->N)) {
fprintf(stderr, "Invalid A\n");
return -1;
}
if (!check_bn("A", Apub,
if (!TEST_true(check_bn("A", Apub,
"61D5E490F6F1B79547B0704C436F523DD0E560F0C64115BB72557EC4"
"4352E8903211C04692272D8B2D1A5358A2CF1B6E0BFCF99F921530EC"
"8E39356179EAE45E42BA92AEACED825171E1E8B9AF6D9C03E1327F44"
"BE087EF06530E69F66615261EEF54073CA11CF5858F0EDFDFE15EFEA"
"B349EF5D76988A3672FAC47B0769447B"))
"B349EF5D76988A3672FAC47B0769447B")))
goto err;
/* Both sides calculate u */
u = SRP_Calc_u(Apub, Bpub, GN->N);
if (!check_bn("u", u, "CE38B9593487DA98554ED47D70A7AE5F462EF019"))
if (!TEST_true(check_bn("u", u,
"CE38B9593487DA98554ED47D70A7AE5F462EF019")))
goto err;
/* Client's key */
x = SRP_Calc_x(s, "alice", "password123");
Kclient = SRP_Calc_client_key(GN->N, Bpub, GN->g, x, a, u);
if (!check_bn("Client's key", Kclient,
if (!TEST_true(check_bn("Client's key", Kclient,
"B0DC82BABCF30674AE450C0287745E7990A3381F63B387AAF271A10D"
"233861E359B48220F7C4693C9AE12B0A6F67809F0876E2D013800D6C"
"41BB59B6D5979B5C00A172B4A2A5903A0BDCAF8A709585EB2AFAFA8F"
"3499B200210DCC1F10EB33943CD67FC88A2F39A4BE5BEC4EC0A3212D"
"C346D7E474B29EDE8A469FFECA686E5A"))
"C346D7E474B29EDE8A469FFECA686E5A")))
goto err;
/* Server's key */
Kserver = SRP_Calc_server_key(Apub, v, u, b, GN->N);
if (!check_bn("Server's key", Kserver,
if (!TEST_true(check_bn("Server's key", Kserver,
"B0DC82BABCF30674AE450C0287745E7990A3381F63B387AAF271A10D"
"233861E359B48220F7C4693C9AE12B0A6F67809F0876E2D013800D6C"
"41BB59B6D5979B5C00A172B4A2A5903A0BDCAF8A709585EB2AFAFA8F"
"3499B200210DCC1F10EB33943CD67FC88A2F39A4BE5BEC4EC0A3212D"
"C346D7E474B29EDE8A469FFECA686E5A"))
"C346D7E474B29EDE8A469FFECA686E5A")))
goto err;
ret = 1;
err:
err:
BN_clear_free(Kclient);
BN_clear_free(Kserver);
BN_clear_free(x);
@ -274,39 +265,22 @@ static int run_srp_kat(void)
return ret;
}
int main(int argc, char **argv)
static int run_srp_tests(void)
{
BIO *bio_err;
bio_err = BIO_new_fp(stderr, BIO_NOCLOSE | BIO_FP_TEXT);
CRYPTO_set_mem_debug(1);
CRYPTO_mem_ctrl(CRYPTO_MEM_CHECK_ON);
/* "Negative" test, expect a mismatch */
if (run_srp("alice", "password1", "password2") == 0) {
fprintf(stderr, "Mismatched SRP run failed\n");
return 1;
}
if (!TEST_false(run_srp("alice", "password1", "password2")))
return 0;
/* "Positive" test, should pass */
if (run_srp("alice", "password", "password") != 0) {
fprintf(stderr, "Plain SRP run failed\n");
return 1;
}
if (!TEST_true(run_srp("alice", "password", "password")))
return 0;
/* KAT from RFC5054: should pass */
if (run_srp_kat() != 1) {
fprintf(stderr, "SRP KAT failed\n");
return 1;
}
return 1;
}
#ifndef OPENSSL_NO_CRYPTO_MDEBUG
if (CRYPTO_mem_leaks(bio_err) <= 0)
return 1;
#endif
BIO_free(bio_err);
return 0;
void register_tests(void)
{
ADD_TEST(run_srp_tests);
ADD_TEST(run_srp_kat);
}
#endif