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
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
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
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
# 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;
"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)
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;
- BIO_printf(out, ".");
- (void)BIO_flush(out);
+
/* verify the signature */
- if (ECDSA_do_verify(digest, 20, signature, key) != 1)
+ if (!TEST_int_eq(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);
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;
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++) {
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));
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
* 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);
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);
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;
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;
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
# 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
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");
+ TEST_info("Remove failed - probably no hardware support present");
+ }
ENGINE_free(ptr);
+ TEST_info("Engines:");
display_engine_list();
- if (!ENGINE_add(new_h1) || !ENGINE_remove(new_h1)) {
- printf("Couldn't add and remove to an empty list!\n");
+
+ if (!TEST_true(ENGINE_add(new_h1))
+ || !TEST_true(ENGINE_remove(new_h1)))
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);
+
+ 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 %i", loop);
+ sprintf(buf, "Fake engine type %d", 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");
+ 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 < 512; loop++) {
- if (!ENGINE_add(block[loop])) {
- printf("\nAdding stopped at %i, (%s,%s)\n",
+ 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
*/
#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);
}
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) {
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);
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) {
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;
}
int testresult = 1;
if (argc != 3) {
- printf("Invalid argument count\n");
+ TEST_error("Invalid argument count");
return 1;
}
-
cert = argv[1];
privkey = argv[2];
# 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 */
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;
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);
/* 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);
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);
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 */
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 */
/* 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 */
/* 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);
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;
- }
-
- /* KAT from RFC5054: should pass */
- if (run_srp_kat() != 1) {
- fprintf(stderr, "SRP KAT failed\n");
- return 1;
- }
+ if (!TEST_true(run_srp("alice", "password", "password")))
+ return 0;
-#ifndef OPENSSL_NO_CRYPTO_MDEBUG
- if (CRYPTO_mem_leaks(bio_err) <= 0)
- return 1;
-#endif
- BIO_free(bio_err);
+ return 1;
+}
- return 0;
+void register_tests(void)
+{
+ ADD_TEST(run_srp_tests);
+ ADD_TEST(run_srp_kat);
}
#endif
projects / oweals / openssl.git / commitdiff