source: asp3_tinet_ecnl_rx/trunk/wolfssl-3.12.2/wolfcrypt/src/hash.c@ 337

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

ASP3版ECNLを追加
  • Property svn:eol-style set to native
  • Property svn:mime-type set to text/x-csrc;charset=UTF-8
File size: 14.5 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
50
51int wc_HashGetOID(enum wc_HashType hash_type)
52{
53 int oid = HASH_TYPE_E; /* Default to hash type error */
54 switch(hash_type)
55 {
56 case WC_HASH_TYPE_MD2:
57 #ifdef WOLFSSL_MD2
58 oid = MD2h;
59 #endif
60 break;
61 case WC_HASH_TYPE_MD5_SHA:
62 case WC_HASH_TYPE_MD5:
63 #ifndef NO_MD5
64 oid = MD5h;
65 #endif
66 break;
67 case WC_HASH_TYPE_SHA:
68 #ifndef NO_SHA
69 oid = SHAh;
70 #endif
71 break;
72 case WC_HASH_TYPE_SHA224:
73 #if defined(WOLFSSL_SHA224)
74 oid = SHA224h;
75 #endif
76 break;
77 case WC_HASH_TYPE_SHA256:
78 #ifndef NO_SHA256
79 oid = SHA256h;
80 #endif
81 break;
82 case WC_HASH_TYPE_SHA384:
83 #if defined(WOLFSSL_SHA512) && defined(WOLFSSL_SHA384)
84 oid = SHA384h;
85 #endif
86 break;
87 case WC_HASH_TYPE_SHA512:
88 #ifdef WOLFSSL_SHA512
89 oid = SHA512h;
90 #endif
91 break;
92
93 /* Not Supported */
94 case WC_HASH_TYPE_MD4:
95 case WC_HASH_TYPE_NONE:
96 default:
97 oid = BAD_FUNC_ARG;
98 break;
99 }
100 return oid;
101}
102#endif
103
104/* Get Hash digest size */
105int wc_HashGetDigestSize(enum wc_HashType hash_type)
106{
107 int dig_size = HASH_TYPE_E; /* Default to hash type error */
108 switch(hash_type)
109 {
110 case WC_HASH_TYPE_MD5:
111#ifndef NO_MD5
112 dig_size = WC_MD5_DIGEST_SIZE;
113#endif
114 break;
115 case WC_HASH_TYPE_SHA:
116#ifndef NO_SHA
117 dig_size = WC_SHA_DIGEST_SIZE;
118#endif
119 break;
120 case WC_HASH_TYPE_SHA224:
121#ifdef WOLFSSL_SHA224
122 dig_size = WC_SHA224_DIGEST_SIZE;
123#endif
124 break;
125 case WC_HASH_TYPE_SHA256:
126#ifndef NO_SHA256
127 dig_size = WC_SHA256_DIGEST_SIZE;
128#endif
129 break;
130 case WC_HASH_TYPE_SHA384:
131#if defined(WOLFSSL_SHA512) && defined(WOLFSSL_SHA384)
132 dig_size = WC_SHA384_DIGEST_SIZE;
133#endif
134 break;
135 case WC_HASH_TYPE_SHA512:
136#ifdef WOLFSSL_SHA512
137 dig_size = WC_SHA512_DIGEST_SIZE;
138#endif
139 break;
140 case WC_HASH_TYPE_MD5_SHA:
141#if !defined(NO_MD5) && !defined(NO_SHA)
142 dig_size = WC_MD5_DIGEST_SIZE + WC_SHA_DIGEST_SIZE;
143#endif
144 break;
145
146 /* Not Supported */
147 case WC_HASH_TYPE_MD2:
148 case WC_HASH_TYPE_MD4:
149 case WC_HASH_TYPE_NONE:
150 default:
151 dig_size = BAD_FUNC_ARG;
152 break;
153 }
154 return dig_size;
155}
156
157/* Generic Hashing Wrapper */
158int wc_Hash(enum wc_HashType hash_type, const byte* data,
159 word32 data_len, byte* hash, word32 hash_len)
160{
161 int ret = HASH_TYPE_E; /* Default to hash type error */
162 word32 dig_size;
163
164 /* Validate hash buffer size */
165 dig_size = wc_HashGetDigestSize(hash_type);
166 if (hash_len < dig_size) {
167 return BUFFER_E;
168 }
169
170 /* Suppress possible unused arg if all hashing is disabled */
171 (void)data;
172 (void)data_len;
173 (void)hash;
174 (void)hash_len;
175
176 switch(hash_type)
177 {
178 case WC_HASH_TYPE_MD5:
179#ifndef NO_MD5
180 ret = wc_Md5Hash(data, data_len, hash);
181#endif
182 break;
183 case WC_HASH_TYPE_SHA:
184#ifndef NO_SHA
185 ret = wc_ShaHash(data, data_len, hash);
186#endif
187 break;
188 case WC_HASH_TYPE_SHA224:
189#ifdef WOLFSSL_SHA224
190 ret = wc_Sha224Hash(data, data_len, hash);
191#endif
192 break;
193 case WC_HASH_TYPE_SHA256:
194#ifndef NO_SHA256
195 ret = wc_Sha256Hash(data, data_len, hash);
196#endif
197 break;
198 case WC_HASH_TYPE_SHA384:
199#if defined(WOLFSSL_SHA512) && defined(WOLFSSL_SHA384)
200 ret = wc_Sha384Hash(data, data_len, hash);
201#endif
202 break;
203 case WC_HASH_TYPE_SHA512:
204#ifdef WOLFSSL_SHA512
205 ret = wc_Sha512Hash(data, data_len, hash);
206#endif
207 break;
208 case WC_HASH_TYPE_MD5_SHA:
209#if !defined(NO_MD5) && !defined(NO_SHA)
210 ret = wc_Md5Hash(data, data_len, hash);
211 if (ret == 0) {
212 ret = wc_ShaHash(data, data_len, &hash[WC_MD5_DIGEST_SIZE]);
213 }
214#endif
215 break;
216
217 /* Not Supported */
218 case WC_HASH_TYPE_MD2:
219 case WC_HASH_TYPE_MD4:
220 case WC_HASH_TYPE_NONE:
221 default:
222 ret = BAD_FUNC_ARG;
223 break;
224 }
225 return ret;
226}
227
228int wc_HashInit(wc_HashAlg* hash, enum wc_HashType type)
229{
230 int ret = HASH_TYPE_E; /* Default to hash type error */
231
232 if (hash == NULL)
233 return BAD_FUNC_ARG;
234
235 switch (type) {
236 case WC_HASH_TYPE_MD5:
237#ifndef NO_MD5
238 wc_InitMd5(&hash->md5);
239 ret = 0;
240#endif
241 break;
242 case WC_HASH_TYPE_SHA:
243#ifndef NO_SHA
244 ret = wc_InitSha(&hash->sha);
245#endif
246 break;
247 case WC_HASH_TYPE_SHA224:
248#ifdef WOLFSSL_SHA224
249 ret = wc_InitSha224(&hash->sha224);
250#endif
251 break;
252 case WC_HASH_TYPE_SHA256:
253#ifndef NO_SHA256
254 ret = wc_InitSha256(&hash->sha256);
255#endif
256 break;
257 case WC_HASH_TYPE_SHA384:
258#ifdef WOLFSSL_SHA384
259 ret = wc_InitSha384(&hash->sha384);
260#endif
261 break;
262 case WC_HASH_TYPE_SHA512:
263#ifdef WOLFSSL_SHA512
264 ret = wc_InitSha512(&hash->sha512);
265#endif
266 break;
267
268 /* not supported */
269 case WC_HASH_TYPE_MD5_SHA:
270 case WC_HASH_TYPE_MD2:
271 case WC_HASH_TYPE_MD4:
272 case WC_HASH_TYPE_NONE:
273 default:
274 ret = BAD_FUNC_ARG;
275 };
276
277 return ret;
278}
279
280int wc_HashUpdate(wc_HashAlg* hash, enum wc_HashType type, const byte* data,
281 word32 dataSz)
282{
283 int ret = HASH_TYPE_E; /* Default to hash type error */
284
285 if (hash == NULL || data == NULL)
286 return BAD_FUNC_ARG;
287
288 switch (type) {
289 case WC_HASH_TYPE_MD5:
290#ifndef NO_MD5
291 wc_Md5Update(&hash->md5, data, dataSz);
292 ret = 0;
293#endif
294 break;
295 case WC_HASH_TYPE_SHA:
296#ifndef NO_SHA
297 ret = wc_ShaUpdate(&hash->sha, data, dataSz);
298 if (ret != 0)
299 return ret;
300#endif
301 break;
302 case WC_HASH_TYPE_SHA224:
303#ifdef WOLFSSL_SHA224
304 ret = wc_Sha224Update(&hash->sha224, data, dataSz);
305#endif
306 break;
307 case WC_HASH_TYPE_SHA256:
308#ifndef NO_SHA256
309 ret = wc_Sha256Update(&hash->sha256, data, dataSz);
310#endif
311 break;
312 case WC_HASH_TYPE_SHA384:
313#ifdef WOLFSSL_SHA384
314 ret = wc_Sha384Update(&hash->sha384, data, dataSz);
315#endif
316 break;
317 case WC_HASH_TYPE_SHA512:
318#ifdef WOLFSSL_SHA512
319 ret = wc_Sha512Update(&hash->sha512, data, dataSz);
320#endif
321 break;
322
323 /* not supported */
324 case WC_HASH_TYPE_MD5_SHA:
325 case WC_HASH_TYPE_MD2:
326 case WC_HASH_TYPE_MD4:
327 case WC_HASH_TYPE_NONE:
328 default:
329 ret = BAD_FUNC_ARG;
330 };
331
332 return ret;
333}
334
335int wc_HashFinal(wc_HashAlg* hash, enum wc_HashType type, byte* out)
336{
337 int ret = HASH_TYPE_E; /* Default to hash type error */
338
339 if (hash == NULL || out == NULL)
340 return BAD_FUNC_ARG;
341
342 switch (type) {
343 case WC_HASH_TYPE_MD5:
344#ifndef NO_MD5
345 wc_Md5Final(&hash->md5, out);
346 ret = 0;
347#endif
348 break;
349 case WC_HASH_TYPE_SHA:
350#ifndef NO_SHA
351 ret = wc_ShaFinal(&hash->sha, out);
352#endif
353 break;
354 case WC_HASH_TYPE_SHA224:
355#ifdef WOLFSSL_SHA224
356 ret = wc_Sha224Final(&hash->sha224, out);
357#endif
358 break;
359 case WC_HASH_TYPE_SHA256:
360#ifndef NO_SHA256
361 ret = wc_Sha256Final(&hash->sha256, out);
362#endif
363 break;
364 case WC_HASH_TYPE_SHA384:
365#ifdef WOLFSSL_SHA384
366 ret = wc_Sha384Final(&hash->sha384, out);
367#endif
368 break;
369 case WC_HASH_TYPE_SHA512:
370#ifdef WOLFSSL_SHA512
371 ret = wc_Sha512Final(&hash->sha512, out);
372#endif
373 break;
374
375 /* not supported */
376 case WC_HASH_TYPE_MD5_SHA:
377 case WC_HASH_TYPE_MD2:
378 case WC_HASH_TYPE_MD4:
379 case WC_HASH_TYPE_NONE:
380 default:
381 ret = BAD_FUNC_ARG;
382 };
383
384 return ret;
385}
386
387
388#if !defined(WOLFSSL_TI_HASH)
389
390#if !defined(NO_MD5)
391 int wc_Md5Hash(const byte* data, word32 len, byte* hash)
392 {
393 int ret;
394 #ifdef WOLFSSL_SMALL_STACK
395 wc_Md5* md5;
396 #else
397 wc_Md5 md5[1];
398 #endif
399
400 #ifdef WOLFSSL_SMALL_STACK
401 md5 = (wc_Md5*)XMALLOC(sizeof(wc_Md5), NULL, DYNAMIC_TYPE_TMP_BUFFER);
402 if (md5 == NULL)
403 return MEMORY_E;
404 #endif
405
406 ret = wc_InitMd5(md5);
407 if (ret == 0) {
408 ret = wc_Md5Update(md5, data, len);
409 if (ret == 0) {
410 ret = wc_Md5Final(md5, hash);
411 }
412 }
413
414 #ifdef WOLFSSL_SMALL_STACK
415 XFREE(md5, NULL, DYNAMIC_TYPE_TMP_BUFFER);
416 #endif
417
418 return ret;
419 }
420#endif /* !NO_MD5 */
421
422#if !defined(NO_SHA)
423 int wc_ShaHash(const byte* data, word32 len, byte* hash)
424 {
425 int ret = 0;
426 #ifdef WOLFSSL_SMALL_STACK
427 wc_Sha* sha;
428 #else
429 wc_Sha sha[1];
430 #endif
431
432 #ifdef WOLFSSL_SMALL_STACK
433 sha = (wc_Sha*)XMALLOC(sizeof(wc_Sha), NULL, DYNAMIC_TYPE_TMP_BUFFER);
434 if (sha == NULL)
435 return MEMORY_E;
436 #endif
437
438 if ((ret = wc_InitSha(sha)) != 0) {
439 WOLFSSL_MSG("wc_InitSha failed");
440 }
441 else {
442 wc_ShaUpdate(sha, data, len);
443 wc_ShaFinal(sha, hash);
444 }
445
446 #ifdef WOLFSSL_SMALL_STACK
447 XFREE(sha, NULL, DYNAMIC_TYPE_TMP_BUFFER);
448 #endif
449
450 return ret;
451 }
452#endif /* !NO_SHA */
453
454#if defined(WOLFSSL_SHA224)
455int wc_Sha224Hash(const byte* data, word32 len, byte* hash)
456{
457 int ret = 0;
458#ifdef WOLFSSL_SMALL_STACK
459 wc_Sha224* sha224;
460#else
461 wc_Sha224 sha224[1];
462#endif
463
464#ifdef WOLFSSL_SMALL_STACK
465 sha224 = (wc_Sha224*)XMALLOC(sizeof(wc_Sha224), NULL,
466 DYNAMIC_TYPE_TMP_BUFFER);
467 if (sha224 == NULL)
468 return MEMORY_E;
469#endif
470
471 if ((ret = wc_InitSha224(sha224)) != 0) {
472 WOLFSSL_MSG("InitSha224 failed");
473 }
474 else if ((ret = wc_Sha224Update(sha224, data, len)) != 0) {
475 WOLFSSL_MSG("Sha224Update failed");
476 }
477 else if ((ret = wc_Sha224Final(sha224, hash)) != 0) {
478 WOLFSSL_MSG("Sha224Final failed");
479 }
480
481#ifdef WOLFSSL_SMALL_STACK
482 XFREE(sha224, NULL, DYNAMIC_TYPE_TMP_BUFFER);
483#endif
484
485 return ret;
486}
487#endif /* WOLFSSL_SHA224 */
488
489#if !defined(NO_SHA256)
490 int wc_Sha256Hash(const byte* data, word32 len, byte* hash)
491 {
492 int ret = 0;
493 #ifdef WOLFSSL_SMALL_STACK
494 wc_Sha256* sha256;
495 #else
496 wc_Sha256 sha256[1];
497 #endif
498
499 #ifdef WOLFSSL_SMALL_STACK
500 sha256 = (wc_Sha256*)XMALLOC(sizeof(wc_Sha256), NULL,
501 DYNAMIC_TYPE_TMP_BUFFER);
502 if (sha256 == NULL)
503 return MEMORY_E;
504 #endif
505
506 if ((ret = wc_InitSha256(sha256)) != 0) {
507 WOLFSSL_MSG("InitSha256 failed");
508 }
509 else if ((ret = wc_Sha256Update(sha256, data, len)) != 0) {
510 WOLFSSL_MSG("Sha256Update failed");
511 }
512 else if ((ret = wc_Sha256Final(sha256, hash)) != 0) {
513 WOLFSSL_MSG("Sha256Final failed");
514 }
515
516 #ifdef WOLFSSL_SMALL_STACK
517 XFREE(sha256, NULL, DYNAMIC_TYPE_TMP_BUFFER);
518 #endif
519
520 return ret;
521 }
522#endif /* !NO_SHA256 */
523
524#endif /* !defined(WOLFSSL_TI_HASH) */
525
526
527#if defined(WOLFSSL_SHA512)
528 int wc_Sha512Hash(const byte* data, word32 len, byte* hash)
529 {
530 int ret = 0;
531 #ifdef WOLFSSL_SMALL_STACK
532 wc_Sha512* sha512;
533 #else
534 wc_Sha512 sha512[1];
535 #endif
536
537 #ifdef WOLFSSL_SMALL_STACK
538 sha512 = (wc_Sha512*)XMALLOC(sizeof(wc_Sha512), NULL,
539 DYNAMIC_TYPE_TMP_BUFFER);
540 if (sha512 == NULL)
541 return MEMORY_E;
542 #endif
543
544 if ((ret = wc_InitSha512(sha512)) != 0) {
545 WOLFSSL_MSG("InitSha512 failed");
546 }
547 else if ((ret = wc_Sha512Update(sha512, data, len)) != 0) {
548 WOLFSSL_MSG("Sha512Update failed");
549 }
550 else if ((ret = wc_Sha512Final(sha512, hash)) != 0) {
551 WOLFSSL_MSG("Sha512Final failed");
552 }
553
554 #ifdef WOLFSSL_SMALL_STACK
555 XFREE(sha512, NULL, DYNAMIC_TYPE_TMP_BUFFER);
556 #endif
557
558 return ret;
559 }
560
561 #if defined(WOLFSSL_SHA384)
562 int wc_Sha384Hash(const byte* data, word32 len, byte* hash)
563 {
564 int ret = 0;
565 #ifdef WOLFSSL_SMALL_STACK
566 wc_Sha384* sha384;
567 #else
568 wc_Sha384 sha384[1];
569 #endif
570
571 #ifdef WOLFSSL_SMALL_STACK
572 sha384 = (wc_Sha384*)XMALLOC(sizeof(wc_Sha384), NULL,
573 DYNAMIC_TYPE_TMP_BUFFER);
574 if (sha384 == NULL)
575 return MEMORY_E;
576 #endif
577
578 if ((ret = wc_InitSha384(sha384)) != 0) {
579 WOLFSSL_MSG("InitSha384 failed");
580 }
581 else if ((ret = wc_Sha384Update(sha384, data, len)) != 0) {
582 WOLFSSL_MSG("Sha384Update failed");
583 }
584 else if ((ret = wc_Sha384Final(sha384, hash)) != 0) {
585 WOLFSSL_MSG("Sha384Final failed");
586 }
587
588 #ifdef WOLFSSL_SMALL_STACK
589 XFREE(sha384, NULL, DYNAMIC_TYPE_TMP_BUFFER);
590 #endif
591
592 return ret;
593 }
594 #endif /* WOLFSSL_SHA384 */
595#endif /* WOLFSSL_SHA512 */
Note: See TracBrowser for help on using the repository browser.