]>
Commit | Line | Data |
---|---|---|
d5e5e2ff | 1 | /* |
da1c088f | 2 | * Copyright 2019-2023 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> |
2741128e | 16 | #include <openssl/proverr.h> |
d5e5e2ff | 17 | #include "internal/sha3.h" |
7c214f10 | 18 | #include "prov/digestcommon.h" |
af3e7e1b | 19 | #include "prov/implementations.h" |
d5e5e2ff | 20 | |
af53092c SL |
21 | #define SHA3_FLAGS PROV_DIGEST_FLAG_ALGID_ABSENT |
22 | #define SHAKE_FLAGS PROV_DIGEST_FLAG_XOF | |
23 | #define KMAC_FLAGS PROV_DIGEST_FLAG_XOF | |
24 | ||
d5e5e2ff SL |
25 | /* |
26 | * Forward declaration of any unique methods implemented here. This is not strictly | |
27 | * necessary for the compiler, but provides an assurance that the signatures | |
28 | * of the functions in the dispatch table are correct. | |
29 | */ | |
363b1e5d | 30 | static OSSL_FUNC_digest_init_fn keccak_init; |
d7ec1dda | 31 | static OSSL_FUNC_digest_init_fn keccak_init_params; |
363b1e5d DMSP |
32 | static OSSL_FUNC_digest_update_fn keccak_update; |
33 | static OSSL_FUNC_digest_final_fn keccak_final; | |
34 | static OSSL_FUNC_digest_freectx_fn keccak_freectx; | |
35 | static OSSL_FUNC_digest_dupctx_fn keccak_dupctx; | |
36 | static OSSL_FUNC_digest_set_ctx_params_fn shake_set_ctx_params; | |
37 | static OSSL_FUNC_digest_settable_ctx_params_fn shake_settable_ctx_params; | |
d5e5e2ff SL |
38 | static sha3_absorb_fn generic_sha3_absorb; |
39 | static sha3_final_fn generic_sha3_final; | |
40 | ||
41 | #if defined(OPENSSL_CPUID_OBJ) && defined(__s390__) && defined(KECCAK1600_ASM) | |
42 | /* | |
43 | * IBM S390X support | |
44 | */ | |
45 | # include "s390x_arch.h" | |
46 | # define S390_SHA3 1 | |
47 | # define S390_SHA3_CAPABLE(name) \ | |
48 | ((OPENSSL_s390xcap_P.kimd[0] & S390X_CAPBIT(S390X_##name)) && \ | |
49 | (OPENSSL_s390xcap_P.klmd[0] & S390X_CAPBIT(S390X_##name))) | |
50 | ||
51 | #endif | |
52 | ||
d7ec1dda | 53 | static int keccak_init(void *vctx, ossl_unused const OSSL_PARAM params[]) |
d5e5e2ff | 54 | { |
1c1daab9 P |
55 | if (!ossl_prov_is_running()) |
56 | return 0; | |
d5e5e2ff | 57 | /* The newctx() handles most of the ctx fixed setup. */ |
b68a947f | 58 | ossl_sha3_reset((KECCAK1600_CTX *)vctx); |
d5e5e2ff SL |
59 | return 1; |
60 | } | |
61 | ||
d7ec1dda P |
62 | static int keccak_init_params(void *vctx, const OSSL_PARAM params[]) |
63 | { | |
64 | return keccak_init(vctx, NULL) | |
65 | && shake_set_ctx_params(vctx, params); | |
66 | } | |
67 | ||
d5e5e2ff SL |
68 | static int keccak_update(void *vctx, const unsigned char *inp, size_t len) |
69 | { | |
70 | KECCAK1600_CTX *ctx = vctx; | |
71 | const size_t bsz = ctx->block_size; | |
72 | size_t num, rem; | |
73 | ||
74 | if (len == 0) | |
75 | return 1; | |
76 | ||
77 | /* Is there anything in the buffer already ? */ | |
78 | if ((num = ctx->bufsz) != 0) { | |
79 | /* Calculate how much space is left in the buffer */ | |
80 | rem = bsz - num; | |
81 | /* If the new input does not fill the buffer then just add it */ | |
82 | if (len < rem) { | |
83 | memcpy(ctx->buf + num, inp, len); | |
84 | ctx->bufsz += len; | |
85 | return 1; | |
86 | } | |
87 | /* otherwise fill up the buffer and absorb the buffer */ | |
88 | memcpy(ctx->buf + num, inp, rem); | |
89 | /* Update the input pointer */ | |
90 | inp += rem; | |
91 | len -= rem; | |
92 | ctx->meth.absorb(ctx, ctx->buf, bsz); | |
93 | ctx->bufsz = 0; | |
94 | } | |
95 | /* Absorb the input - rem = leftover part of the input < blocksize) */ | |
96 | rem = ctx->meth.absorb(ctx, inp, len); | |
97 | /* Copy the leftover bit of the input into the buffer */ | |
98 | if (rem) { | |
99 | memcpy(ctx->buf, inp + len - rem, rem); | |
100 | ctx->bufsz = rem; | |
101 | } | |
102 | return 1; | |
103 | } | |
104 | ||
105 | static int keccak_final(void *vctx, unsigned char *out, size_t *outl, | |
106 | size_t outsz) | |
107 | { | |
a890ef83 | 108 | int ret = 1; |
d5e5e2ff SL |
109 | KECCAK1600_CTX *ctx = vctx; |
110 | ||
1c1daab9 P |
111 | if (!ossl_prov_is_running()) |
112 | return 0; | |
a890ef83 PS |
113 | if (outsz > 0) |
114 | ret = ctx->meth.final(out, ctx); | |
115 | ||
d5e5e2ff SL |
116 | *outl = ctx->md_size; |
117 | return ret; | |
118 | } | |
119 | ||
120 | /*- | |
121 | * Generic software version of the absorb() and final(). | |
122 | */ | |
123 | static size_t generic_sha3_absorb(void *vctx, const void *inp, size_t len) | |
124 | { | |
125 | KECCAK1600_CTX *ctx = vctx; | |
126 | ||
127 | return SHA3_absorb(ctx->A, inp, len, ctx->block_size); | |
128 | } | |
129 | ||
130 | static int generic_sha3_final(unsigned char *md, void *vctx) | |
131 | { | |
b68a947f | 132 | return ossl_sha3_final(md, (KECCAK1600_CTX *)vctx); |
d5e5e2ff SL |
133 | } |
134 | ||
135 | static PROV_SHA3_METHOD sha3_generic_md = | |
136 | { | |
137 | generic_sha3_absorb, | |
138 | generic_sha3_final | |
139 | }; | |
140 | ||
141 | #if defined(S390_SHA3) | |
142 | ||
143 | static sha3_absorb_fn s390x_sha3_absorb; | |
144 | static sha3_final_fn s390x_sha3_final; | |
145 | static sha3_final_fn s390x_shake_final; | |
146 | ||
147 | /*- | |
148 | * The platform specific parts of the absorb() and final() for S390X. | |
149 | */ | |
150 | static size_t s390x_sha3_absorb(void *vctx, const void *inp, size_t len) | |
151 | { | |
152 | KECCAK1600_CTX *ctx = vctx; | |
153 | size_t rem = len % ctx->block_size; | |
154 | ||
155 | s390x_kimd(inp, len - rem, ctx->pad, ctx->A); | |
156 | return rem; | |
157 | } | |
158 | ||
159 | static int s390x_sha3_final(unsigned char *md, void *vctx) | |
160 | { | |
161 | KECCAK1600_CTX *ctx = vctx; | |
162 | ||
1c1daab9 P |
163 | if (!ossl_prov_is_running()) |
164 | return 0; | |
d5e5e2ff SL |
165 | s390x_klmd(ctx->buf, ctx->bufsz, NULL, 0, ctx->pad, ctx->A); |
166 | memcpy(md, ctx->A, ctx->md_size); | |
be1dc984 | 167 | return 1; |
d5e5e2ff SL |
168 | } |
169 | ||
170 | static int s390x_shake_final(unsigned char *md, void *vctx) | |
171 | { | |
172 | KECCAK1600_CTX *ctx = vctx; | |
173 | ||
1c1daab9 P |
174 | if (!ossl_prov_is_running()) |
175 | return 0; | |
d5e5e2ff SL |
176 | s390x_klmd(ctx->buf, ctx->bufsz, md, ctx->md_size, ctx->pad, ctx->A); |
177 | return 1; | |
178 | } | |
179 | ||
affc070a JC |
180 | static int s390x_keccakc_final(unsigned char *md, void *vctx, int padding) |
181 | { | |
086d88a6 JC |
182 | KECCAK1600_CTX *ctx = vctx; |
183 | size_t bsz = ctx->block_size; | |
184 | size_t num = ctx->bufsz; | |
76aa4f3a | 185 | size_t needed = ctx->md_size; |
086d88a6 JC |
186 | |
187 | if (!ossl_prov_is_running()) | |
188 | return 0; | |
189 | if (ctx->md_size == 0) | |
190 | return 1; | |
191 | memset(ctx->buf + num, 0, bsz - num); | |
affc070a | 192 | ctx->buf[num] = padding; |
086d88a6 JC |
193 | ctx->buf[bsz - 1] |= 0x80; |
194 | s390x_kimd(ctx->buf, bsz, ctx->pad, ctx->A); | |
de136993 JC |
195 | num = needed > bsz ? bsz : needed; |
196 | memcpy(md, ctx->A, num); | |
197 | needed -= num; | |
198 | if (needed > 0) | |
199 | s390x_klmd(NULL, 0, md + bsz, needed, ctx->pad | S390X_KLMD_PS, ctx->A); | |
76aa4f3a | 200 | |
086d88a6 JC |
201 | return 1; |
202 | } | |
203 | ||
affc070a JC |
204 | static int s390x_keccak_final(unsigned char *md, void *vctx) |
205 | { | |
206 | return s390x_keccakc_final(md, vctx, 0x01); | |
207 | } | |
208 | ||
209 | static int s390x_kmac_final(unsigned char *md, void *vctx) | |
210 | { | |
211 | return s390x_keccakc_final(md, vctx, 0x04); | |
212 | } | |
213 | ||
d5e5e2ff SL |
214 | static PROV_SHA3_METHOD sha3_s390x_md = |
215 | { | |
216 | s390x_sha3_absorb, | |
217 | s390x_sha3_final | |
218 | }; | |
219 | ||
524f1261 UM |
220 | static PROV_SHA3_METHOD keccak_s390x_md = |
221 | { | |
222 | s390x_sha3_absorb, | |
086d88a6 | 223 | s390x_keccak_final |
524f1261 UM |
224 | }; |
225 | ||
d5e5e2ff SL |
226 | static PROV_SHA3_METHOD shake_s390x_md = |
227 | { | |
228 | s390x_sha3_absorb, | |
229 | s390x_shake_final | |
230 | }; | |
231 | ||
affc070a JC |
232 | static PROV_SHA3_METHOD kmac_s390x_md = |
233 | { | |
234 | s390x_sha3_absorb, | |
235 | s390x_kmac_final | |
236 | }; | |
237 | ||
c85d5e02 SL |
238 | # define SHA3_SET_MD(uname, typ) \ |
239 | if (S390_SHA3_CAPABLE(uname)) { \ | |
240 | ctx->pad = S390X_##uname; \ | |
241 | ctx->meth = typ##_s390x_md; \ | |
242 | } else { \ | |
243 | ctx->meth = sha3_generic_md; \ | |
d5e5e2ff | 244 | } |
affc070a JC |
245 | # define KMAC_SET_MD(bitlen) \ |
246 | if (S390_SHA3_CAPABLE(SHAKE_##bitlen)) { \ | |
247 | ctx->pad = S390X_SHAKE_##bitlen; \ | |
248 | ctx->meth = kmac_s390x_md; \ | |
249 | } else { \ | |
250 | ctx->meth = sha3_generic_md; \ | |
251 | } | |
f6484de2 | 252 | #elif defined(__aarch64__) |
253 | # include "arm_arch.h" | |
254 | ||
255 | static sha3_absorb_fn armsha3_sha3_absorb; | |
256 | ||
257 | size_t SHA3_absorb_cext(uint64_t A[5][5], const unsigned char *inp, size_t len, | |
258 | size_t r); | |
259 | /*- | |
260 | * Hardware-assisted ARMv8.2 SHA3 extension version of the absorb() | |
261 | */ | |
262 | static size_t armsha3_sha3_absorb(void *vctx, const void *inp, size_t len) | |
263 | { | |
264 | KECCAK1600_CTX *ctx = vctx; | |
265 | ||
266 | return SHA3_absorb_cext(ctx->A, inp, len, ctx->block_size); | |
267 | } | |
268 | ||
269 | static PROV_SHA3_METHOD sha3_ARMSHA3_md = | |
270 | { | |
271 | armsha3_sha3_absorb, | |
272 | generic_sha3_final | |
273 | }; | |
08e6eb21 | 274 | # define SHA3_SET_MD(uname, typ) \ |
ba9472c1 | 275 | if (OPENSSL_armcap_P & ARMV8_HAVE_SHA3_AND_WORTH_USING) { \ |
f6484de2 | 276 | ctx->meth = sha3_ARMSHA3_md; \ |
277 | } else { \ | |
278 | ctx->meth = sha3_generic_md; \ | |
279 | } | |
08e6eb21 | 280 | # define KMAC_SET_MD(bitlen) \ |
ba9472c1 | 281 | if (OPENSSL_armcap_P & ARMV8_HAVE_SHA3_AND_WORTH_USING) { \ |
f6484de2 | 282 | ctx->meth = sha3_ARMSHA3_md; \ |
283 | } else { \ | |
284 | ctx->meth = sha3_generic_md; \ | |
285 | } | |
d5e5e2ff SL |
286 | #else |
287 | # define SHA3_SET_MD(uname, typ) ctx->meth = sha3_generic_md; | |
affc070a | 288 | # define KMAC_SET_MD(bitlen) ctx->meth = sha3_generic_md; |
d5e5e2ff SL |
289 | #endif /* S390_SHA3 */ |
290 | ||
c85d5e02 | 291 | #define SHA3_newctx(typ, uname, name, bitlen, pad) \ |
363b1e5d | 292 | static OSSL_FUNC_digest_newctx_fn name##_newctx; \ |
c85d5e02 SL |
293 | static void *name##_newctx(void *provctx) \ |
294 | { \ | |
1c1daab9 P |
295 | KECCAK1600_CTX *ctx = ossl_prov_is_running() ? OPENSSL_zalloc(sizeof(*ctx)) \ |
296 | : NULL; \ | |
c85d5e02 SL |
297 | \ |
298 | if (ctx == NULL) \ | |
299 | return NULL; \ | |
b68a947f | 300 | ossl_sha3_init(ctx, pad, bitlen); \ |
c85d5e02 SL |
301 | SHA3_SET_MD(uname, typ) \ |
302 | return ctx; \ | |
d5e5e2ff SL |
303 | } |
304 | ||
c85d5e02 | 305 | #define KMAC_newctx(uname, bitlen, pad) \ |
363b1e5d | 306 | static OSSL_FUNC_digest_newctx_fn uname##_newctx; \ |
c85d5e02 SL |
307 | static void *uname##_newctx(void *provctx) \ |
308 | { \ | |
1c1daab9 P |
309 | KECCAK1600_CTX *ctx = ossl_prov_is_running() ? OPENSSL_zalloc(sizeof(*ctx)) \ |
310 | : NULL; \ | |
c85d5e02 SL |
311 | \ |
312 | if (ctx == NULL) \ | |
313 | return NULL; \ | |
b68a947f | 314 | ossl_keccak_kmac_init(ctx, pad, bitlen); \ |
affc070a | 315 | KMAC_SET_MD(bitlen) \ |
c85d5e02 | 316 | return ctx; \ |
d5e5e2ff SL |
317 | } |
318 | ||
c85d5e02 SL |
319 | #define PROV_FUNC_SHA3_DIGEST_COMMON(name, bitlen, blksize, dgstsize, flags) \ |
320 | PROV_FUNC_DIGEST_GET_PARAM(name, blksize, dgstsize, flags) \ | |
1be63951 | 321 | const OSSL_DISPATCH ossl_##name##_functions[] = { \ |
c85d5e02 | 322 | { OSSL_FUNC_DIGEST_NEWCTX, (void (*)(void))name##_newctx }, \ |
c85d5e02 SL |
323 | { OSSL_FUNC_DIGEST_UPDATE, (void (*)(void))keccak_update }, \ |
324 | { OSSL_FUNC_DIGEST_FINAL, (void (*)(void))keccak_final }, \ | |
325 | { OSSL_FUNC_DIGEST_FREECTX, (void (*)(void))keccak_freectx }, \ | |
326 | { OSSL_FUNC_DIGEST_DUPCTX, (void (*)(void))keccak_dupctx }, \ | |
327 | PROV_DISPATCH_FUNC_DIGEST_GET_PARAMS(name) | |
328 | ||
329 | #define PROV_FUNC_SHA3_DIGEST(name, bitlen, blksize, dgstsize, flags) \ | |
330 | PROV_FUNC_SHA3_DIGEST_COMMON(name, bitlen, blksize, dgstsize, flags), \ | |
d7ec1dda | 331 | { OSSL_FUNC_DIGEST_INIT, (void (*)(void))keccak_init }, \ |
c85d5e02 SL |
332 | PROV_DISPATCH_FUNC_DIGEST_CONSTRUCT_END |
333 | ||
334 | #define PROV_FUNC_SHAKE_DIGEST(name, bitlen, blksize, dgstsize, flags) \ | |
335 | PROV_FUNC_SHA3_DIGEST_COMMON(name, bitlen, blksize, dgstsize, flags), \ | |
d7ec1dda | 336 | { OSSL_FUNC_DIGEST_INIT, (void (*)(void))keccak_init_params }, \ |
c85d5e02 SL |
337 | { OSSL_FUNC_DIGEST_SET_CTX_PARAMS, (void (*)(void))shake_set_ctx_params }, \ |
338 | { OSSL_FUNC_DIGEST_SETTABLE_CTX_PARAMS, \ | |
339 | (void (*)(void))shake_settable_ctx_params }, \ | |
340 | PROV_DISPATCH_FUNC_DIGEST_CONSTRUCT_END | |
d5e5e2ff SL |
341 | |
342 | static void keccak_freectx(void *vctx) | |
343 | { | |
344 | KECCAK1600_CTX *ctx = (KECCAK1600_CTX *)vctx; | |
345 | ||
346 | OPENSSL_clear_free(ctx, sizeof(*ctx)); | |
347 | } | |
348 | ||
349 | static void *keccak_dupctx(void *ctx) | |
350 | { | |
351 | KECCAK1600_CTX *in = (KECCAK1600_CTX *)ctx; | |
1c1daab9 | 352 | KECCAK1600_CTX *ret = ossl_prov_is_running() ? OPENSSL_malloc(sizeof(*ret)) |
2c9da416 | 353 | : NULL; |
d5e5e2ff | 354 | |
a89befba P |
355 | if (ret != NULL) |
356 | *ret = *in; | |
d5e5e2ff SL |
357 | return ret; |
358 | } | |
359 | ||
ec02412b | 360 | static const OSSL_PARAM known_shake_settable_ctx_params[] = { |
1e55cbc8 | 361 | {OSSL_DIGEST_PARAM_XOFLEN, OSSL_PARAM_UNSIGNED_INTEGER, NULL, 0, 0}, |
ec02412b RL |
362 | OSSL_PARAM_END |
363 | }; | |
e772f25c P |
364 | static const OSSL_PARAM *shake_settable_ctx_params(ossl_unused void *ctx, |
365 | ossl_unused void *provctx) | |
ec02412b RL |
366 | { |
367 | return known_shake_settable_ctx_params; | |
368 | } | |
369 | ||
92d9d0ae | 370 | static int shake_set_ctx_params(void *vctx, const OSSL_PARAM params[]) |
d5e5e2ff SL |
371 | { |
372 | const OSSL_PARAM *p; | |
373 | KECCAK1600_CTX *ctx = (KECCAK1600_CTX *)vctx; | |
374 | ||
5506cd0b P |
375 | if (ctx == NULL) |
376 | return 0; | |
377 | if (params == NULL) | |
d5e5e2ff | 378 | return 1; |
5506cd0b P |
379 | |
380 | p = OSSL_PARAM_locate_const(params, OSSL_DIGEST_PARAM_XOFLEN); | |
381 | if (p != NULL && !OSSL_PARAM_get_size_t(p, &ctx->md_size)) { | |
382 | ERR_raise(ERR_LIB_PROV, PROV_R_FAILED_TO_GET_PARAMETER); | |
383 | return 0; | |
d5e5e2ff | 384 | } |
5506cd0b | 385 | return 1; |
d5e5e2ff SL |
386 | } |
387 | ||
c85d5e02 SL |
388 | #define IMPLEMENT_SHA3_functions(bitlen) \ |
389 | SHA3_newctx(sha3, SHA3_##bitlen, sha3_##bitlen, bitlen, '\x06') \ | |
390 | PROV_FUNC_SHA3_DIGEST(sha3_##bitlen, bitlen, \ | |
391 | SHA3_BLOCKSIZE(bitlen), SHA3_MDSIZE(bitlen), \ | |
af53092c | 392 | SHA3_FLAGS) |
c85d5e02 | 393 | |
524f1261 UM |
394 | #define IMPLEMENT_KECCAK_functions(bitlen) \ |
395 | SHA3_newctx(keccak, KECCAK_##bitlen, keccak_##bitlen, bitlen, '\x01') \ | |
396 | PROV_FUNC_SHA3_DIGEST(keccak_##bitlen, bitlen, \ | |
397 | SHA3_BLOCKSIZE(bitlen), SHA3_MDSIZE(bitlen), \ | |
398 | SHA3_FLAGS) | |
399 | ||
c85d5e02 SL |
400 | #define IMPLEMENT_SHAKE_functions(bitlen) \ |
401 | SHA3_newctx(shake, SHAKE_##bitlen, shake_##bitlen, bitlen, '\x1f') \ | |
402 | PROV_FUNC_SHAKE_DIGEST(shake_##bitlen, bitlen, \ | |
403 | SHA3_BLOCKSIZE(bitlen), SHA3_MDSIZE(bitlen), \ | |
af53092c | 404 | SHAKE_FLAGS) |
c85d5e02 SL |
405 | #define IMPLEMENT_KMAC_functions(bitlen) \ |
406 | KMAC_newctx(keccak_kmac_##bitlen, bitlen, '\x04') \ | |
407 | PROV_FUNC_SHAKE_DIGEST(keccak_kmac_##bitlen, bitlen, \ | |
408 | SHA3_BLOCKSIZE(bitlen), KMAC_MDSIZE(bitlen), \ | |
af53092c | 409 | KMAC_FLAGS) |
c85d5e02 | 410 | |
1be63951 | 411 | /* ossl_sha3_224_functions */ |
c85d5e02 | 412 | IMPLEMENT_SHA3_functions(224) |
1be63951 | 413 | /* ossl_sha3_256_functions */ |
c85d5e02 | 414 | IMPLEMENT_SHA3_functions(256) |
1be63951 | 415 | /* ossl_sha3_384_functions */ |
c85d5e02 | 416 | IMPLEMENT_SHA3_functions(384) |
1be63951 | 417 | /* ossl_sha3_512_functions */ |
c85d5e02 | 418 | IMPLEMENT_SHA3_functions(512) |
524f1261 UM |
419 | /* ossl_keccak_224_functions */ |
420 | IMPLEMENT_KECCAK_functions(224) | |
421 | /* ossl_keccak_256_functions */ | |
422 | IMPLEMENT_KECCAK_functions(256) | |
423 | /* ossl_keccak_384_functions */ | |
424 | IMPLEMENT_KECCAK_functions(384) | |
425 | /* ossl_keccak_512_functions */ | |
426 | IMPLEMENT_KECCAK_functions(512) | |
1be63951 | 427 | /* ossl_shake_128_functions */ |
c85d5e02 | 428 | IMPLEMENT_SHAKE_functions(128) |
1be63951 | 429 | /* ossl_shake_256_functions */ |
c85d5e02 | 430 | IMPLEMENT_SHAKE_functions(256) |
1be63951 | 431 | /* ossl_keccak_kmac_128_functions */ |
c85d5e02 | 432 | IMPLEMENT_KMAC_functions(128) |
1be63951 | 433 | /* ossl_keccak_kmac_256_functions */ |
c85d5e02 | 434 | IMPLEMENT_KMAC_functions(256) |