Commit b66411f6 authored by Rich Salz's avatar Rich Salz
Browse files

Convert more tests 



recordlentest, srptest, ecdsatest, enginetest, pbelutest

Reviewed-by: default avatarRichard Levitte <levitte@openssl.org>
(Merged from https://github.com/openssl/openssl/pull/3237)
parent 0fef7448

test/build.info

+5 −5
Original line number Diff line number Diff line
@@ -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

test/ecdsatest.c

+111 −205
Original line number Diff line number Diff line
@@ -45,47 +45,38 @@ 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;

}
@@ -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;

    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);
@@ -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,

    if (!TEST_true(x9_62_test_internal(NID_X9_62_prime192v1,

                 "3342403536405981729393488334694600415596881826869351677613",

                             "5735822328888155254683894997897571951568553642892029982342"))

                 "5735822328888155254683894997897571951568553642892029982342")))

        goto x962_err;

    if (!x9_62_test_internal(out, NID_X9_62_prime239v1,

    if (!TEST_true(x9_62_test_internal(NID_X9_62_prime239v1,

                 "3086361431751678114926225473006680188549593787585317781474"

                             "62058306432176",

                 "3238135532097973577080787768312505059318910517550078427819"

                             "78505179448783"))

                             "78505179448783")))

        goto x962_err;



# ifndef OPENSSL_NO_EC2M

    if (!x9_62_test_internal(out, NID_X9_62_c2tnb191v1,

    if (!TEST_true(x9_62_test_internal(NID_X9_62_c2tnb191v1,

                 "87194383164871543355722284926904419997237591535066528048",

                             "308992691965804947361541664549085895292153777025772063598"))

                 "308992691965804947361541664549085895292153777025772063598")))

        goto x962_err;

    if (!x9_62_test_internal(out, NID_X9_62_c2tnb239v1,

    if (!TEST_true(x9_62_test_internal(NID_X9_62_c2tnb239v1,

                 "2159633321041961198501834003903461262881815148684178964245"

                             "5876922391552",

                 "1970303740007316867383349976549972270528498040721988191026"

                             "49413465737174"))

                             "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

test/enginetest.c

+83 −99

File changed.

Preview size limit exceeded, changes collapsed.

test/pbelutest.c

+26 −17
Original line number Diff line number Diff line
@@ -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);

}

test/recordlentest.c

+15 −33
Original line number Diff line number Diff line
@@ -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];