[thirdparty/openssl.git] / providers / implementations / digests / sha3_prov.c

/*
 * Copyright 2019-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 <string.h>
#include <openssl/core_names.h>
#include <openssl/crypto.h>
#include <openssl/evp.h>
#include <openssl/params.h>
#include <openssl/err.h>
#include "internal/sha3.h"
#include "prov/digestcommon.h"
#include "prov/implementations.h"
#include "prov/providercommonerr.h"

/*
 * Forward declaration of any unique methods implemented here. This is not strictly
 * necessary for the compiler, but provides an assurance that the signatures
 * of the functions in the dispatch table are correct.
 */
static OSSL_FUNC_digest_init_fn keccak_init;
static OSSL_FUNC_digest_update_fn keccak_update;
static OSSL_FUNC_digest_final_fn keccak_final;
static OSSL_FUNC_digest_freectx_fn keccak_freectx;
static OSSL_FUNC_digest_dupctx_fn keccak_dupctx;
static OSSL_FUNC_digest_set_ctx_params_fn shake_set_ctx_params;
static OSSL_FUNC_digest_settable_ctx_params_fn shake_settable_ctx_params;
static sha3_absorb_fn generic_sha3_absorb;
static sha3_final_fn generic_sha3_final;

#if defined(OPENSSL_CPUID_OBJ) && defined(__s390__) && defined(KECCAK1600_ASM)
/*
 * IBM S390X support
 */
# include "s390x_arch.h"
# define S390_SHA3 1
# define S390_SHA3_CAPABLE(name) \
    ((OPENSSL_s390xcap_P.kimd[0] & S390X_CAPBIT(S390X_##name)) && \
     (OPENSSL_s390xcap_P.klmd[0] & S390X_CAPBIT(S390X_##name)))

#endif

static int keccak_init(void *vctx)
{
    /* The newctx() handles most of the ctx fixed setup. */
    sha3_reset((KECCAK1600_CTX *)vctx);
    return 1;
}

static int keccak_update(void *vctx, const unsigned char *inp, size_t len)
{
    KECCAK1600_CTX *ctx = vctx;
    const size_t bsz = ctx->block_size;
    size_t num, rem;

    if (len == 0)
        return 1;

    /* Is there anything in the buffer already ? */
    if ((num = ctx->bufsz) != 0) {
        /* Calculate how much space is left in the buffer */
        rem = bsz - num;
        /* If the new input does not fill the buffer then just add it */
        if (len < rem) {
            memcpy(ctx->buf + num, inp, len);
            ctx->bufsz += len;
            return 1;
        }
        /* otherwise fill up the buffer and absorb the buffer */
        memcpy(ctx->buf + num, inp, rem);
        /* Update the input pointer */
        inp += rem;
        len -= rem;
        ctx->meth.absorb(ctx, ctx->buf, bsz);
        ctx->bufsz = 0;
    }
    /* Absorb the input - rem = leftover part of the input < blocksize) */
    rem = ctx->meth.absorb(ctx, inp, len);
    /* Copy the leftover bit of the input into the buffer */
    if (rem) {
        memcpy(ctx->buf, inp + len - rem, rem);
        ctx->bufsz = rem;
    }
    return 1;
}

static int keccak_final(void *vctx, unsigned char *out, size_t *outl,
                        size_t outsz)
{
    int ret = 1;
    KECCAK1600_CTX *ctx = vctx;

    if (outsz > 0)
        ret = ctx->meth.final(out, ctx);

    *outl = ctx->md_size;
    return ret;
}

/*-
 * Generic software version of the absorb() and final().
 */
static size_t generic_sha3_absorb(void *vctx, const void *inp, size_t len)
{
    KECCAK1600_CTX *ctx = vctx;

    return SHA3_absorb(ctx->A, inp, len, ctx->block_size);
}

static int generic_sha3_final(unsigned char *md, void *vctx)
{
    return sha3_final(md, (KECCAK1600_CTX *)vctx);
}

static PROV_SHA3_METHOD sha3_generic_md =
{
    generic_sha3_absorb,
    generic_sha3_final
};

#if defined(S390_SHA3)

static sha3_absorb_fn s390x_sha3_absorb;
static sha3_final_fn s390x_sha3_final;
static sha3_final_fn s390x_shake_final;

/*-
 * The platform specific parts of the absorb() and final() for S390X.
 */
static size_t s390x_sha3_absorb(void *vctx, const void *inp, size_t len)
{
    KECCAK1600_CTX *ctx = vctx;
    size_t rem = len % ctx->block_size;

    s390x_kimd(inp, len - rem, ctx->pad, ctx->A);
    return rem;
}

static int s390x_sha3_final(unsigned char *md, void *vctx)
{
    KECCAK1600_CTX *ctx = vctx;

    s390x_klmd(ctx->buf, ctx->bufsz, NULL, 0, ctx->pad, ctx->A);
    memcpy(md, ctx->A, ctx->md_size);
    return 1;
}

static int s390x_shake_final(unsigned char *md, void *vctx)
{
    KECCAK1600_CTX *ctx = vctx;

    s390x_klmd(ctx->buf, ctx->bufsz, md, ctx->md_size, ctx->pad, ctx->A);
    return 1;
}

static PROV_SHA3_METHOD sha3_s390x_md =
{
    s390x_sha3_absorb,
    s390x_sha3_final
};

static PROV_SHA3_METHOD shake_s390x_md =
{
    s390x_sha3_absorb,
    s390x_shake_final
};

# define SHA3_SET_MD(uname, typ)                                               \
    if (S390_SHA3_CAPABLE(uname)) {                                            \
        ctx->pad = S390X_##uname;                                              \
        ctx->meth = typ##_s390x_md;                                            \
    } else {                                                                   \
        ctx->meth = sha3_generic_md;                                           \
    }
#else
# define SHA3_SET_MD(uname, typ) ctx->meth = sha3_generic_md;
#endif /* S390_SHA3 */

#define SHA3_newctx(typ, uname, name, bitlen, pad)                             \
static OSSL_FUNC_digest_newctx_fn name##_newctx;                               \
static void *name##_newctx(void *provctx)                                      \
{                                                                              \
    KECCAK1600_CTX *ctx = OPENSSL_zalloc(sizeof(*ctx));                        \
                                                                               \
    if (ctx == NULL)                                                           \
        return NULL;                                                           \
    sha3_init(ctx, pad, bitlen);                                               \
    SHA3_SET_MD(uname, typ)                                                    \
    return ctx;                                                                \
}

#define KMAC_newctx(uname, bitlen, pad)                                        \
static OSSL_FUNC_digest_newctx_fn uname##_newctx;                              \
static void *uname##_newctx(void *provctx)                                     \
{                                                                              \
    KECCAK1600_CTX *ctx = OPENSSL_zalloc(sizeof(*ctx));                        \
                                                                               \
    if (ctx == NULL)                                                           \
        return NULL;                                                           \
    keccak_kmac_init(ctx, pad, bitlen);                                        \
    ctx->meth = sha3_generic_md;                                               \
    return ctx;                                                                \
}

#define PROV_FUNC_SHA3_DIGEST_COMMON(name, bitlen, blksize, dgstsize, flags)   \
PROV_FUNC_DIGEST_GET_PARAM(name, blksize, dgstsize, flags)                     \
const OSSL_DISPATCH name##_functions[] = {                                     \
    { OSSL_FUNC_DIGEST_NEWCTX, (void (*)(void))name##_newctx },                \
    { OSSL_FUNC_DIGEST_INIT, (void (*)(void))keccak_init },                    \
    { OSSL_FUNC_DIGEST_UPDATE, (void (*)(void))keccak_update },                \
    { OSSL_FUNC_DIGEST_FINAL, (void (*)(void))keccak_final },                  \
    { OSSL_FUNC_DIGEST_FREECTX, (void (*)(void))keccak_freectx },              \
    { OSSL_FUNC_DIGEST_DUPCTX, (void (*)(void))keccak_dupctx },                \
    PROV_DISPATCH_FUNC_DIGEST_GET_PARAMS(name)

#define PROV_FUNC_SHA3_DIGEST(name, bitlen, blksize, dgstsize, flags)          \
    PROV_FUNC_SHA3_DIGEST_COMMON(name, bitlen, blksize, dgstsize, flags),      \
    PROV_DISPATCH_FUNC_DIGEST_CONSTRUCT_END

#define PROV_FUNC_SHAKE_DIGEST(name, bitlen, blksize, dgstsize, flags)         \
    PROV_FUNC_SHA3_DIGEST_COMMON(name, bitlen, blksize, dgstsize, flags),      \
    { OSSL_FUNC_DIGEST_SET_CTX_PARAMS, (void (*)(void))shake_set_ctx_params }, \
    { OSSL_FUNC_DIGEST_SETTABLE_CTX_PARAMS,                                    \
     (void (*)(void))shake_settable_ctx_params },                              \
    PROV_DISPATCH_FUNC_DIGEST_CONSTRUCT_END

static void keccak_freectx(void *vctx)
{
    KECCAK1600_CTX *ctx = (KECCAK1600_CTX *)vctx;

    OPENSSL_clear_free(ctx,  sizeof(*ctx));
}

static void *keccak_dupctx(void *ctx)
{
    KECCAK1600_CTX *in = (KECCAK1600_CTX *)ctx;
    KECCAK1600_CTX *ret = OPENSSL_malloc(sizeof(*ret));

    if (ret != NULL)
        *ret = *in;
    return ret;
}

static const OSSL_PARAM known_shake_settable_ctx_params[] = {
    {OSSL_DIGEST_PARAM_XOFLEN, OSSL_PARAM_UNSIGNED_INTEGER, NULL, 0, 0},
    OSSL_PARAM_END
};
static const OSSL_PARAM *shake_settable_ctx_params(void)
{
    return known_shake_settable_ctx_params;
}

static int shake_set_ctx_params(void *vctx, const OSSL_PARAM params[])
{
    const OSSL_PARAM *p;
    KECCAK1600_CTX *ctx = (KECCAK1600_CTX *)vctx;

    if (ctx != NULL && params != NULL) {
        p = OSSL_PARAM_locate_const(params, OSSL_DIGEST_PARAM_XOFLEN);
        if (p != NULL && !OSSL_PARAM_get_size_t(p, &ctx->md_size)) {
            ERR_raise(ERR_LIB_PROV, PROV_R_FAILED_TO_GET_PARAMETER);
            return 0;
        }
        return 1;
    }
    return 0; /* Null Parameter */
}

#define IMPLEMENT_SHA3_functions(bitlen)                                       \
    SHA3_newctx(sha3, SHA3_##bitlen, sha3_##bitlen, bitlen, '\x06')            \
    PROV_FUNC_SHA3_DIGEST(sha3_##bitlen, bitlen,                               \
                          SHA3_BLOCKSIZE(bitlen), SHA3_MDSIZE(bitlen),         \
                          EVP_MD_FLAG_DIGALGID_ABSENT)

#define IMPLEMENT_SHAKE_functions(bitlen)                                      \
    SHA3_newctx(shake, SHAKE_##bitlen, shake_##bitlen, bitlen, '\x1f')         \
    PROV_FUNC_SHAKE_DIGEST(shake_##bitlen, bitlen,                             \
                          SHA3_BLOCKSIZE(bitlen), SHA3_MDSIZE(bitlen),         \
                          EVP_MD_FLAG_XOF)
#define IMPLEMENT_KMAC_functions(bitlen)                                       \
    KMAC_newctx(keccak_kmac_##bitlen, bitlen, '\x04')                          \
    PROV_FUNC_SHAKE_DIGEST(keccak_kmac_##bitlen, bitlen,                       \
                           SHA3_BLOCKSIZE(bitlen), KMAC_MDSIZE(bitlen),        \
                           EVP_MD_FLAG_XOF)

/* sha3_224_functions */
IMPLEMENT_SHA3_functions(224)
/* sha3_256_functions */
IMPLEMENT_SHA3_functions(256)
/* sha3_384_functions */
IMPLEMENT_SHA3_functions(384)
/* sha3_512_functions */
IMPLEMENT_SHA3_functions(512)
/* shake_128_functions */
IMPLEMENT_SHAKE_functions(128)
/* shake_256_functions */
IMPLEMENT_SHAKE_functions(256)
/* keccak_kmac_128_functions */
IMPLEMENT_KMAC_functions(128)
/* keccak_kmac_256_functions */
IMPLEMENT_KMAC_functions(256)
Commit	Line	Data
d5e5e2ff	1	/*
33388b44	2	* Copyright 2019-2020 The OpenSSL Project Authors. All Rights Reserved.
d5e5e2ff SL	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
d5e5e2ff	10	#include <string.h>
c85d5e02	11	#include <openssl/core_names.h>
d5e5e2ff SL	12	#include <openssl/crypto.h>
	13	#include <openssl/evp.h>
	14	#include <openssl/params.h>
c85d5e02	15	#include <openssl/err.h>
d5e5e2ff	16	#include "internal/sha3.h"
7c214f10	17	#include "prov/digestcommon.h"
af3e7e1b	18	#include "prov/implementations.h"
ddd21319	19	#include "prov/providercommonerr.h"
d5e5e2ff SL	20
	21	/*
	22	* Forward declaration of any unique methods implemented here. This is not strictly
	23	* necessary for the compiler, but provides an assurance that the signatures
	24	* of the functions in the dispatch table are correct.
	25	*/
363b1e5d DMSP	26	static OSSL_FUNC_digest_init_fn keccak_init;
	27	static OSSL_FUNC_digest_update_fn keccak_update;
	28	static OSSL_FUNC_digest_final_fn keccak_final;
	29	static OSSL_FUNC_digest_freectx_fn keccak_freectx;
	30	static OSSL_FUNC_digest_dupctx_fn keccak_dupctx;
	31	static OSSL_FUNC_digest_set_ctx_params_fn shake_set_ctx_params;
	32	static OSSL_FUNC_digest_settable_ctx_params_fn shake_settable_ctx_params;
d5e5e2ff SL	33	static sha3_absorb_fn generic_sha3_absorb;
	34	static sha3_final_fn generic_sha3_final;
	35
	36	#if defined(OPENSSL_CPUID_OBJ) && defined(__s390__) && defined(KECCAK1600_ASM)
	37	/*
	38	* IBM S390X support
	39	*/
	40	# include "s390x_arch.h"
	41	# define S390_SHA3 1
	42	# define S390_SHA3_CAPABLE(name) \
	43	((OPENSSL_s390xcap_P.kimd[0] & S390X_CAPBIT(S390X_##name)) && \
	44	(OPENSSL_s390xcap_P.klmd[0] & S390X_CAPBIT(S390X_##name)))
	45
	46	#endif
	47
	48	static int keccak_init(void *vctx)
	49	{
	50	/* The newctx() handles most of the ctx fixed setup. */
	51	sha3_reset((KECCAK1600_CTX *)vctx);
	52	return 1;
	53	}
	54
	55	static int keccak_update(void vctx, const unsigned char inp, size_t len)
	56	{
	57	KECCAK1600_CTX *ctx = vctx;
	58	const size_t bsz = ctx->block_size;
	59	size_t num, rem;
	60
	61	if (len == 0)
	62	return 1;
	63
	64	/* Is there anything in the buffer already ? */
	65	if ((num = ctx->bufsz) != 0) {
	66	/* Calculate how much space is left in the buffer */
	67	rem = bsz - num;
	68	/* If the new input does not fill the buffer then just add it */
	69	if (len < rem) {
	70	memcpy(ctx->buf + num, inp, len);
	71	ctx->bufsz += len;
	72	return 1;
	73	}
	74	/* otherwise fill up the buffer and absorb the buffer */
	75	memcpy(ctx->buf + num, inp, rem);
	76	/* Update the input pointer */
	77	inp += rem;
	78	len -= rem;
	79	ctx->meth.absorb(ctx, ctx->buf, bsz);
	80	ctx->bufsz = 0;
	81	}
	82	/* Absorb the input - rem = leftover part of the input < blocksize) */
	83	rem = ctx->meth.absorb(ctx, inp, len);
	84	/* Copy the leftover bit of the input into the buffer */
	85	if (rem) {
	86	memcpy(ctx->buf, inp + len - rem, rem);
	87	ctx->bufsz = rem;
	88	}
	89	return 1;
	90	}
	91
	92	static int keccak_final(void vctx, unsigned char out, size_t *outl,
	93	size_t outsz)
	94	{
a890ef83	95	int ret = 1;
d5e5e2ff SL	96	KECCAK1600_CTX *ctx = vctx;
d5e5e2ff SL	97
a890ef83 PS	98	if (outsz > 0)
	99	ret = ctx->meth.final(out, ctx);
	100
d5e5e2ff SL	101	*outl = ctx->md_size;
	102	return ret;
	103	}
	104
	105	/*-
	106	* Generic software version of the absorb() and final().
	107	*/
	108	static size_t generic_sha3_absorb(void vctx, const void inp, size_t len)
	109	{
	110	KECCAK1600_CTX *ctx = vctx;
	111
	112	return SHA3_absorb(ctx->A, inp, len, ctx->block_size);
	113	}
	114
	115	static int generic_sha3_final(unsigned char md, void vctx)
	116	{
	117	return sha3_final(md, (KECCAK1600_CTX *)vctx);
	118	}
	119
	120	static PROV_SHA3_METHOD sha3_generic_md =
	121	{
	122	generic_sha3_absorb,
	123	generic_sha3_final
	124	};
	125
	126	#if defined(S390_SHA3)
	127
	128	static sha3_absorb_fn s390x_sha3_absorb;
	129	static sha3_final_fn s390x_sha3_final;
	130	static sha3_final_fn s390x_shake_final;
	131
	132	/*-
	133	* The platform specific parts of the absorb() and final() for S390X.
	134	*/
	135	static size_t s390x_sha3_absorb(void vctx, const void inp, size_t len)
	136	{
	137	KECCAK1600_CTX *ctx = vctx;
	138	size_t rem = len % ctx->block_size;
	139
	140	s390x_kimd(inp, len - rem, ctx->pad, ctx->A);
	141	return rem;
	142	}
	143
	144	static int s390x_sha3_final(unsigned char md, void vctx)
	145	{
	146	KECCAK1600_CTX *ctx = vctx;
	147
	148	s390x_klmd(ctx->buf, ctx->bufsz, NULL, 0, ctx->pad, ctx->A);
	149	memcpy(md, ctx->A, ctx->md_size);
be1dc984	150	return 1;
d5e5e2ff SL	151	}
	152
	153	static int s390x_shake_final(unsigned char md, void vctx)
	154	{
	155	KECCAK1600_CTX *ctx = vctx;
	156
	157	s390x_klmd(ctx->buf, ctx->bufsz, md, ctx->md_size, ctx->pad, ctx->A);
	158	return 1;
	159	}
	160
	161	static PROV_SHA3_METHOD sha3_s390x_md =
	162	{
	163	s390x_sha3_absorb,
	164	s390x_sha3_final
	165	};
	166
	167	static PROV_SHA3_METHOD shake_s390x_md =
	168	{
	169	s390x_sha3_absorb,
	170	s390x_shake_final
	171	};
	172
c85d5e02 SL	173	# define SHA3_SET_MD(uname, typ) \
	174	if (S390_SHA3_CAPABLE(uname)) { \
	175	ctx->pad = S390X_##uname; \
	176	ctx->meth = typ##_s390x_md; \
	177	} else { \
	178	ctx->meth = sha3_generic_md; \
d5e5e2ff SL	179	}
	180	#else
	181	# define SHA3_SET_MD(uname, typ) ctx->meth = sha3_generic_md;
	182	#endif /* S390_SHA3 */
	183
c85d5e02	184	#define SHA3_newctx(typ, uname, name, bitlen, pad) \
363b1e5d	185	static OSSL_FUNC_digest_newctx_fn name##_newctx; \
c85d5e02 SL	186	static void name##_newctx(void provctx) \
	187	{ \
	188	KECCAK1600_CTX ctx = OPENSSL_zalloc(sizeof(ctx)); \
	189	\
	190	if (ctx == NULL) \
	191	return NULL; \
	192	sha3_init(ctx, pad, bitlen); \
	193	SHA3_SET_MD(uname, typ) \
	194	return ctx; \
d5e5e2ff SL	195	}
d5e5e2ff SL	196
c85d5e02	197	#define KMAC_newctx(uname, bitlen, pad) \
363b1e5d	198	static OSSL_FUNC_digest_newctx_fn uname##_newctx; \
c85d5e02 SL	199	static void uname##_newctx(void provctx) \
	200	{ \
	201	KECCAK1600_CTX ctx = OPENSSL_zalloc(sizeof(ctx)); \
	202	\
	203	if (ctx == NULL) \
	204	return NULL; \
	205	keccak_kmac_init(ctx, pad, bitlen); \
	206	ctx->meth = sha3_generic_md; \
	207	return ctx; \
d5e5e2ff SL	208	}
d5e5e2ff SL	209
c85d5e02 SL	210	#define PROV_FUNC_SHA3_DIGEST_COMMON(name, bitlen, blksize, dgstsize, flags) \
	211	PROV_FUNC_DIGEST_GET_PARAM(name, blksize, dgstsize, flags) \
	212	const OSSL_DISPATCH name##_functions[] = { \
	213	{ OSSL_FUNC_DIGEST_NEWCTX, (void (*)(void))name##_newctx }, \
	214	{ OSSL_FUNC_DIGEST_INIT, (void (*)(void))keccak_init }, \
	215	{ OSSL_FUNC_DIGEST_UPDATE, (void (*)(void))keccak_update }, \
	216	{ OSSL_FUNC_DIGEST_FINAL, (void (*)(void))keccak_final }, \
	217	{ OSSL_FUNC_DIGEST_FREECTX, (void (*)(void))keccak_freectx }, \
	218	{ OSSL_FUNC_DIGEST_DUPCTX, (void (*)(void))keccak_dupctx }, \
	219	PROV_DISPATCH_FUNC_DIGEST_GET_PARAMS(name)
	220
	221	#define PROV_FUNC_SHA3_DIGEST(name, bitlen, blksize, dgstsize, flags) \
	222	PROV_FUNC_SHA3_DIGEST_COMMON(name, bitlen, blksize, dgstsize, flags), \
	223	PROV_DISPATCH_FUNC_DIGEST_CONSTRUCT_END
	224
	225	#define PROV_FUNC_SHAKE_DIGEST(name, bitlen, blksize, dgstsize, flags) \
	226	PROV_FUNC_SHA3_DIGEST_COMMON(name, bitlen, blksize, dgstsize, flags), \
	227	{ OSSL_FUNC_DIGEST_SET_CTX_PARAMS, (void (*)(void))shake_set_ctx_params }, \
	228	{ OSSL_FUNC_DIGEST_SETTABLE_CTX_PARAMS, \
	229	(void (*)(void))shake_settable_ctx_params }, \
	230	PROV_DISPATCH_FUNC_DIGEST_CONSTRUCT_END
d5e5e2ff SL	231
	232	static void keccak_freectx(void *vctx)
	233	{
	234	KECCAK1600_CTX ctx = (KECCAK1600_CTX )vctx;
	235
	236	OPENSSL_clear_free(ctx, sizeof(*ctx));
	237	}
	238
	239	static void keccak_dupctx(void ctx)
	240	{
	241	KECCAK1600_CTX in = (KECCAK1600_CTX )ctx;
	242	KECCAK1600_CTX ret = OPENSSL_malloc(sizeof(ret));
	243
a89befba P	244	if (ret != NULL)
a89befba P	245	ret = in;
d5e5e2ff SL	246	return ret;
	247	}
	248
ec02412b	249	static const OSSL_PARAM known_shake_settable_ctx_params[] = {
1e55cbc8	250	{OSSL_DIGEST_PARAM_XOFLEN, OSSL_PARAM_UNSIGNED_INTEGER, NULL, 0, 0},
ec02412b RL	251	OSSL_PARAM_END
ec02412b RL	252	};
ec02412b RL	253	static const OSSL_PARAM *shake_settable_ctx_params(void)
	254	{
	255	return known_shake_settable_ctx_params;
	256	}
	257
92d9d0ae	258	static int shake_set_ctx_params(void *vctx, const OSSL_PARAM params[])
d5e5e2ff SL	259	{
	260	const OSSL_PARAM *p;
	261	KECCAK1600_CTX ctx = (KECCAK1600_CTX )vctx;
	262
	263	if (ctx != NULL && params != NULL) {
4e7991b4	264	p = OSSL_PARAM_locate_const(params, OSSL_DIGEST_PARAM_XOFLEN);
c85d5e02 SL	265	if (p != NULL && !OSSL_PARAM_get_size_t(p, &ctx->md_size)) {
c85d5e02 SL	266	ERR_raise(ERR_LIB_PROV, PROV_R_FAILED_TO_GET_PARAMETER);
d5e5e2ff	267	return 0;
c85d5e02	268	}
d5e5e2ff SL	269	return 1;
	270	}
	271	return 0; /* Null Parameter */
	272	}
	273
c85d5e02 SL	274	#define IMPLEMENT_SHA3_functions(bitlen) \
	275	SHA3_newctx(sha3, SHA3_##bitlen, sha3_##bitlen, bitlen, '\x06') \
	276	PROV_FUNC_SHA3_DIGEST(sha3_##bitlen, bitlen, \
	277	SHA3_BLOCKSIZE(bitlen), SHA3_MDSIZE(bitlen), \
	278	EVP_MD_FLAG_DIGALGID_ABSENT)
	279
	280	#define IMPLEMENT_SHAKE_functions(bitlen) \
	281	SHA3_newctx(shake, SHAKE_##bitlen, shake_##bitlen, bitlen, '\x1f') \
	282	PROV_FUNC_SHAKE_DIGEST(shake_##bitlen, bitlen, \
	283	SHA3_BLOCKSIZE(bitlen), SHA3_MDSIZE(bitlen), \
	284	EVP_MD_FLAG_XOF)
	285	#define IMPLEMENT_KMAC_functions(bitlen) \
	286	KMAC_newctx(keccak_kmac_##bitlen, bitlen, '\x04') \
	287	PROV_FUNC_SHAKE_DIGEST(keccak_kmac_##bitlen, bitlen, \
	288	SHA3_BLOCKSIZE(bitlen), KMAC_MDSIZE(bitlen), \
	289	EVP_MD_FLAG_XOF)
	290
	291	/* sha3_224_functions */
	292	IMPLEMENT_SHA3_functions(224)
	293	/* sha3_256_functions */
	294	IMPLEMENT_SHA3_functions(256)
	295	/* sha3_384_functions */
	296	IMPLEMENT_SHA3_functions(384)
	297	/* sha3_512_functions */
	298	IMPLEMENT_SHA3_functions(512)
	299	/* shake_128_functions */
	300	IMPLEMENT_SHAKE_functions(128)
	301	/* shake_256_functions */
	302	IMPLEMENT_SHAKE_functions(256)
	303	/* keccak_kmac_128_functions */
	304	IMPLEMENT_KMAC_functions(128)
	305	/* keccak_kmac_256_functions */
	306	IMPLEMENT_KMAC_functions(256)