source: azure_iot_hub_f767zi/trunk/wolfssl-4.7.0/wolfcrypt/src/hash.c@ 464

Last change on this file since 464 was 464, checked in by coas-nagasima, 3 years ago

WolfSSLとAzure IoT SDKを更新
  • Property svn:eol-style set to native
  • Property svn:mime-type set to text/x-csrc;charset=UTF-8
File size: 45.8 KB
Line 
1/* hash.c
2 *
3 * Copyright (C) 2006-2020 wolfSSL Inc.
4 *
5 * This file is part of wolfSSL.
6 *
7 * wolfSSL is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License as published by
9 * the Free Software Foundation; either version 2 of the License, or
10 * (at your option) any later version.
11 *
12 * wolfSSL is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 * GNU General Public License for more details.
16 *
17 * You should have received a copy of the GNU General Public License
18 * along with this program; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335, USA
20 */
21
22
23#ifdef HAVE_CONFIG_H
24 #include <config.h>
25#endif
26
27#include <wolfssl/wolfcrypt/settings.h>
28#include <wolfssl/wolfcrypt/logging.h>
29#include <wolfssl/wolfcrypt/error-crypt.h>
30#ifndef NO_ASN
31#include <wolfssl/wolfcrypt/asn.h>
32#endif
33
34#include <wolfssl/wolfcrypt/hash.h>
35#include <wolfssl/wolfcrypt/hmac.h>
36#include <wolfssl/wolfcrypt/cryptocb.h>
37
38#ifdef NO_INLINE
39 #include <wolfssl/wolfcrypt/misc.h>
40#else
41 #define WOLFSSL_MISC_INCLUDED
42 #include <wolfcrypt/src/misc.c>
43#endif
44
45
46#ifdef NO_ASN
47enum Hash_Sum {
48 MD2h = 646,
49 MD5h = 649,
50 SHAh = 88,
51 SHA224h = 417,
52 SHA256h = 414,
53 SHA384h = 415,
54 SHA512h = 416,
55 SHA3_224h = 420,
56 SHA3_256h = 421,
57 SHA3_384h = 422,
58 SHA3_512h = 423
59};
60#endif /* !NO_ASN */
61
62#if !defined(NO_PWDBASED) || !defined(NO_ASN)
63/* function converts int hash type to enum */
64enum wc_HashType wc_HashTypeConvert(int hashType)
65{
66 /* Default to hash type none as error */
67 enum wc_HashType eHashType = WC_HASH_TYPE_NONE;
68#if defined(HAVE_FIPS) || defined(HAVE_SELFTEST)
69 /* original FIPSv1 and CAVP selftest require a mapping for unique hash
70 type to wc_HashType */
71 switch (hashType) {
72 #ifndef NO_MD5
73 case WC_MD5:
74 eHashType = WC_HASH_TYPE_MD5;
75 break;
76 #endif /* !NO_MD5 */
77 #ifndef NO_SHA
78 case WC_SHA:
79 eHashType = WC_HASH_TYPE_SHA;
80 break;
81 #endif /* !NO_SHA */
82
83 #ifdef WOLFSSL_SHA224
84 case WC_SHA224:
85 eHashType = WC_HASH_TYPE_SHA224;
86 break;
87 #endif /* WOLFSSL_SHA224 */
88
89 #ifndef NO_SHA256
90 case WC_SHA256:
91 eHashType = WC_HASH_TYPE_SHA256;
92 break;
93 #endif /* !NO_SHA256 */
94
95 #ifdef WOLFSSL_SHA384
96 case WC_SHA384:
97 eHashType = WC_HASH_TYPE_SHA384;
98 break;
99 #endif /* WOLFSSL_SHA384 */
100 #ifdef WOLFSSL_SHA512
101 case WC_SHA512:
102 eHashType = WC_HASH_TYPE_SHA512;
103 break;
104 #endif /* WOLFSSL_SHA512 */
105 #ifdef WOLFSSL_SHA3
106 case WC_SHA3_224:
107 eHashType = WC_HASH_TYPE_SHA3_224;
108 break;
109 case WC_SHA3_256:
110 eHashType = WC_HASH_TYPE_SHA3_256;
111 break;
112 case WC_SHA3_384:
113 eHashType = WC_HASH_TYPE_SHA3_384;
114 break;
115 case WC_SHA3_512:
116 eHashType = WC_HASH_TYPE_SHA3_512;
117 break;
118 #endif /* WOLFSSL_SHA3 */
119 default:
120 eHashType = WC_HASH_TYPE_NONE;
121 break;
122 }
123#else
124 /* current master uses same unique types as wc_HashType */
125 if (hashType > 0 && hashType <= WC_HASH_TYPE_MAX) {
126 eHashType = (enum wc_HashType)hashType;
127 }
128#endif
129 return eHashType;
130}
131#endif /* !NO_PWDBASED || !NO_ASN */
132
133#if !defined(NO_ASN) || !defined(NO_DH) || defined(HAVE_ECC)
134
135int wc_HashGetOID(enum wc_HashType hash_type)
136{
137 int oid = HASH_TYPE_E; /* Default to hash type error */
138 switch(hash_type)
139 {
140 case WC_HASH_TYPE_MD2:
141 #ifdef WOLFSSL_MD2
142 oid = MD2h;
143 #endif
144 break;
145 case WC_HASH_TYPE_MD5_SHA:
146 case WC_HASH_TYPE_MD5:
147 #ifndef NO_MD5
148 oid = MD5h;
149 #endif
150 break;
151 case WC_HASH_TYPE_SHA:
152 #ifndef NO_SHA
153 oid = SHAh;
154 #endif
155 break;
156 case WC_HASH_TYPE_SHA224:
157 #ifdef WOLFSSL_SHA224
158 oid = SHA224h;
159 #endif
160 break;
161 case WC_HASH_TYPE_SHA256:
162 #ifndef NO_SHA256
163 oid = SHA256h;
164 #endif
165 break;
166 case WC_HASH_TYPE_SHA384:
167 #ifdef WOLFSSL_SHA384
168 oid = SHA384h;
169 #endif
170 break;
171 case WC_HASH_TYPE_SHA512:
172 #ifdef WOLFSSL_SHA512
173 oid = SHA512h;
174 #endif
175 break;
176 case WC_HASH_TYPE_SHA3_224:
177 #if defined(WOLFSSL_SHA3) && !defined(WOLFSSL_NOSHA3_224)
178 oid = SHA3_224h;
179 #endif
180 break;
181 case WC_HASH_TYPE_SHA3_256:
182 #if defined(WOLFSSL_SHA3) && !defined(WOLFSSL_NOSHA3_256)
183 oid = SHA3_256h;
184 #endif
185 break;
186 case WC_HASH_TYPE_SHA3_384:
187 #if defined(WOLFSSL_SHA3) && !defined(WOLFSSL_NOSHA3_384)
188 oid = SHA3_384h;
189 #endif
190 break;
191 case WC_HASH_TYPE_SHA3_512:
192 #if defined(WOLFSSL_SHA3) && !defined(WOLFSSL_NOSHA3_512)
193 oid = SHA3_512h;
194 #endif
195 break;
196
197 /* Not Supported */
198 case WC_HASH_TYPE_MD4:
199 case WC_HASH_TYPE_BLAKE2B:
200 case WC_HASH_TYPE_BLAKE2S:
201 case WC_HASH_TYPE_NONE:
202 default:
203 oid = BAD_FUNC_ARG;
204 break;
205 }
206 return oid;
207}
208
209enum wc_HashType wc_OidGetHash(int oid)
210{
211 enum wc_HashType hash_type = WC_HASH_TYPE_NONE;
212 switch (oid)
213 {
214 #ifdef WOLFSSL_MD2
215 case MD2h:
216 hash_type = WC_HASH_TYPE_MD2;
217 break;
218 #endif
219 case MD5h:
220 #ifndef NO_MD5
221 hash_type = WC_HASH_TYPE_MD5;
222 #endif
223 break;
224 case SHAh:
225 #ifndef NO_SHA
226 hash_type = WC_HASH_TYPE_SHA;
227 #endif
228 break;
229 case SHA224h:
230 #ifdef WOLFSSL_SHA224
231 hash_type = WC_HASH_TYPE_SHA224;
232 #endif
233 break;
234 case SHA256h:
235 #ifndef NO_SHA256
236 hash_type = WC_HASH_TYPE_SHA256;
237 #endif
238 break;
239 case SHA384h:
240 #ifdef WOLFSSL_SHA384
241 hash_type = WC_HASH_TYPE_SHA384;
242 #endif
243 break;
244 case SHA512h:
245 #ifdef WOLFSSL_SHA512
246 hash_type = WC_HASH_TYPE_SHA512;
247 #endif
248 break;
249 #ifdef WOLFSSL_SHA3
250 case SHA3_224h:
251 hash_type = WC_HASH_TYPE_SHA3_224;
252 break;
253 case SHA3_256h:
254 hash_type = WC_HASH_TYPE_SHA3_256;
255 break;
256 case SHA3_384h:
257 hash_type = WC_HASH_TYPE_SHA3_384;
258 break;
259 case SHA3_512h:
260 hash_type = WC_HASH_TYPE_SHA3_512;
261 break;
262 #endif /* WOLFSSL_SHA3 */
263 default:
264 break;
265 }
266 return hash_type;
267}
268#endif /* !NO_ASN || !NO_DH || HAVE_ECC */
269
270#ifndef NO_HASH_WRAPPER
271
272/* Get Hash digest size */
273int wc_HashGetDigestSize(enum wc_HashType hash_type)
274{
275 int dig_size = HASH_TYPE_E; /* Default to hash type error */
276 switch(hash_type)
277 {
278 case WC_HASH_TYPE_MD2:
279 #ifdef WOLFSSL_MD2
280 dig_size = MD2_DIGEST_SIZE;
281 #endif
282 break;
283 case WC_HASH_TYPE_MD4:
284 #ifndef NO_MD4
285 dig_size = MD4_DIGEST_SIZE;
286 #endif
287 break;
288 case WC_HASH_TYPE_MD5:
289 #ifndef NO_MD5
290 dig_size = WC_MD5_DIGEST_SIZE;
291 #endif
292 break;
293 case WC_HASH_TYPE_SHA:
294 #ifndef NO_SHA
295 dig_size = WC_SHA_DIGEST_SIZE;
296 #endif
297 break;
298 case WC_HASH_TYPE_SHA224:
299 #ifdef WOLFSSL_SHA224
300 dig_size = WC_SHA224_DIGEST_SIZE;
301 #endif
302 break;
303 case WC_HASH_TYPE_SHA256:
304 #ifndef NO_SHA256
305 dig_size = WC_SHA256_DIGEST_SIZE;
306 #endif
307 break;
308 case WC_HASH_TYPE_SHA384:
309 #ifdef WOLFSSL_SHA384
310 dig_size = WC_SHA384_DIGEST_SIZE;
311 #endif
312 break;
313 case WC_HASH_TYPE_SHA512:
314 #ifdef WOLFSSL_SHA512
315 dig_size = WC_SHA512_DIGEST_SIZE;
316 #endif
317 break;
318 case WC_HASH_TYPE_MD5_SHA: /* Old TLS Specific */
319 #if !defined(NO_MD5) && !defined(NO_SHA)
320 dig_size = (int)WC_MD5_DIGEST_SIZE + (int)WC_SHA_DIGEST_SIZE;
321 #endif
322 break;
323
324 case WC_HASH_TYPE_SHA3_224:
325 #if defined(WOLFSSL_SHA3) && !defined(WOLFSSL_NOSHA3_224)
326 dig_size = WC_SHA3_224_DIGEST_SIZE;
327 #endif
328 break;
329 case WC_HASH_TYPE_SHA3_256:
330 #if defined(WOLFSSL_SHA3) && !defined(WOLFSSL_NOSHA3_256)
331 dig_size = WC_SHA3_256_DIGEST_SIZE;
332 #endif
333 break;
334 case WC_HASH_TYPE_SHA3_384:
335 #if defined(WOLFSSL_SHA3) && !defined(WOLFSSL_NOSHA3_384)
336 dig_size = WC_SHA3_384_DIGEST_SIZE;
337 #endif
338 break;
339 case WC_HASH_TYPE_SHA3_512:
340 #if defined(WOLFSSL_SHA3) && !defined(WOLFSSL_NOSHA3_512)
341 dig_size = WC_SHA3_512_DIGEST_SIZE;
342 #endif
343 break;
344 case WC_HASH_TYPE_BLAKE2B:
345 case WC_HASH_TYPE_BLAKE2S:
346 #if defined(HAVE_BLAKE2) || defined(HAVE_BLAKE2S)
347 dig_size = BLAKE2S_OUTBYTES;
348 #endif
349 break;
350
351 /* Not Supported */
352 case WC_HASH_TYPE_NONE:
353 default:
354 dig_size = BAD_FUNC_ARG;
355 break;
356 }
357 return dig_size;
358}
359
360
361/* Get Hash block size */
362int wc_HashGetBlockSize(enum wc_HashType hash_type)
363{
364 int block_size = HASH_TYPE_E; /* Default to hash type error */
365 switch (hash_type)
366 {
367 case WC_HASH_TYPE_MD2:
368 #ifdef WOLFSSL_MD2
369 block_size = MD2_BLOCK_SIZE;
370 #endif
371 break;
372 case WC_HASH_TYPE_MD4:
373 #ifndef NO_MD4
374 block_size = MD4_BLOCK_SIZE;
375 #endif
376 break;
377 case WC_HASH_TYPE_MD5:
378 #ifndef NO_MD5
379 block_size = WC_MD5_BLOCK_SIZE;
380 #endif
381 break;
382 case WC_HASH_TYPE_SHA:
383 #ifndef NO_SHA
384 block_size = WC_SHA_BLOCK_SIZE;
385 #endif
386 break;
387 case WC_HASH_TYPE_SHA224:
388 #ifdef WOLFSSL_SHA224
389 block_size = WC_SHA224_BLOCK_SIZE;
390 #endif
391 break;
392 case WC_HASH_TYPE_SHA256:
393 #ifndef NO_SHA256
394 block_size = WC_SHA256_BLOCK_SIZE;
395 #endif
396 break;
397 case WC_HASH_TYPE_SHA384:
398 #ifdef WOLFSSL_SHA384
399 block_size = WC_SHA384_BLOCK_SIZE;
400 #endif
401 break;
402 case WC_HASH_TYPE_SHA512:
403 #ifdef WOLFSSL_SHA512
404 block_size = WC_SHA512_BLOCK_SIZE;
405 #endif
406 break;
407 case WC_HASH_TYPE_MD5_SHA: /* Old TLS Specific */
408 #if !defined(NO_MD5) && !defined(NO_SHA)
409 block_size = (int)WC_MD5_BLOCK_SIZE + (int)WC_SHA_BLOCK_SIZE;
410 #endif
411 break;
412
413 case WC_HASH_TYPE_SHA3_224:
414 #if defined(WOLFSSL_SHA3) && !defined(WOLFSSL_NOSHA3_224)
415 block_size = WC_SHA3_224_BLOCK_SIZE;
416 #endif
417 break;
418 case WC_HASH_TYPE_SHA3_256:
419 #if defined(WOLFSSL_SHA3) && !defined(WOLFSSL_NOSHA3_256)
420 block_size = WC_SHA3_256_BLOCK_SIZE;
421 #endif
422 break;
423 case WC_HASH_TYPE_SHA3_384:
424 #if defined(WOLFSSL_SHA3) && !defined(WOLFSSL_NOSHA3_384)
425 block_size = WC_SHA3_384_BLOCK_SIZE;
426 #endif
427 break;
428 case WC_HASH_TYPE_SHA3_512:
429 #if defined(WOLFSSL_SHA3) && !defined(WOLFSSL_NOSHA3_512)
430 block_size = WC_SHA3_512_BLOCK_SIZE;
431 #endif
432 break;
433 case WC_HASH_TYPE_BLAKE2B:
434 case WC_HASH_TYPE_BLAKE2S:
435 #if defined(HAVE_BLAKE2) || defined(HAVE_BLAKE2S)
436 block_size = BLAKE2S_BLOCKBYTES;
437 #endif
438 break;
439
440 /* Not Supported */
441 case WC_HASH_TYPE_NONE:
442 default:
443 block_size = BAD_FUNC_ARG;
444 break;
445 }
446 return block_size;
447}
448
449/* Generic Hashing Wrapper */
450int wc_Hash(enum wc_HashType hash_type, const byte* data,
451 word32 data_len, byte* hash, word32 hash_len)
452{
453 int ret = HASH_TYPE_E; /* Default to hash type error */
454 word32 dig_size;
455
456 /* Validate hash buffer size */
457 dig_size = wc_HashGetDigestSize(hash_type);
458 if (hash_len < dig_size) {
459 return BUFFER_E;
460 }
461
462 /* Suppress possible unused arg if all hashing is disabled */
463 (void)data;
464 (void)data_len;
465 (void)hash;
466 (void)hash_len;
467
468 switch(hash_type)
469 {
470 case WC_HASH_TYPE_MD5:
471#ifndef NO_MD5
472 ret = wc_Md5Hash(data, data_len, hash);
473#endif
474 break;
475 case WC_HASH_TYPE_SHA:
476#ifndef NO_SHA
477 ret = wc_ShaHash(data, data_len, hash);
478#endif
479 break;
480 case WC_HASH_TYPE_SHA224:
481#ifdef WOLFSSL_SHA224
482 ret = wc_Sha224Hash(data, data_len, hash);
483#endif
484 break;
485 case WC_HASH_TYPE_SHA256:
486#ifndef NO_SHA256
487 ret = wc_Sha256Hash(data, data_len, hash);
488#endif
489 break;
490 case WC_HASH_TYPE_SHA384:
491#ifdef WOLFSSL_SHA384
492 ret = wc_Sha384Hash(data, data_len, hash);
493#endif
494 break;
495 case WC_HASH_TYPE_SHA512:
496#ifdef WOLFSSL_SHA512
497 ret = wc_Sha512Hash(data, data_len, hash);
498#endif
499 break;
500 case WC_HASH_TYPE_MD5_SHA:
501#if !defined(NO_MD5) && !defined(NO_SHA)
502 ret = wc_Md5Hash(data, data_len, hash);
503 if (ret == 0) {
504 ret = wc_ShaHash(data, data_len, &hash[WC_MD5_DIGEST_SIZE]);
505 }
506#endif
507 break;
508
509 case WC_HASH_TYPE_SHA3_224:
510#if defined(WOLFSSL_SHA3) && !defined(WOLFSSL_NOSHA3_224)
511 ret = wc_Sha3_224Hash(data, data_len, hash);
512#endif
513 break;
514 case WC_HASH_TYPE_SHA3_256:
515#if defined(WOLFSSL_SHA3) && !defined(WOLFSSL_NOSHA3_256)
516 ret = wc_Sha3_256Hash(data, data_len, hash);
517#endif
518 break;
519 case WC_HASH_TYPE_SHA3_384:
520#if defined(WOLFSSL_SHA3) && !defined(WOLFSSL_NOSHA3_384)
521 ret = wc_Sha3_384Hash(data, data_len, hash);
522#endif
523 break;
524 case WC_HASH_TYPE_SHA3_512:
525#if defined(WOLFSSL_SHA3) && !defined(WOLFSSL_NOSHA3_512)
526 ret = wc_Sha3_512Hash(data, data_len, hash);
527#endif
528 break;
529
530 /* Not Supported */
531 case WC_HASH_TYPE_MD2:
532 case WC_HASH_TYPE_MD4:
533 case WC_HASH_TYPE_BLAKE2B:
534 case WC_HASH_TYPE_BLAKE2S:
535 case WC_HASH_TYPE_NONE:
536 default:
537 ret = BAD_FUNC_ARG;
538 break;
539 }
540 return ret;
541}
542
543int wc_HashInit_ex(wc_HashAlg* hash, enum wc_HashType type, void* heap,
544 int devId)
545{
546 int ret = HASH_TYPE_E; /* Default to hash type error */
547
548 if (hash == NULL)
549 return BAD_FUNC_ARG;
550
551 switch (type) {
552 case WC_HASH_TYPE_MD5:
553#ifndef NO_MD5
554 ret = wc_InitMd5_ex(&hash->md5, heap, devId);
555#endif
556 break;
557 case WC_HASH_TYPE_SHA:
558#ifndef NO_SHA
559 ret = wc_InitSha_ex(&hash->sha, heap, devId);
560#endif
561 break;
562 case WC_HASH_TYPE_SHA224:
563#ifdef WOLFSSL_SHA224
564 ret = wc_InitSha224_ex(&hash->sha224, heap, devId);
565#endif
566 break;
567 case WC_HASH_TYPE_SHA256:
568#ifndef NO_SHA256
569 ret = wc_InitSha256_ex(&hash->sha256, heap, devId);
570#endif
571 break;
572 case WC_HASH_TYPE_SHA384:
573#ifdef WOLFSSL_SHA384
574 ret = wc_InitSha384_ex(&hash->sha384, heap, devId);
575#endif
576 break;
577 case WC_HASH_TYPE_SHA512:
578#ifdef WOLFSSL_SHA512
579 ret = wc_InitSha512_ex(&hash->sha512, heap, devId);
580#endif
581 break;
582
583 case WC_HASH_TYPE_SHA3_224:
584#if defined(WOLFSSL_SHA3) && !defined(WOLFSSL_NOSHA3_224)
585 ret = wc_InitSha3_224(&hash->sha3, heap, devId);
586#endif
587 break;
588 case WC_HASH_TYPE_SHA3_256:
589#if defined(WOLFSSL_SHA3) && !defined(WOLFSSL_NOSHA3_256)
590 ret = wc_InitSha3_256(&hash->sha3, heap, devId);
591#endif
592 break;
593 case WC_HASH_TYPE_SHA3_384:
594#if defined(WOLFSSL_SHA3) && !defined(WOLFSSL_NOSHA3_384)
595 ret = wc_InitSha3_384(&hash->sha3, heap, devId);
596#endif
597 break;
598 case WC_HASH_TYPE_SHA3_512:
599#if defined(WOLFSSL_SHA3) && !defined(WOLFSSL_NOSHA3_512)
600 ret = wc_InitSha3_512(&hash->sha3, heap, devId);
601#endif
602 break;
603
604 /* not supported */
605 case WC_HASH_TYPE_MD5_SHA:
606 case WC_HASH_TYPE_MD2:
607 case WC_HASH_TYPE_MD4:
608 case WC_HASH_TYPE_BLAKE2B:
609 case WC_HASH_TYPE_BLAKE2S:
610 case WC_HASH_TYPE_NONE:
611 default:
612 ret = BAD_FUNC_ARG;
613 };
614
615 return ret;
616}
617
618int wc_HashInit(wc_HashAlg* hash, enum wc_HashType type)
619{
620 return wc_HashInit_ex(hash, type, NULL, INVALID_DEVID);
621}
622
623int wc_HashUpdate(wc_HashAlg* hash, enum wc_HashType type, const byte* data,
624 word32 dataSz)
625{
626 int ret = HASH_TYPE_E; /* Default to hash type error */
627
628 if (hash == NULL || (data == NULL && dataSz > 0))
629 return BAD_FUNC_ARG;
630
631 switch (type) {
632 case WC_HASH_TYPE_MD5:
633#ifndef NO_MD5
634 ret = wc_Md5Update(&hash->md5, data, dataSz);
635#endif
636 break;
637 case WC_HASH_TYPE_SHA:
638#ifndef NO_SHA
639 ret = wc_ShaUpdate(&hash->sha, data, dataSz);
640#endif
641 break;
642 case WC_HASH_TYPE_SHA224:
643#ifdef WOLFSSL_SHA224
644 ret = wc_Sha224Update(&hash->sha224, data, dataSz);
645#endif
646 break;
647 case WC_HASH_TYPE_SHA256:
648#ifndef NO_SHA256
649 ret = wc_Sha256Update(&hash->sha256, data, dataSz);
650#endif
651 break;
652 case WC_HASH_TYPE_SHA384:
653#ifdef WOLFSSL_SHA384
654 ret = wc_Sha384Update(&hash->sha384, data, dataSz);
655#endif
656 break;
657 case WC_HASH_TYPE_SHA512:
658#ifdef WOLFSSL_SHA512
659 ret = wc_Sha512Update(&hash->sha512, data, dataSz);
660#endif
661 break;
662
663 case WC_HASH_TYPE_SHA3_224:
664#if defined(WOLFSSL_SHA3) && !defined(WOLFSSL_NOSHA3_224)
665 ret = wc_Sha3_224_Update(&hash->sha3, data, dataSz);
666#endif
667 break;
668 case WC_HASH_TYPE_SHA3_256:
669#if defined(WOLFSSL_SHA3) && !defined(WOLFSSL_NOSHA3_256)
670 ret = wc_Sha3_256_Update(&hash->sha3, data, dataSz);
671#endif
672 break;
673 case WC_HASH_TYPE_SHA3_384:
674#if defined(WOLFSSL_SHA3) && !defined(WOLFSSL_NOSHA3_384)
675 ret = wc_Sha3_384_Update(&hash->sha3, data, dataSz);
676#endif
677 break;
678 case WC_HASH_TYPE_SHA3_512:
679#if defined(WOLFSSL_SHA3) && !defined(WOLFSSL_NOSHA3_512)
680 ret = wc_Sha3_512_Update(&hash->sha3, data, dataSz);
681#endif
682 break;
683
684 /* not supported */
685 case WC_HASH_TYPE_MD5_SHA:
686 case WC_HASH_TYPE_MD2:
687 case WC_HASH_TYPE_MD4:
688 case WC_HASH_TYPE_BLAKE2B:
689 case WC_HASH_TYPE_BLAKE2S:
690 case WC_HASH_TYPE_NONE:
691 default:
692 ret = BAD_FUNC_ARG;
693 };
694
695 return ret;
696}
697
698int wc_HashFinal(wc_HashAlg* hash, enum wc_HashType type, byte* out)
699{
700 int ret = HASH_TYPE_E; /* Default to hash type error */
701
702 if (hash == NULL || out == NULL)
703 return BAD_FUNC_ARG;
704
705 switch (type) {
706 case WC_HASH_TYPE_MD5:
707#ifndef NO_MD5
708 ret = wc_Md5Final(&hash->md5, out);
709#endif
710 break;
711 case WC_HASH_TYPE_SHA:
712#ifndef NO_SHA
713 ret = wc_ShaFinal(&hash->sha, out);
714#endif
715 break;
716 case WC_HASH_TYPE_SHA224:
717#ifdef WOLFSSL_SHA224
718 ret = wc_Sha224Final(&hash->sha224, out);
719#endif
720 break;
721 case WC_HASH_TYPE_SHA256:
722#ifndef NO_SHA256
723 ret = wc_Sha256Final(&hash->sha256, out);
724#endif
725 break;
726 case WC_HASH_TYPE_SHA384:
727#ifdef WOLFSSL_SHA384
728 ret = wc_Sha384Final(&hash->sha384, out);
729#endif
730 break;
731 case WC_HASH_TYPE_SHA512:
732#ifdef WOLFSSL_SHA512
733 ret = wc_Sha512Final(&hash->sha512, out);
734#endif
735 break;
736
737 case WC_HASH_TYPE_SHA3_224:
738#if defined(WOLFSSL_SHA3) && !defined(WOLFSSL_NOSHA3_224)
739 ret = wc_Sha3_224_Final(&hash->sha3, out);
740#endif
741 break;
742 case WC_HASH_TYPE_SHA3_256:
743#if defined(WOLFSSL_SHA3) && !defined(WOLFSSL_NOSHA3_256)
744 ret = wc_Sha3_256_Final(&hash->sha3, out);
745#endif
746 break;
747 case WC_HASH_TYPE_SHA3_384:
748#if defined(WOLFSSL_SHA3) && !defined(WOLFSSL_NOSHA3_384)
749 ret = wc_Sha3_384_Final(&hash->sha3, out);
750#endif
751 break;
752 case WC_HASH_TYPE_SHA3_512:
753#if defined(WOLFSSL_SHA3) && !defined(WOLFSSL_NOSHA3_512)
754 ret = wc_Sha3_512_Final(&hash->sha3, out);
755#endif
756 break;
757
758 /* not supported */
759 case WC_HASH_TYPE_MD5_SHA:
760 case WC_HASH_TYPE_MD2:
761 case WC_HASH_TYPE_MD4:
762 case WC_HASH_TYPE_BLAKE2B:
763 case WC_HASH_TYPE_BLAKE2S:
764 case WC_HASH_TYPE_NONE:
765 default:
766 ret = BAD_FUNC_ARG;
767 };
768
769 return ret;
770}
771
772int wc_HashFree(wc_HashAlg* hash, enum wc_HashType type)
773{
774 int ret = HASH_TYPE_E; /* Default to hash type error */
775
776 if (hash == NULL)
777 return BAD_FUNC_ARG;
778
779 switch (type) {
780 case WC_HASH_TYPE_MD5:
781#ifndef NO_MD5
782 wc_Md5Free(&hash->md5);
783 ret = 0;
784#endif
785 break;
786 case WC_HASH_TYPE_SHA:
787#ifndef NO_SHA
788 wc_ShaFree(&hash->sha);
789 ret = 0;
790#endif
791 break;
792 case WC_HASH_TYPE_SHA224:
793#ifdef WOLFSSL_SHA224
794 wc_Sha224Free(&hash->sha224);
795 ret = 0;
796#endif
797 break;
798 case WC_HASH_TYPE_SHA256:
799#ifndef NO_SHA256
800 wc_Sha256Free(&hash->sha256);
801 ret = 0;
802#endif
803 break;
804 case WC_HASH_TYPE_SHA384:
805#ifdef WOLFSSL_SHA384
806 wc_Sha384Free(&hash->sha384);
807 ret = 0;
808#endif
809 break;
810 case WC_HASH_TYPE_SHA512:
811#ifdef WOLFSSL_SHA512
812 wc_Sha512Free(&hash->sha512);
813 ret = 0;
814#endif
815 break;
816
817 case WC_HASH_TYPE_SHA3_224:
818#if defined(WOLFSSL_SHA3) && !defined(WOLFSSL_NOSHA3_224)
819 wc_Sha3_224_Free(&hash->sha3);
820 ret = 0;
821#endif
822 break;
823 case WC_HASH_TYPE_SHA3_256:
824#if defined(WOLFSSL_SHA3) && !defined(WOLFSSL_NOSHA3_256)
825 wc_Sha3_256_Free(&hash->sha3);
826 ret = 0;
827#endif
828 break;
829 case WC_HASH_TYPE_SHA3_384:
830#if defined(WOLFSSL_SHA3) && !defined(WOLFSSL_NOSHA3_384)
831 wc_Sha3_384_Free(&hash->sha3);
832 ret = 0;
833#endif
834 break;
835 case WC_HASH_TYPE_SHA3_512:
836#if defined(WOLFSSL_SHA3) && !defined(WOLFSSL_NOSHA3_512)
837 wc_Sha3_512_Free(&hash->sha3);
838 ret = 0;
839#endif
840 break;
841
842 /* not supported */
843 case WC_HASH_TYPE_MD5_SHA:
844 case WC_HASH_TYPE_MD2:
845 case WC_HASH_TYPE_MD4:
846 case WC_HASH_TYPE_BLAKE2B:
847 case WC_HASH_TYPE_BLAKE2S:
848 case WC_HASH_TYPE_NONE:
849 default:
850 ret = BAD_FUNC_ARG;
851 };
852
853 return ret;
854}
855
856#if defined(WOLFSSL_HASH_FLAGS) || defined(WOLF_CRYPTO_CB)
857int wc_HashSetFlags(wc_HashAlg* hash, enum wc_HashType type, word32 flags)
858{
859 int ret = HASH_TYPE_E; /* Default to hash type error */
860
861 if (hash == NULL)
862 return BAD_FUNC_ARG;
863
864 switch (type) {
865 case WC_HASH_TYPE_MD5:
866#ifndef NO_MD5
867 ret = wc_Md5SetFlags(&hash->md5, flags);
868#endif
869 break;
870 case WC_HASH_TYPE_SHA:
871#ifndef NO_SHA
872 ret = wc_ShaSetFlags(&hash->sha, flags);
873#endif
874 break;
875 case WC_HASH_TYPE_SHA224:
876#ifdef WOLFSSL_SHA224
877 ret = wc_Sha224SetFlags(&hash->sha224, flags);
878#endif
879 break;
880 case WC_HASH_TYPE_SHA256:
881#ifndef NO_SHA256
882 ret = wc_Sha256SetFlags(&hash->sha256, flags);
883#endif
884 break;
885 case WC_HASH_TYPE_SHA384:
886#ifdef WOLFSSL_SHA384
887 ret = wc_Sha384SetFlags(&hash->sha384, flags);
888#endif
889 break;
890 case WC_HASH_TYPE_SHA512:
891#ifdef WOLFSSL_SHA512
892 ret = wc_Sha512SetFlags(&hash->sha512, flags);
893#endif
894 break;
895
896 case WC_HASH_TYPE_SHA3_224:
897 case WC_HASH_TYPE_SHA3_256:
898 case WC_HASH_TYPE_SHA3_384:
899 case WC_HASH_TYPE_SHA3_512:
900#ifdef WOLFSSL_SHA3
901 ret = wc_Sha3_SetFlags(&hash->sha3, flags);
902#endif
903 break;
904
905 /* not supported */
906 case WC_HASH_TYPE_MD5_SHA:
907 case WC_HASH_TYPE_MD2:
908 case WC_HASH_TYPE_MD4:
909 case WC_HASH_TYPE_BLAKE2B:
910 case WC_HASH_TYPE_BLAKE2S:
911 case WC_HASH_TYPE_NONE:
912 default:
913 ret = BAD_FUNC_ARG;
914 };
915
916 return ret;
917}
918int wc_HashGetFlags(wc_HashAlg* hash, enum wc_HashType type, word32* flags)
919{
920 int ret = HASH_TYPE_E; /* Default to hash type error */
921
922 if (hash == NULL)
923 return BAD_FUNC_ARG;
924
925 switch (type) {
926 case WC_HASH_TYPE_MD5:
927#ifndef NO_MD5
928 ret = wc_Md5GetFlags(&hash->md5, flags);
929#endif
930 break;
931 case WC_HASH_TYPE_SHA:
932#ifndef NO_SHA
933 ret = wc_ShaGetFlags(&hash->sha, flags);
934#endif
935 break;
936 case WC_HASH_TYPE_SHA224:
937#ifdef WOLFSSL_SHA224
938 ret = wc_Sha224GetFlags(&hash->sha224, flags);
939#endif
940 break;
941 case WC_HASH_TYPE_SHA256:
942#ifndef NO_SHA256
943 ret = wc_Sha256GetFlags(&hash->sha256, flags);
944#endif
945 break;
946 case WC_HASH_TYPE_SHA384:
947#ifdef WOLFSSL_SHA384
948 ret = wc_Sha384GetFlags(&hash->sha384, flags);
949#endif
950 break;
951 case WC_HASH_TYPE_SHA512:
952#ifdef WOLFSSL_SHA512
953 ret = wc_Sha512GetFlags(&hash->sha512, flags);
954#endif
955 break;
956
957 case WC_HASH_TYPE_SHA3_224:
958 case WC_HASH_TYPE_SHA3_256:
959 case WC_HASH_TYPE_SHA3_384:
960 case WC_HASH_TYPE_SHA3_512:
961#ifdef WOLFSSL_SHA3
962 ret = wc_Sha3_GetFlags(&hash->sha3, flags);
963#endif
964 break;
965
966 /* not supported */
967 case WC_HASH_TYPE_MD5_SHA:
968 case WC_HASH_TYPE_MD2:
969 case WC_HASH_TYPE_MD4:
970 case WC_HASH_TYPE_BLAKE2B:
971 case WC_HASH_TYPE_BLAKE2S:
972 case WC_HASH_TYPE_NONE:
973 default:
974 ret = BAD_FUNC_ARG;
975 };
976
977 return ret;
978}
979#endif
980
981
982#if !defined(WOLFSSL_TI_HASH)
983
984#if !defined(NO_MD5)
985 int wc_Md5Hash(const byte* data, word32 len, byte* hash)
986 {
987 int ret;
988 #ifdef WOLFSSL_SMALL_STACK
989 wc_Md5* md5;
990 #else
991 wc_Md5 md5[1];
992 #endif
993
994 #ifdef WOLFSSL_SMALL_STACK
995 md5 = (wc_Md5*)XMALLOC(sizeof(wc_Md5), NULL, DYNAMIC_TYPE_TMP_BUFFER);
996 if (md5 == NULL)
997 return MEMORY_E;
998 #endif
999
1000 if ((ret = wc_InitMd5(md5)) != 0) {
1001 WOLFSSL_MSG("InitMd5 failed");
1002 }
1003 else {
1004 if ((ret = wc_Md5Update(md5, data, len)) != 0) {
1005 WOLFSSL_MSG("Md5Update failed");
1006 }
1007 else if ((ret = wc_Md5Final(md5, hash)) != 0) {
1008 WOLFSSL_MSG("Md5Final failed");
1009 }
1010 wc_Md5Free(md5);
1011 }
1012
1013 #ifdef WOLFSSL_SMALL_STACK
1014 XFREE(md5, NULL, DYNAMIC_TYPE_TMP_BUFFER);
1015 #endif
1016
1017 return ret;
1018 }
1019#endif /* !NO_MD5 */
1020
1021#if !defined(NO_SHA)
1022 int wc_ShaHash(const byte* data, word32 len, byte* hash)
1023 {
1024 int ret = 0;
1025 #ifdef WOLFSSL_SMALL_STACK
1026 wc_Sha* sha;
1027 #else
1028 wc_Sha sha[1];
1029 #endif
1030 int devId = INVALID_DEVID;
1031
1032 #ifdef WOLFSSL_SMALL_STACK
1033 sha = (wc_Sha*)XMALLOC(sizeof(wc_Sha), NULL, DYNAMIC_TYPE_TMP_BUFFER);
1034 if (sha == NULL)
1035 return MEMORY_E;
1036 #endif
1037
1038 #ifdef WOLF_CRYPTO_CB
1039 /* only use devId if its not an empty hash */
1040 if (data != NULL && len > 0)
1041 devId = wc_CryptoCb_GetDevIdAtIndex(0);
1042 #endif
1043
1044 if ((ret = wc_InitSha_ex(sha, NULL, devId)) != 0) {
1045 WOLFSSL_MSG("InitSha failed");
1046 }
1047 else {
1048 if ((ret = wc_ShaUpdate(sha, data, len)) != 0) {
1049 WOLFSSL_MSG("ShaUpdate failed");
1050 }
1051 else if ((ret = wc_ShaFinal(sha, hash)) != 0) {
1052 WOLFSSL_MSG("ShaFinal failed");
1053 }
1054 wc_ShaFree(sha);
1055 }
1056
1057 #ifdef WOLFSSL_SMALL_STACK
1058 XFREE(sha, NULL, DYNAMIC_TYPE_TMP_BUFFER);
1059 #endif
1060
1061 return ret;
1062 }
1063#endif /* !NO_SHA */
1064
1065#if defined(WOLFSSL_SHA224)
1066 int wc_Sha224Hash(const byte* data, word32 len, byte* hash)
1067 {
1068 int ret = 0;
1069 #ifdef WOLFSSL_SMALL_STACK
1070 wc_Sha224* sha224;
1071 #else
1072 wc_Sha224 sha224[1];
1073 #endif
1074
1075 #ifdef WOLFSSL_SMALL_STACK
1076 sha224 = (wc_Sha224*)XMALLOC(sizeof(wc_Sha224), NULL,
1077 DYNAMIC_TYPE_TMP_BUFFER);
1078 if (sha224 == NULL)
1079 return MEMORY_E;
1080 #endif
1081
1082 if ((ret = wc_InitSha224(sha224)) != 0) {
1083 WOLFSSL_MSG("InitSha224 failed");
1084 }
1085 else {
1086 if ((ret = wc_Sha224Update(sha224, data, len)) != 0) {
1087 WOLFSSL_MSG("Sha224Update failed");
1088 }
1089 else if ((ret = wc_Sha224Final(sha224, hash)) != 0) {
1090 WOLFSSL_MSG("Sha224Final failed");
1091 }
1092 wc_Sha224Free(sha224);
1093 }
1094
1095 #ifdef WOLFSSL_SMALL_STACK
1096 XFREE(sha224, NULL, DYNAMIC_TYPE_TMP_BUFFER);
1097 #endif
1098
1099 return ret;
1100}
1101#endif /* WOLFSSL_SHA224 */
1102
1103#if !defined(NO_SHA256)
1104 int wc_Sha256Hash(const byte* data, word32 len, byte* hash)
1105 {
1106 int ret = 0;
1107 #ifdef WOLFSSL_SMALL_STACK
1108 wc_Sha256* sha256;
1109 #else
1110 wc_Sha256 sha256[1];
1111 #endif
1112 int devId = INVALID_DEVID;
1113
1114 #ifdef WOLFSSL_SMALL_STACK
1115 sha256 = (wc_Sha256*)XMALLOC(sizeof(wc_Sha256), NULL,
1116 DYNAMIC_TYPE_TMP_BUFFER);
1117 if (sha256 == NULL)
1118 return MEMORY_E;
1119 #endif
1120
1121 #ifdef WOLF_CRYPTO_CB
1122 /* only use devId if its not an empty hash */
1123 if (data != NULL && len > 0)
1124 devId = wc_CryptoCb_GetDevIdAtIndex(0);
1125 #endif
1126
1127 if ((ret = wc_InitSha256_ex(sha256, NULL, devId)) != 0) {
1128 WOLFSSL_MSG("InitSha256 failed");
1129 }
1130 else {
1131 if ((ret = wc_Sha256Update(sha256, data, len)) != 0) {
1132 WOLFSSL_MSG("Sha256Update failed");
1133 }
1134 else if ((ret = wc_Sha256Final(sha256, hash)) != 0) {
1135 WOLFSSL_MSG("Sha256Final failed");
1136 }
1137 wc_Sha256Free(sha256);
1138 }
1139
1140
1141 #ifdef WOLFSSL_SMALL_STACK
1142 XFREE(sha256, NULL, DYNAMIC_TYPE_TMP_BUFFER);
1143 #endif
1144
1145 return ret;
1146 }
1147#endif /* !NO_SHA256 */
1148
1149#endif /* !defined(WOLFSSL_TI_HASH) */
1150
1151
1152#if defined(WOLFSSL_SHA512)
1153 int wc_Sha512Hash(const byte* data, word32 len, byte* hash)
1154 {
1155 int ret = 0;
1156 #ifdef WOLFSSL_SMALL_STACK
1157 wc_Sha512* sha512;
1158 #else
1159 wc_Sha512 sha512[1];
1160 #endif
1161
1162 #ifdef WOLFSSL_SMALL_STACK
1163 sha512 = (wc_Sha512*)XMALLOC(sizeof(wc_Sha512), NULL,
1164 DYNAMIC_TYPE_TMP_BUFFER);
1165 if (sha512 == NULL)
1166 return MEMORY_E;
1167 #endif
1168
1169 if ((ret = wc_InitSha512(sha512)) != 0) {
1170 WOLFSSL_MSG("InitSha512 failed");
1171 }
1172 else {
1173 if ((ret = wc_Sha512Update(sha512, data, len)) != 0) {
1174 WOLFSSL_MSG("Sha512Update failed");
1175 }
1176 else if ((ret = wc_Sha512Final(sha512, hash)) != 0) {
1177 WOLFSSL_MSG("Sha512Final failed");
1178 }
1179 wc_Sha512Free(sha512);
1180 }
1181
1182 #ifdef WOLFSSL_SMALL_STACK
1183 XFREE(sha512, NULL, DYNAMIC_TYPE_TMP_BUFFER);
1184 #endif
1185
1186 return ret;
1187 }
1188#endif /* WOLFSSL_SHA512 */
1189
1190#if defined(WOLFSSL_SHA384)
1191 int wc_Sha384Hash(const byte* data, word32 len, byte* hash)
1192 {
1193 int ret = 0;
1194 #ifdef WOLFSSL_SMALL_STACK
1195 wc_Sha384* sha384;
1196 #else
1197 wc_Sha384 sha384[1];
1198 #endif
1199
1200 #ifdef WOLFSSL_SMALL_STACK
1201 sha384 = (wc_Sha384*)XMALLOC(sizeof(wc_Sha384), NULL,
1202 DYNAMIC_TYPE_TMP_BUFFER);
1203 if (sha384 == NULL)
1204 return MEMORY_E;
1205 #endif
1206
1207 if ((ret = wc_InitSha384(sha384)) != 0) {
1208 WOLFSSL_MSG("InitSha384 failed");
1209 }
1210 else {
1211 if ((ret = wc_Sha384Update(sha384, data, len)) != 0) {
1212 WOLFSSL_MSG("Sha384Update failed");
1213 }
1214 else if ((ret = wc_Sha384Final(sha384, hash)) != 0) {
1215 WOLFSSL_MSG("Sha384Final failed");
1216 }
1217 wc_Sha384Free(sha384);
1218 }
1219
1220 #ifdef WOLFSSL_SMALL_STACK
1221 XFREE(sha384, NULL, DYNAMIC_TYPE_TMP_BUFFER);
1222 #endif
1223
1224 return ret;
1225 }
1226#endif /* WOLFSSL_SHA384 */
1227
1228#if defined(WOLFSSL_SHA3)
1229#if !defined(WOLFSSL_NOSHA3_224)
1230 int wc_Sha3_224Hash(const byte* data, word32 len, byte* hash)
1231 {
1232 int ret = 0;
1233 #ifdef WOLFSSL_SMALL_STACK
1234 wc_Sha3* sha3;
1235 #else
1236 wc_Sha3 sha3[1];
1237 #endif
1238
1239 #ifdef WOLFSSL_SMALL_STACK
1240 sha3 = (wc_Sha3*)XMALLOC(sizeof(wc_Sha3), NULL,
1241 DYNAMIC_TYPE_TMP_BUFFER);
1242 if (sha3 == NULL)
1243 return MEMORY_E;
1244 #endif
1245
1246 if ((ret = wc_InitSha3_224(sha3, NULL, INVALID_DEVID)) != 0) {
1247 WOLFSSL_MSG("InitSha3_224 failed");
1248 }
1249 else {
1250 if ((ret = wc_Sha3_224_Update(sha3, data, len)) != 0) {
1251 WOLFSSL_MSG("Sha3_224_Update failed");
1252 }
1253 else if ((ret = wc_Sha3_224_Final(sha3, hash)) != 0) {
1254 WOLFSSL_MSG("Sha3_224_Final failed");
1255 }
1256 wc_Sha3_224_Free(sha3);
1257 }
1258
1259 #ifdef WOLFSSL_SMALL_STACK
1260 XFREE(sha3, NULL, DYNAMIC_TYPE_TMP_BUFFER);
1261 #endif
1262
1263 return ret;
1264 }
1265#endif /* !WOLFSSL_NOSHA3_224 */
1266
1267#if !defined(WOLFSSL_NOSHA3_256)
1268 int wc_Sha3_256Hash(const byte* data, word32 len, byte* hash)
1269 {
1270 int ret = 0;
1271 #ifdef WOLFSSL_SMALL_STACK
1272 wc_Sha3* sha3;
1273 #else
1274 wc_Sha3 sha3[1];
1275 #endif
1276
1277 #ifdef WOLFSSL_SMALL_STACK
1278 sha3 = (wc_Sha3*)XMALLOC(sizeof(wc_Sha3), NULL,
1279 DYNAMIC_TYPE_TMP_BUFFER);
1280 if (sha3 == NULL)
1281 return MEMORY_E;
1282 #endif
1283
1284 if ((ret = wc_InitSha3_256(sha3, NULL, INVALID_DEVID)) != 0) {
1285 WOLFSSL_MSG("InitSha3_256 failed");
1286 }
1287 else {
1288 if ((ret = wc_Sha3_256_Update(sha3, data, len)) != 0) {
1289 WOLFSSL_MSG("Sha3_256_Update failed");
1290 }
1291 else if ((ret = wc_Sha3_256_Final(sha3, hash)) != 0) {
1292 WOLFSSL_MSG("Sha3_256_Final failed");
1293 }
1294 wc_Sha3_256_Free(sha3);
1295 }
1296
1297 #ifdef WOLFSSL_SMALL_STACK
1298 XFREE(sha3, NULL, DYNAMIC_TYPE_TMP_BUFFER);
1299 #endif
1300
1301 return ret;
1302 }
1303#endif /* !WOLFSSL_NOSHA3_256 */
1304
1305#if !defined(WOLFSSL_NOSHA3_384)
1306 int wc_Sha3_384Hash(const byte* data, word32 len, byte* hash)
1307 {
1308 int ret = 0;
1309 #ifdef WOLFSSL_SMALL_STACK
1310 wc_Sha3* sha3;
1311 #else
1312 wc_Sha3 sha3[1];
1313 #endif
1314
1315 #ifdef WOLFSSL_SMALL_STACK
1316 sha3 = (wc_Sha3*)XMALLOC(sizeof(wc_Sha3), NULL,
1317 DYNAMIC_TYPE_TMP_BUFFER);
1318 if (sha3 == NULL)
1319 return MEMORY_E;
1320 #endif
1321
1322 if ((ret = wc_InitSha3_384(sha3, NULL, INVALID_DEVID)) != 0) {
1323 WOLFSSL_MSG("InitSha3_384 failed");
1324 }
1325 else {
1326 if ((ret = wc_Sha3_384_Update(sha3, data, len)) != 0) {
1327 WOLFSSL_MSG("Sha3_384_Update failed");
1328 }
1329 else if ((ret = wc_Sha3_384_Final(sha3, hash)) != 0) {
1330 WOLFSSL_MSG("Sha3_384_Final failed");
1331 }
1332 wc_Sha3_384_Free(sha3);
1333 }
1334
1335 #ifdef WOLFSSL_SMALL_STACK
1336 XFREE(sha3, NULL, DYNAMIC_TYPE_TMP_BUFFER);
1337 #endif
1338
1339 return ret;
1340 }
1341#endif /* !WOLFSSL_NOSHA3_384 */
1342
1343#if !defined(WOLFSSL_NOSHA3_512)
1344 int wc_Sha3_512Hash(const byte* data, word32 len, byte* hash)
1345 {
1346 int ret = 0;
1347 #ifdef WOLFSSL_SMALL_STACK
1348 wc_Sha3* sha3;
1349 #else
1350 wc_Sha3 sha3[1];
1351 #endif
1352
1353 #ifdef WOLFSSL_SMALL_STACK
1354 sha3 = (wc_Sha3*)XMALLOC(sizeof(wc_Sha3), NULL,
1355 DYNAMIC_TYPE_TMP_BUFFER);
1356 if (sha3 == NULL)
1357 return MEMORY_E;
1358 #endif
1359
1360 if ((ret = wc_InitSha3_512(sha3, NULL, INVALID_DEVID)) != 0) {
1361 WOLFSSL_MSG("InitSha3_512 failed");
1362 }
1363 else {
1364 if ((ret = wc_Sha3_512_Update(sha3, data, len)) != 0) {
1365 WOLFSSL_MSG("Sha3_512_Update failed");
1366 }
1367 else if ((ret = wc_Sha3_512_Final(sha3, hash)) != 0) {
1368 WOLFSSL_MSG("Sha3_512_Final failed");
1369 }
1370 wc_Sha3_512_Free(sha3);
1371 }
1372
1373 #ifdef WOLFSSL_SMALL_STACK
1374 XFREE(sha3, NULL, DYNAMIC_TYPE_TMP_BUFFER);
1375 #endif
1376
1377 return ret;
1378 }
1379#endif /* !WOLFSSL_NOSHA3_512 */
1380
1381#if defined(WOLFSSL_SHAKE256) && !defined(WOLFSSL_NO_SHAKE256)
1382 int wc_Shake256Hash(const byte* data, word32 len, byte* hash,
1383 word32 hashLen)
1384 {
1385 int ret = 0;
1386 #ifdef WOLFSSL_SMALL_STACK
1387 wc_Shake* shake;
1388 #else
1389 wc_Shake shake[1];
1390 #endif
1391
1392 #ifdef WOLFSSL_SMALL_STACK
1393 shake = (wc_Shake*)XMALLOC(sizeof(wc_Shake), NULL,
1394 DYNAMIC_TYPE_TMP_BUFFER);
1395 if (shake == NULL)
1396 return MEMORY_E;
1397 #endif
1398
1399 if ((ret = wc_InitShake256(shake, NULL, INVALID_DEVID)) != 0) {
1400 WOLFSSL_MSG("InitShake256 failed");
1401 }
1402 else {
1403 if ((ret = wc_Shake256_Update(shake, data, len)) != 0) {
1404 WOLFSSL_MSG("Shake256_Update failed");
1405 }
1406 else if ((ret = wc_Shake256_Final(shake, hash, hashLen)) != 0) {
1407 WOLFSSL_MSG("Shake256_Final failed");
1408 }
1409 wc_Shake256_Free(shake);
1410 }
1411
1412 #ifdef WOLFSSL_SMALL_STACK
1413 XFREE(shake, NULL, DYNAMIC_TYPE_TMP_BUFFER);
1414 #endif
1415
1416 return ret;
1417 }
1418#endif /* WOLFSSL_SHAKE_256 && !WOLFSSL_NO_SHAKE256 */
1419#endif /* WOLFSSL_SHA3 */
1420
1421#endif /* !NO_HASH_WRAPPER */
1422
1423#ifdef WOLFSSL_HAVE_PRF
1424
1425#ifdef WOLFSSL_SHA384
1426 #define P_HASH_MAX_SIZE WC_SHA384_DIGEST_SIZE
1427#else
1428 #define P_HASH_MAX_SIZE WC_SHA256_DIGEST_SIZE
1429#endif
1430
1431/* Pseudo Random Function for MD5, SHA-1, SHA-256, or SHA-384 */
1432int wc_PRF(byte* result, word32 resLen, const byte* secret,
1433 word32 secLen, const byte* seed, word32 seedLen, int hash,
1434 void* heap, int devId)
1435{
1436 word32 len = P_HASH_MAX_SIZE;
1437 word32 times;
1438 word32 lastLen;
1439 word32 lastTime;
1440 word32 i;
1441 word32 idx = 0;
1442 int ret = 0;
1443#ifdef WOLFSSL_SMALL_STACK
1444 byte* previous;
1445 byte* current;
1446 Hmac* hmac;
1447#else
1448 byte previous[P_HASH_MAX_SIZE]; /* max size */
1449 byte current[P_HASH_MAX_SIZE]; /* max size */
1450 Hmac hmac[1];
1451#endif
1452
1453#ifdef WOLFSSL_SMALL_STACK
1454 previous = (byte*)XMALLOC(P_HASH_MAX_SIZE, heap, DYNAMIC_TYPE_DIGEST);
1455 current = (byte*)XMALLOC(P_HASH_MAX_SIZE, heap, DYNAMIC_TYPE_DIGEST);
1456 hmac = (Hmac*)XMALLOC(sizeof(Hmac), heap, DYNAMIC_TYPE_HMAC);
1457
1458 if (previous == NULL || current == NULL || hmac == NULL) {
1459 if (previous) XFREE(previous, heap, DYNAMIC_TYPE_DIGEST);
1460 if (current) XFREE(current, heap, DYNAMIC_TYPE_DIGEST);
1461 if (hmac) XFREE(hmac, heap, DYNAMIC_TYPE_HMAC);
1462
1463 return MEMORY_E;
1464 }
1465#endif
1466
1467 switch (hash) {
1468 #ifndef NO_MD5
1469 case md5_mac:
1470 hash = WC_MD5;
1471 len = WC_MD5_DIGEST_SIZE;
1472 break;
1473 #endif
1474
1475 #ifndef NO_SHA256
1476 case sha256_mac:
1477 hash = WC_SHA256;
1478 len = WC_SHA256_DIGEST_SIZE;
1479 break;
1480 #endif
1481
1482 #ifdef WOLFSSL_SHA384
1483 case sha384_mac:
1484 hash = WC_SHA384;
1485 len = WC_SHA384_DIGEST_SIZE;
1486 break;
1487 #endif
1488
1489 #ifndef NO_SHA
1490 case sha_mac:
1491 default:
1492 hash = WC_SHA;
1493 len = WC_SHA_DIGEST_SIZE;
1494 break;
1495 #endif
1496 }
1497
1498 times = resLen / len;
1499 lastLen = resLen % len;
1500
1501 if (lastLen)
1502 times += 1;
1503
1504 lastTime = times - 1;
1505
1506 ret = wc_HmacInit(hmac, heap, devId);
1507 if (ret == 0) {
1508 ret = wc_HmacSetKey(hmac, hash, secret, secLen);
1509 if (ret == 0)
1510 ret = wc_HmacUpdate(hmac, seed, seedLen); /* A0 = seed */
1511 if (ret == 0)
1512 ret = wc_HmacFinal(hmac, previous); /* A1 */
1513 if (ret == 0) {
1514 for (i = 0; i < times; i++) {
1515 ret = wc_HmacUpdate(hmac, previous, len);
1516 if (ret != 0)
1517 break;
1518 ret = wc_HmacUpdate(hmac, seed, seedLen);
1519 if (ret != 0)
1520 break;
1521 ret = wc_HmacFinal(hmac, current);
1522 if (ret != 0)
1523 break;
1524
1525 if ((i == lastTime) && lastLen)
1526 XMEMCPY(&result[idx], current,
1527 min(lastLen, P_HASH_MAX_SIZE));
1528 else {
1529 XMEMCPY(&result[idx], current, len);
1530 idx += len;
1531 ret = wc_HmacUpdate(hmac, previous, len);
1532 if (ret != 0)
1533 break;
1534 ret = wc_HmacFinal(hmac, previous);
1535 if (ret != 0)
1536 break;
1537 }
1538 }
1539 }
1540 wc_HmacFree(hmac);
1541 }
1542
1543 ForceZero(previous, P_HASH_MAX_SIZE);
1544 ForceZero(current, P_HASH_MAX_SIZE);
1545 ForceZero(hmac, sizeof(Hmac));
1546
1547#ifdef WOLFSSL_SMALL_STACK
1548 XFREE(previous, heap, DYNAMIC_TYPE_DIGEST);
1549 XFREE(current, heap, DYNAMIC_TYPE_DIGEST);
1550 XFREE(hmac, heap, DYNAMIC_TYPE_HMAC);
1551#endif
1552
1553 return ret;
1554}
1555#undef P_HASH_MAX_SIZE
1556
1557/* compute PRF (pseudo random function) using SHA1 and MD5 for TLSv1 */
1558int wc_PRF_TLSv1(byte* digest, word32 digLen, const byte* secret,
1559 word32 secLen, const byte* label, word32 labLen,
1560 const byte* seed, word32 seedLen, void* heap, int devId)
1561{
1562 int ret = 0;
1563 word32 half = (secLen + 1) / 2;
1564
1565#ifdef WOLFSSL_SMALL_STACK
1566 byte* md5_half;
1567 byte* sha_half;
1568 byte* md5_result;
1569 byte* sha_result;
1570#else
1571 byte md5_half[MAX_PRF_HALF]; /* half is real size */
1572 byte sha_half[MAX_PRF_HALF]; /* half is real size */
1573 byte md5_result[MAX_PRF_DIG]; /* digLen is real size */
1574 byte sha_result[MAX_PRF_DIG]; /* digLen is real size */
1575#endif
1576#if defined(WOLFSSL_ASYNC_CRYPT) && !defined(WC_ASYNC_NO_HASH)
1577 DECLARE_VAR(labelSeed, byte, MAX_PRF_LABSEED, heap);
1578 if (labelSeed == NULL)
1579 return MEMORY_E;
1580#else
1581 byte labelSeed[MAX_PRF_LABSEED];
1582#endif
1583
1584 if (half > MAX_PRF_HALF ||
1585 labLen + seedLen > MAX_PRF_LABSEED ||
1586 digLen > MAX_PRF_DIG)
1587 {
1588 #if defined(WOLFSSL_ASYNC_CRYPT) && !defined(WC_ASYNC_NO_HASH)
1589 FREE_VAR(labelSeed, heap);
1590 #endif
1591 return BUFFER_E;
1592 }
1593
1594#ifdef WOLFSSL_SMALL_STACK
1595 md5_half = (byte*)XMALLOC(MAX_PRF_HALF, heap, DYNAMIC_TYPE_DIGEST);
1596 sha_half = (byte*)XMALLOC(MAX_PRF_HALF, heap, DYNAMIC_TYPE_DIGEST);
1597 md5_result = (byte*)XMALLOC(MAX_PRF_DIG, heap, DYNAMIC_TYPE_DIGEST);
1598 sha_result = (byte*)XMALLOC(MAX_PRF_DIG, heap, DYNAMIC_TYPE_DIGEST);
1599
1600 if (md5_half == NULL || sha_half == NULL || md5_result == NULL ||
1601 sha_result == NULL) {
1602 if (md5_half) XFREE(md5_half, heap, DYNAMIC_TYPE_DIGEST);
1603 if (sha_half) XFREE(sha_half, heap, DYNAMIC_TYPE_DIGEST);
1604 if (md5_result) XFREE(md5_result, heap, DYNAMIC_TYPE_DIGEST);
1605 if (sha_result) XFREE(sha_result, heap, DYNAMIC_TYPE_DIGEST);
1606 #if defined(WOLFSSL_ASYNC_CRYPT) && !defined(WC_ASYNC_NO_HASH)
1607 FREE_VAR(labelSeed, heap);
1608 #endif
1609
1610 return MEMORY_E;
1611 }
1612#endif
1613
1614 XMEMSET(md5_result, 0, digLen);
1615 XMEMSET(sha_result, 0, digLen);
1616
1617 XMEMCPY(md5_half, secret, half);
1618 XMEMCPY(sha_half, secret + half - secLen % 2, half);
1619
1620 XMEMCPY(labelSeed, label, labLen);
1621 XMEMCPY(labelSeed + labLen, seed, seedLen);
1622
1623 if ((ret = wc_PRF(md5_result, digLen, md5_half, half, labelSeed,
1624 labLen + seedLen, md5_mac, heap, devId)) == 0) {
1625 if ((ret = wc_PRF(sha_result, digLen, sha_half, half, labelSeed,
1626 labLen + seedLen, sha_mac, heap, devId)) == 0) {
1627 /* calculate XOR for TLSv1 PRF */
1628 XMEMCPY(digest, md5_result, digLen);
1629 xorbuf(digest, sha_result, digLen);
1630 }
1631 }
1632
1633#ifdef WOLFSSL_SMALL_STACK
1634 XFREE(md5_half, heap, DYNAMIC_TYPE_DIGEST);
1635 XFREE(sha_half, heap, DYNAMIC_TYPE_DIGEST);
1636 XFREE(md5_result, heap, DYNAMIC_TYPE_DIGEST);
1637 XFREE(sha_result, heap, DYNAMIC_TYPE_DIGEST);
1638#endif
1639
1640#if defined(WOLFSSL_ASYNC_CRYPT) && !defined(WC_ASYNC_NO_HASH)
1641 FREE_VAR(labelSeed, heap);
1642#endif
1643
1644 return ret;
1645}
1646
1647/* Wrapper for TLS 1.2 and TLSv1 cases to calculate PRF */
1648/* In TLS 1.2 case call straight thru to wc_PRF */
1649int wc_PRF_TLS(byte* digest, word32 digLen, const byte* secret, word32 secLen,
1650 const byte* label, word32 labLen, const byte* seed, word32 seedLen,
1651 int useAtLeastSha256, int hash_type, void* heap, int devId)
1652{
1653 int ret = 0;
1654
1655 if (useAtLeastSha256) {
1656 #if defined(WOLFSSL_ASYNC_CRYPT) && !defined(WC_ASYNC_NO_HASH)
1657 DECLARE_VAR(labelSeed, byte, MAX_PRF_LABSEED, heap);
1658 if (labelSeed == NULL)
1659 return MEMORY_E;
1660 #else
1661 byte labelSeed[MAX_PRF_LABSEED];
1662 #endif
1663
1664 if (labLen + seedLen > MAX_PRF_LABSEED)
1665 return BUFFER_E;
1666
1667 XMEMCPY(labelSeed, label, labLen);
1668 XMEMCPY(labelSeed + labLen, seed, seedLen);
1669
1670 /* If a cipher suite wants an algorithm better than sha256, it
1671 * should use better. */
1672 if (hash_type < sha256_mac || hash_type == blake2b_mac)
1673 hash_type = sha256_mac;
1674 /* compute PRF for MD5, SHA-1, SHA-256, or SHA-384 for TLSv1.2 PRF */
1675 ret = wc_PRF(digest, digLen, secret, secLen, labelSeed,
1676 labLen + seedLen, hash_type, heap, devId);
1677
1678 #if defined(WOLFSSL_ASYNC_CRYPT) && !defined(WC_ASYNC_NO_HASH)
1679 FREE_VAR(labelSeed, heap);
1680 #endif
1681 }
1682#ifndef NO_OLD_TLS
1683 else {
1684 /* compute TLSv1 PRF (pseudo random function using HMAC) */
1685 ret = wc_PRF_TLSv1(digest, digLen, secret, secLen, label, labLen, seed,
1686 seedLen, heap, devId);
1687 }
1688#endif
1689
1690 return ret;
1691}
1692#endif /* WOLFSSL_HAVE_PRF */
Note: See TracBrowser for help on using the repository browser.