2 * Copyright 2017-2018 The OpenSSL Project Authors. All Rights Reserved.
4 * Licensed under the OpenSSL license (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
13 #include <openssl/evp.h>
14 #include <openssl/objects.h>
15 #include "internal/evp_int.h"
18 size_t SHA3_absorb(uint64_t A[5][5], const unsigned char *inp, size_t len,
20 void SHA3_squeeze(uint64_t A[5][5], unsigned char *out, size_t len, size_t r);
22 #define KECCAK1600_WIDTH 1600
26 size_t block_size; /* cached ctx->digest->block_size */
27 size_t md_size; /* output length, variable in XOF */
28 size_t num; /* used bytes in below buffer */
29 unsigned char buf[KECCAK1600_WIDTH / 8 - 32];
33 static int init(EVP_MD_CTX *evp_ctx, unsigned char pad)
35 KECCAK1600_CTX *ctx = evp_ctx->md_data;
36 size_t bsz = evp_ctx->digest->block_size;
38 if (bsz <= sizeof(ctx->buf)) {
39 memset(ctx->A, 0, sizeof(ctx->A));
42 ctx->block_size = bsz;
43 ctx->md_size = evp_ctx->digest->md_size;
52 static int sha3_init(EVP_MD_CTX *evp_ctx)
54 return init(evp_ctx, '\x06');
57 static int shake_init(EVP_MD_CTX *evp_ctx)
59 return init(evp_ctx, '\x1f');
62 static int sha3_update(EVP_MD_CTX *evp_ctx, const void *_inp, size_t len)
64 KECCAK1600_CTX *ctx = evp_ctx->md_data;
65 const unsigned char *inp = _inp;
66 size_t bsz = ctx->block_size;
72 if ((num = ctx->num) != 0) { /* process intermediate buffer? */
76 memcpy(ctx->buf + num, inp, len);
81 * We have enough data to fill or overflow the intermediate
82 * buffer. So we append |rem| bytes and process the block,
83 * leaving the rest for later processing...
85 memcpy(ctx->buf + num, inp, rem);
86 inp += rem, len -= rem;
87 (void)SHA3_absorb(ctx->A, ctx->buf, bsz, bsz);
89 /* ctx->buf is processed, ctx->num is guaranteed to be zero */
93 rem = SHA3_absorb(ctx->A, inp, len, bsz);
98 memcpy(ctx->buf, inp + len - rem, rem);
105 static int sha3_final(EVP_MD_CTX *evp_ctx, unsigned char *md)
107 KECCAK1600_CTX *ctx = evp_ctx->md_data;
108 size_t bsz = ctx->block_size;
109 size_t num = ctx->num;
112 * Pad the data with 10*1. Note that |num| can be |bsz - 1|
113 * in which case both byte operations below are performed on
116 memset(ctx->buf + num, 0, bsz - num);
117 ctx->buf[num] = ctx->pad;
118 ctx->buf[bsz - 1] |= 0x80;
120 (void)SHA3_absorb(ctx->A, ctx->buf, bsz, bsz);
122 SHA3_squeeze(ctx->A, md, ctx->md_size, bsz);
127 static int shake_ctrl(EVP_MD_CTX *evp_ctx, int cmd, int p1, void *p2)
129 KECCAK1600_CTX *ctx = evp_ctx->md_data;
132 case EVP_MD_CTRL_XOF_LEN:
140 #if defined(OPENSSL_CPUID_OBJ) && defined(__s390__) && defined(KECCAK1600_ASM)
144 # include "s390x_arch.h"
146 # define S390X_SHA3_FC(ctx) ((ctx)->pad)
148 # define S390X_sha3_224_CAPABLE ((OPENSSL_s390xcap_P.kimd[0] & \
149 S390X_CAPBIT(S390X_SHA3_224)) && \
150 (OPENSSL_s390xcap_P.klmd[0] & \
151 S390X_CAPBIT(S390X_SHA3_224)))
152 # define S390X_sha3_256_CAPABLE ((OPENSSL_s390xcap_P.kimd[0] & \
153 S390X_CAPBIT(S390X_SHA3_256)) && \
154 (OPENSSL_s390xcap_P.klmd[0] & \
155 S390X_CAPBIT(S390X_SHA3_256)))
156 # define S390X_sha3_384_CAPABLE ((OPENSSL_s390xcap_P.kimd[0] & \
157 S390X_CAPBIT(S390X_SHA3_384)) && \
158 (OPENSSL_s390xcap_P.klmd[0] & \
159 S390X_CAPBIT(S390X_SHA3_384)))
160 # define S390X_sha3_512_CAPABLE ((OPENSSL_s390xcap_P.kimd[0] & \
161 S390X_CAPBIT(S390X_SHA3_512)) && \
162 (OPENSSL_s390xcap_P.klmd[0] & \
163 S390X_CAPBIT(S390X_SHA3_512)))
164 # define S390X_shake128_CAPABLE ((OPENSSL_s390xcap_P.kimd[0] & \
165 S390X_CAPBIT(S390X_SHAKE_128)) && \
166 (OPENSSL_s390xcap_P.klmd[0] & \
167 S390X_CAPBIT(S390X_SHAKE_128)))
168 # define S390X_shake256_CAPABLE ((OPENSSL_s390xcap_P.kimd[0] & \
169 S390X_CAPBIT(S390X_SHAKE_256)) && \
170 (OPENSSL_s390xcap_P.klmd[0] & \
171 S390X_CAPBIT(S390X_SHAKE_256)))
173 /* Convert md-size to block-size. */
174 # define S390X_KECCAK1600_BSZ(n) ((KECCAK1600_WIDTH - ((n) << 1)) >> 3)
176 static int s390x_sha3_init(EVP_MD_CTX *evp_ctx)
178 KECCAK1600_CTX *ctx = evp_ctx->md_data;
179 const size_t bsz = evp_ctx->digest->block_size;
182 * KECCAK1600_CTX structure's pad field is used to store the KIMD/KLMD
186 case S390X_KECCAK1600_BSZ(224):
187 ctx->pad = S390X_SHA3_224;
189 case S390X_KECCAK1600_BSZ(256):
190 ctx->pad = S390X_SHA3_256;
192 case S390X_KECCAK1600_BSZ(384):
193 ctx->pad = S390X_SHA3_384;
195 case S390X_KECCAK1600_BSZ(512):
196 ctx->pad = S390X_SHA3_512;
202 memset(ctx->A, 0, sizeof(ctx->A));
204 ctx->block_size = bsz;
205 ctx->md_size = evp_ctx->digest->md_size;
209 static int s390x_shake_init(EVP_MD_CTX *evp_ctx)
211 KECCAK1600_CTX *ctx = evp_ctx->md_data;
212 const size_t bsz = evp_ctx->digest->block_size;
215 * KECCAK1600_CTX structure's pad field is used to store the KIMD/KLMD
219 case S390X_KECCAK1600_BSZ(128):
220 ctx->pad = S390X_SHAKE_128;
222 case S390X_KECCAK1600_BSZ(256):
223 ctx->pad = S390X_SHAKE_256;
229 memset(ctx->A, 0, sizeof(ctx->A));
231 ctx->block_size = bsz;
232 ctx->md_size = evp_ctx->digest->md_size;
236 static int s390x_sha3_update(EVP_MD_CTX *evp_ctx, const void *_inp, size_t len)
238 KECCAK1600_CTX *ctx = evp_ctx->md_data;
239 const unsigned char *inp = _inp;
240 const size_t bsz = ctx->block_size;
246 if ((num = ctx->num) != 0) {
250 memcpy(ctx->buf + num, inp, len);
254 memcpy(ctx->buf + num, inp, rem);
257 s390x_kimd(ctx->buf, bsz, ctx->pad, ctx->A);
262 s390x_kimd(inp, len - rem, ctx->pad, ctx->A);
265 memcpy(ctx->buf, inp + len - rem, rem);
271 static int s390x_sha3_final(EVP_MD_CTX *evp_ctx, unsigned char *md)
273 KECCAK1600_CTX *ctx = evp_ctx->md_data;
275 s390x_klmd(ctx->buf, ctx->num, NULL, 0, ctx->pad, ctx->A);
276 memcpy(md, ctx->A, ctx->md_size);
280 static int s390x_shake_final(EVP_MD_CTX *evp_ctx, unsigned char *md)
282 KECCAK1600_CTX *ctx = evp_ctx->md_data;
284 s390x_klmd(ctx->buf, ctx->num, md, ctx->md_size, ctx->pad, ctx->A);
288 # define EVP_MD_SHA3(bitlen) \
289 const EVP_MD *EVP_sha3_##bitlen(void) \
291 static const EVP_MD s390x_sha3_##bitlen##_md = { \
293 NID_RSA_SHA3_##bitlen, \
295 EVP_MD_FLAG_DIGALGID_ABSENT, \
301 (KECCAK1600_WIDTH - bitlen * 2) / 8, \
302 sizeof(KECCAK1600_CTX), \
304 static const EVP_MD sha3_##bitlen##_md = { \
306 NID_RSA_SHA3_##bitlen, \
308 EVP_MD_FLAG_DIGALGID_ABSENT, \
314 (KECCAK1600_WIDTH - bitlen * 2) / 8, \
315 sizeof(KECCAK1600_CTX), \
317 return S390X_sha3_##bitlen##_CAPABLE ? \
318 &s390x_sha3_##bitlen##_md : \
319 &sha3_##bitlen##_md; \
322 # define EVP_MD_SHAKE(bitlen) \
323 const EVP_MD *EVP_shake##bitlen(void) \
325 static const EVP_MD s390x_shake##bitlen##_md = { \
335 (KECCAK1600_WIDTH - bitlen * 2) / 8, \
336 sizeof(KECCAK1600_CTX), \
339 static const EVP_MD shake##bitlen##_md = { \
349 (KECCAK1600_WIDTH - bitlen * 2) / 8, \
350 sizeof(KECCAK1600_CTX), \
353 return S390X_shake##bitlen##_CAPABLE ? \
354 &s390x_shake##bitlen##_md : \
355 &shake##bitlen##_md; \
360 # define EVP_MD_SHA3(bitlen) \
361 const EVP_MD *EVP_sha3_##bitlen(void) \
363 static const EVP_MD sha3_##bitlen##_md = { \
365 NID_RSA_SHA3_##bitlen, \
367 EVP_MD_FLAG_DIGALGID_ABSENT, \
373 (KECCAK1600_WIDTH - bitlen * 2) / 8, \
374 sizeof(KECCAK1600_CTX), \
376 return &sha3_##bitlen##_md; \
379 # define EVP_MD_SHAKE(bitlen) \
380 const EVP_MD *EVP_shake##bitlen(void) \
382 static const EVP_MD shake##bitlen##_md = { \
392 (KECCAK1600_WIDTH - bitlen * 2) / 8, \
393 sizeof(KECCAK1600_CTX), \
396 return &shake##bitlen##_md; \