[thirdparty/openssl.git] / test / keymgmt_internal_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 <string.h>

#include <openssl/bio.h>
#include <openssl/bn.h>
#include <openssl/rsa.h>
#include <openssl/evp.h>
#include <openssl/provider.h>
#include <openssl/core_names.h>
#include "internal/core.h"
#include "internal/nelem.h"
#include "crypto/evp.h"          /* For the internal API */
#include "testutil.h"

typedef struct {
    OPENSSL_CTX *ctx1;
    OSSL_PROVIDER *prov1;
    OPENSSL_CTX *ctx2;
    OSSL_PROVIDER *prov2;
} FIXTURE;

static void tear_down(FIXTURE *fixture)
{
    if (fixture != NULL) {
        OSSL_PROVIDER_unload(fixture->prov1);
        OSSL_PROVIDER_unload(fixture->prov2);
        OPENSSL_CTX_free(fixture->ctx1);
        OPENSSL_CTX_free(fixture->ctx2);
        OPENSSL_free(fixture);
    }
}

static FIXTURE *set_up(const char *testcase_name)
{
    FIXTURE *fixture;

    if (!TEST_ptr(fixture = OPENSSL_zalloc(sizeof(*fixture)))
        || !TEST_ptr(fixture->ctx1 = OPENSSL_CTX_new())
        || !TEST_ptr(fixture->prov1 = OSSL_PROVIDER_load(fixture->ctx1,
                                                         "default"))
        || !TEST_ptr(fixture->ctx2 = OPENSSL_CTX_new())
        || !TEST_ptr(fixture->prov2 = OSSL_PROVIDER_load(fixture->ctx2,
                                                         "default"))) {
        tear_down(fixture);
        return NULL;
    }
    return fixture;
}

/* Array indexes */
#define N       0
#define E       1
#define D       2
#define P       3
#define Q       4
#define F3      5                /* Extra factor */
#define DP      6
#define DQ      7
#define E3      8                /* Extra exponent */
#define QINV    9
#define C3      10               /* Extra coefficient */

/*
 * We have to do this because OSSL_PARAM_get_ulong() can't handle params
 * holding data that isn't exactly sizeof(uint32_t) or sizeof(uint64_t),
 * and because the other end deals with BIGNUM, the resulting param might
 * be any size.  In this particular test, we know that the expected data
 * fits within an unsigned long, and we want to get the data in that form
 * to make testing of values easier.
 */
static int get_ulong_via_BN(const OSSL_PARAM *p, unsigned long *goal)
{
    BIGNUM *n = NULL;
    int ret = 1;                 /* Ever so hopeful */

    if (!TEST_true(OSSL_PARAM_get_BN(p, &n))
        || !TEST_true(BN_bn2nativepad(n, (unsigned char *)goal, sizeof(*goal))))
        ret = 0;
    BN_free(n);
    return ret;
}

static int export_cb(const OSSL_PARAM *params, void *arg)
{
    unsigned long *keydata = arg;
    const OSSL_PARAM *p = NULL;
    int factors_idx;
    int exponents_idx;
    int coefficients_idx;
    int ret = 1;                 /* Ever so hopeful */

    if (keydata == NULL)
        return 0;

    if (!TEST_ptr(p = OSSL_PARAM_locate_const(params, OSSL_PKEY_PARAM_RSA_N))
        || !TEST_true(get_ulong_via_BN(p, &keydata[N]))
        || !TEST_ptr(p = OSSL_PARAM_locate_const(params, OSSL_PKEY_PARAM_RSA_E))
        || !TEST_true(get_ulong_via_BN(p, &keydata[E]))
        || !TEST_ptr(p = OSSL_PARAM_locate_const(params, OSSL_PKEY_PARAM_RSA_D))
        || !TEST_true(get_ulong_via_BN(p, &keydata[D])))
        ret = 0;

    for (p = OSSL_PARAM_locate_const(params, OSSL_PKEY_PARAM_RSA_FACTOR),
             factors_idx = P;
         p != NULL && factors_idx <= F3;
         p = OSSL_PARAM_locate_const(p + 1, OSSL_PKEY_PARAM_RSA_FACTOR),
         factors_idx++)
        if (!TEST_true(get_ulong_via_BN(p, &keydata[factors_idx])))
            ret = 0;
    for (p = OSSL_PARAM_locate_const(params, OSSL_PKEY_PARAM_RSA_EXPONENT),
             exponents_idx = DP;
         p != NULL && exponents_idx <= E3;
         p = OSSL_PARAM_locate_const(p + 1, OSSL_PKEY_PARAM_RSA_EXPONENT),
         exponents_idx++)
        if (!TEST_true(get_ulong_via_BN(p, &keydata[exponents_idx])))
            ret = 0;
    for (p = OSSL_PARAM_locate_const(params, OSSL_PKEY_PARAM_RSA_COEFFICIENT),
             coefficients_idx = QINV;
         p != NULL && coefficients_idx <= C3;
         p = OSSL_PARAM_locate_const(p + 1, OSSL_PKEY_PARAM_RSA_COEFFICIENT),
         coefficients_idx++)
        if (!TEST_true(get_ulong_via_BN(p, &keydata[coefficients_idx])))
            ret = 0;

    if (!TEST_int_le(factors_idx, F3)
        || !TEST_int_le(exponents_idx, E3)
        || !TEST_int_le(coefficients_idx, C3))
        ret = 0;
    return ret;
}

static int test_pass_rsa(FIXTURE *fixture)
{
    size_t i;
    int ret = 0;
    RSA *rsa = NULL;
    BIGNUM *bn1 = NULL, *bn2 = NULL, *bn3 = NULL;
    EVP_PKEY *pk = NULL;
    EVP_KEYMGMT *km1 = NULL, *km2 = NULL;
    void *provdata = NULL;
    /*
     * 32-bit RSA key, extracted from this command,
     * executed with OpenSSL 1.0.2:
     *
     * openssl genrsa 32 | openssl rsa -text
     */
    static BN_ULONG expected[] = {
        0xbc747fc5,              /* N */
        0x10001,                 /* E */
        0x7b133399,              /* D */
        0xe963,                  /* P */
        0xceb7,                  /* Q */
        0,                       /* F3 */
        0x8599,                  /* DP */
        0xbd87,                  /* DQ */
        0,                       /* E3 */
        0xcc3b,                  /* QINV */
        0,                       /* C3 */
        0                        /* Extra, should remain zero */
    };
    static unsigned long keydata[OSSL_NELEM(expected)] = { 0, };

    if (!TEST_ptr(rsa = RSA_new()))
        goto err;

    if (!TEST_ptr(bn1 = BN_new())
        || !TEST_true(BN_set_word(bn1, expected[N]))
        || !TEST_ptr(bn2 = BN_new())
        || !TEST_true(BN_set_word(bn2, expected[E]))
        || !TEST_ptr(bn3 = BN_new())
        || !TEST_true(BN_set_word(bn3, expected[D]))
        || !TEST_true(RSA_set0_key(rsa, bn1, bn2, bn3)))
        goto err;

    if (!TEST_ptr(bn1 = BN_new())
        || !TEST_true(BN_set_word(bn1, expected[P]))
        || !TEST_ptr(bn2 = BN_new())
        || !TEST_true(BN_set_word(bn2, expected[Q]))
        || !TEST_true(RSA_set0_factors(rsa, bn1, bn2)))
        goto err;

    if (!TEST_ptr(bn1 = BN_new())
        || !TEST_true(BN_set_word(bn1, expected[DP]))
        || !TEST_ptr(bn2 = BN_new())
        || !TEST_true(BN_set_word(bn2, expected[DQ]))
        || !TEST_ptr(bn3 = BN_new())
        || !TEST_true(BN_set_word(bn3, expected[QINV]))
        || !TEST_true(RSA_set0_crt_params(rsa, bn1, bn2, bn3)))
        goto err;
    bn1 = bn2 = bn3 = NULL;

    if (!TEST_ptr(pk = EVP_PKEY_new())
        || !TEST_true(EVP_PKEY_assign_RSA(pk, rsa)))
        goto err;
    rsa = NULL;

    if (!TEST_ptr(km1 = EVP_KEYMGMT_fetch(fixture->ctx1, "RSA", NULL))
        || !TEST_ptr(km2 = EVP_KEYMGMT_fetch(fixture->ctx2, "RSA", NULL))
        || !TEST_ptr_ne(km1, km2))
        goto err;

    if (!TEST_ptr(evp_keymgmt_util_export_to_provider(pk, km1, 0))
        || !TEST_ptr(provdata =
                     evp_keymgmt_util_export_to_provider(pk, km2, 0)))
        goto err;

    if (!TEST_true(evp_keymgmt_exportkey(km2, provdata, &export_cb, keydata)))
        goto err;

    /*
     * At this point, the hope is that keydata will have all the numbers
     * from the key.
     */

    for (i = 0; i < OSSL_NELEM(expected); i++) {
        int rv = TEST_int_eq(expected[i], keydata[i]);

        if (!rv)
            TEST_info("i = %zu", i);
        else
            ret++;
    }

    ret = (ret == OSSL_NELEM(expected));

 err:
    RSA_free(rsa);
    BN_free(bn1);
    BN_free(bn2);
    BN_free(bn3);
    EVP_PKEY_free(pk);
    EVP_KEYMGMT_free(km1);
    EVP_KEYMGMT_free(km2);

    return ret;
}

static int (*tests[])(FIXTURE *) = {
    test_pass_rsa
};

static int test_pass_key(int n)
{
    SETUP_TEST_FIXTURE(FIXTURE, set_up);
    EXECUTE_TEST(tests[n], tear_down);
    return result;
}

int setup_tests(void)
{
    ADD_ALL_TESTS(test_pass_key, 1);
    return 1;
}
Commit	Line	Data
5a02d13d 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 <string.h>
	11
	12	#include <openssl/bio.h>
	13	#include <openssl/bn.h>
	14	#include <openssl/rsa.h>
	15	#include <openssl/evp.h>
	16	#include <openssl/provider.h>
	17	#include <openssl/core_names.h>
1640d48c	18	#include "internal/core.h"
5a02d13d RL	19	#include "internal/nelem.h"
	20	#include "crypto/evp.h" /* For the internal API */
	21	#include "testutil.h"
	22
	23	typedef struct {
	24	OPENSSL_CTX *ctx1;
	25	OSSL_PROVIDER *prov1;
	26	OPENSSL_CTX *ctx2;
	27	OSSL_PROVIDER *prov2;
	28	} FIXTURE;
	29
	30	static void tear_down(FIXTURE *fixture)
	31	{
	32	if (fixture != NULL) {
	33	OSSL_PROVIDER_unload(fixture->prov1);
	34	OSSL_PROVIDER_unload(fixture->prov2);
	35	OPENSSL_CTX_free(fixture->ctx1);
	36	OPENSSL_CTX_free(fixture->ctx2);
	37	OPENSSL_free(fixture);
	38	}
	39	}
	40
	41	static FIXTURE set_up(const char testcase_name)
	42	{
	43	FIXTURE *fixture;
	44
	45	if (!TEST_ptr(fixture = OPENSSL_zalloc(sizeof(*fixture)))
	46	\|\| !TEST_ptr(fixture->ctx1 = OPENSSL_CTX_new())
	47	\|\| !TEST_ptr(fixture->prov1 = OSSL_PROVIDER_load(fixture->ctx1,
	48	"default"))
	49	\|\| !TEST_ptr(fixture->ctx2 = OPENSSL_CTX_new())
	50	\|\| !TEST_ptr(fixture->prov2 = OSSL_PROVIDER_load(fixture->ctx2,
	51	"default"))) {
	52	tear_down(fixture);
	53	return NULL;
	54	}
	55	return fixture;
	56	}
	57
1640d48c	58	/* Array indexes */
5a02d13d RL	59	#define N 0
	60	#define E 1
	61	#define D 2
	62	#define P 3
	63	#define Q 4
	64	#define F3 5 /* Extra factor */
	65	#define DP 6
	66	#define DQ 7
	67	#define E3 8 /* Extra exponent */
	68	#define QINV 9
	69	#define C3 10 /* Extra coefficient */
	70
1640d48c RL	71	/*
	72	* We have to do this because OSSL_PARAM_get_ulong() can't handle params
	73	* holding data that isn't exactly sizeof(uint32_t) or sizeof(uint64_t),
	74	* and because the other end deals with BIGNUM, the resulting param might
	75	* be any size. In this particular test, we know that the expected data
	76	* fits within an unsigned long, and we want to get the data in that form
	77	* to make testing of values easier.
	78	*/
	79	static int get_ulong_via_BN(const OSSL_PARAM p, unsigned long goal)
	80	{
	81	BIGNUM *n = NULL;
	82	int ret = 1; /* Ever so hopeful */
	83
	84	if (!TEST_true(OSSL_PARAM_get_BN(p, &n))
	85	\|\| !TEST_true(BN_bn2nativepad(n, (unsigned char )goal, sizeof(goal))))
	86	ret = 0;
	87	BN_free(n);
	88	return ret;
	89	}
	90
	91	static int export_cb(const OSSL_PARAM params, void arg)
	92	{
	93	unsigned long *keydata = arg;
	94	const OSSL_PARAM *p = NULL;
	95	int factors_idx;
	96	int exponents_idx;
	97	int coefficients_idx;
	98	int ret = 1; /* Ever so hopeful */
	99
	100	if (keydata == NULL)
	101	return 0;
	102
	103	if (!TEST_ptr(p = OSSL_PARAM_locate_const(params, OSSL_PKEY_PARAM_RSA_N))
	104	\|\| !TEST_true(get_ulong_via_BN(p, &keydata[N]))
	105	\|\| !TEST_ptr(p = OSSL_PARAM_locate_const(params, OSSL_PKEY_PARAM_RSA_E))
	106	\|\| !TEST_true(get_ulong_via_BN(p, &keydata[E]))
	107	\|\| !TEST_ptr(p = OSSL_PARAM_locate_const(params, OSSL_PKEY_PARAM_RSA_D))
	108	\|\| !TEST_true(get_ulong_via_BN(p, &keydata[D])))
	109	ret = 0;
	110
	111	for (p = OSSL_PARAM_locate_const(params, OSSL_PKEY_PARAM_RSA_FACTOR),
	112	factors_idx = P;
	113	p != NULL && factors_idx <= F3;
	114	p = OSSL_PARAM_locate_const(p + 1, OSSL_PKEY_PARAM_RSA_FACTOR),
	115	factors_idx++)
	116	if (!TEST_true(get_ulong_via_BN(p, &keydata[factors_idx])))
	117	ret = 0;
	118	for (p = OSSL_PARAM_locate_const(params, OSSL_PKEY_PARAM_RSA_EXPONENT),
	119	exponents_idx = DP;
	120	p != NULL && exponents_idx <= E3;
	121	p = OSSL_PARAM_locate_const(p + 1, OSSL_PKEY_PARAM_RSA_EXPONENT),
	122	exponents_idx++)
	123	if (!TEST_true(get_ulong_via_BN(p, &keydata[exponents_idx])))
	124	ret = 0;
	125	for (p = OSSL_PARAM_locate_const(params, OSSL_PKEY_PARAM_RSA_COEFFICIENT),
	126	coefficients_idx = QINV;
	127	p != NULL && coefficients_idx <= C3;
	128	p = OSSL_PARAM_locate_const(p + 1, OSSL_PKEY_PARAM_RSA_COEFFICIENT),
	129	coefficients_idx++)
	130	if (!TEST_true(get_ulong_via_BN(p, &keydata[coefficients_idx])))
	131	ret = 0;
	132
	133	if (!TEST_int_le(factors_idx, F3)
	134	\|\| !TEST_int_le(exponents_idx, E3)
135	\|\| !TEST_int_le(coefficients_idx, C3))
136	ret = 0;
137	return ret;
138	}
139
140	static int test_pass_rsa(FIXTURE *fixture)
141	{
5a02d13d RL	142	size_t i;
	143	int ret = 0;
	144	RSA *rsa = NULL;
	145	BIGNUM bn1 = NULL, bn2 = NULL, *bn3 = NULL;
	146	EVP_PKEY *pk = NULL;
	147	EVP_KEYMGMT km1 = NULL, km2 = NULL;
	148	void *provdata = NULL;
	149	/*
	150	* 32-bit RSA key, extracted from this command,
	151	* executed with OpenSSL 1.0.2:
	152	*
	153	* openssl genrsa 32 \| openssl rsa -text
	154	*/
	155	static BN_ULONG expected[] = {
	156	0xbc747fc5, /* N */
	157	0x10001, /* E */
	158	0x7b133399, /* D */
	159	0xe963, /* P */
	160	0xceb7, /* Q */
	161	0, /* F3 */
	162	0x8599, /* DP */
	163	0xbd87, /* DQ */
	164	0, /* E3 */
	165	0xcc3b, /* QINV */
	166	0, /* C3 */
	167	0 /* Extra, should remain zero */
	168	};
	169	static unsigned long keydata[OSSL_NELEM(expected)] = { 0, };
5a02d13d RL	170
	171	if (!TEST_ptr(rsa = RSA_new()))
	172	goto err;
	173
	174	if (!TEST_ptr(bn1 = BN_new())
	175	\|\| !TEST_true(BN_set_word(bn1, expected[N]))
	176	\|\| !TEST_ptr(bn2 = BN_new())
	177	\|\| !TEST_true(BN_set_word(bn2, expected[E]))
	178	\|\| !TEST_ptr(bn3 = BN_new())
	179	\|\| !TEST_true(BN_set_word(bn3, expected[D]))
	180	\|\| !TEST_true(RSA_set0_key(rsa, bn1, bn2, bn3)))
	181	goto err;
	182
	183	if (!TEST_ptr(bn1 = BN_new())
	184	\|\| !TEST_true(BN_set_word(bn1, expected[P]))
	185	\|\| !TEST_ptr(bn2 = BN_new())
	186	\|\| !TEST_true(BN_set_word(bn2, expected[Q]))
	187	\|\| !TEST_true(RSA_set0_factors(rsa, bn1, bn2)))
	188	goto err;
	189
	190	if (!TEST_ptr(bn1 = BN_new())
	191	\|\| !TEST_true(BN_set_word(bn1, expected[DP]))
	192	\|\| !TEST_ptr(bn2 = BN_new())
	193	\|\| !TEST_true(BN_set_word(bn2, expected[DQ]))
	194	\|\| !TEST_ptr(bn3 = BN_new())
	195	\|\| !TEST_true(BN_set_word(bn3, expected[QINV]))
	196	\|\| !TEST_true(RSA_set0_crt_params(rsa, bn1, bn2, bn3)))
	197	goto err;
	198	bn1 = bn2 = bn3 = NULL;
	199
	200	if (!TEST_ptr(pk = EVP_PKEY_new())
	201	\|\| !TEST_true(EVP_PKEY_assign_RSA(pk, rsa)))
	202	goto err;
	203	rsa = NULL;
	204
	205	if (!TEST_ptr(km1 = EVP_KEYMGMT_fetch(fixture->ctx1, "RSA", NULL))
	206	\|\| !TEST_ptr(km2 = EVP_KEYMGMT_fetch(fixture->ctx2, "RSA", NULL))
	207	\|\| !TEST_ptr_ne(km1, km2))
	208	goto err;
	209
68552cde RL	210	if (!TEST_ptr(evp_keymgmt_util_export_to_provider(pk, km1, 0))
	211	\|\| !TEST_ptr(provdata =
	212	evp_keymgmt_util_export_to_provider(pk, km2, 0)))
5a02d13d RL	213	goto err;
5a02d13d RL	214
1640d48c	215	if (!TEST_true(evp_keymgmt_exportkey(km2, provdata, &export_cb, keydata)))
5a02d13d RL	216	goto err;
	217
	218	/*
	219	* At this point, the hope is that keydata will have all the numbers
	220	* from the key.
	221	*/
	222
1640d48c RL	223	for (i = 0; i < OSSL_NELEM(expected); i++) {
	224	int rv = TEST_int_eq(expected[i], keydata[i]);
	225
	226	if (!rv)
	227	TEST_info("i = %zu", i);
	228	else
	229	ret++;
	230	}
5a02d13d RL	231
	232	ret = (ret == OSSL_NELEM(expected));
	233
	234	err:
	235	RSA_free(rsa);
	236	BN_free(bn1);
	237	BN_free(bn2);
	238	BN_free(bn3);
	239	EVP_PKEY_free(pk);
	240	EVP_KEYMGMT_free(km1);
	241	EVP_KEYMGMT_free(km2);
	242
	243	return ret;
	244	}
	245
	246	static int (tests[])(FIXTURE ) = {
	247	test_pass_rsa
	248	};
	249
	250	static int test_pass_key(int n)
	251	{
	252	SETUP_TEST_FIXTURE(FIXTURE, set_up);
	253	EXECUTE_TEST(tests[n], tear_down);
	254	return result;
	255	}
	256
	257	int setup_tests(void)
	258	{
	259	ADD_ALL_TESTS(test_pass_key, 1);
	260	return 1;
	261	}