[thirdparty/openssl.git] / providers / implementations / exchange / ecx_exch.c

/*
 * Copyright 2020-2024 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/crypto.h>
#include <openssl/core_dispatch.h>
#include <openssl/core_names.h>
#include <openssl/params.h>
#include <openssl/err.h>
#include <openssl/proverr.h>
#include "internal/cryptlib.h"
#include "crypto/ecx.h"
#include "prov/implementations.h"
#include "prov/providercommon.h"
#include "prov/securitycheck.h"

static OSSL_FUNC_keyexch_newctx_fn x25519_newctx;
static OSSL_FUNC_keyexch_newctx_fn x448_newctx;
static OSSL_FUNC_keyexch_init_fn x25519_init;
static OSSL_FUNC_keyexch_init_fn x448_init;
static OSSL_FUNC_keyexch_set_peer_fn ecx_set_peer;
static OSSL_FUNC_keyexch_derive_fn ecx_derive;
static OSSL_FUNC_keyexch_freectx_fn ecx_freectx;
static OSSL_FUNC_keyexch_dupctx_fn ecx_dupctx;
static OSSL_FUNC_keyexch_gettable_ctx_params_fn ecx_gettable_ctx_params;
static OSSL_FUNC_keyexch_get_ctx_params_fn ecx_get_ctx_params;

/*
 * What's passed as an actual key is defined by the KEYMGMT interface.
 * We happen to know that our KEYMGMT simply passes ECX_KEY structures, so
 * we use that here too.
 */

typedef struct {
    size_t keylen;
    ECX_KEY *key;
    ECX_KEY *peerkey;
} PROV_ECX_CTX;

static void *ecx_newctx(void *provctx, size_t keylen)
{
    PROV_ECX_CTX *ctx;

    if (!ossl_prov_is_running())
        return NULL;

    ctx = OPENSSL_zalloc(sizeof(PROV_ECX_CTX));
    if (ctx == NULL)
        return NULL;

    ctx->keylen = keylen;

    return ctx;
}

static void *x25519_newctx(void *provctx)
{
    return ecx_newctx(provctx, X25519_KEYLEN);
}

static void *x448_newctx(void *provctx)
{
    return ecx_newctx(provctx, X448_KEYLEN);
}

static int ecx_init(void *vecxctx, void *vkey, const char *algname)
{
    PROV_ECX_CTX *ecxctx = (PROV_ECX_CTX *)vecxctx;
    ECX_KEY *key = vkey;

    if (!ossl_prov_is_running())
        return 0;

    if (ecxctx == NULL
            || key == NULL
            || key->keylen != ecxctx->keylen
            || !ossl_ecx_key_up_ref(key)) {
        ERR_raise(ERR_LIB_PROV, ERR_R_INTERNAL_ERROR);
        return 0;
    }

    ossl_ecx_key_free(ecxctx->key);
    ecxctx->key = key;

#ifdef FIPS_MODULE
    if (!ossl_FIPS_IND_callback(key->libctx, algname, "Init"))
        return 0;
#endif
    return 1;
}

static int x25519_init(void *vecxctx, void *vkey,
                       ossl_unused const OSSL_PARAM params[])
{
    return ecx_init(vecxctx, vkey, "X25519");
}

static int x448_init(void *vecxctx, void *vkey,
                     ossl_unused const OSSL_PARAM params[])
{
    return ecx_init(vecxctx, vkey, "X448");
}

static int ecx_set_peer(void *vecxctx, void *vkey)
{
    PROV_ECX_CTX *ecxctx = (PROV_ECX_CTX *)vecxctx;
    ECX_KEY *key = vkey;

    if (!ossl_prov_is_running())
        return 0;

    if (ecxctx == NULL
            || key == NULL
            || key->keylen != ecxctx->keylen
            || !ossl_ecx_key_up_ref(key)) {
        ERR_raise(ERR_LIB_PROV, ERR_R_INTERNAL_ERROR);
        return 0;
    }
    ossl_ecx_key_free(ecxctx->peerkey);
    ecxctx->peerkey = key;

    return 1;
}

static int ecx_derive(void *vecxctx, unsigned char *secret, size_t *secretlen,
                      size_t outlen)
{
    PROV_ECX_CTX *ecxctx = (PROV_ECX_CTX *)vecxctx;

    if (!ossl_prov_is_running())
        return 0;
    return ossl_ecx_compute_key(ecxctx->peerkey, ecxctx->key, ecxctx->keylen,
                                secret, secretlen, outlen);
}

static void ecx_freectx(void *vecxctx)
{
    PROV_ECX_CTX *ecxctx = (PROV_ECX_CTX *)vecxctx;

    ossl_ecx_key_free(ecxctx->key);
    ossl_ecx_key_free(ecxctx->peerkey);

    OPENSSL_free(ecxctx);
}

static void *ecx_dupctx(void *vecxctx)
{
    PROV_ECX_CTX *srcctx = (PROV_ECX_CTX *)vecxctx;
    PROV_ECX_CTX *dstctx;

    if (!ossl_prov_is_running())
        return NULL;

    dstctx = OPENSSL_zalloc(sizeof(*srcctx));
    if (dstctx == NULL)
        return NULL;

    *dstctx = *srcctx;
    if (dstctx->key != NULL && !ossl_ecx_key_up_ref(dstctx->key)) {
        ERR_raise(ERR_LIB_PROV, ERR_R_INTERNAL_ERROR);
        OPENSSL_free(dstctx);
        return NULL;
    }

    if (dstctx->peerkey != NULL && !ossl_ecx_key_up_ref(dstctx->peerkey)) {
        ERR_raise(ERR_LIB_PROV, ERR_R_INTERNAL_ERROR);
        ossl_ecx_key_free(dstctx->key);
        OPENSSL_free(dstctx);
        return NULL;
    }

    return dstctx;
}

static const OSSL_PARAM *ecx_gettable_ctx_params(ossl_unused void *vctx,
                                                 ossl_unused void *provctx)
{
    static const OSSL_PARAM known_gettable_ctx_params[] = {
        OSSL_FIPS_IND_GETTABLE_CTX_PARAM()
        OSSL_PARAM_END
    };
    return known_gettable_ctx_params;
}

static int ecx_get_ctx_params(ossl_unused void *vctx, OSSL_PARAM params[])
{
#ifdef FIPS_MODULE
    int approved = 0;
    OSSL_PARAM *p = OSSL_PARAM_locate(params,
                                      OSSL_ALG_PARAM_FIPS_APPROVED_INDICATOR);

    if (p != NULL && !OSSL_PARAM_set_int(p, approved))
        return 0;
#endif
    return 1;
}

const OSSL_DISPATCH ossl_x25519_keyexch_functions[] = {
    { OSSL_FUNC_KEYEXCH_NEWCTX, (void (*)(void))x25519_newctx },
    { OSSL_FUNC_KEYEXCH_INIT, (void (*)(void))x25519_init },
    { OSSL_FUNC_KEYEXCH_DERIVE, (void (*)(void))ecx_derive },
    { OSSL_FUNC_KEYEXCH_SET_PEER, (void (*)(void))ecx_set_peer },
    { OSSL_FUNC_KEYEXCH_FREECTX, (void (*)(void))ecx_freectx },
    { OSSL_FUNC_KEYEXCH_DUPCTX, (void (*)(void))ecx_dupctx },
    { OSSL_FUNC_KEYEXCH_GET_CTX_PARAMS, (void (*)(void))ecx_get_ctx_params },
    { OSSL_FUNC_KEYEXCH_GETTABLE_CTX_PARAMS,
      (void (*)(void))ecx_gettable_ctx_params },
    OSSL_DISPATCH_END
};

const OSSL_DISPATCH ossl_x448_keyexch_functions[] = {
    { OSSL_FUNC_KEYEXCH_NEWCTX, (void (*)(void))x448_newctx },
    { OSSL_FUNC_KEYEXCH_INIT, (void (*)(void))x448_init },
    { OSSL_FUNC_KEYEXCH_DERIVE, (void (*)(void))ecx_derive },
    { OSSL_FUNC_KEYEXCH_SET_PEER, (void (*)(void))ecx_set_peer },
    { OSSL_FUNC_KEYEXCH_FREECTX, (void (*)(void))ecx_freectx },
    { OSSL_FUNC_KEYEXCH_DUPCTX, (void (*)(void))ecx_dupctx },
    { OSSL_FUNC_KEYEXCH_GET_CTX_PARAMS, (void (*)(void))ecx_get_ctx_params },
    { OSSL_FUNC_KEYEXCH_GETTABLE_CTX_PARAMS,
      (void (*)(void))ecx_gettable_ctx_params },
    OSSL_DISPATCH_END
};
Commit	Line	Data
	1	/*
	2	* Copyright 2020-2024 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/crypto.h>
	11	#include <openssl/core_dispatch.h>
	12	#include <openssl/core_names.h>
	13	#include <openssl/params.h>
	14	#include <openssl/err.h>
	15	#include <openssl/proverr.h>
	16	#include "internal/cryptlib.h"
	17	#include "crypto/ecx.h"
	18	#include "prov/implementations.h"
	19	#include "prov/providercommon.h"
	20	#include "prov/securitycheck.h"
	21
	22	static OSSL_FUNC_keyexch_newctx_fn x25519_newctx;
	23	static OSSL_FUNC_keyexch_newctx_fn x448_newctx;
	24	static OSSL_FUNC_keyexch_init_fn x25519_init;
	25	static OSSL_FUNC_keyexch_init_fn x448_init;
	26	static OSSL_FUNC_keyexch_set_peer_fn ecx_set_peer;
	27	static OSSL_FUNC_keyexch_derive_fn ecx_derive;
	28	static OSSL_FUNC_keyexch_freectx_fn ecx_freectx;
	29	static OSSL_FUNC_keyexch_dupctx_fn ecx_dupctx;
	30	static OSSL_FUNC_keyexch_gettable_ctx_params_fn ecx_gettable_ctx_params;
	31	static OSSL_FUNC_keyexch_get_ctx_params_fn ecx_get_ctx_params;
	32
	33	/*
	34	* What's passed as an actual key is defined by the KEYMGMT interface.
	35	* We happen to know that our KEYMGMT simply passes ECX_KEY structures, so
	36	* we use that here too.
	37	*/
	38
	39	typedef struct {
	40	size_t keylen;
	41	ECX_KEY *key;
	42	ECX_KEY *peerkey;
	43	} PROV_ECX_CTX;
	44
	45	static void ecx_newctx(void provctx, size_t keylen)
	46	{
	47	PROV_ECX_CTX *ctx;
	48
	49	if (!ossl_prov_is_running())
	50	return NULL;
	51
	52	ctx = OPENSSL_zalloc(sizeof(PROV_ECX_CTX));
	53	if (ctx == NULL)
	54	return NULL;
	55
	56	ctx->keylen = keylen;
	57
	58	return ctx;
	59	}
	60
	61	static void x25519_newctx(void provctx)
	62	{
	63	return ecx_newctx(provctx, X25519_KEYLEN);
	64	}
	65
	66	static void x448_newctx(void provctx)
	67	{
	68	return ecx_newctx(provctx, X448_KEYLEN);
	69	}
	70
	71	static int ecx_init(void vecxctx, void vkey, const char *algname)
	72	{
	73	PROV_ECX_CTX ecxctx = (PROV_ECX_CTX )vecxctx;
	74	ECX_KEY *key = vkey;
	75
	76	if (!ossl_prov_is_running())
	77	return 0;
	78
	79	if (ecxctx == NULL
	80	\|\| key == NULL
	81	\|\| key->keylen != ecxctx->keylen
	82	\|\| !ossl_ecx_key_up_ref(key)) {
	83	ERR_raise(ERR_LIB_PROV, ERR_R_INTERNAL_ERROR);
	84	return 0;
	85	}
	86
	87	ossl_ecx_key_free(ecxctx->key);
	88	ecxctx->key = key;
	89
	90	#ifdef FIPS_MODULE
	91	if (!ossl_FIPS_IND_callback(key->libctx, algname, "Init"))
	92	return 0;
	93	#endif
	94	return 1;
	95	}
	96
	97	static int x25519_init(void vecxctx, void vkey,
	98	ossl_unused const OSSL_PARAM params[])
	99	{
	100	return ecx_init(vecxctx, vkey, "X25519");
	101	}
	102
	103	static int x448_init(void vecxctx, void vkey,
	104	ossl_unused const OSSL_PARAM params[])
	105	{
	106	return ecx_init(vecxctx, vkey, "X448");
	107	}
	108
	109	static int ecx_set_peer(void vecxctx, void vkey)
	110	{
	111	PROV_ECX_CTX ecxctx = (PROV_ECX_CTX )vecxctx;
	112	ECX_KEY *key = vkey;
	113
	114	if (!ossl_prov_is_running())
	115	return 0;
	116
	117	if (ecxctx == NULL
	118	\|\| key == NULL
	119	\|\| key->keylen != ecxctx->keylen
	120	\|\| !ossl_ecx_key_up_ref(key)) {
	121	ERR_raise(ERR_LIB_PROV, ERR_R_INTERNAL_ERROR);
	122	return 0;
	123	}
	124	ossl_ecx_key_free(ecxctx->peerkey);
	125	ecxctx->peerkey = key;
	126
	127	return 1;
	128	}
	129
	130	static int ecx_derive(void vecxctx, unsigned char secret, size_t *secretlen,
	131	size_t outlen)
	132	{
	133	PROV_ECX_CTX ecxctx = (PROV_ECX_CTX )vecxctx;
	134
	135	if (!ossl_prov_is_running())
	136	return 0;
	137	return ossl_ecx_compute_key(ecxctx->peerkey, ecxctx->key, ecxctx->keylen,
	138	secret, secretlen, outlen);
	139	}
	140
	141	static void ecx_freectx(void *vecxctx)
	142	{
	143	PROV_ECX_CTX ecxctx = (PROV_ECX_CTX )vecxctx;
	144
	145	ossl_ecx_key_free(ecxctx->key);
	146	ossl_ecx_key_free(ecxctx->peerkey);
	147
	148	OPENSSL_free(ecxctx);
	149	}
	150
	151	static void ecx_dupctx(void vecxctx)
	152	{
	153	PROV_ECX_CTX srcctx = (PROV_ECX_CTX )vecxctx;
	154	PROV_ECX_CTX *dstctx;
	155
	156	if (!ossl_prov_is_running())
	157	return NULL;
	158
	159	dstctx = OPENSSL_zalloc(sizeof(*srcctx));
	160	if (dstctx == NULL)
	161	return NULL;
	162
	163	dstctx = srcctx;
	164	if (dstctx->key != NULL && !ossl_ecx_key_up_ref(dstctx->key)) {
	165	ERR_raise(ERR_LIB_PROV, ERR_R_INTERNAL_ERROR);
	166	OPENSSL_free(dstctx);
	167	return NULL;
	168	}
	169
	170	if (dstctx->peerkey != NULL && !ossl_ecx_key_up_ref(dstctx->peerkey)) {
	171	ERR_raise(ERR_LIB_PROV, ERR_R_INTERNAL_ERROR);
	172	ossl_ecx_key_free(dstctx->key);
	173	OPENSSL_free(dstctx);
	174	return NULL;
	175	}
	176
	177	return dstctx;
	178	}
	179
	180	static const OSSL_PARAM ecx_gettable_ctx_params(ossl_unused void vctx,
	181	ossl_unused void *provctx)
	182	{
	183	static const OSSL_PARAM known_gettable_ctx_params[] = {
	184	OSSL_FIPS_IND_GETTABLE_CTX_PARAM()
	185	OSSL_PARAM_END
	186	};
	187	return known_gettable_ctx_params;
	188	}
	189
	190	static int ecx_get_ctx_params(ossl_unused void *vctx, OSSL_PARAM params[])
	191	{
	192	#ifdef FIPS_MODULE
	193	int approved = 0;
	194	OSSL_PARAM *p = OSSL_PARAM_locate(params,
	195	OSSL_ALG_PARAM_FIPS_APPROVED_INDICATOR);
	196
	197	if (p != NULL && !OSSL_PARAM_set_int(p, approved))
	198	return 0;
	199	#endif
	200	return 1;
	201	}
	202
	203	const OSSL_DISPATCH ossl_x25519_keyexch_functions[] = {
	204	{ OSSL_FUNC_KEYEXCH_NEWCTX, (void (*)(void))x25519_newctx },
	205	{ OSSL_FUNC_KEYEXCH_INIT, (void (*)(void))x25519_init },
	206	{ OSSL_FUNC_KEYEXCH_DERIVE, (void (*)(void))ecx_derive },
	207	{ OSSL_FUNC_KEYEXCH_SET_PEER, (void (*)(void))ecx_set_peer },
	208	{ OSSL_FUNC_KEYEXCH_FREECTX, (void (*)(void))ecx_freectx },
	209	{ OSSL_FUNC_KEYEXCH_DUPCTX, (void (*)(void))ecx_dupctx },
	210	{ OSSL_FUNC_KEYEXCH_GET_CTX_PARAMS, (void (*)(void))ecx_get_ctx_params },
	211	{ OSSL_FUNC_KEYEXCH_GETTABLE_CTX_PARAMS,
	212	(void (*)(void))ecx_gettable_ctx_params },
	213	OSSL_DISPATCH_END
	214	};
	215
	216	const OSSL_DISPATCH ossl_x448_keyexch_functions[] = {
	217	{ OSSL_FUNC_KEYEXCH_NEWCTX, (void (*)(void))x448_newctx },
	218	{ OSSL_FUNC_KEYEXCH_INIT, (void (*)(void))x448_init },
	219	{ OSSL_FUNC_KEYEXCH_DERIVE, (void (*)(void))ecx_derive },
	220	{ OSSL_FUNC_KEYEXCH_SET_PEER, (void (*)(void))ecx_set_peer },
	221	{ OSSL_FUNC_KEYEXCH_FREECTX, (void (*)(void))ecx_freectx },
	222	{ OSSL_FUNC_KEYEXCH_DUPCTX, (void (*)(void))ecx_dupctx },
	223	{ OSSL_FUNC_KEYEXCH_GET_CTX_PARAMS, (void (*)(void))ecx_get_ctx_params },
	224	{ OSSL_FUNC_KEYEXCH_GETTABLE_CTX_PARAMS,
	225	(void (*)(void))ecx_gettable_ctx_params },
	226	OSSL_DISPATCH_END
	227	};