#include <openssl/core_names.h>
#include <openssl/params.h>
#include "internal/cryptlib.h"
+#include "internal/numbers.h"
#include "internal/evp_int.h"
-#include "kdf_local.h"
+#include "internal/provider_ctx.h"
+#include "internal/providercommonerr.h"
+#include "internal/provider_algs.h"
-struct evp_kdf_impl_st {
+typedef struct {
+ void *provctx;
EVP_MAC *mac; /* H(x) = HMAC_hash OR H(x) = KMAC */
- const EVP_MD *md; /* H(x) = hash OR when H(x) = HMAC_hash */
+ EVP_MD *md; /* H(x) = hash OR when H(x) = HMAC_hash */
unsigned char *secret;
size_t secret_len;
unsigned char *info;
unsigned char *salt;
size_t salt_len;
size_t out_len; /* optional KMAC parameter */
-};
+} KDF_SSKDF;
#define SSKDF_MAX_INLEN (1<<30)
#define SSKDF_KMAC128_DEFAULT_SALT_SIZE (168 - 4)
/* KMAC uses a Customisation string of 'KDF' */
static const unsigned char kmac_custom_str[] = { 0x4B, 0x44, 0x46 };
+static OSSL_OP_kdf_newctx_fn sskdf_new;
+static OSSL_OP_kdf_freectx_fn sskdf_free;
+static OSSL_OP_kdf_reset_fn sskdf_reset;
+static OSSL_OP_kdf_derive_fn sskdf_derive;
+static OSSL_OP_kdf_derive_fn x963kdf_derive;
+static OSSL_OP_kdf_settable_ctx_params_fn sskdf_settable_ctx_params;
+static OSSL_OP_kdf_set_ctx_params_fn sskdf_set_ctx_params;
+static OSSL_OP_kdf_gettable_ctx_params_fn sskdf_gettable_ctx_params;
+static OSSL_OP_kdf_get_ctx_params_fn sskdf_get_ctx_params;
+
/*
* Refer to https://csrc.nist.gov/publications/detail/sp/800-56c/rev-1/final
* Section 4. One-Step Key Derivation using H(x) = hash(x)
return ret;
}
-static EVP_KDF_IMPL *sskdf_new(void)
+static void *sskdf_new(void *provctx)
{
- EVP_KDF_IMPL *impl;
+ KDF_SSKDF *ctx;
- if ((impl = OPENSSL_zalloc(sizeof(*impl))) == NULL)
- KDFerr(KDF_F_SSKDF_NEW, ERR_R_MALLOC_FAILURE);
- return impl;
+ if ((ctx = OPENSSL_zalloc(sizeof(*ctx))) == NULL)
+ ERR_raise(ERR_LIB_PROV, ERR_R_MALLOC_FAILURE);
+ ctx->provctx = provctx;
+ return ctx;
}
-static void sskdf_reset(EVP_KDF_IMPL *impl)
+static void sskdf_reset(void *vctx)
{
- OPENSSL_clear_free(impl->secret, impl->secret_len);
- OPENSSL_clear_free(impl->info, impl->info_len);
- OPENSSL_clear_free(impl->salt, impl->salt_len);
- EVP_MAC_free(impl->mac);
-#if 0 /* TODO(3.0) When we switch to fetched MDs */
- EVP_MD_meth_free(impl->md);
-#endif
- memset(impl, 0, sizeof(*impl));
-}
+ KDF_SSKDF *ctx = (KDF_SSKDF *)vctx;
-static void sskdf_free(EVP_KDF_IMPL *impl)
-{
- sskdf_reset(impl);
- OPENSSL_free(impl);
+ OPENSSL_clear_free(ctx->secret, ctx->secret_len);
+ OPENSSL_clear_free(ctx->info, ctx->info_len);
+ OPENSSL_clear_free(ctx->salt, ctx->salt_len);
+ EVP_MAC_free(ctx->mac);
+ memset(ctx, 0, sizeof(*ctx));
}
-static int sskdf_set_buffer(va_list args, unsigned char **out, size_t *out_len)
+static void sskdf_free(void *vctx)
{
- const unsigned char *p;
- size_t len;
-
- p = va_arg(args, const unsigned char *);
- len = va_arg(args, size_t);
- if (len == 0 || p == NULL)
- return 1;
+ KDF_SSKDF *ctx = (KDF_SSKDF *)vctx;
- OPENSSL_free(*out);
- *out = OPENSSL_memdup(p, len);
- if (*out == NULL)
- return 0;
-
- *out_len = len;
- return 1;
+ sskdf_reset(ctx);
+ EVP_MD_meth_free(ctx->md);
+ EVP_MAC_free(ctx->mac);
+ OPENSSL_free(ctx);
}
-static int sskdf_ctrl(EVP_KDF_IMPL *impl, int cmd, va_list args)
+static int sskdf_set_buffer(unsigned char **out, size_t *out_len,
+ const OSSL_PARAM *p)
{
- const EVP_MD *md;
-
- switch (cmd) {
- case EVP_KDF_CTRL_SET_KEY:
- return sskdf_set_buffer(args, &impl->secret, &impl->secret_len);
-
- case EVP_KDF_CTRL_SET_SSKDF_INFO:
- return sskdf_set_buffer(args, &impl->info, &impl->info_len);
-
- case EVP_KDF_CTRL_SET_MD:
- md = va_arg(args, const EVP_MD *);
- if (md == NULL)
- return 0;
-
-#if 0 /* TODO(3.0) When we switch to fetched MDs */
- EVP_MD_meth_free(impl->md);
-#endif
- impl->md = md;
- return 1;
-
- case EVP_KDF_CTRL_SET_MAC:
- {
- const char *name;
- EVP_MAC *mac;
-
- name = va_arg(args, const char *);
- if (name == NULL)
- return 0;
-
- EVP_MAC_free(impl->mac);
- impl->mac = NULL;
-
- /*
- * TODO(3.0) add support for OPENSSL_CTX and properties in KDFs
- */
- mac = EVP_MAC_fetch(NULL, name, NULL);
- if (mac == NULL)
- return 0;
-
- impl->mac = mac;
- return 1;
- }
- case EVP_KDF_CTRL_SET_SALT:
- return sskdf_set_buffer(args, &impl->salt, &impl->salt_len);
-
- case EVP_KDF_CTRL_SET_MAC_SIZE:
- impl->out_len = va_arg(args, size_t);
+ if (p->data == NULL || p->data_size == 0)
return 1;
-
- default:
- return -2;
- }
-}
-
-static int sskdf_ctrl_str(EVP_KDF_IMPL *impl, const char *type,
- const char *value)
-{
- if (strcmp(type, "secret") == 0 || strcmp(type, "key") == 0)
- return kdf_str2ctrl(impl, sskdf_ctrl, EVP_KDF_CTRL_SET_KEY,
- value);
-
- if (strcmp(type, "hexsecret") == 0 || strcmp(type, "hexkey") == 0)
- return kdf_hex2ctrl(impl, sskdf_ctrl, EVP_KDF_CTRL_SET_KEY,
- value);
-
- if (strcmp(type, "info") == 0)
- return kdf_str2ctrl(impl, sskdf_ctrl, EVP_KDF_CTRL_SET_SSKDF_INFO,
- value);
-
- if (strcmp(type, "hexinfo") == 0)
- return kdf_hex2ctrl(impl, sskdf_ctrl, EVP_KDF_CTRL_SET_SSKDF_INFO,
- value);
-
- if (strcmp(type, "digest") == 0)
- return kdf_md2ctrl(impl, sskdf_ctrl, EVP_KDF_CTRL_SET_MD, value);
-
- if (strcmp(type, "mac") == 0)
- return kdf_str2ctrl(impl, sskdf_ctrl, EVP_KDF_CTRL_SET_MAC, value);
-
- if (strcmp(type, "salt") == 0)
- return kdf_str2ctrl(impl, sskdf_ctrl, EVP_KDF_CTRL_SET_SALT, value);
-
- if (strcmp(type, "hexsalt") == 0)
- return kdf_hex2ctrl(impl, sskdf_ctrl, EVP_KDF_CTRL_SET_SALT, value);
-
-
- if (strcmp(type, "maclen") == 0) {
- int val = atoi(value);
- if (val < 0) {
- KDFerr(KDF_F_SSKDF_CTRL_STR, KDF_R_VALUE_ERROR);
- return 0;
- }
- return call_ctrl(sskdf_ctrl, impl, EVP_KDF_CTRL_SET_MAC_SIZE,
- (size_t)val);
- }
- return -2;
+ OPENSSL_free(*out);
+ *out = NULL;
+ return OSSL_PARAM_get_octet_string(p, (void **)out, 0, out_len);
}
-static size_t sskdf_size(EVP_KDF_IMPL *impl)
+static size_t sskdf_size(KDF_SSKDF *ctx)
{
int len;
- if (impl->md == NULL) {
- KDFerr(KDF_F_SSKDF_SIZE, KDF_R_MISSING_MESSAGE_DIGEST);
+ if (ctx->md == NULL) {
+ ERR_raise(ERR_LIB_PROV, PROV_R_MISSING_MESSAGE_DIGEST);
return 0;
}
- len = EVP_MD_size(impl->md);
+ len = EVP_MD_size(ctx->md);
return (len <= 0) ? 0 : (size_t)len;
}
-static int sskdf_derive(EVP_KDF_IMPL *impl, unsigned char *key, size_t keylen)
+static int sskdf_derive(void *vctx, unsigned char *key, size_t keylen)
{
- if (impl->secret == NULL) {
- KDFerr(KDF_F_SSKDF_DERIVE, KDF_R_MISSING_SECRET);
+ KDF_SSKDF *ctx = (KDF_SSKDF *)vctx;
+
+ if (ctx->secret == NULL) {
+ ERR_raise(ERR_LIB_PROV, PROV_R_MISSING_SECRET);
return 0;
}
- if (impl->mac != NULL) {
+ if (ctx->mac != NULL) {
/* H(x) = KMAC or H(x) = HMAC */
int ret;
const unsigned char *custom = NULL;
* Why does KMAC require a salt length that's shorter than the MD
* block size?
*/
- macname = EVP_MAC_name(impl->mac);
+ macname = EVP_MAC_name(ctx->mac);
if (strcmp(macname, OSSL_MAC_NAME_HMAC) == 0) {
/* H(x) = HMAC(x, salt, hash) */
- if (impl->md == NULL) {
- KDFerr(KDF_F_SSKDF_DERIVE, KDF_R_MISSING_MESSAGE_DIGEST);
+ if (ctx->md == NULL) {
+ ERR_raise(ERR_LIB_PROV, PROV_R_MISSING_MESSAGE_DIGEST);
return 0;
}
- default_salt_len = EVP_MD_block_size(impl->md);
+ default_salt_len = EVP_MD_block_size(ctx->md);
if (default_salt_len <= 0)
return 0;
} else if (strcmp(macname, OSSL_MAC_NAME_KMAC128) == 0
else
default_salt_len = SSKDF_KMAC256_DEFAULT_SALT_SIZE;
} else {
- KDFerr(KDF_F_SSKDF_DERIVE, KDF_R_UNSUPPORTED_MAC_TYPE);
+ ERR_raise(ERR_LIB_PROV, PROV_R_UNSUPPORTED_MAC_TYPE);
return 0;
}
/* If no salt is set then use a default_salt of zeros */
- if (impl->salt == NULL || impl->salt_len <= 0) {
- impl->salt = OPENSSL_zalloc(default_salt_len);
- if (impl->salt == NULL) {
- KDFerr(KDF_F_SSKDF_DERIVE, ERR_R_MALLOC_FAILURE);
+ if (ctx->salt == NULL || ctx->salt_len <= 0) {
+ ctx->salt = OPENSSL_zalloc(default_salt_len);
+ if (ctx->salt == NULL) {
+ ERR_raise(ERR_LIB_PROV, ERR_R_MALLOC_FAILURE);
return 0;
}
- impl->salt_len = default_salt_len;
+ ctx->salt_len = default_salt_len;
}
- ret = SSKDF_mac_kdm(impl->mac, impl->md,
- custom, custom_len, impl->out_len,
- impl->salt, impl->salt_len,
- impl->secret, impl->secret_len,
- impl->info, impl->info_len, key, keylen);
+ ret = SSKDF_mac_kdm(ctx->mac, ctx->md,
+ custom, custom_len, ctx->out_len,
+ ctx->salt, ctx->salt_len,
+ ctx->secret, ctx->secret_len,
+ ctx->info, ctx->info_len, key, keylen);
return ret;
} else {
/* H(x) = hash */
- if (impl->md == NULL) {
- KDFerr(KDF_F_SSKDF_DERIVE, KDF_R_MISSING_MESSAGE_DIGEST);
+ if (ctx->md == NULL) {
+ ERR_raise(ERR_LIB_PROV, PROV_R_MISSING_MESSAGE_DIGEST);
return 0;
}
- return SSKDF_hash_kdm(impl->md, impl->secret, impl->secret_len,
- impl->info, impl->info_len, 0, key, keylen);
+ return SSKDF_hash_kdm(ctx->md, ctx->secret, ctx->secret_len,
+ ctx->info, ctx->info_len, 0, key, keylen);
}
}
-static int x963kdf_derive(EVP_KDF_IMPL *impl, unsigned char *key, size_t keylen)
+static int x963kdf_derive(void *vctx, unsigned char *key, size_t keylen)
{
- if (impl->secret == NULL) {
- KDFerr(KDF_F_X963KDF_DERIVE, KDF_R_MISSING_SECRET);
+ KDF_SSKDF *ctx = (KDF_SSKDF *)vctx;
+
+ if (ctx->secret == NULL) {
+ ERR_raise(ERR_LIB_PROV, PROV_R_MISSING_SECRET);
return 0;
}
- if (impl->mac != NULL) {
- KDFerr(KDF_F_X963KDF_DERIVE, KDF_R_NOT_SUPPORTED);
+ if (ctx->mac != NULL) {
+ ERR_raise(ERR_LIB_PROV, PROV_R_NOT_SUPPORTED);
return 0;
} else {
/* H(x) = hash */
- if (impl->md == NULL) {
- KDFerr(KDF_F_X963KDF_DERIVE, KDF_R_MISSING_MESSAGE_DIGEST);
+ if (ctx->md == NULL) {
+ ERR_raise(ERR_LIB_PROV, PROV_R_MISSING_MESSAGE_DIGEST);
+ return 0;
+ }
+ return SSKDF_hash_kdm(ctx->md, ctx->secret, ctx->secret_len,
+ ctx->info, ctx->info_len, 1, key, keylen);
+ }
+}
+
+static int sskdf_set_ctx_params(void *vctx, const OSSL_PARAM params[])
+{
+ const OSSL_PARAM *p;
+ KDF_SSKDF *ctx = vctx;
+ EVP_MD *md;
+ EVP_MAC *mac;
+ size_t sz;
+ const char *properties = NULL;
+
+ /* Grab search properties, should be before the digest and mac lookups */
+ if ((p = OSSL_PARAM_locate_const(params, OSSL_KDF_PARAM_PROPERTIES))
+ != NULL) {
+ if (p->data_type != OSSL_PARAM_UTF8_STRING)
+ return 0;
+ properties = p->data;
+ }
+ /* Handle aliasing of digest parameter names */
+ if ((p = OSSL_PARAM_locate_const(params, OSSL_KDF_PARAM_DIGEST)) != NULL) {
+ if (p->data_type != OSSL_PARAM_UTF8_STRING)
+ return 0;
+ md = EVP_MD_fetch(PROV_LIBRARY_CONTEXT_OF(ctx->provctx), p->data,
+ properties);
+ if (md == NULL) {
+ ERR_raise(ERR_LIB_PROV, PROV_R_INVALID_DIGEST);
return 0;
}
- return SSKDF_hash_kdm(impl->md, impl->secret, impl->secret_len,
- impl->info, impl->info_len, 1, key, keylen);
+ EVP_MD_meth_free(ctx->md);
+ ctx->md = md;
+ }
+
+ if ((p = OSSL_PARAM_locate_const(params, OSSL_KDF_PARAM_MAC)) != NULL) {
+ EVP_MAC_free(ctx->mac);
+ ctx->mac = NULL;
+
+ mac = EVP_MAC_fetch(PROV_LIBRARY_CONTEXT_OF(ctx->provctx), p->data,
+ properties);
+ if (mac == NULL)
+ return 0;
+ EVP_MAC_free(ctx->mac);
+ ctx->mac = mac;
+ }
+
+ if ((p = OSSL_PARAM_locate_const(params, OSSL_KDF_PARAM_SECRET)) != NULL
+ || (p = OSSL_PARAM_locate_const(params, OSSL_KDF_PARAM_KEY)) != NULL)
+ if (!sskdf_set_buffer(&ctx->secret, &ctx->secret_len, p))
+ return 0;
+
+ if ((p = OSSL_PARAM_locate_const(params, OSSL_KDF_PARAM_INFO)) != NULL)
+ if (!sskdf_set_buffer(&ctx->info, &ctx->info_len, p))
+ return 0;
+
+ if ((p = OSSL_PARAM_locate_const(params, OSSL_KDF_PARAM_SALT)) != NULL)
+ if (!sskdf_set_buffer(&ctx->salt, &ctx->salt_len, p))
+ return 0;
+
+ if ((p = OSSL_PARAM_locate_const(params, OSSL_KDF_PARAM_MAC_SIZE))
+ != NULL) {
+ if (!OSSL_PARAM_get_size_t(p, &sz) || sz == 0)
+ return 0;
+ ctx->out_len = sz;
}
+ return 1;
+}
+
+static const OSSL_PARAM *sskdf_settable_ctx_params(void)
+{
+ static const OSSL_PARAM known_settable_ctx_params[] = {
+ OSSL_PARAM_octet_string(OSSL_KDF_PARAM_SECRET, NULL, 0),
+ OSSL_PARAM_octet_string(OSSL_KDF_PARAM_KEY, NULL, 0),
+ OSSL_PARAM_octet_string(OSSL_KDF_PARAM_INFO, NULL, 0),
+ OSSL_PARAM_utf8_string(OSSL_KDF_PARAM_PROPERTIES, NULL, 0),
+ OSSL_PARAM_utf8_string(OSSL_KDF_PARAM_DIGEST, NULL, 0),
+ OSSL_PARAM_utf8_string(OSSL_KDF_PARAM_MAC, NULL, 0),
+ OSSL_PARAM_octet_string(OSSL_KDF_PARAM_SALT, NULL, 0),
+ OSSL_PARAM_size_t(OSSL_KDF_PARAM_MAC_SIZE, NULL),
+ OSSL_PARAM_END
+ };
+ return known_settable_ctx_params;
+}
+
+static int sskdf_get_ctx_params(void *vctx, OSSL_PARAM params[])
+{
+ KDF_SSKDF *ctx = (KDF_SSKDF *)vctx;
+ OSSL_PARAM *p;
+
+ if ((p = OSSL_PARAM_locate(params, OSSL_KDF_PARAM_SIZE)) != NULL)
+ return OSSL_PARAM_set_size_t(p, sskdf_size(ctx));
+ return -2;
+}
+
+static const OSSL_PARAM *sskdf_gettable_ctx_params(void)
+{
+ static const OSSL_PARAM known_gettable_ctx_params[] = {
+ OSSL_PARAM_size_t(OSSL_KDF_PARAM_SIZE, NULL),
+ OSSL_PARAM_END
+ };
+ return known_gettable_ctx_params;
}
-const EVP_KDF ss_kdf_meth = {
- EVP_KDF_SS,
- sskdf_new,
- sskdf_free,
- sskdf_reset,
- sskdf_ctrl,
- sskdf_ctrl_str,
- sskdf_size,
- sskdf_derive
+const OSSL_DISPATCH kdf_sskdf_functions[] = {
+ { OSSL_FUNC_KDF_NEWCTX, (void(*)(void))sskdf_new },
+ { OSSL_FUNC_KDF_FREECTX, (void(*)(void))sskdf_free },
+ { OSSL_FUNC_KDF_RESET, (void(*)(void))sskdf_reset },
+ { OSSL_FUNC_KDF_DERIVE, (void(*)(void))sskdf_derive },
+ { OSSL_FUNC_KDF_SETTABLE_CTX_PARAMS,
+ (void(*)(void))sskdf_settable_ctx_params },
+ { OSSL_FUNC_KDF_SET_CTX_PARAMS, (void(*)(void))sskdf_set_ctx_params },
+ { OSSL_FUNC_KDF_GETTABLE_CTX_PARAMS,
+ (void(*)(void))sskdf_gettable_ctx_params },
+ { OSSL_FUNC_KDF_GET_CTX_PARAMS, (void(*)(void))sskdf_get_ctx_params },
+ { 0, NULL }
};
-const EVP_KDF x963_kdf_meth = {
- EVP_KDF_X963,
- sskdf_new,
- sskdf_free,
- sskdf_reset,
- sskdf_ctrl,
- sskdf_ctrl_str,
- sskdf_size,
- x963kdf_derive
+const OSSL_DISPATCH kdf_x963_kdf_functions[] = {
+ { OSSL_FUNC_KDF_NEWCTX, (void(*)(void))sskdf_new },
+ { OSSL_FUNC_KDF_FREECTX, (void(*)(void))sskdf_free },
+ { OSSL_FUNC_KDF_RESET, (void(*)(void))sskdf_reset },
+ { OSSL_FUNC_KDF_DERIVE, (void(*)(void))x963kdf_derive },
+ { OSSL_FUNC_KDF_SETTABLE_CTX_PARAMS,
+ (void(*)(void))sskdf_settable_ctx_params },
+ { OSSL_FUNC_KDF_SET_CTX_PARAMS, (void(*)(void))sskdf_set_ctx_params },
+ { OSSL_FUNC_KDF_GETTABLE_CTX_PARAMS,
+ (void(*)(void))sskdf_gettable_ctx_params },
+ { OSSL_FUNC_KDF_GET_CTX_PARAMS, (void(*)(void))sskdf_get_ctx_params },
+ { 0, NULL }
};
projects / openssl.git / blobdiff