[thirdparty/openssl.git] / test / evp_pkey_provided_test.c

/*
 * Copyright 2019-2020 The OpenSSL Project Authors. All Rights Reserved.
 *
 * Licensed under the Apache License 2.0 (the "License").  You may not use
 * this file except in compliance with the License.  You can obtain a copy
 * in the file LICENSE in the source distribution or at
 * https://www.openssl.org/source/license.html
 */

#include <openssl/evp.h>
#include <openssl/pem.h>
#include <openssl/serializer.h>
#include <openssl/provider.h>
#include <openssl/params.h>
#include <openssl/core_names.h>
#include "crypto/ecx.h"
#include "internal/nelem.h"
#include "internal/param_build.h"
#include "crypto/evp.h"          /* For the internal API */
#include "testutil.h"

static char *datadir = NULL;

#define PRIV_TEXT    0
#define PRIV_PEM     1
#define PRIV_DER     2
#define PUB_TEXT     3
#define PUB_PEM      4
#define PUB_DER      5

static void stripcr(char *buf, size_t *len)
{
    size_t i;
    char *curr, *writ;

    for (i = *len, curr = buf, writ = buf; i > 0; i--, curr++) {
        if (*curr == '\r') {
            (*len)--;
            continue;
        }
        if (curr != writ)
            *writ = *curr;
        writ++;
    }
}

static int compare_with_file(const char *alg, int type, BIO *membio)
{
    char filename[80];
    BIO *file = NULL;
    char buf[1024];
    char *memdata, *fullfile = NULL;
    const char *suffix;
    size_t readbytes;
    int ret = 0;
    int len;
    size_t slen;

    switch (type) {
    case PRIV_TEXT:
        suffix = "priv.txt";
        break;

    case PRIV_PEM:
        suffix = "priv.pem";
        break;

    case PRIV_DER:
        suffix = "priv.der";
        break;

    case PUB_TEXT:
        suffix = "pub.txt";
        break;

    case PUB_PEM:
        suffix = "pub.pem";
        break;

    case PUB_DER:
        suffix = "pub.der";
        break;

    default:
        TEST_error("Invalid file type");
        goto err;
    }

    BIO_snprintf(filename, sizeof(filename), "%s.%s", alg, suffix);
    fullfile = test_mk_file_path(datadir, filename);
    if (!TEST_ptr(fullfile))
        goto err;

    file = BIO_new_file(fullfile, "rb");
    if (!TEST_ptr(file))
        goto err;

    if (!TEST_true(BIO_read_ex(file, buf, sizeof(buf), &readbytes))
            || !TEST_true(BIO_eof(file))
            || !TEST_size_t_lt(readbytes, sizeof(buf)))
        goto err;

    len = BIO_get_mem_data(membio, &memdata);
    if (!TEST_int_gt(len, 0))
        goto err;

    slen = len;
    if (type != PRIV_DER && type != PUB_DER) {
        stripcr(memdata, &slen);
        stripcr(buf, &readbytes);
    }

    if (!TEST_mem_eq(memdata, slen, buf, readbytes))
        goto err;

    ret = 1;
 err:
    OPENSSL_free(fullfile);
    (void)BIO_reset(membio);
    BIO_free(file);
    return ret;
}

static int test_print_key_using_pem(const char *alg, const EVP_PKEY *pk)
{
    BIO *membio = BIO_new(BIO_s_mem());
    int ret = 0;

    if (!TEST_ptr(membio))
        goto err;

    if (!TEST_true(EVP_PKEY_print_private(membio, pk, 0, NULL))
        || !TEST_true(compare_with_file(alg, PRIV_TEXT, membio))
        /* Public key in PEM form */
        || !TEST_true(PEM_write_bio_PUBKEY(membio, pk))
        || !TEST_true(compare_with_file(alg, PUB_PEM, membio))
        /* Unencrypted private key in PEM form */
        || !TEST_true(PEM_write_bio_PrivateKey(membio, pk,
                                               NULL, NULL, 0, NULL, NULL))
        || !TEST_true(compare_with_file(alg, PRIV_PEM, membio))
        /* Encrypted private key in PEM form */
        || !TEST_true(PEM_write_bio_PrivateKey(bio_out, pk, EVP_aes_256_cbc(),
                                               (unsigned char *)"pass", 4,
                                               NULL, NULL)))
        goto err;

    ret = 1;
 err:
    BIO_free(membio);
    return ret;
}

static int test_print_key_type_using_serializer(const char *alg, int type,
                                                const EVP_PKEY *pk)
{
    const char *pq;
    OSSL_SERIALIZER_CTX *ctx = NULL;
    BIO *membio = BIO_new(BIO_s_mem());
    int ret = 0;

    switch (type) {
    case PRIV_TEXT:
        pq = OSSL_SERIALIZER_PrivateKey_TO_TEXT_PQ;
        break;

    case PRIV_PEM:
        pq = OSSL_SERIALIZER_PrivateKey_TO_PEM_PQ;
        break;

    case PRIV_DER:
        pq = OSSL_SERIALIZER_PrivateKey_TO_DER_PQ;
        break;

    case PUB_TEXT:
        pq = OSSL_SERIALIZER_PUBKEY_TO_TEXT_PQ;
        break;

    case PUB_PEM:
        pq = OSSL_SERIALIZER_PUBKEY_TO_PEM_PQ;
        break;

    case PUB_DER:
        pq = OSSL_SERIALIZER_PUBKEY_TO_DER_PQ;
        break;

    default:
        TEST_error("Invalid serialization type");
        goto err;
    }

    if (!TEST_ptr(membio))
        goto err;

    /* Make a context, it's valid for several prints */
    TEST_note("Setting up a OSSL_SERIALIZER context with passphrase");
    if (!TEST_ptr(ctx = OSSL_SERIALIZER_CTX_new_by_EVP_PKEY(pk, pq))
        /* Check that this operation is supported */
        || !TEST_ptr(OSSL_SERIALIZER_CTX_get_serializer(ctx)))
        goto err;

    /* Use no cipher.  This should give us an unencrypted PEM */
    TEST_note("Testing with no encryption");
    if (!TEST_true(OSSL_SERIALIZER_to_bio(ctx, membio))
        || !TEST_true(compare_with_file(alg, type, membio)))
        goto err;

    if (type == PRIV_PEM) {
        /* Set a passphrase to be used later */
        if (!TEST_true(OSSL_SERIALIZER_CTX_set_passphrase(ctx,
                                                          (unsigned char *)"pass",
                                                          4)))
            goto err;

        /* Use a valid cipher name */
        TEST_note("Displaying PEM encrypted with AES-256-CBC");
        if (!TEST_true(OSSL_SERIALIZER_CTX_set_cipher(ctx, "AES-256-CBC", NULL))
            || !TEST_true(OSSL_SERIALIZER_to_bio(ctx, bio_out)))
            goto err;

        /* Use an invalid cipher name, which should generate no output */
        TEST_note("NOT Displaying PEM encrypted with (invalid) FOO");
        if (!TEST_false(OSSL_SERIALIZER_CTX_set_cipher(ctx, "FOO", NULL))
            || !TEST_false(OSSL_SERIALIZER_to_bio(ctx, bio_out)))
            goto err;

        /* Clear the cipher.  This should give us an unencrypted PEM again */
        TEST_note("Testing with encryption cleared (no encryption)");
        if (!TEST_true(OSSL_SERIALIZER_CTX_set_cipher(ctx, NULL, NULL))
            || !TEST_true(OSSL_SERIALIZER_to_bio(ctx, membio))
            || !TEST_true(compare_with_file(alg, type, membio)))
            goto err;
    }
    ret = 1;
err:
    BIO_free(membio);
    OSSL_SERIALIZER_CTX_free(ctx);
    return ret;
}

static int test_print_key_using_serializer(const char *alg, const EVP_PKEY *pk)
{
    int i;
    int ret = 1;

    for (i = 0; i < 6; i++)
        ret = ret && test_print_key_type_using_serializer(alg, i, pk);

    return ret;
}

/* Array indexes used in test_fromdata_rsa */
#define N       0
#define E       1
#define D       2
#define P       3
#define Q       4
#define DP      5
#define DQ      6
#define QINV    7

static int test_fromdata_rsa(void)
{
    int ret = 0;
    EVP_PKEY_CTX *ctx = NULL, *key_ctx = NULL;
    EVP_PKEY *pk = NULL;
    /*
     * 32-bit RSA key, extracted from this command,
     * executed with OpenSSL 1.0.2:
     *
     * openssl genrsa 32 | openssl rsa -text
     */
    static unsigned long key_numbers[] = {
        0xbc747fc5,              /* N */
        0x10001,                 /* E */
        0x7b133399,              /* D */
        0xe963,                  /* P */
        0xceb7,                  /* Q */
        0x8599,                  /* DP */
        0xbd87,                  /* DQ */
        0xcc3b,                  /* QINV */
    };
    OSSL_PARAM fromdata_params[] = {
        OSSL_PARAM_ulong(OSSL_PKEY_PARAM_RSA_N, &key_numbers[N]),
        OSSL_PARAM_ulong(OSSL_PKEY_PARAM_RSA_E, &key_numbers[E]),
        OSSL_PARAM_ulong(OSSL_PKEY_PARAM_RSA_D, &key_numbers[D]),
        OSSL_PARAM_ulong(OSSL_PKEY_PARAM_RSA_FACTOR, &key_numbers[P]),
        OSSL_PARAM_ulong(OSSL_PKEY_PARAM_RSA_FACTOR, &key_numbers[Q]),
        OSSL_PARAM_ulong(OSSL_PKEY_PARAM_RSA_EXPONENT, &key_numbers[DP]),
        OSSL_PARAM_ulong(OSSL_PKEY_PARAM_RSA_EXPONENT, &key_numbers[DQ]),
        OSSL_PARAM_ulong(OSSL_PKEY_PARAM_RSA_COEFFICIENT, &key_numbers[QINV]),
        OSSL_PARAM_END
    };

    if (!TEST_ptr(ctx = EVP_PKEY_CTX_new_from_name(NULL, "RSA", NULL)))
        goto err;

    if (!TEST_true(EVP_PKEY_key_fromdata_init(ctx))
        || !TEST_true(EVP_PKEY_fromdata(ctx, &pk, fromdata_params))
        || !TEST_int_eq(EVP_PKEY_bits(pk), 32)
        || !TEST_int_eq(EVP_PKEY_security_bits(pk), 8)
        || !TEST_int_eq(EVP_PKEY_size(pk), 4))
        goto err;

    if (!TEST_ptr(key_ctx = EVP_PKEY_CTX_new_from_pkey(NULL, pk, "")))
        goto err;

    if (!TEST_true(EVP_PKEY_check(key_ctx))
        || !TEST_true(EVP_PKEY_public_check(key_ctx))
        || !TEST_true(EVP_PKEY_private_check(key_ctx))
        || !TEST_true(EVP_PKEY_pairwise_check(key_ctx)))
        goto err;

    ret = test_print_key_using_pem("RSA", pk)
          && test_print_key_using_serializer("RSA", pk);

 err:
    EVP_PKEY_free(pk);
    EVP_PKEY_CTX_free(key_ctx);
    EVP_PKEY_CTX_free(ctx);

    return ret;
}

#ifndef OPENSSL_NO_DH
/* Array indexes used in test_fromdata_dh */
#define PRIV_KEY        0
#define PUB_KEY         1
#define FFC_P           2
#define FFC_G           3

static int test_fromdata_dh(void)
{
    int ret = 0;
    EVP_PKEY_CTX *ctx = NULL;
    EVP_PKEY *pk = NULL;
    /*
     * 32-bit DH key, extracted from this command,
     * executed with OpenSSL 1.0.2:
     *
     * openssl dhparam -out dhp.pem 32
     * openssl genpkey -paramfile dhp.pem | openssl pkey -text
     */
    static unsigned long key_numbers[] = {
        0x666c2b06,              /* priv-key */
        0x6fa6de50,              /* pub-key */
        0x8bb45f53,              /* P */
        0x2,                     /* G */
    };
    OSSL_PARAM fromdata_params[] = {
        OSSL_PARAM_ulong(OSSL_PKEY_PARAM_PRIV_KEY, &key_numbers[PRIV_KEY]),
        OSSL_PARAM_ulong(OSSL_PKEY_PARAM_PUB_KEY, &key_numbers[PUB_KEY]),
        OSSL_PARAM_ulong(OSSL_PKEY_PARAM_FFC_P, &key_numbers[FFC_P]),
        OSSL_PARAM_ulong(OSSL_PKEY_PARAM_FFC_G, &key_numbers[FFC_G]),
        OSSL_PARAM_END
    };

    if (!TEST_ptr(ctx = EVP_PKEY_CTX_new_from_name(NULL, "DH", NULL)))
        goto err;

    if (!TEST_true(EVP_PKEY_key_fromdata_init(ctx))
        || !TEST_true(EVP_PKEY_fromdata(ctx, &pk, fromdata_params))
        || !TEST_int_eq(EVP_PKEY_bits(pk), 32)
        || !TEST_int_eq(EVP_PKEY_security_bits(pk), 0) /* Missing Q */
        || !TEST_int_eq(EVP_PKEY_size(pk), 4))
        goto err;

    ret = test_print_key_using_pem("DH", pk)
          && test_print_key_using_serializer("DH", pk);

 err:
    EVP_PKEY_free(pk);
    EVP_PKEY_CTX_free(ctx);

    return ret;
}
#endif

#ifndef OPENSSL_NO_EC
/* Array indexes used in test_fromdata_ecx */
# define PRIV_KEY        0
# define PUB_KEY         1

# define X25519_IDX      0
# define X448_IDX        1

static int test_fromdata_ecx(int tst)
{
    int ret = 0;
    EVP_PKEY_CTX *ctx = NULL;
    EVP_PKEY *pk = NULL;
    const char *alg = (tst == X25519_IDX) ? "X25519" : "X448";

    /* X448_KEYLEN > X25519_KEYLEN */
    static unsigned char key_numbers[2][2][X448_KEYLEN] = {
        /* X25519: Keys from RFC 7748 6.1 */
        {
            /* Private Key */
            {
                0x77, 0x07, 0x6d, 0x0a, 0x73, 0x18, 0xa5, 0x7d, 0x3c, 0x16,
                0xc1, 0x72, 0x51, 0xb2, 0x66, 0x45, 0xdf, 0x4c, 0x2f, 0x87,
                0xeb, 0xc0, 0x99, 0x2a, 0xb1, 0x77, 0xfb, 0xa5, 0x1d, 0xb9,
                0x2c, 0x2a
            },
            /* Public Key */
            {
                0x85, 0x20, 0xf0, 0x09, 0x89, 0x30, 0xa7, 0x54, 0x74, 0x8b,
                0x7d, 0xdc, 0xb4, 0x3e, 0xf7, 0x5a, 0x0d, 0xbf, 0x3a, 0x0d,
                0x26, 0x38, 0x1a, 0xf4, 0xeb, 0xa4, 0xa9, 0x8e, 0xaa, 0x9b,
                0x4e, 0x6a
            }
        },
        /* X448: Keys from RFC 7748 6.2 */
        {
            /* Private Key */
            {
                0x9a, 0x8f, 0x49, 0x25, 0xd1, 0x51, 0x9f, 0x57, 0x75, 0xcf,
                0x46, 0xb0, 0x4b, 0x58, 0x00, 0xd4, 0xee, 0x9e, 0xe8, 0xba,
                0xe8, 0xbc, 0x55, 0x65, 0xd4, 0x98, 0xc2, 0x8d, 0xd9, 0xc9,
                0xba, 0xf5, 0x74, 0xa9, 0x41, 0x97, 0x44, 0x89, 0x73, 0x91,
                0x00, 0x63, 0x82, 0xa6, 0xf1, 0x27, 0xab, 0x1d, 0x9a, 0xc2,
                0xd8, 0xc0, 0xa5, 0x98, 0x72, 0x6b
            },
            /* Public Key */
            {
                0x9b, 0x08, 0xf7, 0xcc, 0x31, 0xb7, 0xe3, 0xe6, 0x7d, 0x22,
                0xd5, 0xae, 0xa1, 0x21, 0x07, 0x4a, 0x27, 0x3b, 0xd2, 0xb8,
                0x3d, 0xe0, 0x9c, 0x63, 0xfa, 0xa7, 0x3d, 0x2c, 0x22, 0xc5,
                0xd9, 0xbb, 0xc8, 0x36, 0x64, 0x72, 0x41, 0xd9, 0x53, 0xd4,
                0x0c, 0x5b, 0x12, 0xda, 0x88, 0x12, 0x0d, 0x53, 0x17, 0x7f,
                0x80, 0xe5, 0x32, 0xc4, 0x1f, 0xa0
            }
        }
    };
    OSSL_PARAM x25519_fromdata_params[] = {
        OSSL_PARAM_octet_string(OSSL_PKEY_PARAM_PRIV_KEY,
                                key_numbers[X25519_IDX][PRIV_KEY],
                                X25519_KEYLEN),
        OSSL_PARAM_octet_string(OSSL_PKEY_PARAM_PUB_KEY,
                                key_numbers[X25519_IDX][PUB_KEY],
                                X25519_KEYLEN),
        OSSL_PARAM_END
    };
    OSSL_PARAM x448_fromdata_params[] = {
        OSSL_PARAM_octet_string(OSSL_PKEY_PARAM_PRIV_KEY,
                                key_numbers[X448_IDX][PRIV_KEY],
                                X448_KEYLEN),
        OSSL_PARAM_octet_string(OSSL_PKEY_PARAM_PUB_KEY,
                                key_numbers[X448_IDX][PUB_KEY],
                                X448_KEYLEN),
        OSSL_PARAM_END
    };
    OSSL_PARAM *fromdata_params;
    int bits, security_bits, size;

    if (tst == X25519_IDX) {
        fromdata_params = x25519_fromdata_params;
        bits = X25519_BITS;
        security_bits = X25519_SECURITY_BITS;
        size = X25519_KEYLEN;
    } else {
        fromdata_params = x448_fromdata_params;
        bits = X448_BITS;
        security_bits = X448_SECURITY_BITS;
        size = X448_KEYLEN;
    }

    ctx = EVP_PKEY_CTX_new_from_name(NULL, alg, NULL);
    if (!TEST_ptr(ctx))
        goto err;

    if (!TEST_true(EVP_PKEY_key_fromdata_init(ctx))
        || !TEST_true(EVP_PKEY_fromdata(ctx, &pk, fromdata_params))
        || !TEST_int_eq(EVP_PKEY_bits(pk), bits)
        || !TEST_int_eq(EVP_PKEY_security_bits(pk), security_bits)
        || !TEST_int_eq(EVP_PKEY_size(pk), size))
        goto err;

    ret = test_print_key_using_pem(alg, pk)
          && test_print_key_using_serializer(alg, pk);

err:
    EVP_PKEY_free(pk);
    EVP_PKEY_CTX_free(ctx);

    return ret;
}

static int test_fromdata_ec(void)
{
    int ret = 0;
    EVP_PKEY_CTX *ctx = NULL;
    EVP_PKEY *pk = NULL;
    OSSL_PARAM_BLD bld;
    BIGNUM *ec_priv_bn = NULL;
    OSSL_PARAM *fromdata_params = NULL;
    const char *alg = "EC";
    static const unsigned char ec_pub_keydata[] = {
       0x04,
       0x1b, 0x93, 0x67, 0x55, 0x1c, 0x55, 0x9f, 0x63,
       0xd1, 0x22, 0xa4, 0xd8, 0xd1, 0x0a, 0x60, 0x6d,
       0x02, 0xa5, 0x77, 0x57, 0xc8, 0xa3, 0x47, 0x73,
       0x3a, 0x6a, 0x08, 0x28, 0x39, 0xbd, 0xc9, 0xd2,
       0x80, 0xec, 0xe9, 0xa7, 0x08, 0x29, 0x71, 0x2f,
       0xc9, 0x56, 0x82, 0xee, 0x9a, 0x85, 0x0f, 0x6d,
       0x7f, 0x59, 0x5f, 0x8c, 0xd1, 0x96, 0x0b, 0xdf,
       0x29, 0x3e, 0x49, 0x07, 0x88, 0x3f, 0x9a, 0x29
    };
    static const unsigned char ec_priv_keydata[] = {
        0x33, 0xd0, 0x43, 0x83, 0xa9, 0x89, 0x56, 0x03,
        0xd2, 0xd7, 0xfe, 0x6b, 0x01, 0x6f, 0xe4, 0x59,
        0xcc, 0x0d, 0x9a, 0x24, 0x6c, 0x86, 0x1b, 0x2e,
        0xdc, 0x4b, 0x4d, 0x35, 0x43, 0xe1, 0x1b, 0xad
    };

    ossl_param_bld_init(&bld);

    if (!TEST_ptr(ec_priv_bn = BN_bin2bn(ec_priv_keydata,
                                         sizeof(ec_priv_keydata), NULL)))
        goto err;

    if (ossl_param_bld_push_utf8_string(&bld, OSSL_PKEY_PARAM_EC_NAME,
                                        "prime256v1", 0) <= 0)
        goto err;
    if (ossl_param_bld_push_octet_string(&bld, OSSL_PKEY_PARAM_PUB_KEY,
                                         ec_pub_keydata,
                                         sizeof(ec_pub_keydata)) <= 0)
        goto err;
    if (ossl_param_bld_push_BN(&bld, OSSL_PKEY_PARAM_PRIV_KEY, ec_priv_bn) <= 0)
        goto err;
    if (!TEST_ptr(fromdata_params = ossl_param_bld_to_param(&bld)))
        goto err;
    ctx = EVP_PKEY_CTX_new_from_name(NULL, alg, NULL);
    if (!TEST_ptr(ctx))
        goto err;

    if (!TEST_true(EVP_PKEY_key_fromdata_init(ctx))
        || !TEST_true(EVP_PKEY_fromdata(ctx, &pk, fromdata_params))
        || !TEST_int_eq(EVP_PKEY_bits(pk), 256)
        || !TEST_int_eq(EVP_PKEY_security_bits(pk), 128)
        || !TEST_int_eq(EVP_PKEY_size(pk), 2 + 35 * 2))
        goto err;

    ret = test_print_key_using_pem(alg, pk)
          && test_print_key_using_serializer(alg, pk);
err:
    BN_free(ec_priv_bn);
    ossl_param_bld_free(fromdata_params);
    EVP_PKEY_free(pk);
    EVP_PKEY_CTX_free(ctx);
    return ret;
}

#endif /* OPENSSL_NO_EC */


int setup_tests(void)
{
    if (!test_skip_common_options()) {
        TEST_error("Error parsing test options\n");
        return 0;
    }

    if (!TEST_ptr(datadir = test_get_argument(0)))
        return 0;

    ADD_TEST(test_fromdata_rsa);
#ifndef OPENSSL_NO_DH
    ADD_TEST(test_fromdata_dh);
#endif
#ifndef OPENSSL_NO_EC
    ADD_ALL_TESTS(test_fromdata_ecx, 2);
    ADD_TEST(test_fromdata_ec);
#endif
    return 1;
}
Commit	Line	Data
6ae5543c	1	/*
f552d900	2	* Copyright 2019-2020 The OpenSSL Project Authors. All Rights Reserved.
6ae5543c RL	3	*
	4	* Licensed under the Apache License 2.0 (the "License"). You may not use
	5	* this file except in compliance with the License. You can obtain a copy
	6	* in the file LICENSE in the source distribution or at
	7	* https://www.openssl.org/source/license.html
	8	*/
	9
	10	#include <openssl/evp.h>
	11	#include <openssl/pem.h>
	12	#include <openssl/serializer.h>
	13	#include <openssl/provider.h>
	14	#include <openssl/params.h>
	15	#include <openssl/core_names.h>
8efc4a9c	16	#include "crypto/ecx.h"
6ae5543c	17	#include "internal/nelem.h"
f552d900	18	#include "internal/param_build.h"
6ae5543c RL	19	#include "crypto/evp.h" /* For the internal API */
	20	#include "testutil.h"
	21
8efc4a9c MC	22	static char *datadir = NULL;
	23
	24	#define PRIV_TEXT 0
	25	#define PRIV_PEM 1
	26	#define PRIV_DER 2
	27	#define PUB_TEXT 3
	28	#define PUB_PEM 4
	29	#define PUB_DER 5
	30
	31	static void stripcr(char buf, size_t len)
	32	{
	33	size_t i;
	34	char curr, writ;
	35
	36	for (i = *len, curr = buf, writ = buf; i > 0; i--, curr++) {
	37	if (*curr == '\r') {
	38	(*len)--;
	39	continue;
	40	}
	41	if (curr != writ)
	42	writ = curr;
	43	writ++;
	44	}
	45	}
	46
	47	static int compare_with_file(const char alg, int type, BIO membio)
	48	{
	49	char filename[80];
	50	BIO *file = NULL;
	51	char buf[1024];
	52	char memdata, fullfile = NULL;
	53	const char *suffix;
	54	size_t readbytes;
	55	int ret = 0;
	56	int len;
	57	size_t slen;
	58
	59	switch (type) {
	60	case PRIV_TEXT:
	61	suffix = "priv.txt";
	62	break;
	63
	64	case PRIV_PEM:
	65	suffix = "priv.pem";
	66	break;
	67
	68	case PRIV_DER:
	69	suffix = "priv.der";
	70	break;
	71
	72	case PUB_TEXT:
	73	suffix = "pub.txt";
	74	break;
	75
	76	case PUB_PEM:
	77	suffix = "pub.pem";
	78	break;
	79
	80	case PUB_DER:
	81	suffix = "pub.der";
	82	break;
	83
	84	default:
	85	TEST_error("Invalid file type");
86	goto err;
87	}
88
89	BIO_snprintf(filename, sizeof(filename), "%s.%s", alg, suffix);
90	fullfile = test_mk_file_path(datadir, filename);
91	if (!TEST_ptr(fullfile))
92	goto err;
93
94	file = BIO_new_file(fullfile, "rb");
95	if (!TEST_ptr(file))
96	goto err;
97
98	if (!TEST_true(BIO_read_ex(file, buf, sizeof(buf), &readbytes))
99	\|\| !TEST_true(BIO_eof(file))
100	\|\| !TEST_size_t_lt(readbytes, sizeof(buf)))
101	goto err;
102
103	len = BIO_get_mem_data(membio, &memdata);
104	if (!TEST_int_gt(len, 0))
105	goto err;
106
107	slen = len;
108	if (type != PRIV_DER && type != PUB_DER) {
109	stripcr(memdata, &slen);
110	stripcr(buf, &readbytes);
111	}
112
113	if (!TEST_mem_eq(memdata, slen, buf, readbytes))
114	goto err;
115
116	ret = 1;
117	err:
118	OPENSSL_free(fullfile);
119	(void)BIO_reset(membio);
120	BIO_free(file);
121	return ret;
122	}
123
124	static int test_print_key_using_pem(const char alg, const EVP_PKEY pk)
6ae5543c	125	{
8efc4a9c MC	126	BIO *membio = BIO_new(BIO_s_mem());
	127	int ret = 0;
	128
	129	if (!TEST_ptr(membio))
	130	goto err;
	131
	132	if (!TEST_true(EVP_PKEY_print_private(membio, pk, 0, NULL))
	133	\|\| !TEST_true(compare_with_file(alg, PRIV_TEXT, membio))
6ae5543c	134	/* Public key in PEM form */
8efc4a9c MC	135	\|\| !TEST_true(PEM_write_bio_PUBKEY(membio, pk))
8efc4a9c MC	136	\|\| !TEST_true(compare_with_file(alg, PUB_PEM, membio))
6ae5543c	137	/* Unencrypted private key in PEM form */
8efc4a9c	138	\|\| !TEST_true(PEM_write_bio_PrivateKey(membio, pk,
6ae5543c	139	NULL, NULL, 0, NULL, NULL))
8efc4a9c	140	\|\| !TEST_true(compare_with_file(alg, PRIV_PEM, membio))
6ae5543c RL	141	/* Encrypted private key in PEM form */
	142	\|\| !TEST_true(PEM_write_bio_PrivateKey(bio_out, pk, EVP_aes_256_cbc(),
	143	(unsigned char *)"pass", 4,
	144	NULL, NULL)))
8efc4a9c	145	goto err;
6ae5543c	146
8efc4a9c MC	147	ret = 1;
	148	err:
	149	BIO_free(membio);
	150	return ret;
6ae5543c RL	151	}
6ae5543c RL	152
8efc4a9c MC	153	static int test_print_key_type_using_serializer(const char *alg, int type,
8efc4a9c MC	154	const EVP_PKEY *pk)
6ae5543c	155	{
8efc4a9c	156	const char *pq;
6ae5543c	157	OSSL_SERIALIZER_CTX *ctx = NULL;
8efc4a9c	158	BIO *membio = BIO_new(BIO_s_mem());
f552d900	159	int ret = 0;
6ae5543c	160
8efc4a9c MC	161	switch (type) {
	162	case PRIV_TEXT:
	163	pq = OSSL_SERIALIZER_PrivateKey_TO_TEXT_PQ;
	164	break;
	165
	166	case PRIV_PEM:
	167	pq = OSSL_SERIALIZER_PrivateKey_TO_PEM_PQ;
	168	break;
	169
	170	case PRIV_DER:
	171	pq = OSSL_SERIALIZER_PrivateKey_TO_DER_PQ;
	172	break;
	173
	174	case PUB_TEXT:
	175	pq = OSSL_SERIALIZER_PUBKEY_TO_TEXT_PQ;
	176	break;
	177
	178	case PUB_PEM:
	179	pq = OSSL_SERIALIZER_PUBKEY_TO_PEM_PQ;
	180	break;
	181
	182	case PUB_DER:
	183	pq = OSSL_SERIALIZER_PUBKEY_TO_DER_PQ;
	184	break;
	185
	186	default:
	187	TEST_error("Invalid serialization type");
	188	goto err;
	189	}
	190
f552d900	191	if (!TEST_ptr(membio))
8efc4a9c	192	goto err;
8efc4a9c	193
6ae5543c RL	194	/* Make a context, it's valid for several prints */
	195	TEST_note("Setting up a OSSL_SERIALIZER context with passphrase");
	196	if (!TEST_ptr(ctx = OSSL_SERIALIZER_CTX_new_by_EVP_PKEY(pk, pq))
	197	/* Check that this operation is supported */
8efc4a9c	198	\|\| !TEST_ptr(OSSL_SERIALIZER_CTX_get_serializer(ctx)))
6ae5543c RL	199	goto err;
	200
	201	/* Use no cipher. This should give us an unencrypted PEM */
8efc4a9c MC	202	TEST_note("Testing with no encryption");
	203	if (!TEST_true(OSSL_SERIALIZER_to_bio(ctx, membio))
	204	\|\| !TEST_true(compare_with_file(alg, type, membio)))
f552d900	205	goto err;
6ae5543c	206
8efc4a9c MC	207	if (type == PRIV_PEM) {
	208	/* Set a passphrase to be used later */
	209	if (!TEST_true(OSSL_SERIALIZER_CTX_set_passphrase(ctx,
	210	(unsigned char *)"pass",
	211	4)))
	212	goto err;
6ae5543c	213
8efc4a9c MC	214	/* Use a valid cipher name */
	215	TEST_note("Displaying PEM encrypted with AES-256-CBC");
	216	if (!TEST_true(OSSL_SERIALIZER_CTX_set_cipher(ctx, "AES-256-CBC", NULL))
	217	\|\| !TEST_true(OSSL_SERIALIZER_to_bio(ctx, bio_out)))
f552d900	218	goto err;
6ae5543c	219
8efc4a9c MC	220	/* Use an invalid cipher name, which should generate no output */
	221	TEST_note("NOT Displaying PEM encrypted with (invalid) FOO");
	222	if (!TEST_false(OSSL_SERIALIZER_CTX_set_cipher(ctx, "FOO", NULL))
	223	\|\| !TEST_false(OSSL_SERIALIZER_to_bio(ctx, bio_out)))
f552d900	224	goto err;
8efc4a9c MC	225
	226	/* Clear the cipher. This should give us an unencrypted PEM again */
	227	TEST_note("Testing with encryption cleared (no encryption)");
	228	if (!TEST_true(OSSL_SERIALIZER_CTX_set_cipher(ctx, NULL, NULL))
	229	\|\| !TEST_true(OSSL_SERIALIZER_to_bio(ctx, membio))
	230	\|\| !TEST_true(compare_with_file(alg, type, membio)))
f552d900	231	goto err;
8efc4a9c	232	}
f552d900	233	ret = 1;
6ae5543c	234	err:
8efc4a9c	235	BIO_free(membio);
6ae5543c RL	236	OSSL_SERIALIZER_CTX_free(ctx);
	237	return ret;
	238	}
	239
8efc4a9c MC	240	static int test_print_key_using_serializer(const char alg, const EVP_PKEY pk)
	241	{
	242	int i;
	243	int ret = 1;
	244
	245	for (i = 0; i < 6; i++)
	246	ret = ret && test_print_key_type_using_serializer(alg, i, pk);
	247
	248	return ret;
	249	}
	250
6ae5543c RL	251	/* Array indexes used in test_fromdata_rsa */
	252	#define N 0
	253	#define E 1
	254	#define D 2
	255	#define P 3
	256	#define Q 4
	257	#define DP 5
	258	#define DQ 6
	259	#define QINV 7
	260
	261	static int test_fromdata_rsa(void)
	262	{
	263	int ret = 0;
12603de6	264	EVP_PKEY_CTX ctx = NULL, key_ctx = NULL;
6ae5543c RL	265	EVP_PKEY *pk = NULL;
	266	/*
	267	* 32-bit RSA key, extracted from this command,
	268	* executed with OpenSSL 1.0.2:
	269	*
	270	* openssl genrsa 32 \| openssl rsa -text
	271	*/
	272	static unsigned long key_numbers[] = {
	273	0xbc747fc5, /* N */
	274	0x10001, /* E */
	275	0x7b133399, /* D */
	276	0xe963, /* P */
	277	0xceb7, /* Q */
	278	0x8599, /* DP */
	279	0xbd87, /* DQ */
	280	0xcc3b, /* QINV */
	281	};
	282	OSSL_PARAM fromdata_params[] = {
	283	OSSL_PARAM_ulong(OSSL_PKEY_PARAM_RSA_N, &key_numbers[N]),
	284	OSSL_PARAM_ulong(OSSL_PKEY_PARAM_RSA_E, &key_numbers[E]),
	285	OSSL_PARAM_ulong(OSSL_PKEY_PARAM_RSA_D, &key_numbers[D]),
	286	OSSL_PARAM_ulong(OSSL_PKEY_PARAM_RSA_FACTOR, &key_numbers[P]),
	287	OSSL_PARAM_ulong(OSSL_PKEY_PARAM_RSA_FACTOR, &key_numbers[Q]),
	288	OSSL_PARAM_ulong(OSSL_PKEY_PARAM_RSA_EXPONENT, &key_numbers[DP]),
	289	OSSL_PARAM_ulong(OSSL_PKEY_PARAM_RSA_EXPONENT, &key_numbers[DQ]),
	290	OSSL_PARAM_ulong(OSSL_PKEY_PARAM_RSA_COEFFICIENT, &key_numbers[QINV]),
	291	OSSL_PARAM_END
	292	};
	293
e683582b	294	if (!TEST_ptr(ctx = EVP_PKEY_CTX_new_from_name(NULL, "RSA", NULL)))
6ae5543c RL	295	goto err;
	296
	297	if (!TEST_true(EVP_PKEY_key_fromdata_init(ctx))
81a624f2 RL	298	\|\| !TEST_true(EVP_PKEY_fromdata(ctx, &pk, fromdata_params))
	299	\|\| !TEST_int_eq(EVP_PKEY_bits(pk), 32)
	300	\|\| !TEST_int_eq(EVP_PKEY_security_bits(pk), 8)
	301	\|\| !TEST_int_eq(EVP_PKEY_size(pk), 4))
6ae5543c RL	302	goto err;
6ae5543c RL	303
12603de6 SL	304	if (!TEST_ptr(key_ctx = EVP_PKEY_CTX_new_from_pkey(NULL, pk, "")))
	305	goto err;
	306
	307	if (!TEST_true(EVP_PKEY_check(key_ctx))
	308	\|\| !TEST_true(EVP_PKEY_public_check(key_ctx))
	309	\|\| !TEST_true(EVP_PKEY_private_check(key_ctx))
	310	\|\| !TEST_true(EVP_PKEY_pairwise_check(key_ctx)))
	311	goto err;
	312
8efc4a9c MC	313	ret = test_print_key_using_pem("RSA", pk)
8efc4a9c MC	314	&& test_print_key_using_serializer("RSA", pk);
6ae5543c RL	315
	316	err:
	317	EVP_PKEY_free(pk);
12603de6	318	EVP_PKEY_CTX_free(key_ctx);
6ae5543c RL	319	EVP_PKEY_CTX_free(ctx);
	320
	321	return ret;
	322	}
	323
285c6913	324	#ifndef OPENSSL_NO_DH
6ae5543c RL	325	/* Array indexes used in test_fromdata_dh */
	326	#define PRIV_KEY 0
	327	#define PUB_KEY 1
	328	#define FFC_P 2
	329	#define FFC_G 3
	330
	331	static int test_fromdata_dh(void)
	332	{
	333	int ret = 0;
	334	EVP_PKEY_CTX *ctx = NULL;
	335	EVP_PKEY *pk = NULL;
	336	/*
	337	* 32-bit DH key, extracted from this command,
	338	* executed with OpenSSL 1.0.2:
	339	*
	340	* openssl dhparam -out dhp.pem 32
	341	* openssl genpkey -paramfile dhp.pem \| openssl pkey -text
	342	*/
	343	static unsigned long key_numbers[] = {
	344	0x666c2b06, /* priv-key */
	345	0x6fa6de50, /* pub-key */
	346	0x8bb45f53, /* P */
	347	0x2, /* G */
	348	};
	349	OSSL_PARAM fromdata_params[] = {
90d3cb57 MC	350	OSSL_PARAM_ulong(OSSL_PKEY_PARAM_PRIV_KEY, &key_numbers[PRIV_KEY]),
90d3cb57 MC	351	OSSL_PARAM_ulong(OSSL_PKEY_PARAM_PUB_KEY, &key_numbers[PUB_KEY]),
6ae5543c RL	352	OSSL_PARAM_ulong(OSSL_PKEY_PARAM_FFC_P, &key_numbers[FFC_P]),
	353	OSSL_PARAM_ulong(OSSL_PKEY_PARAM_FFC_G, &key_numbers[FFC_G]),
	354	OSSL_PARAM_END
	355	};
	356
e683582b	357	if (!TEST_ptr(ctx = EVP_PKEY_CTX_new_from_name(NULL, "DH", NULL)))
6ae5543c RL	358	goto err;
	359
	360	if (!TEST_true(EVP_PKEY_key_fromdata_init(ctx))
81a624f2 RL	361	\|\| !TEST_true(EVP_PKEY_fromdata(ctx, &pk, fromdata_params))
	362	\|\| !TEST_int_eq(EVP_PKEY_bits(pk), 32)
	363	\|\| !TEST_int_eq(EVP_PKEY_security_bits(pk), 0) /* Missing Q */
	364	\|\| !TEST_int_eq(EVP_PKEY_size(pk), 4))
6ae5543c RL	365	goto err;
6ae5543c RL	366
8efc4a9c MC	367	ret = test_print_key_using_pem("DH", pk)
	368	&& test_print_key_using_serializer("DH", pk);
	369
	370	err:
	371	EVP_PKEY_free(pk);
	372	EVP_PKEY_CTX_free(ctx);
	373
	374	return ret;
	375	}
	376	#endif
	377
	378	#ifndef OPENSSL_NO_EC
	379	/* Array indexes used in test_fromdata_ecx */
	380	# define PRIV_KEY 0
	381	# define PUB_KEY 1
	382
	383	# define X25519_IDX 0
	384	# define X448_IDX 1
	385
	386	static int test_fromdata_ecx(int tst)
	387	{
	388	int ret = 0;
	389	EVP_PKEY_CTX *ctx = NULL;
	390	EVP_PKEY *pk = NULL;
	391	const char *alg = (tst == X25519_IDX) ? "X25519" : "X448";
	392
	393	/* X448_KEYLEN > X25519_KEYLEN */
	394	static unsigned char key_numbers[2][2][X448_KEYLEN] = {
	395	/* X25519: Keys from RFC 7748 6.1 */
	396	{
	397	/* Private Key */
	398	{
	399	0x77, 0x07, 0x6d, 0x0a, 0x73, 0x18, 0xa5, 0x7d, 0x3c, 0x16,
	400	0xc1, 0x72, 0x51, 0xb2, 0x66, 0x45, 0xdf, 0x4c, 0x2f, 0x87,
	401	0xeb, 0xc0, 0x99, 0x2a, 0xb1, 0x77, 0xfb, 0xa5, 0x1d, 0xb9,
	402	0x2c, 0x2a
	403	},
	404	/* Public Key */
	405	{
	406	0x85, 0x20, 0xf0, 0x09, 0x89, 0x30, 0xa7, 0x54, 0x74, 0x8b,
	407	0x7d, 0xdc, 0xb4, 0x3e, 0xf7, 0x5a, 0x0d, 0xbf, 0x3a, 0x0d,
	408	0x26, 0x38, 0x1a, 0xf4, 0xeb, 0xa4, 0xa9, 0x8e, 0xaa, 0x9b,
	409	0x4e, 0x6a
	410	}
	411	},
	412	/* X448: Keys from RFC 7748 6.2 */
	413	{
	414	/* Private Key */
	415	{
	416	0x9a, 0x8f, 0x49, 0x25, 0xd1, 0x51, 0x9f, 0x57, 0x75, 0xcf,
	417	0x46, 0xb0, 0x4b, 0x58, 0x00, 0xd4, 0xee, 0x9e, 0xe8, 0xba,
	418	0xe8, 0xbc, 0x55, 0x65, 0xd4, 0x98, 0xc2, 0x8d, 0xd9, 0xc9,
	419	0xba, 0xf5, 0x74, 0xa9, 0x41, 0x97, 0x44, 0x89, 0x73, 0x91,
	420	0x00, 0x63, 0x82, 0xa6, 0xf1, 0x27, 0xab, 0x1d, 0x9a, 0xc2,
	421	0xd8, 0xc0, 0xa5, 0x98, 0x72, 0x6b
	422	},
	423	/* Public Key */
	424	{
	425	0x9b, 0x08, 0xf7, 0xcc, 0x31, 0xb7, 0xe3, 0xe6, 0x7d, 0x22,
	426	0xd5, 0xae, 0xa1, 0x21, 0x07, 0x4a, 0x27, 0x3b, 0xd2, 0xb8,
	427	0x3d, 0xe0, 0x9c, 0x63, 0xfa, 0xa7, 0x3d, 0x2c, 0x22, 0xc5,
	428	0xd9, 0xbb, 0xc8, 0x36, 0x64, 0x72, 0x41, 0xd9, 0x53, 0xd4,
	429	0x0c, 0x5b, 0x12, 0xda, 0x88, 0x12, 0x0d, 0x53, 0x17, 0x7f,
	430	0x80, 0xe5, 0x32, 0xc4, 0x1f, 0xa0
431	}
432	}
433	};
434	OSSL_PARAM x25519_fromdata_params[] = {
435	OSSL_PARAM_octet_string(OSSL_PKEY_PARAM_PRIV_KEY,
436	key_numbers[X25519_IDX][PRIV_KEY],
437	X25519_KEYLEN),
438	OSSL_PARAM_octet_string(OSSL_PKEY_PARAM_PUB_KEY,
439	key_numbers[X25519_IDX][PUB_KEY],
440	X25519_KEYLEN),
441	OSSL_PARAM_END
442	};
443	OSSL_PARAM x448_fromdata_params[] = {
444	OSSL_PARAM_octet_string(OSSL_PKEY_PARAM_PRIV_KEY,
445	key_numbers[X448_IDX][PRIV_KEY],
446	X448_KEYLEN),
447	OSSL_PARAM_octet_string(OSSL_PKEY_PARAM_PUB_KEY,
448	key_numbers[X448_IDX][PUB_KEY],
449	X448_KEYLEN),
450	OSSL_PARAM_END
451	};
452	OSSL_PARAM *fromdata_params;
453	int bits, security_bits, size;
454
455	if (tst == X25519_IDX) {
456	fromdata_params = x25519_fromdata_params;
457	bits = X25519_BITS;
458	security_bits = X25519_SECURITY_BITS;
459	size = X25519_KEYLEN;
460	} else {
461	fromdata_params = x448_fromdata_params;
462	bits = X448_BITS;
463	security_bits = X448_SECURITY_BITS;
464	size = X448_KEYLEN;
465	}
466
467	ctx = EVP_PKEY_CTX_new_from_name(NULL, alg, NULL);
468	if (!TEST_ptr(ctx))
469	goto err;
470
471	if (!TEST_true(EVP_PKEY_key_fromdata_init(ctx))
472	\|\| !TEST_true(EVP_PKEY_fromdata(ctx, &pk, fromdata_params))
473	\|\| !TEST_int_eq(EVP_PKEY_bits(pk), bits)
474	\|\| !TEST_int_eq(EVP_PKEY_security_bits(pk), security_bits)
475	\|\| !TEST_int_eq(EVP_PKEY_size(pk), size))
476	goto err;
477
478	ret = test_print_key_using_pem(alg, pk)
479	&& test_print_key_using_serializer(alg, pk);
6ae5543c	480
f552d900	481	err:
6ae5543c RL	482	EVP_PKEY_free(pk);
	483	EVP_PKEY_CTX_free(ctx);
	484
	485	return ret;
	486	}
f552d900 SL	487
	488	static int test_fromdata_ec(void)
	489	{
	490	int ret = 0;
	491	EVP_PKEY_CTX *ctx = NULL;
	492	EVP_PKEY *pk = NULL;
	493	OSSL_PARAM_BLD bld;
	494	BIGNUM *ec_priv_bn = NULL;
	495	OSSL_PARAM *fromdata_params = NULL;
	496	const char *alg = "EC";
	497	static const unsigned char ec_pub_keydata[] = {
	498	0x04,
	499	0x1b, 0x93, 0x67, 0x55, 0x1c, 0x55, 0x9f, 0x63,
	500	0xd1, 0x22, 0xa4, 0xd8, 0xd1, 0x0a, 0x60, 0x6d,
	501	0x02, 0xa5, 0x77, 0x57, 0xc8, 0xa3, 0x47, 0x73,
	502	0x3a, 0x6a, 0x08, 0x28, 0x39, 0xbd, 0xc9, 0xd2,
	503	0x80, 0xec, 0xe9, 0xa7, 0x08, 0x29, 0x71, 0x2f,
	504	0xc9, 0x56, 0x82, 0xee, 0x9a, 0x85, 0x0f, 0x6d,
	505	0x7f, 0x59, 0x5f, 0x8c, 0xd1, 0x96, 0x0b, 0xdf,
	506	0x29, 0x3e, 0x49, 0x07, 0x88, 0x3f, 0x9a, 0x29
	507	};
	508	static const unsigned char ec_priv_keydata[] = {
	509	0x33, 0xd0, 0x43, 0x83, 0xa9, 0x89, 0x56, 0x03,
	510	0xd2, 0xd7, 0xfe, 0x6b, 0x01, 0x6f, 0xe4, 0x59,
	511	0xcc, 0x0d, 0x9a, 0x24, 0x6c, 0x86, 0x1b, 0x2e,
	512	0xdc, 0x4b, 0x4d, 0x35, 0x43, 0xe1, 0x1b, 0xad
	513	};
	514
	515	ossl_param_bld_init(&bld);
	516
	517	if (!TEST_ptr(ec_priv_bn = BN_bin2bn(ec_priv_keydata,
	518	sizeof(ec_priv_keydata), NULL)))
	519	goto err;
	520
	521	if (ossl_param_bld_push_utf8_string(&bld, OSSL_PKEY_PARAM_EC_NAME,
	522	"prime256v1", 0) <= 0)
	523	goto err;
	524	if (ossl_param_bld_push_octet_string(&bld, OSSL_PKEY_PARAM_PUB_KEY,
	525	ec_pub_keydata,
	526	sizeof(ec_pub_keydata)) <= 0)
	527	goto err;
	528	if (ossl_param_bld_push_BN(&bld, OSSL_PKEY_PARAM_PRIV_KEY, ec_priv_bn) <= 0)
	529	goto err;
	530	if (!TEST_ptr(fromdata_params = ossl_param_bld_to_param(&bld)))
	531	goto err;
	532	ctx = EVP_PKEY_CTX_new_from_name(NULL, alg, NULL);
	533	if (!TEST_ptr(ctx))
	534	goto err;
	535
	536	if (!TEST_true(EVP_PKEY_key_fromdata_init(ctx))
	537	\|\| !TEST_true(EVP_PKEY_fromdata(ctx, &pk, fromdata_params))
	538	\|\| !TEST_int_eq(EVP_PKEY_bits(pk), 256)
	539	\|\| !TEST_int_eq(EVP_PKEY_security_bits(pk), 128)
	540	\|\| !TEST_int_eq(EVP_PKEY_size(pk), 2 + 35 * 2))
	541	goto err;
	542
	543	ret = test_print_key_using_pem(alg, pk)
	544	&& test_print_key_using_serializer(alg, pk);
	545	err:
	546	BN_free(ec_priv_bn);
	547	ossl_param_bld_free(fromdata_params);
	548	EVP_PKEY_free(pk);
	549	EVP_PKEY_CTX_free(ctx);
	550	return ret;
551	}
552
553	#endif /* OPENSSL_NO_EC */
6ae5543c	554
8efc4a9c	555
6ae5543c RL	556	int setup_tests(void)
6ae5543c RL	557	{
8efc4a9c MC	558	if (!test_skip_common_options()) {
	559	TEST_error("Error parsing test options\n");
	560	return 0;
	561	}
	562
	563	if (!TEST_ptr(datadir = test_get_argument(0)))
	564	return 0;
	565
6ae5543c	566	ADD_TEST(test_fromdata_rsa);
285c6913	567	#ifndef OPENSSL_NO_DH
6ae5543c	568	ADD_TEST(test_fromdata_dh);
8efc4a9c MC	569	#endif
	570	#ifndef OPENSSL_NO_EC
	571	ADD_ALL_TESTS(test_fromdata_ecx, 2);
f552d900	572	ADD_TEST(test_fromdata_ec);
285c6913	573	#endif
6ae5543c RL	574	return 1;
6ae5543c RL	575	}