and HMAC_CTX_get_md.
Use of these low level functions has been informally discouraged for a long
- time. Instead applications should use L<EVP_MAC_new_ctx(3)>,
- L<EVP_MAC_free_ctx(3)>, L<EVP_MAC_init(3)>, L<EVP_MAC_update(3)>
+ time. Instead applications should use L<EVP_MAC_CTX_new(3)>,
+ L<EVP_MAC_CTX_free(3)>, L<EVP_MAC_init(3)>, L<EVP_MAC_update(3)>
and L<EVP_MAC_final(3)>.
*Paul Dale*
CMAC_CTX_copy, CMAC_Init, CMAC_Update, CMAC_Final and CMAC_resume.
Use of these low level functions has been informally discouraged for a long
- time. Instead applications should use L<EVP_MAC_new_ctx(3)>,
- L<EVP_MAC_free_ctx(3)>, L<EVP_MAC_init(3)>, L<EVP_MAC_update(3)>
+ time. Instead applications should use L<EVP_MAC_CTX_new(3)>,
+ L<EVP_MAC_CTX_free(3)>, L<EVP_MAC_init(3)>, L<EVP_MAC_update(3)>
and L<EVP_MAC_final(3)>.
*Paul Dale*
goto end;
}
- ctx = EVP_MAC_new_ctx(mac);
+ ctx = EVP_MAC_CTX_new(mac);
if (ctx == NULL) {
BIO_printf(bio_err, "Unable to create MAC CTX for module check\n");
goto end;
if (params == NULL)
goto end;
- if (!EVP_MAC_set_ctx_params(ctx, params)) {
+ if (!EVP_MAC_CTX_set_params(ctx, params)) {
BIO_printf(bio_err, "MAC parameter error\n");
ERR_print_errors(bio_err);
ok = 0;
goto end;
}
- ctx2 = EVP_MAC_dup_ctx(ctx);
+ ctx2 = EVP_MAC_CTX_dup(ctx);
if (ctx2 == NULL) {
BIO_printf(bio_err, "Unable to create MAC CTX for install indicator\n");
goto end;
BIO_free(module_bio);
sk_OPENSSL_STRING_free(opts);
EVP_MAC_free(mac);
- EVP_MAC_free_ctx(ctx2);
- EVP_MAC_free_ctx(ctx);
+ EVP_MAC_CTX_free(ctx2);
+ EVP_MAC_CTX_free(ctx);
OPENSSL_free(read_buffer);
free_config_and_unload(conf);
return ret;
BIO_printf(bio_err, "HMAC not found\n");
goto end;
}
- ctx = EVP_MAC_new_ctx(hmac);
+ ctx = EVP_MAC_CTX_new(hmac);
if (ctx == NULL) {
BIO_printf(bio_err, "HMAC context allocation failed\n");
goto end;
*p++ = OSSL_PARAM_construct_octet_string(OSSL_MAC_PARAM_KEY, cookie_secret,
COOKIE_SECRET_LENGTH);
*p = OSSL_PARAM_construct_end();
- if (!EVP_MAC_set_ctx_params(ctx, params)) {
+ if (!EVP_MAC_CTX_set_params(ctx, params)) {
BIO_printf(bio_err, "HMAC context parameter setting failed\n");
goto end;
}
goto opthelp;
}
- ctx = EVP_MAC_new_ctx(mac);
+ ctx = EVP_MAC_CTX_new(mac);
if (ctx == NULL)
goto err;
if (params == NULL)
goto err;
- if (!EVP_MAC_set_ctx_params(ctx, params)) {
+ if (!EVP_MAC_CTX_set_params(ctx, params)) {
BIO_printf(bio_err, "MAC parameter error\n");
ERR_print_errors(bio_err);
ok = 0;
sk_OPENSSL_STRING_free(opts);
BIO_free(in);
BIO_free(out);
- EVP_MAC_free_ctx(ctx);
+ EVP_MAC_CTX_free(ctx);
EVP_MAC_free(mac);
return ret;
}
static void cmac_key_free(EVP_PKEY *pkey)
{
EVP_MAC_CTX *cmctx = EVP_PKEY_get0(pkey);
- EVP_MAC *mac = cmctx == NULL ? NULL : EVP_MAC_get_ctx_mac(cmctx);
+ EVP_MAC *mac = cmctx == NULL ? NULL : EVP_MAC_CTX_mac(cmctx);
- EVP_MAC_free_ctx(cmctx);
+ EVP_MAC_CTX_free(cmctx);
EVP_MAC_free(mac);
}
macparams[1] = OSSL_PARAM_construct_octet_string(OSSL_MAC_PARAM_KEY,
basekey, bklen);
if ((mac = EVP_MAC_fetch(NULL, "HMAC", NULL)) == NULL
- || (mctx = EVP_MAC_new_ctx(mac)) == NULL
- || !EVP_MAC_set_ctx_params(mctx, macparams)
+ || (mctx = EVP_MAC_CTX_new(mac)) == NULL
+ || !EVP_MAC_CTX_set_params(mctx, macparams)
|| !EVP_MAC_init(mctx)
|| !EVP_MAC_update(mctx, msg, msglen)
|| !EVP_MAC_final(mctx, mac_res, outlen, EVP_MAX_MD_SIZE))
err:
/* cleanup */
OPENSSL_cleanse(basekey, bklen);
- EVP_MAC_free_ctx(mctx);
+ EVP_MAC_CTX_free(mctx);
EVP_MAC_free(mac);
EVP_MD_CTX_free(ctx);
EVP_F_EVP_KEYEXCH_FROM_DISPATCH:244:evp_keyexch_from_dispatch
EVP_F_EVP_MAC_CTRL:209:EVP_MAC_ctrl
EVP_F_EVP_MAC_CTRL_STR:210:EVP_MAC_ctrl_str
+EVP_F_EVP_MAC_CTX_DUP:211:EVP_MAC_CTX_dup
+EVP_F_EVP_MAC_CTX_NEW:213:EVP_MAC_CTX_new
EVP_F_EVP_MAC_INIT:212:EVP_MAC_init
EVP_F_EVP_MD_BLOCK_SIZE:232:EVP_MD_block_size
EVP_F_EVP_MD_CTX_COPY_EX:110:EVP_MD_CTX_copy_ex
#include "internal/provider.h"
#include "evp_local.h"
-EVP_MAC_CTX *EVP_MAC_new_ctx(EVP_MAC *mac)
+EVP_MAC_CTX *EVP_MAC_CTX_new(EVP_MAC *mac)
{
EVP_MAC_CTX *ctx = OPENSSL_zalloc(sizeof(EVP_MAC_CTX));
if (ctx == NULL
|| (ctx->data = mac->newctx(ossl_provider_ctx(mac->prov))) == NULL
|| !EVP_MAC_up_ref(mac)) {
- EVPerr(0, ERR_R_MALLOC_FAILURE);
+ EVPerr(EVP_F_EVP_MAC_CTX_NEW, ERR_R_MALLOC_FAILURE);
if (ctx != NULL)
mac->freectx(ctx->data);
OPENSSL_free(ctx);
return ctx;
}
-void EVP_MAC_free_ctx(EVP_MAC_CTX *ctx)
+void EVP_MAC_CTX_free(EVP_MAC_CTX *ctx)
{
if (ctx != NULL) {
ctx->meth->freectx(ctx->data);
OPENSSL_free(ctx);
}
-EVP_MAC_CTX *EVP_MAC_dup_ctx(const EVP_MAC_CTX *src)
+EVP_MAC_CTX *EVP_MAC_CTX_dup(const EVP_MAC_CTX *src)
{
EVP_MAC_CTX *dst;
dst = OPENSSL_malloc(sizeof(*dst));
if (dst == NULL) {
- EVPerr(0, ERR_R_MALLOC_FAILURE);
+ EVPerr(EVP_F_EVP_MAC_CTX_DUP, ERR_R_MALLOC_FAILURE);
return NULL;
}
*dst = *src;
if (!EVP_MAC_up_ref(dst->meth)) {
- EVPerr(0, ERR_R_MALLOC_FAILURE);
+ EVPerr(EVP_F_EVP_MAC_CTX_DUP, ERR_R_MALLOC_FAILURE);
OPENSSL_free(dst);
return NULL;
}
dst->data = src->meth->dupctx(src->data);
if (dst->data == NULL) {
- EVP_MAC_free_ctx(dst);
+ EVP_MAC_CTX_free(dst);
return NULL;
}
return dst;
}
-EVP_MAC *EVP_MAC_get_ctx_mac(EVP_MAC_CTX *ctx)
+EVP_MAC *EVP_MAC_CTX_mac(EVP_MAC_CTX *ctx)
{
return ctx->meth;
}
return 1;
}
-int EVP_MAC_get_ctx_params(EVP_MAC_CTX *ctx, OSSL_PARAM params[])
+int EVP_MAC_CTX_get_params(EVP_MAC_CTX *ctx, OSSL_PARAM params[])
{
if (ctx->meth->get_ctx_params != NULL)
return ctx->meth->get_ctx_params(ctx->data, params);
return 1;
}
-int EVP_MAC_set_ctx_params(EVP_MAC_CTX *ctx, const OSSL_PARAM params[])
+int EVP_MAC_CTX_set_params(EVP_MAC_CTX *ctx, const OSSL_PARAM params[])
{
if (ctx->meth->set_ctx_params != NULL)
return ctx->meth->set_ctx_params(ctx->data, params);
prov == NULL ? NULL : ossl_provider_library_context(prov);
EVP_PKEY *ret = EVP_PKEY_new();
EVP_MAC *cmac = EVP_MAC_fetch(libctx, OSSL_MAC_NAME_CMAC, NULL);
- EVP_MAC_CTX *cmctx = cmac != NULL ? EVP_MAC_new_ctx(cmac) : NULL;
+ EVP_MAC_CTX *cmctx = cmac != NULL ? EVP_MAC_CTX_new(cmac) : NULL;
OSSL_PARAM params[4];
size_t paramsn = 0;
(char *)priv, len);
params[paramsn] = OSSL_PARAM_construct_end();
- if (!EVP_MAC_set_ctx_params(cmctx, params)) {
+ if (!EVP_MAC_CTX_set_params(cmctx, params)) {
EVPerr(EVP_F_EVP_PKEY_NEW_CMAC_KEY, EVP_R_KEY_SETUP_FAILED);
goto err;
}
err:
EVP_PKEY_free(ret);
- EVP_MAC_free_ctx(cmctx);
+ EVP_MAC_CTX_free(cmctx);
EVP_MAC_free(cmac);
return NULL;
# else
}
if (mac != NULL) {
- hctx->ctx = EVP_MAC_new_ctx(mac);
+ hctx->ctx = EVP_MAC_CTX_new(mac);
if (hctx->ctx == NULL) {
OPENSSL_free(hctx);
return 0;
EVP_PKEY_CTX_set_data(dst, dctx);
dst->keygen_info_count = 0;
- dctx->ctx = EVP_MAC_dup_ctx(sctx->ctx);
+ dctx->ctx = EVP_MAC_CTX_dup(sctx->ctx);
if (dctx->ctx == NULL)
goto err;
* fetches the MAC method anew in this case. Therefore, its reference
* count must be adjusted here.
*/
- if (!EVP_MAC_up_ref(EVP_MAC_get_ctx_mac(dctx->ctx)))
+ if (!EVP_MAC_up_ref(EVP_MAC_CTX_mac(dctx->ctx)))
goto err;
dctx->type = sctx->type;
MAC_PKEY_CTX *hctx = ctx == NULL ? NULL : EVP_PKEY_CTX_get_data(ctx);
if (hctx != NULL) {
- EVP_MAC *mac = hctx->ctx != NULL ? EVP_MAC_get_ctx_mac(hctx->ctx)
- : NULL;
+ EVP_MAC *mac = hctx->ctx != NULL ? EVP_MAC_CTX_mac(hctx->ctx) : NULL;
switch (hctx->type) {
case MAC_TYPE_RAW:
hctx->raw_data.ktmp.length);
break;
}
- EVP_MAC_free_ctx(hctx->ctx);
+ EVP_MAC_CTX_free(hctx->ctx);
EVP_MAC_free(mac);
OPENSSL_free(hctx);
EVP_PKEY_CTX_set_data(ctx, NULL);
return 0;
}
- cmkey = EVP_MAC_dup_ctx(hctx->ctx);
+ cmkey = EVP_MAC_CTX_dup(hctx->ctx);
if (cmkey == NULL)
return 0;
- if (!EVP_MAC_up_ref(EVP_MAC_get_ctx_mac(hctx->ctx)))
+ if (!EVP_MAC_up_ref(EVP_MAC_CTX_mac(hctx->ctx)))
return 0;
EVP_PKEY_assign(pkey, nid, cmkey);
}
}
if (set_key) {
- if (!EVP_MAC_is_a(EVP_MAC_get_ctx_mac(hctx->ctx),
+ if (!EVP_MAC_is_a(EVP_MAC_CTX_mac(hctx->ctx),
OBJ_nid2sn(EVP_PKEY_id(EVP_PKEY_CTX_get0_pkey(ctx)))))
return 0;
key = EVP_PKEY_get0(EVP_PKEY_CTX_get0_pkey(ctx));
OSSL_PARAM_construct_octet_string(OSSL_MAC_PARAM_KEY,
key->data, key->length);
params[params_n++] = OSSL_PARAM_construct_end();
- rv = EVP_MAC_set_ctx_params(hctx->ctx, params);
+ rv = EVP_MAC_CTX_set_params(hctx->ctx, params);
}
return rv;
}
return 0;
}
- if (!EVP_MAC_set_ctx_params(hctx->ctx, params)
+ if (!EVP_MAC_CTX_set_params(hctx->ctx, params)
|| !EVP_MAC_init(hctx->ctx))
return 0;
}
if (ctx->pkey == NULL)
return 0;
- new_mac_ctx = EVP_MAC_dup_ctx(ctx->pkey->pkey.ptr);
+ new_mac_ctx = EVP_MAC_CTX_dup(ctx->pkey->pkey.ptr);
if (new_mac_ctx == NULL)
return 0;
- EVP_MAC_free_ctx(hctx->ctx);
+ EVP_MAC_CTX_free(hctx->ctx);
hctx->ctx = new_mac_ctx;
}
break;
return 0;
}
- if (!EVP_MAC_set_ctx_params(hctx->ctx, params))
+ if (!EVP_MAC_CTX_set_params(hctx->ctx, params))
return 0;
params[0] =
OSSL_PARAM_construct_size_t(OSSL_MAC_PARAM_SIZE, &verify);
- if (!EVP_MAC_get_ctx_params(hctx->ctx, params))
+ if (!EVP_MAC_CTX_get_params(hctx->ctx, params))
return 0;
/*
return 0;
}
- return EVP_MAC_set_ctx_params(hctx->ctx, params);
+ return EVP_MAC_CTX_set_params(hctx->ctx, params);
}
break;
default:
key->data, key->length);
params[params_n] = OSSL_PARAM_construct_end();
- return EVP_MAC_set_ctx_params(hctx->ctx, params);
+ return EVP_MAC_CTX_set_params(hctx->ctx, params);
}
break;
case MAC_TYPE_MAC:
EVPerr(0, EVP_R_FETCH_FAILED);
return 0;
}
- mac = EVP_MAC_get_ctx_mac(hctx->ctx);
+ mac = EVP_MAC_CTX_mac(hctx->ctx);
/*
* Translation of some control names that are equivalent to a single
return 0;
params[1] = OSSL_PARAM_construct_end();
- ok = EVP_MAC_set_ctx_params(hctx->ctx, params);
+ ok = EVP_MAC_CTX_set_params(hctx->ctx, params);
OPENSSL_free(params[0].data);
return ok;
}
EVP_MAC_CTX *mac_ctx;
int ret = 0;
- mac_ctx = EVP_MAC_dup_ctx(ctx->mac_ctx_init);
+ mac_ctx = EVP_MAC_CTX_dup(ctx->mac_ctx_init);
if (mac_ctx == NULL)
return 0;
ret = 1;
err:
- EVP_MAC_free_ctx(mac_ctx);
+ EVP_MAC_CTX_free(mac_ctx);
return ret;
}
/* TODO(3.0) library context */
|| (ctx->mac =
EVP_MAC_fetch(NULL, OSSL_MAC_NAME_CMAC, NULL)) == NULL
- || (ctx->mac_ctx_init = EVP_MAC_new_ctx(ctx->mac)) == NULL
- || !EVP_MAC_set_ctx_params(ctx->mac_ctx_init, params)
+ || (ctx->mac_ctx_init = EVP_MAC_CTX_new(ctx->mac)) == NULL
+ || !EVP_MAC_CTX_set_params(ctx->mac_ctx_init, params)
|| !EVP_EncryptInit_ex(ctx->cipher_ctx, ctr, NULL, key + klen, NULL)
- || (mac_ctx = EVP_MAC_dup_ctx(ctx->mac_ctx_init)) == NULL
+ || (mac_ctx = EVP_MAC_CTX_dup(ctx->mac_ctx_init)) == NULL
|| !EVP_MAC_update(mac_ctx, zero, sizeof(zero))
|| !EVP_MAC_final(mac_ctx, ctx->d.byte, &out_len,
sizeof(ctx->d.byte))) {
EVP_CIPHER_CTX_free(ctx->cipher_ctx);
- EVP_MAC_free_ctx(ctx->mac_ctx_init);
- EVP_MAC_free_ctx(mac_ctx);
+ EVP_MAC_CTX_free(ctx->mac_ctx_init);
+ EVP_MAC_CTX_free(mac_ctx);
EVP_MAC_free(ctx->mac);
return 0;
}
- EVP_MAC_free_ctx(mac_ctx);
+ EVP_MAC_CTX_free(mac_ctx);
ctx->final_ret = -1;
ctx->crypto_ok = 1;
memcpy(&dest->d, &src->d, sizeof(src->d));
if (!EVP_CIPHER_CTX_copy(dest->cipher_ctx, src->cipher_ctx))
return 0;
- EVP_MAC_free_ctx(dest->mac_ctx_init);
- dest->mac_ctx_init = EVP_MAC_dup_ctx(src->mac_ctx_init);
+ EVP_MAC_CTX_free(dest->mac_ctx_init);
+ dest->mac_ctx_init = EVP_MAC_CTX_dup(src->mac_ctx_init);
if (dest->mac_ctx_init == NULL)
return 0;
return 1;
siv128_dbl(&ctx->d);
- if ((mac_ctx = EVP_MAC_dup_ctx(ctx->mac_ctx_init)) == NULL
+ if ((mac_ctx = EVP_MAC_CTX_dup(ctx->mac_ctx_init)) == NULL
|| !EVP_MAC_update(mac_ctx, aad, len)
|| !EVP_MAC_final(mac_ctx, mac_out.byte, &out_len,
sizeof(mac_out.byte))
|| out_len != SIV_LEN) {
- EVP_MAC_free_ctx(mac_ctx);
+ EVP_MAC_CTX_free(mac_ctx);
return 0;
}
- EVP_MAC_free_ctx(mac_ctx);
+ EVP_MAC_CTX_free(mac_ctx);
siv128_xorblock(&ctx->d, &mac_out);
if (ctx != NULL) {
EVP_CIPHER_CTX_free(ctx->cipher_ctx);
ctx->cipher_ctx = NULL;
- EVP_MAC_free_ctx(ctx->mac_ctx_init);
+ EVP_MAC_CTX_free(ctx->mac_ctx_init);
ctx->mac_ctx_init = NULL;
EVP_MAC_free(ctx->mac);
ctx->mac = NULL;
Passes options to the MAC algorithm.
A comprehensive list of controls can be found in the EVP_MAC implementation
documentation.
-Common parameter names used by EVP_MAC_get_ctx_params() are:
+Common parameter names used by EVP_MAC_CTX_get_params() are:
=over 4
EVP_MAC, EVP_MAC_fetch, EVP_MAC_up_ref, EVP_MAC_free,
EVP_MAC_is_a, EVP_MAC_number, EVP_MAC_names_do_all,
EVP_MAC_provider, EVP_MAC_get_params, EVP_MAC_gettable_params,
-EVP_MAC_CTX, EVP_MAC_new_ctx, EVP_MAC_free_ctx, EVP_MAC_dup_ctx,
-EVP_MAC_get_ctx_mac, EVP_MAC_get_ctx_params, EVP_MAC_set_ctx_params,
+EVP_MAC_CTX, EVP_MAC_CTX_new, EVP_MAC_CTX_free, EVP_MAC_CTX_dup,
+EVP_MAC_CTX_mac, EVP_MAC_CTX_get_params, EVP_MAC_CTX_set_params,
EVP_MAC_size, EVP_MAC_init, EVP_MAC_update, EVP_MAC_final,
EVP_MAC_gettable_ctx_params, EVP_MAC_settable_ctx_params,
EVP_MAC_do_all_provided - EVP MAC routines
const OSSL_PROVIDER *EVP_MAC_provider(const EVP_MAC *mac);
int EVP_MAC_get_params(EVP_MAC *mac, OSSL_PARAM params[]);
- EVP_MAC_CTX *EVP_MAC_new_ctx(EVP_MAC *mac);
- void EVP_MAC_free_ctx(EVP_MAC_CTX *ctx);
- EVP_MAC_CTX *EVP_MAC_dup_ctx(const EVP_MAC_CTX *src);
- EVP_MAC *EVP_MAC_get_ctx_mac(EVP_MAC_CTX *ctx);
- int EVP_MAC_get_ctx_params(EVP_MAC_CTX *ctx, OSSL_PARAM params[]);
- int EVP_MAC_set_ctx_params(EVP_MAC_CTX *ctx, const OSSL_PARAM params[]);
+ EVP_MAC_CTX *EVP_MAC_CTX_new(EVP_MAC *mac);
+ void EVP_MAC_CTX_free(EVP_MAC_CTX *ctx);
+ EVP_MAC_CTX *EVP_MAC_CTX_dup(const EVP_MAC_CTX *src);
+ EVP_MAC *EVP_MAC_CTX_mac(EVP_MAC_CTX *ctx);
+ int EVP_MAC_CTX_get_params(EVP_MAC_CTX *ctx, OSSL_PARAM params[]);
+ int EVP_MAC_CTX_set_params(EVP_MAC_CTX *ctx, const OSSL_PARAM params[]);
size_t EVP_MAC_size(EVP_MAC_CTX *ctx);
int EVP_MAC_init(EVP_MAC_CTX *ctx);
=head2 Context manipulation functions
-EVP_MAC_new_ctx() creates a new context for the MAC type I<mac>.
+EVP_MAC_CTX_new() creates a new context for the MAC type I<mac>.
The created context can then be used with most other functions
described here.
-EVP_MAC_free_ctx() frees the contents of the context, including an
+EVP_MAC_CTX_free() frees the contents of the context, including an
underlying context if there is one, as well as the context itself.
NULL is a valid parameter, for which this function is a no-op.
-EVP_MAC_dup_ctx() duplicates the I<src> context and returns a newly allocated
+EVP_MAC_CTX_dup() duplicates the I<src> context and returns a newly allocated
context.
-EVP_MAC_get_ctx_mac() returns the B<EVP_MAC> associated with the context
+EVP_MAC_CTX_mac() returns the B<EVP_MAC> associated with the context
I<ctx>.
=head2 Computing functions
Note that a parameter that is unknown in the underlying context is
simply ignored.
-EVP_MAC_get_ctx_params() retrieves chosen parameters, given the
+EVP_MAC_CTX_get_params() retrieves chosen parameters, given the
context I<ctx> and its underlying context.
The set of parameters given with I<params> determine exactly what
parameters should be retrieved.
Note that a parameter that is unknown in the underlying context is
simply ignored.
-EVP_MAC_set_ctx_params() passes chosen parameters to the underlying
+EVP_MAC_CTX_set_params() passes chosen parameters to the underlying
context, given a context I<ctx>.
The set of parameters given with I<params> determine exactly what
parameters are passed down.
EVP_MAC_gettable_params(), EVP_MAC_gettable_ctx_params() and
EVP_MAC_settable_ctx_params() get a constant B<OSSL_PARAM> array that
describes the retrievable and settable parameters, i.e. parameters that
-can be used with EVP_MAC_get_params(), EVP_MAC_get_ctx_params()
-and EVP_MAC_set_ctx_params(), respectively.
+can be used with EVP_MAC_get_params(), EVP_MAC_CTX_get_params()
+and EVP_MAC_CTX_set_params(), respectively.
See L<OSSL_PARAM(3)> for the use of B<OSSL_PARAM> as parameter descriptor.
=head2 Information functions
EVP_MAC_provider() returns a pointer to the provider for the MAC, or
NULL on error.
-EVP_MAC_new_ctx() and EVP_MAC_dup_ctx() return a pointer to a newly
+EVP_MAC_CTX_new() and EVP_MAC_CTX_dup() return a pointer to a newly
created EVP_MAC_CTX, or NULL if allocation failed.
-EVP_MAC_free_ctx() returns nothing at all.
+EVP_MAC_CTX_free() returns nothing at all.
-EVP_MAC_get_ctx_params() and EVP_MAC_set_ctx_params() return 1 on
+EVP_MAC_CTX_get_params() and EVP_MAC_CTX_set_params() return 1 on
success, 0 on error.
EVP_MAC_init(), EVP_MAC_update(), and EVP_MAC_final() return 1 on success, 0
if (mac == NULL
|| key == NULL
- || (ctx = EVP_MAC_new_ctx(mac)) == NULL
- || EVP_MAC_set_ctx_params(ctx, params) <= 0)
+ || (ctx = EVP_MAC_CTX_new(mac)) == NULL
+ || EVP_MAC_CTX_set_params(ctx, params) <= 0)
goto err;
if (!EVP_MAC_init(ctx))
printf("%02X", buf[i]);
printf("\n");
- EVP_MAC_free_ctx(ctx);
+ EVP_MAC_CTX_free(ctx);
EVP_MAC_free(mac);
exit(0);
err:
- EVP_MAC_free_ctx(ctx);
+ EVP_MAC_CTX_free(ctx);
EVP_MAC_free(mac);
fprintf(stderr, "Something went wrong\n");
ERR_print_errors_fp(stderr);
=head1 DESCRIPTION
All of the functions described on this page are deprecated. Applications should
-instead use L<EVP_MAC_new_ctx(3)>, L<EVP_MAC_free_ctx(3)>, L<EVP_MAC_init(3)>,
+instead use L<EVP_MAC_CTX_new(3)>, L<EVP_MAC_CTX_free(3)>, L<EVP_MAC_init(3)>,
L<EVP_MAC_update(3)> and L<EVP_MAC_final(3)>.
HMAC is a MAC (message authentication code), i.e. a keyed hash
goto err;
}
params[params_n] = OSSL_PARAM_construct_end();
- if (!EVP_MAC_set_ctx_params(ctx, params))
+ if (!EVP_MAC_CTX_set_params(ctx, params))
goto err;
while (params_n-- > 0)
OPENSSL_free(params[params_n].data);
ticket.
Before the callback function is started I<ctx> and I<hctx> have been
-initialised with L<EVP_CIPHER_CTX_reset(3)> and L<EVP_MAC_new_ctx(3)>
+initialised with L<EVP_CIPHER_CTX_reset(3)> and L<EVP_MAC_CTX_new(3)>
respectively.
For new sessions tickets, when the client doesn't present a session ticket, or
The initialization vector I<iv> should be a random value. The cipher context
I<ctx> should use the initialisation vector I<iv>. The cipher context can be
set using L<EVP_EncryptInit_ex(3)>. The hmac context and digest can be set using
-L<EVP_MAC_set_ctx_params(3)> with the B<OSSL_MAC_PARAM_KEY> and
+L<EVP_MAC_CTX_set_params(3)> with the B<OSSL_MAC_PARAM_KEY> and
B<OSSL_MAC_PARAM_DIGEST> parameters respectively.
When the client presents a session ticket, the callback function with be called
to retrieve a cryptographic parameters and that the cryptographic context
I<ctx> will be set with the retrieved parameters and the initialization vector
I<iv>. using a function like L<EVP_DecryptInit_ex(3)>. The key material and
-digest for I<hctx> need to be set using L<EVP_MAC_set_ctx_params(3)> with the
+digest for I<hctx> need to be set using L<EVP_MAC_CTX_set_params(3)> with the
B<OSSL_MAC_PARAM_KEY> and B<OSSL_MAC_PARAM_DIGEST> parameters respectively.
If the I<name> is still valid but a renewal of the ticket is required the
SSL_CTX_set_tlsext_ticket_key_evp_cb() except that it takes a deprecated
HMAC_CTX pointer instead of an EVP_MAC_CTX one.
Before this callback function is started I<hctx> will have been
-initialised with L<EVP_MAC_new_ctx(3)> and the digest set with
-L<EVP_MAC_set_ctx_params(3)>.
+initialised with L<EVP_MAC_CTX_new(3)> and the digest set with
+L<EVP_MAC_CTX_set_params(3)>.
The I<hctx> key material can be set using L<HMAC_Init_ex(3)>.
=head1 NOTES
params[1] = OSSL_PARAM_construct_utf8_string(OSSL_MAC_PARAM_DIGEST,
"sha256", 0);
params[2] = OSSL_PARAM_construct_end();
- EVP_MAC_set_ctx_params(hctx, params);
+ EVP_MAC_CTX_set_params(hctx, params);
return 1;
params[1] = OSSL_PARAM_construct_utf8_string(OSSL_MAC_PARAM_DIGEST,
"sha256", 0);
params[2] = OSSL_PARAM_construct_end();
- EVP_MAC_set_ctx_params(hctx, params);
+ EVP_MAC_CTX_set_params(hctx, params);
EVP_DecryptInit_ex(&ctx, EVP_aes_256_cbc(), NULL, key->aes_key, iv);
The general description of these parameters can be found in
L<EVP_MAC(3)/PARAMETERS>.
-All these parameters can be set with EVP_MAC_set_ctx_params().
+All these parameters can be set with EVP_MAC_CTX_set_params().
Furthermore, the "size" parameter can be retrieved with
-EVP_MAC_get_ctx_params(), or with EVP_MAC_size().
+EVP_MAC_CTX_get_params(), or with EVP_MAC_size().
The length of the "size" parameter should not exceed that of a B<size_t>.
=over 4
=head1 SEE ALSO
-L<EVP_MAC_get_ctx_params(3)>, L<EVP_MAC_set_ctx_params(3)>,
+L<EVP_MAC_CTX_get_params(3)>, L<EVP_MAC_CTX_set_params(3)>,
L<EVP_MAC(3)/PARAMETERS>, L<OSSL_PARAM(3)>
=head1 HISTORY
The general description of these parameters can be found in
L<EVP_MAC(3)/PARAMETERS>.
-The following parameter can be set with EVP_MAC_set_ctx_params():
+The following parameter can be set with EVP_MAC_CTX_set_params():
=over 4
=back
The following parameters can be retrieved with
-EVP_MAC_get_ctx_params():
+EVP_MAC_CTX_get_params():
=over 4
=head1 SEE ALSO
-L<EVP_MAC_get_ctx_params(3)>, L<EVP_MAC_set_ctx_params(3)>,
+L<EVP_MAC_CTX_get_params(3)>, L<EVP_MAC_CTX_set_params(3)>,
L<EVP_MAC(3)/PARAMETERS>, L<OSSL_PARAM(3)>
=head1 COPYRIGHT
The general description of these parameters can be found in
L<EVP_MAC(3)/PARAMETERS>.
-The following parameter can be set with EVP_MAC_set_ctx_params():
+The following parameter can be set with EVP_MAC_CTX_set_params():
=over 4
=back
The following parameters can be retrieved with
-EVP_MAC_get_ctx_params():
+EVP_MAC_CTX_get_params():
=over 4
=head1 SEE ALSO
-L<EVP_MAC_get_ctx_params(3)>, L<EVP_MAC_set_ctx_params(3)>,
+L<EVP_MAC_CTX_get_params(3)>, L<EVP_MAC_CTX_set_params(3)>,
L<EVP_MAC(3)/PARAMETERS>, L<OSSL_PARAM(3)>
=head1 COPYRIGHT
The general description of these parameters can be found in
L<EVP_MAC(3)/PARAMETERS>.
-The following parameter can be set with EVP_MAC_set_ctx_params():
+The following parameter can be set with EVP_MAC_CTX_set_params():
=over 4
The "flags" parameter is passed directly to HMAC_CTX_set_flags().
The following parameter can be retrieved with
-EVP_MAC_get_ctx_params():
+EVP_MAC_CTX_get_params():
=over 4
=head1 SEE ALSO
-L<EVP_MAC_get_ctx_params(3)>, L<EVP_MAC_set_ctx_params(3)>,
+L<EVP_MAC_CTX_get_params(3)>, L<EVP_MAC_CTX_set_params(3)>,
L<EVP_MAC(3)/PARAMETERS>, L<OSSL_PARAM(3)>, L<HMAC(3)>
=head1 COPYRIGHT
The general description of these parameters can be found in
L<EVP_MAC(3)/PARAMETERS>.
-All these parameters can be set with EVP_MAC_set_ctx_params().
+All these parameters can be set with EVP_MAC_CTX_set_params().
Furthermore, the "size" parameter can be retrieved with
-EVP_MAC_get_ctx_params(), or with EVP_MAC_size().
+EVP_MAC_CTX_get_params(), or with EVP_MAC_size().
The length of the "size" parameter should not exceed that of a B<size_t>.
=over 4
=head1 SEE ALSO
-L<EVP_MAC_get_ctx_params(3)>, L<EVP_MAC_set_ctx_params(3)>,
+L<EVP_MAC_CTX_get_params(3)>, L<EVP_MAC_CTX_set_params(3)>,
L<EVP_MAC(3)/PARAMETERS>, L<OSSL_PARAM(3)>
=head1 COPYRIGHT
The general description of these parameters can be found in
L<EVP_MAC(3)/PARAMETERS>.
-The following parameter can be set with EVP_MAC_set_ctx_params():
+The following parameter can be set with EVP_MAC_CTX_set_params():
=over 4
=back
The following parameters can be retrieved with
-EVP_MAC_get_ctx_params():
+EVP_MAC_CTX_get_params():
=over 4
=head1 SEE ALSO
-L<EVP_MAC_get_ctx_params(3)>, L<EVP_MAC_set_ctx_params(3)>,
+L<EVP_MAC_CTX_get_params(3)>, L<EVP_MAC_CTX_set_params(3)>,
L<EVP_MAC(3)/PARAMETERS>, L<OSSL_PARAM(3)>
=head1 COPYRIGHT
The general description of these parameters can be found in
L<EVP_MAC(3)/PARAMETERS>.
-All these parameters can be set with EVP_MAC_set_ctx_params().
+All these parameters can be set with EVP_MAC_CTX_set_params().
Furthermore, the "size" parameter can be retrieved with
-EVP_MAC_get_ctx_params(), or with EVP_MAC_size().
+EVP_MAC_CTX_get_params(), or with EVP_MAC_size().
The length of the "size" parameter should not exceed that of a B<size_t>.
=over 4
=head1 SEE ALSO
-L<EVP_MAC_get_ctx_params(3)>, L<EVP_MAC_set_ctx_params(3)>,
+L<EVP_MAC_CTX_get_params(3)>, L<EVP_MAC_CTX_set_params(3)>,
L<EVP_MAC(3)/PARAMETERS>, L<OSSL_PARAM(3)>
=head1 COPYRIGHT
# include <openssl/evperr.h>
# include <openssl/params.h>
-# include <openssl/mac.h>
-
# define EVP_MAX_MD_SIZE 64/* longest known is SHA512 */
# define EVP_MAX_KEY_LENGTH 64
# define EVP_MAX_IV_LENGTH 16
void (*fn)(EVP_MD *md, void *arg),
void *arg);
+/* MAC stuff */
+
+EVP_MAC *EVP_MAC_fetch(OPENSSL_CTX *libctx, const char *algorithm,
+ const char *properties);
+int EVP_MAC_up_ref(EVP_MAC *mac);
+void EVP_MAC_free(EVP_MAC *mac);
+int EVP_MAC_number(const EVP_MAC *mac);
+int EVP_MAC_is_a(const EVP_MAC *mac, const char *name);
+const OSSL_PROVIDER *EVP_MAC_provider(const EVP_MAC *mac);
+int EVP_MAC_get_params(EVP_MAC *mac, OSSL_PARAM params[]);
+
+EVP_MAC_CTX *EVP_MAC_CTX_new(EVP_MAC *mac);
+void EVP_MAC_CTX_free(EVP_MAC_CTX *ctx);
+EVP_MAC_CTX *EVP_MAC_CTX_dup(const EVP_MAC_CTX *src);
+EVP_MAC *EVP_MAC_CTX_mac(EVP_MAC_CTX *ctx);
+int EVP_MAC_CTX_get_params(EVP_MAC_CTX *ctx, OSSL_PARAM params[]);
+int EVP_MAC_CTX_set_params(EVP_MAC_CTX *ctx, const OSSL_PARAM params[]);
+
+size_t EVP_MAC_size(EVP_MAC_CTX *ctx);
+int EVP_MAC_init(EVP_MAC_CTX *ctx);
+int EVP_MAC_update(EVP_MAC_CTX *ctx, const unsigned char *data, size_t datalen);
+int EVP_MAC_final(EVP_MAC_CTX *ctx,
+ unsigned char *out, size_t *outl, size_t outsize);
+const OSSL_PARAM *EVP_MAC_gettable_params(const EVP_MAC *mac);
+const OSSL_PARAM *EVP_MAC_gettable_ctx_params(const EVP_MAC *mac);
+const OSSL_PARAM *EVP_MAC_settable_ctx_params(const EVP_MAC *mac);
+
+void EVP_MAC_do_all_provided(OPENSSL_CTX *libctx,
+ void (*fn)(EVP_MAC *mac, void *arg),
+ void *arg);
+void EVP_MAC_names_do_all(const EVP_MAC *mac,
+ void (*fn)(const char *name, void *data),
+ void *data);
+
/* RAND stuff */
EVP_RAND *EVP_RAND_fetch(OPENSSL_CTX *libctx, const char *algorithm,
const char *properties);
+++ /dev/null
-/*
- * Copyright 2019-2020=-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
- */
-
-/* MAC stuff */
-
-#ifndef OPENSSL_EVP_MAC_H
-# define OPENSSL_EVP_MAC_H
-# pragma once
-
-# include <openssl/opensslconf.h>
-# include <openssl/types.h>
-# include <openssl/core.h>
-
-# ifdef __cplusplus
-extern "C" {
-# endif
-
-EVP_MAC *EVP_MAC_fetch(OPENSSL_CTX *libctx, const char *algorithm,
- const char *properties);
-int EVP_MAC_up_ref(EVP_MAC *mac);
-void EVP_MAC_free(EVP_MAC *mac);
-int EVP_MAC_number(const EVP_MAC *mac);
-int EVP_MAC_is_a(const EVP_MAC *mac, const char *name);
-const OSSL_PROVIDER *EVP_MAC_provider(const EVP_MAC *mac);
-int EVP_MAC_get_params(EVP_MAC *mac, OSSL_PARAM params[]);
-
-EVP_MAC_CTX *EVP_MAC_new_ctx(EVP_MAC *mac);
-void EVP_MAC_free_ctx(EVP_MAC_CTX *ctx);
-EVP_MAC_CTX *EVP_MAC_dup_ctx(const EVP_MAC_CTX *src);
-EVP_MAC *EVP_MAC_get_ctx_mac(EVP_MAC_CTX *ctx);
-int EVP_MAC_get_ctx_params(EVP_MAC_CTX *ctx, OSSL_PARAM params[]);
-int EVP_MAC_set_ctx_params(EVP_MAC_CTX *ctx, const OSSL_PARAM params[]);
-
-size_t EVP_MAC_size(EVP_MAC_CTX *ctx);
-int EVP_MAC_init(EVP_MAC_CTX *ctx);
-int EVP_MAC_update(EVP_MAC_CTX *ctx, const unsigned char *data, size_t datalen);
-int EVP_MAC_final(EVP_MAC_CTX *ctx,
- unsigned char *out, size_t *outl, size_t outsize);
-const OSSL_PARAM *EVP_MAC_gettable_params(const EVP_MAC *mac);
-const OSSL_PARAM *EVP_MAC_gettable_ctx_params(const EVP_MAC *mac);
-const OSSL_PARAM *EVP_MAC_settable_ctx_params(const EVP_MAC *mac);
-
-void EVP_MAC_do_all_provided(OPENSSL_CTX *libctx,
- void (*fn)(EVP_MAC *mac, void *arg),
- void *arg);
-void EVP_MAC_names_do_all(const EVP_MAC *mac,
- void (*fn)(const char *name, void *data),
- void *data);
-
-# ifdef __cplusplus
-}
-# endif
-#endif /* OPENSSL_EVP_MAC_H */
if (macname != NULL) {
EVP_MAC *mac = EVP_MAC_fetch(libctx, macname, properties);
- EVP_MAC_free_ctx(*macctx);
- *macctx = mac == NULL ? NULL : EVP_MAC_new_ctx(mac);
+ EVP_MAC_CTX_free(*macctx);
+ *macctx = mac == NULL ? NULL : EVP_MAC_CTX_new(mac);
/* The context holds on to the MAC */
EVP_MAC_free(mac);
if (*macctx == NULL)
#endif
*mp = OSSL_PARAM_construct_end();
- if (EVP_MAC_set_ctx_params(*macctx, mac_params))
+ if (EVP_MAC_CTX_set_params(*macctx, mac_params))
return 1;
- EVP_MAC_free_ctx(*macctx);
+ EVP_MAC_CTX_free(*macctx);
*macctx = NULL;
return 0;
}
OSSL_SELF_TEST_onbegin(ev, event_type, OSSL_SELF_TEST_DESC_INTEGRITY_HMAC);
mac = EVP_MAC_fetch(libctx, MAC_NAME, NULL);
- ctx = EVP_MAC_new_ctx(mac);
+ ctx = EVP_MAC_CTX_new(mac);
if (mac == NULL || ctx == NULL)
goto err;
sizeof(fixed_key));
*p = OSSL_PARAM_construct_end();
- if (EVP_MAC_set_ctx_params(ctx, params) <= 0
+ if (EVP_MAC_CTX_set_params(ctx, params) <= 0
|| !EVP_MAC_init(ctx))
goto err;
ret = 1;
err:
OSSL_SELF_TEST_onend(ev, ret);
- EVP_MAC_free_ctx(ctx);
+ EVP_MAC_CTX_free(ctx);
EVP_MAC_free(mac);
return ret;
}
KBKDF *ctx = (KBKDF *)vctx;
void *provctx = ctx->provctx;
- EVP_MAC_free_ctx(ctx->ctx_init);
+ EVP_MAC_CTX_free(ctx->ctx_init);
OPENSSL_clear_free(ctx->context, ctx->context_len);
OPENSSL_clear_free(ctx->label, ctx->label_len);
OPENSSL_clear_free(ctx->ki, ctx->ki_len);
for (counter = 1; written < ko_len; counter++) {
i = be32(counter);
- ctx = EVP_MAC_dup_ctx(ctx_init);
+ ctx = EVP_MAC_CTX_dup(ctx_init);
if (ctx == NULL)
goto done;
written += h;
k_i_len = h;
- EVP_MAC_free_ctx(ctx);
+ EVP_MAC_CTX_free(ctx);
ctx = NULL;
}
ret = 1;
done:
- EVP_MAC_free_ctx(ctx);
+ EVP_MAC_CTX_free(ctx);
return ret;
}
NULL, NULL, libctx))
return 0;
else if (ctx->ctx_init != NULL
- && !EVP_MAC_is_a(EVP_MAC_get_ctx_mac(ctx->ctx_init),
+ && !EVP_MAC_is_a(EVP_MAC_CTX_mac(ctx->ctx_init),
OSSL_MAC_NAME_HMAC)
- && !EVP_MAC_is_a(EVP_MAC_get_ctx_mac(ctx->ctx_init),
+ && !EVP_MAC_is_a(EVP_MAC_CTX_mac(ctx->ctx_init),
OSSL_MAC_NAME_CMAC)) {
ERR_raise(ERR_LIB_PROV, PROV_R_INVALID_MAC);
return 0;
ctx->ki, ctx->ki_len);
mparams[1] = OSSL_PARAM_construct_end();
- if (!EVP_MAC_set_ctx_params(ctx->ctx_init, mparams)
+ if (!EVP_MAC_CTX_set_params(ctx->ctx_init, mparams)
|| !EVP_MAC_init(ctx->ctx_init))
return 0;
}
(void *)custom, custom_len);
params[1] = OSSL_PARAM_construct_end();
- if (!EVP_MAC_set_ctx_params(ctx, params))
+ if (!EVP_MAC_CTX_set_params(ctx, params))
return 0;
/* By default only do one iteration if kmac_out_len is not specified */
params[0] = OSSL_PARAM_construct_size_t(OSSL_MAC_PARAM_SIZE,
&kmac_out_len);
- if (EVP_MAC_set_ctx_params(ctx, params) <= 0)
+ if (EVP_MAC_CTX_set_params(ctx, params) <= 0)
return 0;
/*
(void *)salt, salt_len);
*p = OSSL_PARAM_construct_end();
- if (!EVP_MAC_set_ctx_params(ctx_init, params))
+ if (!EVP_MAC_CTX_set_params(ctx_init, params))
goto end;
if (!kmac_init(ctx_init, kmac_custom, kmac_custom_len, kmac_out_len,
c[2] = (unsigned char)((counter >> 8) & 0xff);
c[3] = (unsigned char)(counter & 0xff);
- ctx = EVP_MAC_dup_ctx(ctx_init);
+ ctx = EVP_MAC_CTX_dup(ctx_init);
if (!(ctx != NULL
&& EVP_MAC_update(ctx, c, sizeof(c))
&& EVP_MAC_update(ctx, z, z_len)
memcpy(out, mac, len);
break;
}
- EVP_MAC_free_ctx(ctx);
+ EVP_MAC_CTX_free(ctx);
ctx = NULL;
}
ret = 1;
else
OPENSSL_cleanse(mac_buf, sizeof(mac_buf));
- EVP_MAC_free_ctx(ctx);
+ EVP_MAC_CTX_free(ctx);
return ret;
}
KDF_SSKDF *ctx = (KDF_SSKDF *)vctx;
void *provctx = ctx->provctx;
- EVP_MAC_free_ctx(ctx->macctx);
+ EVP_MAC_CTX_free(ctx->macctx);
ossl_prov_digest_reset(&ctx->digest);
OPENSSL_clear_free(ctx->secret, ctx->secret_len);
OPENSSL_clear_free(ctx->info, ctx->info_len);
const unsigned char *custom = NULL;
size_t custom_len = 0;
int default_salt_len;
- EVP_MAC *mac = EVP_MAC_get_ctx_mac(ctx->macctx);
+ EVP_MAC *mac = EVP_MAC_CTX_mac(ctx->macctx);
/*
* TODO(3.0) investigate the necessity to have all these controls.
TLS1_PRF *ctx = (TLS1_PRF *)vctx;
void *provctx = ctx->provctx;
- EVP_MAC_free_ctx(ctx->P_hash);
- EVP_MAC_free_ctx(ctx->P_sha1);
+ EVP_MAC_CTX_free(ctx->P_hash);
+ EVP_MAC_CTX_free(ctx->P_sha1);
OPENSSL_clear_free(ctx->sec, ctx->seclen);
OPENSSL_cleanse(ctx->seed, ctx->seedlen);
memset(ctx, 0, sizeof(*ctx));
NULL, SN_sha1, libctx))
return 0;
} else {
- EVP_MAC_free_ctx(ctx->P_sha1);
+ EVP_MAC_CTX_free(ctx->P_sha1);
if (!ossl_prov_macctx_load_from_params(&ctx->P_hash, params,
OSSL_MAC_NAME_HMAC,
NULL, NULL, libctx))
*p++ = OSSL_PARAM_construct_octet_string(OSSL_MAC_PARAM_KEY,
(void *)sec, sec_len);
*p = OSSL_PARAM_construct_end();
- if (!EVP_MAC_set_ctx_params(ctx_init, params))
+ if (!EVP_MAC_CTX_set_params(ctx_init, params))
goto err;
if (!EVP_MAC_init(ctx_init))
goto err;
if (chunk == 0)
goto err;
/* A(0) = seed */
- ctx_Ai = EVP_MAC_dup_ctx(ctx_init);
+ ctx_Ai = EVP_MAC_CTX_dup(ctx_init);
if (ctx_Ai == NULL)
goto err;
if (seed != NULL && !EVP_MAC_update(ctx_Ai, seed, seed_len))
/* calc: A(i) = HMAC_<hash>(secret, A(i-1)) */
if (!EVP_MAC_final(ctx_Ai, Ai, &Ai_len, sizeof(Ai)))
goto err;
- EVP_MAC_free_ctx(ctx_Ai);
+ EVP_MAC_CTX_free(ctx_Ai);
ctx_Ai = NULL;
/* calc next chunk: HMAC_<hash>(secret, A(i) + seed) */
- ctx = EVP_MAC_dup_ctx(ctx_init);
+ ctx = EVP_MAC_CTX_dup(ctx_init);
if (ctx == NULL)
goto err;
if (!EVP_MAC_update(ctx, Ai, Ai_len))
goto err;
/* save state for calculating next A(i) value */
if (olen > chunk) {
- ctx_Ai = EVP_MAC_dup_ctx(ctx);
+ ctx_Ai = EVP_MAC_CTX_dup(ctx);
if (ctx_Ai == NULL)
goto err;
}
}
if (!EVP_MAC_final(ctx, out, NULL, olen))
goto err;
- EVP_MAC_free_ctx(ctx);
+ EVP_MAC_CTX_free(ctx);
ctx = NULL;
out += chunk;
olen -= chunk;
}
ret = 1;
err:
- EVP_MAC_free_ctx(ctx);
- EVP_MAC_free_ctx(ctx_Ai);
+ EVP_MAC_CTX_free(ctx);
+ EVP_MAC_CTX_free(ctx_Ai);
OPENSSL_cleanse(Ai, sizeof(Ai));
return ret;
}
}
#endif
mac = EVP_MAC_fetch(ctx->libctx, "HMAC", NULL);
- if (mac == NULL || (ret->ctx = EVP_MAC_new_ctx(mac)) == NULL)
+ if (mac == NULL || (ret->ctx = EVP_MAC_CTX_new(mac)) == NULL)
goto err;
EVP_MAC_free(mac);
return ret;
err:
- EVP_MAC_free_ctx(ret->ctx);
+ EVP_MAC_CTX_free(ret->ctx);
EVP_MAC_free(mac);
OPENSSL_free(ret);
return NULL;
void ssl_hmac_free(SSL_HMAC *ctx)
{
if (ctx != NULL) {
- EVP_MAC_free_ctx(ctx->ctx);
+ EVP_MAC_CTX_free(ctx->ctx);
#ifndef OPENSSL_NO_DEPRECATED_3_0
HMAC_CTX_free(ctx->old_ctx);
#endif
*p++ = OSSL_PARAM_construct_utf8_string(OSSL_MAC_PARAM_DIGEST, md, 0);
*p++ = OSSL_PARAM_construct_octet_string(OSSL_KDF_PARAM_KEY, key, len);
*p = OSSL_PARAM_construct_end();
- if (EVP_MAC_set_ctx_params(ctx->ctx, params) && EVP_MAC_init(ctx->ctx))
+ if (EVP_MAC_CTX_set_params(ctx->ctx, params) && EVP_MAC_init(ctx->ctx))
return 1;
}
#ifndef OPENSSL_NO_DEPRECATED_3_0
}
*p++ = OSSL_PARAM_construct_end();
- ctx = EVP_MAC_new_ctx(hmac);
+ ctx = EVP_MAC_CTX_new(hmac);
if (ctx == NULL
- || !EVP_MAC_set_ctx_params(ctx, params)
+ || !EVP_MAC_CTX_set_params(ctx, params)
|| !EVP_MAC_init(ctx)
|| !EVP_MAC_update(ctx, hash, hashlen)
/* outsize as per sizeof(peer_finish_md) */
ret = hashlen;
err:
OPENSSL_cleanse(finsecret, sizeof(finsecret));
- EVP_MAC_free_ctx(ctx);
+ EVP_MAC_CTX_free(ctx);
EVP_MAC_free(hmac);
return ret;
}
/* Append HMAC to data */
hmac = EVP_MAC_fetch(NULL, "HMAC", NULL);
- ctx = EVP_MAC_new_ctx(hmac);
+ ctx = EVP_MAC_CTX_new(hmac);
EVP_MAC_free(hmac);
params[0] = OSSL_PARAM_construct_utf8_string(OSSL_MAC_PARAM_DIGEST,
"SHA1", 0);
params[1] = OSSL_PARAM_construct_octet_string(OSSL_KDF_PARAM_KEY,
mac_key, 20);
params[2] = OSSL_PARAM_construct_end();
- EVP_MAC_set_ctx_params(ctx, params);
+ EVP_MAC_CTX_set_params(ctx, params);
EVP_MAC_init(ctx);
EVP_MAC_update(ctx, epoch, 2);
EVP_MAC_update(ctx, seq, 6);
EVP_MAC_update(ctx, lenbytes, 2); /* Length */
EVP_MAC_update(ctx, enc, len); /* Finally the data itself */
EVP_MAC_final(ctx, enc + len, NULL, SHA_DIGEST_LENGTH);
- EVP_MAC_free_ctx(ctx);
+ EVP_MAC_CTX_free(ctx);
/* Append padding bytes */
len += SHA_DIGEST_LENGTH;
}
params[params_n] = OSSL_PARAM_construct_end();
- if ((ctx = EVP_MAC_new_ctx(expected->mac)) == NULL) {
+ if ((ctx = EVP_MAC_CTX_new(expected->mac)) == NULL) {
t->err = "MAC_CREATE_ERROR";
goto err;
}
- if (!EVP_MAC_set_ctx_params(ctx, params)) {
+ if (!EVP_MAC_CTX_set_params(ctx, params)) {
t->err = "MAC_BAD_PARAMS";
goto err;
}
while (params_n-- > params_n_allocstart) {
OPENSSL_free(params[params_n].data);
}
- EVP_MAC_free_ctx(ctx);
+ EVP_MAC_CTX_free(ctx);
OPENSSL_free(got);
return 1;
}
params[2] = OSSL_PARAM_construct_end();
if (aes128cbc == NULL
|| !EVP_CipherInit_ex(ctx, aes128cbc, NULL, tick_aes_key, iv, enc)
- || !EVP_MAC_set_ctx_params(hctx, params)
+ || !EVP_MAC_CTX_set_params(hctx, params)
|| !EVP_MAC_init(hctx))
ret = -1;
else
EVP_MD_CTX_set_pkey_ctx 4531 3_0_0 EXIST::FUNCTION:
EVP_PKEY_meth_set_digest_custom 4532 3_0_0 EXIST::FUNCTION:
EVP_PKEY_meth_get_digest_custom 4533 3_0_0 EXIST::FUNCTION:
-EVP_MAC_new_ctx ? 3_0_0 EXIST::FUNCTION:
-EVP_MAC_free_ctx ? 3_0_0 EXIST::FUNCTION:
-EVP_MAC_dup_ctx ? 3_0_0 EXIST::FUNCTION:
-EVP_MAC_get_ctx_mac ? 3_0_0 EXIST::FUNCTION:
+EVP_MAC_CTX_new ? 3_0_0 EXIST::FUNCTION:
+EVP_MAC_CTX_free ? 3_0_0 EXIST::FUNCTION:
+EVP_MAC_CTX_dup ? 3_0_0 EXIST::FUNCTION:
+EVP_MAC_CTX_mac ? 3_0_0 EXIST::FUNCTION:
EVP_MAC_size ? 3_0_0 EXIST::FUNCTION:
EVP_MAC_init ? 3_0_0 EXIST::FUNCTION:
EVP_MAC_update ? 3_0_0 EXIST::FUNCTION:
EVP_MD_get_params ? 3_0_0 EXIST::FUNCTION:
EVP_MAC_fetch ? 3_0_0 EXIST::FUNCTION:
EVP_MAC_settable_ctx_params ? 3_0_0 EXIST::FUNCTION:
-EVP_MAC_set_ctx_params ? 3_0_0 EXIST::FUNCTION:
-EVP_MAC_get_ctx_params ? 3_0_0 EXIST::FUNCTION:
+EVP_MAC_CTX_set_params ? 3_0_0 EXIST::FUNCTION:
+EVP_MAC_CTX_get_params ? 3_0_0 EXIST::FUNCTION:
EVP_MAC_gettable_ctx_params ? 3_0_0 EXIST::FUNCTION:
EVP_MAC_free ? 3_0_0 EXIST::FUNCTION:
EVP_MAC_up_ref ? 3_0_0 EXIST::FUNCTION:
projects / thirdparty / openssl.git / commitdiff
