source: azure_iot_hub/trunk/wolfssl-3.15.7/wolfcrypt/src/hash.c@ 388

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

Azure IoT Hub Device C SDK を使ったサンプルの追加
  • Property svn:eol-style set to native
  • Property svn:keywords set to Id
  • Property svn:mime-type set to text/x-csrc
File size: 23.1 KB
Line 
1/* hash.c
2 *
3 * Copyright (C) 2006-2017 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
36
37#if !defined(NO_ASN) || !defined(NO_DH) || defined(HAVE_ECC)
38
39#ifdef NO_ASN
40enum Hash_Sum {
41 MD2h = 646,
42 MD5h = 649,
43 SHAh = 88,
44 SHA224h = 417,
45 SHA256h = 414,
46 SHA384h = 415,
47 SHA512h = 416
48};
49#endif /* !NO_ASN */
50
51#ifdef HAVE_SELFTEST
52enum {
53 /* CAVP selftest includes these in hmac.h instead of sha3.h,
54 copied here for that build */
55 WC_SHA3_224_BLOCK_SIZE = 144,
56 WC_SHA3_256_BLOCK_SIZE = 136,
57 WC_SHA3_384_BLOCK_SIZE = 104,
58 WC_SHA3_512_BLOCK_SIZE = 72,
59};
60#endif
61
62
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 default:
106 eHashType = WC_HASH_TYPE_NONE;
107 break;
108 }
109#else
110 /* current master uses same unique types as wc_HashType */
111 if (hashType > 0 && hashType <= WC_HASH_TYPE_MAX) {
112 eHashType = (enum wc_HashType)hashType;
113 }
114#endif
115 return eHashType;
116}
117
118
119int wc_HashGetOID(enum wc_HashType hash_type)
120{
121 int oid = HASH_TYPE_E; /* Default to hash type error */
122 switch(hash_type)
123 {
124 case WC_HASH_TYPE_MD2:
125 #ifdef WOLFSSL_MD2
126 oid = MD2h;
127 #endif
128 break;
129 case WC_HASH_TYPE_MD5_SHA:
130 case WC_HASH_TYPE_MD5:
131 #ifndef NO_MD5
132 oid = MD5h;
133 #endif
134 break;
135 case WC_HASH_TYPE_SHA:
136 #ifndef NO_SHA
137 oid = SHAh;
138 #endif
139 break;
140 case WC_HASH_TYPE_SHA224:
141 #ifdef WOLFSSL_SHA224
142 oid = SHA224h;
143 #endif
144 break;
145 case WC_HASH_TYPE_SHA256:
146 #ifndef NO_SHA256
147 oid = SHA256h;
148 #endif
149 break;
150 case WC_HASH_TYPE_SHA384:
151 #ifdef WOLFSSL_SHA384
152 oid = SHA384h;
153 #endif
154 break;
155 case WC_HASH_TYPE_SHA512:
156 #ifdef WOLFSSL_SHA512
157 oid = SHA512h;
158 #endif
159 break;
160
161 /* Not Supported */
162 case WC_HASH_TYPE_MD4:
163 case WC_HASH_TYPE_SHA3_224:
164 case WC_HASH_TYPE_SHA3_256:
165 case WC_HASH_TYPE_SHA3_384:
166 case WC_HASH_TYPE_SHA3_512:
167 case WC_HASH_TYPE_BLAKE2B:
168 case WC_HASH_TYPE_NONE:
169 default:
170 oid = BAD_FUNC_ARG;
171 break;
172 }
173 return oid;
174}
175
176enum wc_HashType wc_OidGetHash(int oid)
177{
178 enum wc_HashType hash_type = WC_HASH_TYPE_NONE;
179 switch (oid)
180 {
181 #ifdef WOLFSSL_MD2
182 case MD2h:
183 hash_type = WC_HASH_TYPE_MD2;
184 break;
185 #endif
186 case MD5h:
187 #ifndef NO_MD5
188 hash_type = WC_HASH_TYPE_MD5;
189#endif
190 break;
191 case SHAh:
192 #ifndef NO_SHA
193 hash_type = WC_HASH_TYPE_SHA;
194 #endif
195 break;
196 case SHA224h:
197 #ifdef WOLFSSL_SHA224
198 hash_type = WC_HASH_TYPE_SHA224;
199 #endif
200 break;
201 case SHA256h:
202 #ifndef NO_SHA256
203 hash_type = WC_HASH_TYPE_SHA256;
204 #endif
205 break;
206 case SHA384h:
207 #ifdef WOLFSSL_SHA384
208 hash_type = WC_HASH_TYPE_SHA384;
209 #endif
210 break;
211 case SHA512h:
212 #ifdef WOLFSSL_SHA512
213 hash_type = WC_HASH_TYPE_SHA512;
214 #endif
215 break;
216 default:
217 break;
218 }
219 return hash_type;
220}
221#endif /* !NO_ASN || !NO_DH || HAVE_ECC */
222
223
224
225/* Get Hash digest size */
226int wc_HashGetDigestSize(enum wc_HashType hash_type)
227{
228 int dig_size = HASH_TYPE_E; /* Default to hash type error */
229 switch(hash_type)
230 {
231 case WC_HASH_TYPE_MD2:
232 #ifdef WOLFSSL_MD2
233 dig_size = MD2_DIGEST_SIZE;
234 #endif
235 break;
236 case WC_HASH_TYPE_MD4:
237 #ifndef NO_MD4
238 dig_size = MD4_DIGEST_SIZE;
239 #endif
240 break;
241 case WC_HASH_TYPE_MD5:
242#ifndef NO_MD5
243 dig_size = WC_MD5_DIGEST_SIZE;
244#endif
245 break;
246 case WC_HASH_TYPE_SHA:
247#ifndef NO_SHA
248 dig_size = WC_SHA_DIGEST_SIZE;
249#endif
250 break;
251 case WC_HASH_TYPE_SHA224:
252#ifdef WOLFSSL_SHA224
253 dig_size = WC_SHA224_DIGEST_SIZE;
254#endif
255 break;
256 case WC_HASH_TYPE_SHA256:
257#ifndef NO_SHA256
258 dig_size = WC_SHA256_DIGEST_SIZE;
259#endif
260 break;
261 case WC_HASH_TYPE_SHA384:
262 #ifdef WOLFSSL_SHA384
263 dig_size = WC_SHA384_DIGEST_SIZE;
264#endif
265 break;
266 case WC_HASH_TYPE_SHA512:
267#ifdef WOLFSSL_SHA512
268 dig_size = WC_SHA512_DIGEST_SIZE;
269#endif
270 break;
271 case WC_HASH_TYPE_MD5_SHA: /* Old TLS Specific */
272#if !defined(NO_MD5) && !defined(NO_SHA)
273 dig_size = (int)WC_MD5_DIGEST_SIZE + (int)WC_SHA_DIGEST_SIZE;
274 #endif
275 break;
276
277 case WC_HASH_TYPE_SHA3_224:
278 #ifdef WOLFSSL_SHA3
279 dig_size = WC_SHA3_224_DIGEST_SIZE;
280 #endif
281 break;
282 case WC_HASH_TYPE_SHA3_256:
283 #ifdef WOLFSSL_SHA3
284 dig_size = WC_SHA3_256_DIGEST_SIZE;
285 #endif
286 break;
287 case WC_HASH_TYPE_SHA3_384:
288 #ifdef WOLFSSL_SHA3
289 dig_size = WC_SHA3_384_DIGEST_SIZE;
290 #endif
291 break;
292 case WC_HASH_TYPE_SHA3_512:
293 #ifdef WOLFSSL_SHA3
294 dig_size = WC_SHA3_512_DIGEST_SIZE;
295#endif
296 break;
297
298 /* Not Supported */
299 case WC_HASH_TYPE_BLAKE2B:
300 case WC_HASH_TYPE_NONE:
301 default:
302 dig_size = BAD_FUNC_ARG;
303 break;
304 }
305 return dig_size;
306}
307
308
309/* Get Hash block size */
310int wc_HashGetBlockSize(enum wc_HashType hash_type)
311{
312 int block_size = HASH_TYPE_E; /* Default to hash type error */
313 switch (hash_type)
314 {
315 case WC_HASH_TYPE_MD2:
316 #ifdef WOLFSSL_MD2
317 block_size = MD2_BLOCK_SIZE;
318 #endif
319 break;
320 case WC_HASH_TYPE_MD4:
321 #ifndef NO_MD4
322 block_size = MD4_BLOCK_SIZE;
323 #endif
324 break;
325 case WC_HASH_TYPE_MD5:
326 #ifndef NO_MD5
327 block_size = WC_MD5_BLOCK_SIZE;
328 #endif
329 break;
330 case WC_HASH_TYPE_SHA:
331 #ifndef NO_SHA
332 block_size = WC_SHA_BLOCK_SIZE;
333 #endif
334 break;
335 case WC_HASH_TYPE_SHA224:
336 #ifdef WOLFSSL_SHA224
337 block_size = WC_SHA224_BLOCK_SIZE;
338 #endif
339 break;
340 case WC_HASH_TYPE_SHA256:
341 #ifndef NO_SHA256
342 block_size = WC_SHA256_BLOCK_SIZE;
343 #endif
344 break;
345 case WC_HASH_TYPE_SHA384:
346 #ifdef WOLFSSL_SHA384
347 block_size = WC_SHA384_BLOCK_SIZE;
348 #endif
349 break;
350 case WC_HASH_TYPE_SHA512:
351 #ifdef WOLFSSL_SHA512
352 block_size = WC_SHA512_BLOCK_SIZE;
353 #endif
354 break;
355 case WC_HASH_TYPE_MD5_SHA: /* Old TLS Specific */
356 #if !defined(NO_MD5) && !defined(NO_SHA)
357 block_size = (int)WC_MD5_BLOCK_SIZE + (int)WC_SHA_BLOCK_SIZE;
358 #endif
359 break;
360
361 case WC_HASH_TYPE_SHA3_224:
362 #ifdef WOLFSSL_SHA3
363 block_size = WC_SHA3_224_BLOCK_SIZE;
364 #endif
365 break;
366 case WC_HASH_TYPE_SHA3_256:
367 #ifdef WOLFSSL_SHA3
368 block_size = WC_SHA3_256_BLOCK_SIZE;
369 #endif
370 break;
371 case WC_HASH_TYPE_SHA3_384:
372 #ifdef WOLFSSL_SHA3
373 block_size = WC_SHA3_384_BLOCK_SIZE;
374 #endif
375 break;
376 case WC_HASH_TYPE_SHA3_512:
377 #ifdef WOLFSSL_SHA3
378 block_size = WC_SHA3_512_BLOCK_SIZE;
379 #endif
380 break;
381
382 /* Not Supported */
383 case WC_HASH_TYPE_BLAKE2B:
384 case WC_HASH_TYPE_NONE:
385 default:
386 block_size = BAD_FUNC_ARG;
387 break;
388 }
389 return block_size;
390}
391
392/* Generic Hashing Wrapper */
393int wc_Hash(enum wc_HashType hash_type, const byte* data,
394 word32 data_len, byte* hash, word32 hash_len)
395{
396 int ret = HASH_TYPE_E; /* Default to hash type error */
397 word32 dig_size;
398
399 /* Validate hash buffer size */
400 dig_size = wc_HashGetDigestSize(hash_type);
401 if (hash_len < dig_size) {
402 return BUFFER_E;
403 }
404
405 /* Suppress possible unused arg if all hashing is disabled */
406 (void)data;
407 (void)data_len;
408 (void)hash;
409 (void)hash_len;
410
411 switch(hash_type)
412 {
413 case WC_HASH_TYPE_MD5:
414#ifndef NO_MD5
415 ret = wc_Md5Hash(data, data_len, hash);
416#endif
417 break;
418 case WC_HASH_TYPE_SHA:
419#ifndef NO_SHA
420 ret = wc_ShaHash(data, data_len, hash);
421#endif
422 break;
423 case WC_HASH_TYPE_SHA224:
424#ifdef WOLFSSL_SHA224
425 ret = wc_Sha224Hash(data, data_len, hash);
426#endif
427 break;
428 case WC_HASH_TYPE_SHA256:
429#ifndef NO_SHA256
430 ret = wc_Sha256Hash(data, data_len, hash);
431#endif
432 break;
433 case WC_HASH_TYPE_SHA384:
434#ifdef WOLFSSL_SHA384
435 ret = wc_Sha384Hash(data, data_len, hash);
436#endif
437 break;
438 case WC_HASH_TYPE_SHA512:
439#ifdef WOLFSSL_SHA512
440 ret = wc_Sha512Hash(data, data_len, hash);
441#endif
442 break;
443 case WC_HASH_TYPE_MD5_SHA:
444#if !defined(NO_MD5) && !defined(NO_SHA)
445 ret = wc_Md5Hash(data, data_len, hash);
446 if (ret == 0) {
447 ret = wc_ShaHash(data, data_len, &hash[WC_MD5_DIGEST_SIZE]);
448 }
449#endif
450 break;
451
452 /* Not Supported */
453 case WC_HASH_TYPE_MD2:
454 case WC_HASH_TYPE_MD4:
455 case WC_HASH_TYPE_SHA3_224:
456 case WC_HASH_TYPE_SHA3_256:
457 case WC_HASH_TYPE_SHA3_384:
458 case WC_HASH_TYPE_SHA3_512:
459 case WC_HASH_TYPE_BLAKE2B:
460 case WC_HASH_TYPE_NONE:
461 default:
462 ret = BAD_FUNC_ARG;
463 break;
464 }
465 return ret;
466}
467
468int wc_HashInit(wc_HashAlg* hash, enum wc_HashType type)
469{
470 int ret = HASH_TYPE_E; /* Default to hash type error */
471
472 if (hash == NULL)
473 return BAD_FUNC_ARG;
474
475 switch (type) {
476 case WC_HASH_TYPE_MD5:
477#ifndef NO_MD5
478 ret = wc_InitMd5(&hash->md5);
479#endif
480 break;
481 case WC_HASH_TYPE_SHA:
482#ifndef NO_SHA
483 ret = wc_InitSha(&hash->sha);
484#endif
485 break;
486 case WC_HASH_TYPE_SHA224:
487#ifdef WOLFSSL_SHA224
488 ret = wc_InitSha224(&hash->sha224);
489#endif
490 break;
491 case WC_HASH_TYPE_SHA256:
492#ifndef NO_SHA256
493 ret = wc_InitSha256(&hash->sha256);
494#endif
495 break;
496 case WC_HASH_TYPE_SHA384:
497#ifdef WOLFSSL_SHA384
498 ret = wc_InitSha384(&hash->sha384);
499#endif
500 break;
501 case WC_HASH_TYPE_SHA512:
502#ifdef WOLFSSL_SHA512
503 ret = wc_InitSha512(&hash->sha512);
504#endif
505 break;
506
507 /* not supported */
508 case WC_HASH_TYPE_MD5_SHA:
509 case WC_HASH_TYPE_MD2:
510 case WC_HASH_TYPE_MD4:
511 case WC_HASH_TYPE_SHA3_224:
512 case WC_HASH_TYPE_SHA3_256:
513 case WC_HASH_TYPE_SHA3_384:
514 case WC_HASH_TYPE_SHA3_512:
515 case WC_HASH_TYPE_BLAKE2B:
516 case WC_HASH_TYPE_NONE:
517 default:
518 ret = BAD_FUNC_ARG;
519 };
520
521 return ret;
522}
523
524int wc_HashUpdate(wc_HashAlg* hash, enum wc_HashType type, const byte* data,
525 word32 dataSz)
526{
527 int ret = HASH_TYPE_E; /* Default to hash type error */
528
529 if (hash == NULL || data == NULL)
530 return BAD_FUNC_ARG;
531
532 switch (type) {
533 case WC_HASH_TYPE_MD5:
534#ifndef NO_MD5
535 ret = wc_Md5Update(&hash->md5, data, dataSz);
536#endif
537 break;
538 case WC_HASH_TYPE_SHA:
539#ifndef NO_SHA
540 ret = wc_ShaUpdate(&hash->sha, data, dataSz);
541#endif
542 break;
543 case WC_HASH_TYPE_SHA224:
544#ifdef WOLFSSL_SHA224
545 ret = wc_Sha224Update(&hash->sha224, data, dataSz);
546#endif
547 break;
548 case WC_HASH_TYPE_SHA256:
549#ifndef NO_SHA256
550 ret = wc_Sha256Update(&hash->sha256, data, dataSz);
551#endif
552 break;
553 case WC_HASH_TYPE_SHA384:
554#ifdef WOLFSSL_SHA384
555 ret = wc_Sha384Update(&hash->sha384, data, dataSz);
556#endif
557 break;
558 case WC_HASH_TYPE_SHA512:
559#ifdef WOLFSSL_SHA512
560 ret = wc_Sha512Update(&hash->sha512, data, dataSz);
561#endif
562 break;
563
564 /* not supported */
565 case WC_HASH_TYPE_MD5_SHA:
566 case WC_HASH_TYPE_MD2:
567 case WC_HASH_TYPE_MD4:
568 case WC_HASH_TYPE_SHA3_224:
569 case WC_HASH_TYPE_SHA3_256:
570 case WC_HASH_TYPE_SHA3_384:
571 case WC_HASH_TYPE_SHA3_512:
572 case WC_HASH_TYPE_BLAKE2B:
573 case WC_HASH_TYPE_NONE:
574 default:
575 ret = BAD_FUNC_ARG;
576 };
577
578 return ret;
579}
580
581int wc_HashFinal(wc_HashAlg* hash, enum wc_HashType type, byte* out)
582{
583 int ret = HASH_TYPE_E; /* Default to hash type error */
584
585 if (hash == NULL || out == NULL)
586 return BAD_FUNC_ARG;
587
588 switch (type) {
589 case WC_HASH_TYPE_MD5:
590#ifndef NO_MD5
591 ret = wc_Md5Final(&hash->md5, out);
592#endif
593 break;
594 case WC_HASH_TYPE_SHA:
595#ifndef NO_SHA
596 ret = wc_ShaFinal(&hash->sha, out);
597#endif
598 break;
599 case WC_HASH_TYPE_SHA224:
600#ifdef WOLFSSL_SHA224
601 ret = wc_Sha224Final(&hash->sha224, out);
602#endif
603 break;
604 case WC_HASH_TYPE_SHA256:
605#ifndef NO_SHA256
606 ret = wc_Sha256Final(&hash->sha256, out);
607#endif
608 break;
609 case WC_HASH_TYPE_SHA384:
610#ifdef WOLFSSL_SHA384
611 ret = wc_Sha384Final(&hash->sha384, out);
612#endif
613 break;
614 case WC_HASH_TYPE_SHA512:
615#ifdef WOLFSSL_SHA512
616 ret = wc_Sha512Final(&hash->sha512, out);
617#endif
618 break;
619
620 /* not supported */
621 case WC_HASH_TYPE_MD5_SHA:
622 case WC_HASH_TYPE_MD2:
623 case WC_HASH_TYPE_MD4:
624 case WC_HASH_TYPE_SHA3_224:
625 case WC_HASH_TYPE_SHA3_256:
626 case WC_HASH_TYPE_SHA3_384:
627 case WC_HASH_TYPE_SHA3_512:
628 case WC_HASH_TYPE_BLAKE2B:
629 case WC_HASH_TYPE_NONE:
630 default:
631 ret = BAD_FUNC_ARG;
632 };
633
634 return ret;
635}
636
637int wc_HashFree(wc_HashAlg* hash, enum wc_HashType type)
638{
639 int ret = HASH_TYPE_E; /* Default to hash type error */
640
641 if (hash == NULL)
642 return BAD_FUNC_ARG;
643
644 switch (type) {
645 case WC_HASH_TYPE_MD5:
646#ifndef NO_MD5
647 wc_Md5Free(&hash->md5);
648 ret = 0;
649#endif
650 break;
651 case WC_HASH_TYPE_SHA:
652#ifndef NO_SHA
653 wc_ShaFree(&hash->sha);
654 ret = 0;
655#endif
656 break;
657 case WC_HASH_TYPE_SHA224:
658#ifdef WOLFSSL_SHA224
659 wc_Sha224Free(&hash->sha224);
660 ret = 0;
661#endif
662 break;
663 case WC_HASH_TYPE_SHA256:
664#ifndef NO_SHA256
665 wc_Sha256Free(&hash->sha256);
666 ret = 0;
667#endif
668 break;
669 case WC_HASH_TYPE_SHA384:
670#ifdef WOLFSSL_SHA384
671 wc_Sha384Free(&hash->sha384);
672 ret = 0;
673#endif
674 break;
675 case WC_HASH_TYPE_SHA512:
676#ifdef WOLFSSL_SHA512
677 wc_Sha512Free(&hash->sha512);
678 ret = 0;
679#endif
680 break;
681
682 /* not supported */
683 case WC_HASH_TYPE_MD5_SHA:
684 case WC_HASH_TYPE_MD2:
685 case WC_HASH_TYPE_MD4:
686 case WC_HASH_TYPE_SHA3_224:
687 case WC_HASH_TYPE_SHA3_256:
688 case WC_HASH_TYPE_SHA3_384:
689 case WC_HASH_TYPE_SHA3_512:
690 case WC_HASH_TYPE_BLAKE2B:
691 case WC_HASH_TYPE_NONE:
692 default:
693 ret = BAD_FUNC_ARG;
694 };
695
696 return ret;
697}
698
699
700#if !defined(WOLFSSL_TI_HASH)
701
702#if !defined(NO_MD5)
703 int wc_Md5Hash(const byte* data, word32 len, byte* hash)
704 {
705 int ret;
706 #ifdef WOLFSSL_SMALL_STACK
707 wc_Md5* md5;
708 #else
709 wc_Md5 md5[1];
710 #endif
711
712 #ifdef WOLFSSL_SMALL_STACK
713 md5 = (wc_Md5*)XMALLOC(sizeof(wc_Md5), NULL, DYNAMIC_TYPE_TMP_BUFFER);
714 if (md5 == NULL)
715 return MEMORY_E;
716 #endif
717
718 if ((ret = wc_InitMd5(md5)) != 0) {
719 WOLFSSL_MSG("InitMd5 failed");
720 }
721 else {
722 if ((ret = wc_Md5Update(md5, data, len)) != 0) {
723 WOLFSSL_MSG("Md5Update failed");
724 }
725 else if ((ret = wc_Md5Final(md5, hash)) != 0) {
726 WOLFSSL_MSG("Md5Final failed");
727 }
728 wc_Md5Free(md5);
729 }
730
731 #ifdef WOLFSSL_SMALL_STACK
732 XFREE(md5, NULL, DYNAMIC_TYPE_TMP_BUFFER);
733 #endif
734
735 return ret;
736 }
737#endif /* !NO_MD5 */
738
739#if !defined(NO_SHA)
740 int wc_ShaHash(const byte* data, word32 len, byte* hash)
741 {
742 int ret = 0;
743 #ifdef WOLFSSL_SMALL_STACK
744 wc_Sha* sha;
745 #else
746 wc_Sha sha[1];
747 #endif
748
749 #ifdef WOLFSSL_SMALL_STACK
750 sha = (wc_Sha*)XMALLOC(sizeof(wc_Sha), NULL, DYNAMIC_TYPE_TMP_BUFFER);
751 if (sha == NULL)
752 return MEMORY_E;
753 #endif
754
755 if ((ret = wc_InitSha(sha)) != 0) {
756 WOLFSSL_MSG("InitSha failed");
757 }
758 else {
759 if ((ret = wc_ShaUpdate(sha, data, len)) != 0) {
760 WOLFSSL_MSG("ShaUpdate failed");
761 }
762 else if ((ret = wc_ShaFinal(sha, hash)) != 0) {
763 WOLFSSL_MSG("ShaFinal failed");
764 }
765 wc_ShaFree(sha);
766 }
767
768 #ifdef WOLFSSL_SMALL_STACK
769 XFREE(sha, NULL, DYNAMIC_TYPE_TMP_BUFFER);
770 #endif
771
772 return ret;
773 }
774#endif /* !NO_SHA */
775
776#if defined(WOLFSSL_SHA224)
777int wc_Sha224Hash(const byte* data, word32 len, byte* hash)
778{
779 int ret = 0;
780#ifdef WOLFSSL_SMALL_STACK
781 wc_Sha224* sha224;
782#else
783 wc_Sha224 sha224[1];
784#endif
785
786#ifdef WOLFSSL_SMALL_STACK
787 sha224 = (wc_Sha224*)XMALLOC(sizeof(wc_Sha224), NULL,
788 DYNAMIC_TYPE_TMP_BUFFER);
789 if (sha224 == NULL)
790 return MEMORY_E;
791#endif
792
793 if ((ret = wc_InitSha224(sha224)) != 0) {
794 WOLFSSL_MSG("InitSha224 failed");
795 }
796 else {
797 if ((ret = wc_Sha224Update(sha224, data, len)) != 0) {
798 WOLFSSL_MSG("Sha224Update failed");
799 }
800 else if ((ret = wc_Sha224Final(sha224, hash)) != 0) {
801 WOLFSSL_MSG("Sha224Final failed");
802 }
803 wc_Sha224Free(sha224);
804 }
805
806#ifdef WOLFSSL_SMALL_STACK
807 XFREE(sha224, NULL, DYNAMIC_TYPE_TMP_BUFFER);
808#endif
809
810 return ret;
811}
812#endif /* WOLFSSL_SHA224 */
813
814#if !defined(NO_SHA256)
815 int wc_Sha256Hash(const byte* data, word32 len, byte* hash)
816 {
817 int ret = 0;
818 #ifdef WOLFSSL_SMALL_STACK
819 wc_Sha256* sha256;
820 #else
821 wc_Sha256 sha256[1];
822 #endif
823
824 #ifdef WOLFSSL_SMALL_STACK
825 sha256 = (wc_Sha256*)XMALLOC(sizeof(wc_Sha256), NULL,
826 DYNAMIC_TYPE_TMP_BUFFER);
827 if (sha256 == NULL)
828 return MEMORY_E;
829 #endif
830
831 if ((ret = wc_InitSha256(sha256)) != 0) {
832 WOLFSSL_MSG("InitSha256 failed");
833 }
834 else {
835 if ((ret = wc_Sha256Update(sha256, data, len)) != 0) {
836 WOLFSSL_MSG("Sha256Update failed");
837 }
838 else if ((ret = wc_Sha256Final(sha256, hash)) != 0) {
839 WOLFSSL_MSG("Sha256Final failed");
840 }
841 wc_Sha256Free(sha256);
842 }
843
844
845 #ifdef WOLFSSL_SMALL_STACK
846 XFREE(sha256, NULL, DYNAMIC_TYPE_TMP_BUFFER);
847 #endif
848
849 return ret;
850 }
851#endif /* !NO_SHA256 */
852
853#endif /* !defined(WOLFSSL_TI_HASH) */
854
855
856#if defined(WOLFSSL_SHA512)
857 int wc_Sha512Hash(const byte* data, word32 len, byte* hash)
858 {
859 int ret = 0;
860 #ifdef WOLFSSL_SMALL_STACK
861 wc_Sha512* sha512;
862 #else
863 wc_Sha512 sha512[1];
864 #endif
865
866 #ifdef WOLFSSL_SMALL_STACK
867 sha512 = (wc_Sha512*)XMALLOC(sizeof(wc_Sha512), NULL,
868 DYNAMIC_TYPE_TMP_BUFFER);
869 if (sha512 == NULL)
870 return MEMORY_E;
871 #endif
872
873 if ((ret = wc_InitSha512(sha512)) != 0) {
874 WOLFSSL_MSG("InitSha512 failed");
875 }
876 else {
877 if ((ret = wc_Sha512Update(sha512, data, len)) != 0) {
878 WOLFSSL_MSG("Sha512Update failed");
879 }
880 else if ((ret = wc_Sha512Final(sha512, hash)) != 0) {
881 WOLFSSL_MSG("Sha512Final failed");
882 }
883 wc_Sha512Free(sha512);
884 }
885
886 #ifdef WOLFSSL_SMALL_STACK
887 XFREE(sha512, NULL, DYNAMIC_TYPE_TMP_BUFFER);
888 #endif
889
890 return ret;
891 }
892#endif /* WOLFSSL_SHA512 */
893
894 #if defined(WOLFSSL_SHA384)
895 int wc_Sha384Hash(const byte* data, word32 len, byte* hash)
896 {
897 int ret = 0;
898 #ifdef WOLFSSL_SMALL_STACK
899 wc_Sha384* sha384;
900 #else
901 wc_Sha384 sha384[1];
902 #endif
903
904 #ifdef WOLFSSL_SMALL_STACK
905 sha384 = (wc_Sha384*)XMALLOC(sizeof(wc_Sha384), NULL,
906 DYNAMIC_TYPE_TMP_BUFFER);
907 if (sha384 == NULL)
908 return MEMORY_E;
909 #endif
910
911 if ((ret = wc_InitSha384(sha384)) != 0) {
912 WOLFSSL_MSG("InitSha384 failed");
913 }
914 else {
915 if ((ret = wc_Sha384Update(sha384, data, len)) != 0) {
916 WOLFSSL_MSG("Sha384Update failed");
917 }
918 else if ((ret = wc_Sha384Final(sha384, hash)) != 0) {
919 WOLFSSL_MSG("Sha384Final failed");
920 }
921 wc_Sha384Free(sha384);
922 }
923
924 #ifdef WOLFSSL_SMALL_STACK
925 XFREE(sha384, NULL, DYNAMIC_TYPE_TMP_BUFFER);
926 #endif
927
928 return ret;
929 }
930 #endif /* WOLFSSL_SHA384 */
Note: See TracBrowser for help on using the repository browser.