Commit 4cceb185 authored by Pauli's avatar Pauli
Browse files

Add a helper routine so that evp_test can compare memory without producing 


spurious output when checking for error conditions.

Reviewed-by: default avatarTim Hudson <tjh@openssl.org>
Reviewed-by: default avatarMatthias St. Pierre <Matthias.St.Pierre@ncp-e.com>
(Merged from https://github.com/openssl/openssl/pull/6899)
parent cca99621

test/evp_test.c

+61 −38
Original line number Diff line number Diff line
@@ -74,6 +74,27 @@ static int find_key(EVP_PKEY **ppk, const char *name, KEY_LIST *lst); 


static int parse_bin(const char *value, unsigned char **buf, size_t *buflen);



/*

 * Compare two memory regions for equality, returning zero if they differ.

 * However, if there is expected to be an error and the actual error

 * matches then the memory is expected to be different so handle this

 * case without producing unnecessary test framework output.

 */

static int memory_err_compare(EVP_TEST *t, const char *err,

                              const void *expected, size_t expected_len,

                              const void *got, size_t got_len)

{

    int r;



    if (t->expected_err != NULL && strcmp(t->expected_err, err) == 0)

        r = !TEST_mem_ne(expected, expected_len, got, got_len);

    else

        r = TEST_mem_eq(expected, expected_len, got, got_len);

    if (!r)

        t->err = err;

    return r;

}



/*

 * Structure used to hold a list of blocks of memory to test

 * calls to "update" like functions.
@@ -397,10 +418,11 @@ static int digest_test_run(EVP_TEST *t) 
        t->err = "DIGEST_LENGTH_MISMATCH";

        goto err;

    }

    if (!TEST_mem_eq(expected->output, expected->output_len, got, got_len)) {

        t->err = "DIGEST_MISMATCH";

    if (!memory_err_compare(t, "DIGEST_MISMATCH",

                            expected->output, expected->output_len,

                            got, got_len))

        goto err;

    }



    t->err = NULL;



 err:
@@ -688,11 +710,9 @@ static int cipher_test_enc(EVP_TEST *t, int enc, 
        t->err = "CIPHERFINAL_ERROR";

        goto err;

    }

    if (!TEST_mem_eq(expected_out, out_len,

                     tmp + out_misalign, tmplen + tmpflen)) {

        t->err = "VALUE_MISMATCH";

    if (!memory_err_compare(t, "VALUE_MISMATCH", expected_out, out_len,

                            tmp + out_misalign, tmplen + tmpflen))

        goto err;

    }

    if (enc && expected->aead) {

        unsigned char rtag[16];
@@ -705,12 +725,11 @@ static int cipher_test_enc(EVP_TEST *t, int enc, 
            t->err = "TAG_RETRIEVE_ERROR";

            goto err;

        }

        if (!TEST_mem_eq(expected->tag, expected->tag_len,

                         rtag, expected->tag_len)) {

            t->err = "TAG_VALUE_MISMATCH";

        if (!memory_err_compare(t, "TAG_VALUE_MISMATCH",

                                expected->tag, expected->tag_len,

                                rtag, expected->tag_len))

            goto err;

    }

    }

    t->err = NULL;

    ok = 1;

 err:
@@ -950,7 +969,8 @@ static int mac_test_run(EVP_TEST *t) 
        goto err;

    }

    if (!EVP_DigestSignFinal(mctx, got, &got_len)

            || !TEST_mem_eq(expected->output, expected->output_len,

            || !memory_err_compare(t, "TEST_MAC_ERR",

                                   expected->output, expected->output_len,

                                   got, got_len)) {

        t->err = "TEST_MAC_ERR";

        goto err;
@@ -1108,10 +1128,11 @@ static int pkey_test_run(EVP_TEST *t) 
        t->err = "KEYOP_ERROR";

        goto err;

    }

    if (!TEST_mem_eq(expected->output, expected->output_len, got, got_len)) {

        t->err = "KEYOP_MISMATCH";

    if (!memory_err_compare(t, "KEYOP_MISMATCH",

                            expected->output, expected->output_len,

                            got, got_len))

        goto err;

    }



    t->err = NULL;

 err:

    OPENSSL_free(got);
@@ -1226,10 +1247,10 @@ static int pderive_test_run(EVP_TEST *t) 
        t->err = "DERIVE_ERROR";

        goto err;

    }

    if (!TEST_mem_eq(expected->output, expected->output_len, got, got_len)) {

        t->err = "SHARED_SECRET_MISMATCH";

    if (!memory_err_compare(t, "SHARED_SECRET_MISMATCH",

                            expected->output, expected->output_len,

                            got, got_len))

        goto err;

    }



    t->err = NULL;

 err:
@@ -1444,11 +1465,10 @@ static int pbe_test_run(EVP_TEST *t) 
            goto err;

        }

    }

    if (!TEST_mem_eq(expected->key, expected->key_len,

                     key, expected->key_len)) {

        t->err = "KEY_MISMATCH";

    if (!memory_err_compare(t, "KEY_MISMATCH", expected->key, expected->key_len,

                            key, expected->key_len))

        goto err;

    }



    t->err = NULL;

err:

    OPENSSL_free(key);
@@ -1559,12 +1579,11 @@ static int encode_test_run(EVP_TEST *t) 


        EVP_ENCODE_CTX_free(encode_ctx);



        if (!TEST_mem_eq(expected->output, expected->output_len,

                         encode_out, output_len)) {

            t->err = "BAD_ENCODING";

        if (!memory_err_compare(t, "BAD_ENCODING",

                                expected->output, expected->output_len,

                                encode_out, output_len))

            goto err;

    }

    }



    if (!TEST_ptr(decode_out =

                OPENSSL_malloc(EVP_DECODE_LENGTH(expected->output_len))))
@@ -1585,7 +1604,8 @@ static int encode_test_run(EVP_TEST *t) 
    output_len += chunk_len;



    if (expected->encoding != BASE64_INVALID_ENCODING

            && !TEST_mem_eq(expected->input, expected->input_len,

            && !memory_err_compare(t, "BAD_DECODING",

                                   expected->input, expected->input_len,

                                   decode_out, output_len)) {

        t->err = "BAD_DECODING";

        goto err;
@@ -1687,10 +1707,11 @@ static int kdf_test_run(EVP_TEST *t) 
        t->err = "KDF_DERIVE_ERROR";

        goto err;

    }

    if (!TEST_mem_eq(expected->output, expected->output_len, got, got_len)) {

        t->err = "KDF_MISMATCH";

    if (!memory_err_compare(t, "KDF_MISMATCH",

                            expected->output, expected->output_len,

                            got, got_len))

        goto err;

    }



    t->err = NULL;



 err:
@@ -2079,11 +2100,12 @@ static int digestsign_test_run(EVP_TEST *t) 
        t->err = "DIGESTSIGNFINAL_ERROR";

        goto err;

    }

    if (!TEST_mem_eq(expected->output, expected->output_len, got, got_len)) {

        t->err = "SIGNATURE_MISMATCH";

    if (!memory_err_compare(t, "SIGNATURE_MISMATCH",

                            expected->output, expected->output_len,

                            got, got_len))

        goto err;

    }



    t->err = NULL;

 err:

    OPENSSL_free(got);

    return 1;
@@ -2156,11 +2178,12 @@ static int oneshot_digestsign_test_run(EVP_TEST *t) 
        t->err = "DIGESTSIGN_ERROR";

        goto err;

    }

    if (!TEST_mem_eq(expected->output, expected->output_len, got, got_len)) {

        t->err = "SIGNATURE_MISMATCH";

    if (!memory_err_compare(t, "SIGNATURE_MISMATCH",

                            expected->output, expected->output_len,

                            got, got_len))

        goto err;

    }



    t->err = NULL;

 err:

    OPENSSL_free(got);

    return 1;