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

/*
 * Copyright 2019 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 "internal/nelem.h"
#include "crypto/evp.h"          /* For the internal API */
#include "testutil.h"

static int test_print_key_using_pem(const EVP_PKEY *pk)
{
    if (!TEST_true(EVP_PKEY_print_private(bio_out, pk, 0, NULL))
        /* Public key in PEM form */
        || !TEST_true(PEM_write_bio_PUBKEY(bio_out, pk))
        /* Unencrypted private key in PEM form */
        || !TEST_true(PEM_write_bio_PrivateKey(bio_out, pk,
                                               NULL, NULL, 0, NULL, NULL))
        /* 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)))
        return 0;

    return 1;
}

static int test_print_key_using_serializer(const EVP_PKEY *pk)
{
    const char *pq = OSSL_SERIALIZER_PrivateKey_TO_PEM_PQ;
    OSSL_SERIALIZER_CTX *ctx = NULL;
    int ret = 1;

    /* 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))
        /* Set a passphrase to be used later */
        || !TEST_true(OSSL_SERIALIZER_CTX_set_passphrase(ctx,
                                                         (unsigned char *)"pass",
                                                         4)))
        goto err;

    /* Use no cipher.  This should give us an unencrypted PEM */
    TEST_note("Displaying PEM with no encryption");
    if (!TEST_true(OSSL_SERIALIZER_to_bio(ctx, bio_out)))
        ret = 0;

    /* 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)))
        ret = 0;

    /* 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)))
        ret = 0;

    /* Clear the cipher.  This should give us an unencrypted PEM again */
    TEST_note("Displaying PEM with encryption cleared (no encryption)");
    if (!TEST_true(OSSL_SERIALIZER_CTX_set_cipher(ctx, NULL, NULL))
        || !TEST_true(OSSL_SERIALIZER_to_bio(ctx, bio_out)))
        ret = 0;

err:
    OSSL_SERIALIZER_CTX_free(ctx);
    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;
    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_provided(NULL, "RSA", NULL)))
        goto err;

    if (!TEST_true(EVP_PKEY_key_fromdata_init(ctx))
        || !TEST_true(EVP_PKEY_fromdata(ctx, &pk, fromdata_params)))
        goto err;

    ret = test_print_key_using_pem(pk)
        | test_print_key_using_serializer(pk);

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

    return ret;
}

/* 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_DH_PRIV_KEY, &key_numbers[PRIV_KEY]),
        OSSL_PARAM_ulong(OSSL_PKEY_PARAM_DH_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_provided(NULL, "DH", NULL)))
        goto err;

    if (!TEST_true(EVP_PKEY_key_fromdata_init(ctx))
        || !TEST_true(EVP_PKEY_fromdata(ctx, &pk, fromdata_params)))
        goto err;

    ret = test_print_key_using_pem(pk)
        | test_print_key_using_serializer(pk);

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

    return ret;
}

int setup_tests(void)
{
    ADD_TEST(test_fromdata_rsa);
    ADD_TEST(test_fromdata_dh);
    return 1;
}
Commit	Line	Data
6ae5543c RL	1	/*
	2	* Copyright 2019 The OpenSSL Project Authors. All Rights Reserved.
	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>
	16	#include "internal/nelem.h"
	17	#include "crypto/evp.h" /* For the internal API */
	18	#include "testutil.h"
	19
	20	static int test_print_key_using_pem(const EVP_PKEY *pk)
	21	{
	22	if (!TEST_true(EVP_PKEY_print_private(bio_out, pk, 0, NULL))
	23	/* Public key in PEM form */
	24	\|\| !TEST_true(PEM_write_bio_PUBKEY(bio_out, pk))
	25	/* Unencrypted private key in PEM form */
	26	\|\| !TEST_true(PEM_write_bio_PrivateKey(bio_out, pk,
	27	NULL, NULL, 0, NULL, NULL))
	28	/* Encrypted private key in PEM form */
	29	\|\| !TEST_true(PEM_write_bio_PrivateKey(bio_out, pk, EVP_aes_256_cbc(),
	30	(unsigned char *)"pass", 4,
	31	NULL, NULL)))
	32	return 0;
	33
	34	return 1;
	35	}
	36
	37	static int test_print_key_using_serializer(const EVP_PKEY *pk)
	38	{
	39	const char *pq = OSSL_SERIALIZER_PrivateKey_TO_PEM_PQ;
	40	OSSL_SERIALIZER_CTX *ctx = NULL;
	41	int ret = 1;
	42
	43	/* Make a context, it's valid for several prints */
	44	TEST_note("Setting up a OSSL_SERIALIZER context with passphrase");
	45	if (!TEST_ptr(ctx = OSSL_SERIALIZER_CTX_new_by_EVP_PKEY(pk, pq))
	46	/* Check that this operation is supported */
	47	\|\| !TEST_ptr(OSSL_SERIALIZER_CTX_get_serializer(ctx))
	48	/* Set a passphrase to be used later */
	49	\|\| !TEST_true(OSSL_SERIALIZER_CTX_set_passphrase(ctx,
	50	(unsigned char *)"pass",
	51	4)))
	52	goto err;
	53
	54	/* Use no cipher. This should give us an unencrypted PEM */
	55	TEST_note("Displaying PEM with no encryption");
	56	if (!TEST_true(OSSL_SERIALIZER_to_bio(ctx, bio_out)))
	57	ret = 0;
	58
	59	/* Use a valid cipher name */
	60	TEST_note("Displaying PEM encrypted with AES-256-CBC");
	61	if (!TEST_true(OSSL_SERIALIZER_CTX_set_cipher(ctx, "AES-256-CBC", NULL))
	62	\|\| !TEST_true(OSSL_SERIALIZER_to_bio(ctx, bio_out)))
	63	ret = 0;
	64
65	/* Use an invalid cipher name, which should generate no output */
66	TEST_note("NOT Displaying PEM encrypted with (invalid) FOO");
67	if (!TEST_false(OSSL_SERIALIZER_CTX_set_cipher(ctx, "FOO", NULL))
68	\|\| !TEST_false(OSSL_SERIALIZER_to_bio(ctx, bio_out)))
69	ret = 0;
70
71	/* Clear the cipher. This should give us an unencrypted PEM again */
72	TEST_note("Displaying PEM with encryption cleared (no encryption)");
73	if (!TEST_true(OSSL_SERIALIZER_CTX_set_cipher(ctx, NULL, NULL))
74	\|\| !TEST_true(OSSL_SERIALIZER_to_bio(ctx, bio_out)))
75	ret = 0;
76
77	err:
78	OSSL_SERIALIZER_CTX_free(ctx);
79	return ret;
80	}
81
82	/* Array indexes used in test_fromdata_rsa */
83	#define N 0
84	#define E 1
85	#define D 2
86	#define P 3
87	#define Q 4
88	#define DP 5
89	#define DQ 6
90	#define QINV 7
91
92	static int test_fromdata_rsa(void)
93	{
94	int ret = 0;
95	EVP_PKEY_CTX *ctx = NULL;
96	EVP_PKEY *pk = NULL;
97	/*
98	* 32-bit RSA key, extracted from this command,
99	* executed with OpenSSL 1.0.2:
100	*
101	* openssl genrsa 32 \| openssl rsa -text
102	*/
103	static unsigned long key_numbers[] = {
104	0xbc747fc5, /* N */
105	0x10001, /* E */
106	0x7b133399, /* D */
107	0xe963, /* P */
108	0xceb7, /* Q */
109	0x8599, /* DP */
110	0xbd87, /* DQ */
111	0xcc3b, /* QINV */
112	};
113	OSSL_PARAM fromdata_params[] = {
114	OSSL_PARAM_ulong(OSSL_PKEY_PARAM_RSA_N, &key_numbers[N]),
115	OSSL_PARAM_ulong(OSSL_PKEY_PARAM_RSA_E, &key_numbers[E]),
116	OSSL_PARAM_ulong(OSSL_PKEY_PARAM_RSA_D, &key_numbers[D]),
117	OSSL_PARAM_ulong(OSSL_PKEY_PARAM_RSA_FACTOR, &key_numbers[P]),
118	OSSL_PARAM_ulong(OSSL_PKEY_PARAM_RSA_FACTOR, &key_numbers[Q]),
119	OSSL_PARAM_ulong(OSSL_PKEY_PARAM_RSA_EXPONENT, &key_numbers[DP]),
120	OSSL_PARAM_ulong(OSSL_PKEY_PARAM_RSA_EXPONENT, &key_numbers[DQ]),
121	OSSL_PARAM_ulong(OSSL_PKEY_PARAM_RSA_COEFFICIENT, &key_numbers[QINV]),
122	OSSL_PARAM_END
123	};
124
125	if (!TEST_ptr(ctx = EVP_PKEY_CTX_new_provided(NULL, "RSA", NULL)))
126	goto err;
127
128	if (!TEST_true(EVP_PKEY_key_fromdata_init(ctx))
129	\|\| !TEST_true(EVP_PKEY_fromdata(ctx, &pk, fromdata_params)))
130	goto err;
131
132	ret = test_print_key_using_pem(pk)
133	\| test_print_key_using_serializer(pk);
134
135	err:
136	EVP_PKEY_free(pk);
137	EVP_PKEY_CTX_free(ctx);
138
139	return ret;
140	}
141
142	/* Array indexes used in test_fromdata_dh */
143	#define PRIV_KEY 0
144	#define PUB_KEY 1
145	#define FFC_P 2
146	#define FFC_G 3
147
148	static int test_fromdata_dh(void)
149	{
150	int ret = 0;
151	EVP_PKEY_CTX *ctx = NULL;
152	EVP_PKEY *pk = NULL;
153	/*
154	* 32-bit DH key, extracted from this command,
155	* executed with OpenSSL 1.0.2:
156	*
157	* openssl dhparam -out dhp.pem 32
158	* openssl genpkey -paramfile dhp.pem \| openssl pkey -text
159	*/
160	static unsigned long key_numbers[] = {
161	0x666c2b06, /* priv-key */
162	0x6fa6de50, /* pub-key */
163	0x8bb45f53, /* P */
164	0x2, /* G */
165	};
166	OSSL_PARAM fromdata_params[] = {
167	OSSL_PARAM_ulong(OSSL_PKEY_PARAM_DH_PRIV_KEY, &key_numbers[PRIV_KEY]),
168	OSSL_PARAM_ulong(OSSL_PKEY_PARAM_DH_PUB_KEY, &key_numbers[PUB_KEY]),
169	OSSL_PARAM_ulong(OSSL_PKEY_PARAM_FFC_P, &key_numbers[FFC_P]),
170	OSSL_PARAM_ulong(OSSL_PKEY_PARAM_FFC_G, &key_numbers[FFC_G]),
171	OSSL_PARAM_END
172	};
173
174	if (!TEST_ptr(ctx = EVP_PKEY_CTX_new_provided(NULL, "DH", NULL)))
175	goto err;
176
177	if (!TEST_true(EVP_PKEY_key_fromdata_init(ctx))
178	\|\| !TEST_true(EVP_PKEY_fromdata(ctx, &pk, fromdata_params)))
179	goto err;
180
181	ret = test_print_key_using_pem(pk)
182	\| test_print_key_using_serializer(pk);
183
184	err:
185	EVP_PKEY_free(pk);
186	EVP_PKEY_CTX_free(ctx);
187
188	return ret;
189	}
190
191	int setup_tests(void)
192	{
193	ADD_TEST(test_fromdata_rsa);
194	ADD_TEST(test_fromdata_dh);
195	return 1;
196	}