[thirdparty/openssl.git] / providers / implementations / keymgmt / ecx_kmgmt.c

/*
 * Copyright 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 <assert.h>
#include <openssl/core_numbers.h>
#include <openssl/core_names.h>
#include <openssl/params.h>
#include "openssl/param_build.h"
#include "crypto/ecx.h"
#include "prov/implementations.h"
#include "prov/providercommon.h"

static OSSL_OP_keymgmt_new_fn x25519_new_key;
static OSSL_OP_keymgmt_new_fn x448_new_key;
static OSSL_OP_keymgmt_new_fn ed25519_new_key;
static OSSL_OP_keymgmt_new_fn ed448_new_key;
static OSSL_OP_keymgmt_get_params_fn x25519_get_params;
static OSSL_OP_keymgmt_get_params_fn x448_get_params;
static OSSL_OP_keymgmt_get_params_fn ed25519_get_params;
static OSSL_OP_keymgmt_get_params_fn ed448_get_params;
static OSSL_OP_keymgmt_gettable_params_fn ecx_gettable_params;
static OSSL_OP_keymgmt_has_fn ecx_has;
static OSSL_OP_keymgmt_import_fn ecx_import;
static OSSL_OP_keymgmt_import_types_fn ecx_imexport_types;
static OSSL_OP_keymgmt_export_fn ecx_export;
static OSSL_OP_keymgmt_export_types_fn ecx_imexport_types;

#define ECX_POSSIBLE_SELECTIONS (OSSL_KEYMGMT_SELECT_KEYPAIR)

static void *x25519_new_key(void *provctx)
{
    return ecx_key_new(ECX_KEY_TYPE_X25519, 0);
}

static void *x448_new_key(void *provctx)
{
    return ecx_key_new(ECX_KEY_TYPE_X448, 0);
}

static void *ed25519_new_key(void *provctx)
{
    return ecx_key_new(ECX_KEY_TYPE_ED25519, 0);
}

static void *ed448_new_key(void *provctx)
{
    return ecx_key_new(ECX_KEY_TYPE_ED448, 0);
}

static int ecx_has(void *keydata, int selection)
{
    ECX_KEY *key = keydata;
    int ok = 0;

    if (key != NULL) {
        if ((selection & ECX_POSSIBLE_SELECTIONS) != 0)
            ok = 1;

        if ((selection & OSSL_KEYMGMT_SELECT_PUBLIC_KEY) != 0)
            ok = ok && key->haspubkey;

        if ((selection & OSSL_KEYMGMT_SELECT_PRIVATE_KEY) != 0)
            ok = ok && key->privkey != NULL;
    }
    return ok;
}

static int ecx_import(void *keydata, int selection, const OSSL_PARAM params[])
{
    ECX_KEY *key = keydata;
    int ok = 1;
    int include_private = 0;

    if (key == NULL)
        return 0;

    if ((selection & OSSL_KEYMGMT_SELECT_PUBLIC_KEY) == 0)
        return 0;

    include_private = ((selection & OSSL_KEYMGMT_SELECT_PRIVATE_KEY) != 0);
    if ((selection & OSSL_KEYMGMT_SELECT_KEYPAIR) != 0)
        ok = ok && ecx_key_fromdata(key, params, include_private);

    return ok;
}

static int key_to_params(ECX_KEY *key, OSSL_PARAM_BLD *tmpl)
{
    if (key == NULL)
        return 0;

    if (!OSSL_PARAM_BLD_push_octet_string(tmpl, OSSL_PKEY_PARAM_PUB_KEY,
                                          key->pubkey, key->keylen))
        return 0;

    if (key->privkey != NULL
        && !OSSL_PARAM_BLD_push_octet_string(tmpl, OSSL_PKEY_PARAM_PRIV_KEY,
                                             key->privkey, key->keylen))
        return 0;

    return 1;
}

static int ecx_export(void *keydata, int selection, OSSL_CALLBACK *param_cb,
                      void *cbarg)
{
    ECX_KEY *key = keydata;
    OSSL_PARAM_BLD tmpl;
    OSSL_PARAM *params = NULL;
    int ret;

    if (key == NULL)
        return 0;

    if ((selection & OSSL_KEYMGMT_SELECT_KEYPAIR) != 0
            && !key_to_params(key, &tmpl))
        return 0;

    OSSL_PARAM_BLD_init(&tmpl);
    params = OSSL_PARAM_BLD_to_param(&tmpl);
    if (params == NULL) {
        OSSL_PARAM_BLD_free(params);
        return 0;
    }

    ret = param_cb(params, cbarg);
    OSSL_PARAM_BLD_free(params);
    return ret;
}

static const OSSL_PARAM ecx_key_types[] = {
    OSSL_PARAM_octet_string(OSSL_PKEY_PARAM_PUB_KEY, NULL, 0),
    OSSL_PARAM_octet_string(OSSL_PKEY_PARAM_PRIV_KEY, NULL, 0),
    OSSL_PARAM_END
};
static const OSSL_PARAM *ecx_imexport_types(int selection)
{
    if ((selection & OSSL_KEYMGMT_SELECT_KEYPAIR) != 0)
        return ecx_key_types;
    return NULL;
}

static int ecx_get_params(OSSL_PARAM params[], int bits, int secbits,
                          int size)
{
    OSSL_PARAM *p;

    if ((p = OSSL_PARAM_locate(params, OSSL_PKEY_PARAM_BITS)) != NULL
        && !OSSL_PARAM_set_int(p, bits))
        return 0;
    if ((p = OSSL_PARAM_locate(params, OSSL_PKEY_PARAM_SECURITY_BITS)) != NULL
        && !OSSL_PARAM_set_int(p, secbits))
        return 0;
    if ((p = OSSL_PARAM_locate(params, OSSL_PKEY_PARAM_MAX_SIZE)) != NULL
        && !OSSL_PARAM_set_int(p, size))
        return 0;
    return 1;
}

static int x25519_get_params(void *key, OSSL_PARAM params[])
{
    return ecx_get_params(params, X25519_BITS, X25519_SECURITY_BITS, X25519_KEYLEN);
}

static int x448_get_params(void *key, OSSL_PARAM params[])
{
    return ecx_get_params(params, X448_BITS, X448_SECURITY_BITS, X448_KEYLEN);
}

static int ed25519_get_params(void *key, OSSL_PARAM params[])
{
    return ecx_get_params(params, ED25519_BITS, ED25519_SECURITY_BITS, ED25519_KEYLEN);
}

static int ed448_get_params(void *key, OSSL_PARAM params[])
{
    return ecx_get_params(params, ED448_BITS, ED448_SECURITY_BITS, ED448_KEYLEN);
}

static const OSSL_PARAM ecx_params[] = {
    OSSL_PARAM_int(OSSL_PKEY_PARAM_BITS, NULL),
    OSSL_PARAM_int(OSSL_PKEY_PARAM_SECURITY_BITS, NULL),
    OSSL_PARAM_int(OSSL_PKEY_PARAM_MAX_SIZE, NULL),
    OSSL_PARAM_END
};

static const OSSL_PARAM *ecx_gettable_params(void)
{
    return ecx_params;
}

#define MAKE_KEYMGMT_FUNCTIONS(alg) \
    const OSSL_DISPATCH alg##_keymgmt_functions[] = { \
        { OSSL_FUNC_KEYMGMT_NEW, (void (*)(void))alg##_new_key }, \
        { OSSL_FUNC_KEYMGMT_FREE, (void (*)(void))ecx_key_free }, \
        { OSSL_FUNC_KEYMGMT_GET_PARAMS, (void (*) (void))alg##_get_params }, \
        { OSSL_FUNC_KEYMGMT_GETTABLE_PARAMS, (void (*) (void))ecx_gettable_params }, \
        { OSSL_FUNC_KEYMGMT_HAS, (void (*)(void))ecx_has }, \
        { OSSL_FUNC_KEYMGMT_IMPORT, (void (*)(void))ecx_import }, \
        { OSSL_FUNC_KEYMGMT_IMPORT_TYPES, (void (*)(void))ecx_imexport_types }, \
        { OSSL_FUNC_KEYMGMT_EXPORT, (void (*)(void))ecx_export }, \
        { OSSL_FUNC_KEYMGMT_EXPORT_TYPES, (void (*)(void))ecx_imexport_types }, \
        { 0, NULL } \
    };

MAKE_KEYMGMT_FUNCTIONS(x25519)
MAKE_KEYMGMT_FUNCTIONS(x448)
MAKE_KEYMGMT_FUNCTIONS(ed25519)
MAKE_KEYMGMT_FUNCTIONS(ed448)
Commit	Line	Data
90d3cb57 MC	1	/*
	2	* Copyright 2020 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 <assert.h>
	11	#include <openssl/core_numbers.h>
	12	#include <openssl/core_names.h>
	13	#include <openssl/params.h>
110bff61	14	#include "openssl/param_build.h"
90d3cb57 MC	15	#include "crypto/ecx.h"
	16	#include "prov/implementations.h"
	17	#include "prov/providercommon.h"
	18
	19	static OSSL_OP_keymgmt_new_fn x25519_new_key;
	20	static OSSL_OP_keymgmt_new_fn x448_new_key;
af6d8dd3 MC	21	static OSSL_OP_keymgmt_new_fn ed25519_new_key;
af6d8dd3 MC	22	static OSSL_OP_keymgmt_new_fn ed448_new_key;
90d3cb57 MC	23	static OSSL_OP_keymgmt_get_params_fn x25519_get_params;
90d3cb57 MC	24	static OSSL_OP_keymgmt_get_params_fn x448_get_params;
af6d8dd3 MC	25	static OSSL_OP_keymgmt_get_params_fn ed25519_get_params;
af6d8dd3 MC	26	static OSSL_OP_keymgmt_get_params_fn ed448_get_params;
90d3cb57 MC	27	static OSSL_OP_keymgmt_gettable_params_fn ecx_gettable_params;
	28	static OSSL_OP_keymgmt_has_fn ecx_has;
	29	static OSSL_OP_keymgmt_import_fn ecx_import;
	30	static OSSL_OP_keymgmt_import_types_fn ecx_imexport_types;
	31	static OSSL_OP_keymgmt_export_fn ecx_export;
	32	static OSSL_OP_keymgmt_export_types_fn ecx_imexport_types;
	33
f552d900 SL	34	#define ECX_POSSIBLE_SELECTIONS (OSSL_KEYMGMT_SELECT_KEYPAIR)
f552d900 SL	35
90d3cb57 MC	36	static void x25519_new_key(void provctx)
90d3cb57 MC	37	{
244bc297	38	return ecx_key_new(ECX_KEY_TYPE_X25519, 0);
90d3cb57 MC	39	}
	40
	41	static void x448_new_key(void provctx)
	42	{
244bc297	43	return ecx_key_new(ECX_KEY_TYPE_X448, 0);
90d3cb57 MC	44	}
90d3cb57 MC	45
af6d8dd3 MC	46	static void ed25519_new_key(void provctx)
af6d8dd3 MC	47	{
244bc297	48	return ecx_key_new(ECX_KEY_TYPE_ED25519, 0);
af6d8dd3 MC	49	}
	50
	51	static void ed448_new_key(void provctx)
	52	{
244bc297	53	return ecx_key_new(ECX_KEY_TYPE_ED448, 0);
af6d8dd3 MC	54	}
af6d8dd3 MC	55
90d3cb57 MC	56	static int ecx_has(void *keydata, int selection)
	57	{
	58	ECX_KEY *key = keydata;
adc9f731	59	int ok = 0;
90d3cb57	60
adc9f731 RL	61	if (key != NULL) {
	62	if ((selection & ECX_POSSIBLE_SELECTIONS) != 0)
	63	ok = 1;
90d3cb57	64
adc9f731 RL	65	if ((selection & OSSL_KEYMGMT_SELECT_PUBLIC_KEY) != 0)
adc9f731 RL	66	ok = ok && key->haspubkey;
90d3cb57	67
adc9f731 RL	68	if ((selection & OSSL_KEYMGMT_SELECT_PRIVATE_KEY) != 0)
	69	ok = ok && key->privkey != NULL;
	70	}
90d3cb57 MC	71	return ok;
	72	}
	73
	74	static int ecx_import(void *keydata, int selection, const OSSL_PARAM params[])
	75	{
	76	ECX_KEY *key = keydata;
0abae163 RL	77	int ok = 1;
0abae163 RL	78	int include_private = 0;
90d3cb57 MC	79
	80	if (key == NULL)
	81	return 0;
	82
f552d900	83	if ((selection & OSSL_KEYMGMT_SELECT_PUBLIC_KEY) == 0)
90d3cb57 MC	84	return 0;
90d3cb57 MC	85
0abae163 RL	86	include_private = ((selection & OSSL_KEYMGMT_SELECT_PRIVATE_KEY) != 0);
	87	if ((selection & OSSL_KEYMGMT_SELECT_KEYPAIR) != 0)
	88	ok = ok && ecx_key_fromdata(key, params, include_private);
90d3cb57	89
0abae163	90	return ok;
90d3cb57 MC	91	}
	92
	93	static int key_to_params(ECX_KEY key, OSSL_PARAM_BLD tmpl)
	94	{
	95	if (key == NULL)
	96	return 0;
	97
110bff61	98	if (!OSSL_PARAM_BLD_push_octet_string(tmpl, OSSL_PKEY_PARAM_PUB_KEY,
90d3cb57 MC	99	key->pubkey, key->keylen))
	100	return 0;
	101
	102	if (key->privkey != NULL
110bff61	103	&& !OSSL_PARAM_BLD_push_octet_string(tmpl, OSSL_PKEY_PARAM_PRIV_KEY,
90d3cb57 MC	104	key->privkey, key->keylen))
	105	return 0;
	106
	107	return 1;
	108	}
	109
	110	static int ecx_export(void keydata, int selection, OSSL_CALLBACK param_cb,
	111	void *cbarg)
	112	{
	113	ECX_KEY *key = keydata;
	114	OSSL_PARAM_BLD tmpl;
	115	OSSL_PARAM *params = NULL;
	116	int ret;
	117
	118	if (key == NULL)
	119	return 0;
	120
	121	if ((selection & OSSL_KEYMGMT_SELECT_KEYPAIR) != 0
	122	&& !key_to_params(key, &tmpl))
	123	return 0;
	124
110bff61 P	125	OSSL_PARAM_BLD_init(&tmpl);
110bff61 P	126	params = OSSL_PARAM_BLD_to_param(&tmpl);
90d3cb57	127	if (params == NULL) {
110bff61	128	OSSL_PARAM_BLD_free(params);
90d3cb57 MC	129	return 0;
	130	}
	131
	132	ret = param_cb(params, cbarg);
110bff61	133	OSSL_PARAM_BLD_free(params);
90d3cb57 MC	134	return ret;
	135	}
	136
	137	static const OSSL_PARAM ecx_key_types[] = {
8efc4a9c MC	138	OSSL_PARAM_octet_string(OSSL_PKEY_PARAM_PUB_KEY, NULL, 0),
8efc4a9c MC	139	OSSL_PARAM_octet_string(OSSL_PKEY_PARAM_PRIV_KEY, NULL, 0),
90d3cb57 MC	140	OSSL_PARAM_END
	141	};
	142	static const OSSL_PARAM *ecx_imexport_types(int selection)
	143	{
	144	if ((selection & OSSL_KEYMGMT_SELECT_KEYPAIR) != 0)
	145	return ecx_key_types;
	146	return NULL;
	147	}
	148
	149	static int ecx_get_params(OSSL_PARAM params[], int bits, int secbits,
	150	int size)
	151	{
	152	OSSL_PARAM *p;
	153
	154	if ((p = OSSL_PARAM_locate(params, OSSL_PKEY_PARAM_BITS)) != NULL
	155	&& !OSSL_PARAM_set_int(p, bits))
	156	return 0;
	157	if ((p = OSSL_PARAM_locate(params, OSSL_PKEY_PARAM_SECURITY_BITS)) != NULL
	158	&& !OSSL_PARAM_set_int(p, secbits))
	159	return 0;
	160	if ((p = OSSL_PARAM_locate(params, OSSL_PKEY_PARAM_MAX_SIZE)) != NULL
	161	&& !OSSL_PARAM_set_int(p, size))
	162	return 0;
	163	return 1;
	164	}
	165
	166	static int x25519_get_params(void *key, OSSL_PARAM params[])
	167	{
	168	return ecx_get_params(params, X25519_BITS, X25519_SECURITY_BITS, X25519_KEYLEN);
	169	}
	170
	171	static int x448_get_params(void *key, OSSL_PARAM params[])
	172	{
	173	return ecx_get_params(params, X448_BITS, X448_SECURITY_BITS, X448_KEYLEN);
	174	}
	175
af6d8dd3 MC	176	static int ed25519_get_params(void *key, OSSL_PARAM params[])
	177	{
	178	return ecx_get_params(params, ED25519_BITS, ED25519_SECURITY_BITS, ED25519_KEYLEN);
	179	}
	180
	181	static int ed448_get_params(void *key, OSSL_PARAM params[])
	182	{
	183	return ecx_get_params(params, ED448_BITS, ED448_SECURITY_BITS, ED448_KEYLEN);
	184	}
	185
90d3cb57 MC	186	static const OSSL_PARAM ecx_params[] = {
	187	OSSL_PARAM_int(OSSL_PKEY_PARAM_BITS, NULL),
	188	OSSL_PARAM_int(OSSL_PKEY_PARAM_SECURITY_BITS, NULL),
	189	OSSL_PARAM_int(OSSL_PKEY_PARAM_MAX_SIZE, NULL),
	190	OSSL_PARAM_END
	191	};
	192
	193	static const OSSL_PARAM *ecx_gettable_params(void)
	194	{
	195	return ecx_params;
	196	}
	197
af6d8dd3 MC	198	#define MAKE_KEYMGMT_FUNCTIONS(alg) \
	199	const OSSL_DISPATCH alg##_keymgmt_functions[] = { \
	200	{ OSSL_FUNC_KEYMGMT_NEW, (void (*)(void))alg##_new_key }, \
	201	{ OSSL_FUNC_KEYMGMT_FREE, (void (*)(void))ecx_key_free }, \
	202	{ OSSL_FUNC_KEYMGMT_GET_PARAMS, (void (*) (void))alg##_get_params }, \
	203	{ OSSL_FUNC_KEYMGMT_GETTABLE_PARAMS, (void (*) (void))ecx_gettable_params }, \
	204	{ OSSL_FUNC_KEYMGMT_HAS, (void (*)(void))ecx_has }, \
	205	{ OSSL_FUNC_KEYMGMT_IMPORT, (void (*)(void))ecx_import }, \
	206	{ OSSL_FUNC_KEYMGMT_IMPORT_TYPES, (void (*)(void))ecx_imexport_types }, \
	207	{ OSSL_FUNC_KEYMGMT_EXPORT, (void (*)(void))ecx_export }, \
	208	{ OSSL_FUNC_KEYMGMT_EXPORT_TYPES, (void (*)(void))ecx_imexport_types }, \
	209	{ 0, NULL } \
	210	};
	211
	212	MAKE_KEYMGMT_FUNCTIONS(x25519)
	213	MAKE_KEYMGMT_FUNCTIONS(x448)
	214	MAKE_KEYMGMT_FUNCTIONS(ed25519)
	215	MAKE_KEYMGMT_FUNCTIONS(ed448)