hash.c

00001 /* hash.c
00002  *
00003  * Copyright (C) 2006-2017 wolfSSL Inc.
00004  *
00005  * This file is part of wolfSSL.
00006  *
00007  * wolfSSL is free software; you can redistribute it and/or modify
00008  * it under the terms of the GNU General Public License as published by
00009  * the Free Software Foundation; either version 2 of the License, or
00010  * (at your option) any later version.
00011  *
00012  * wolfSSL is distributed in the hope that it will be useful,
00013  * but WITHOUT ANY WARRANTY; without even the implied warranty of
00014  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
00015  * GNU General Public License for more details.
00016  *
00017  * You should have received a copy of the GNU General Public License
00018  * along with this program; if not, write to the Free Software
00019  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335, USA
00020  */
00021 
00022 
00023 #ifdef HAVE_CONFIG_H
00024     #include <config.h>
00025 #endif
00026 
00027 #include <wolfcrypt/settings.h>
00028 #include <wolfcrypt/logging.h>
00029 #include <wolfcrypt/error-crypt.h>
00030 #ifndef NO_ASN
00031 #include <wolfcrypt/asn.h>
00032 #endif
00033 
00034 #include <wolfcrypt/hash.h>
00035 
00036 
00037 #if !defined(NO_ASN) || !defined(NO_DH) || defined(HAVE_ECC)
00038 
00039 #ifdef NO_ASN
00040 enum Hash_Sum  {
00041     MD2h    = 646,
00042     MD5h    = 649,
00043     SHAh    =  88,
00044     SHA224h = 417,
00045     SHA256h = 414,
00046     SHA384h = 415,
00047     SHA512h = 416
00048 };
00049 #endif /* !NO_ASN */
00050 
00051 #ifdef HAVE_SELFTEST
00052 enum {
00053     /* CAVP selftest includes these in hmac.h instead of sha3.h,
00054        copied here for that build */
00055     WC_SHA3_224_BLOCK_SIZE = 144,
00056     WC_SHA3_256_BLOCK_SIZE = 136,
00057     WC_SHA3_384_BLOCK_SIZE = 104,
00058     WC_SHA3_512_BLOCK_SIZE = 72,
00059 };
00060 #endif
00061 
00062 
00063 /* function converts int hash type to enum */
00064 enum wc_HashType wc_HashTypeConvert(int hashType)
00065 {
00066     /* Default to hash type none as error */
00067     enum wc_HashType eHashType = WC_HASH_TYPE_NONE;
00068 #if defined(HAVE_FIPS) || defined(HAVE_SELFTEST)
00069     /* original FIPSv1  and CAVP selftest require a mapping for unique hash
00070        type to wc_HashType */
00071     switch (hashType) {
00072     #ifndef NO_MD5
00073         case WC_MD5:
00074             eHashType = WC_HASH_TYPE_MD5;
00075             break;
00076     #endif /* !NO_MD5 */
00077     #ifndef NO_SHA
00078         case WC_SHA:
00079             eHashType = WC_HASH_TYPE_SHA;
00080             break;
00081     #endif /* !NO_SHA */
00082 
00083     #ifdef WOLFSSL_SHA224
00084         case WC_SHA224:
00085             eHashType = WC_HASH_TYPE_SHA224;
00086             break;
00087     #endif /* WOLFSSL_SHA224 */
00088 
00089     #ifndef NO_SHA256
00090         case WC_SHA256:
00091             eHashType = WC_HASH_TYPE_SHA256;
00092             break;
00093     #endif /* !NO_SHA256 */
00094 
00095     #ifdef WOLFSSL_SHA384
00096         case WC_SHA384:
00097             eHashType = WC_HASH_TYPE_SHA384;
00098             break;
00099     #endif /* WOLFSSL_SHA384 */
00100     #ifdef WOLFSSL_SHA512
00101         case WC_SHA512:
00102             eHashType = WC_HASH_TYPE_SHA512;
00103             break;
00104     #endif /* WOLFSSL_SHA512 */
00105         default:
00106             eHashType = WC_HASH_TYPE_NONE;
00107             break;
00108     }
00109 #else
00110     /* current master uses same unique types as wc_HashType */
00111     if (hashType > 0 && hashType <= WC_HASH_TYPE_MAX) {
00112         eHashType = (enum wc_HashType)hashType;
00113     }
00114 #endif
00115     return eHashType;
00116 }
00117 
00118 
00119 int wc_HashGetOID(enum wc_HashType hash_type)
00120 {
00121     int oid = HASH_TYPE_E; /* Default to hash type error */
00122     switch(hash_type)
00123     {
00124         case WC_HASH_TYPE_MD2:
00125         #ifdef WOLFSSL_MD2
00126             oid = MD2h;
00127         #endif
00128             break;
00129         case WC_HASH_TYPE_MD5_SHA:
00130         case WC_HASH_TYPE_MD5:
00131         #ifndef NO_MD5
00132             oid = MD5h;
00133         #endif
00134             break;
00135         case WC_HASH_TYPE_SHA:
00136         #ifndef NO_SHA
00137             oid = SHAh;
00138         #endif
00139             break;
00140         case WC_HASH_TYPE_SHA224:
00141         #ifdef WOLFSSL_SHA224
00142             oid = SHA224h;
00143         #endif
00144             break;
00145         case WC_HASH_TYPE_SHA256:
00146         #ifndef NO_SHA256
00147             oid = SHA256h;
00148         #endif
00149             break;
00150         case WC_HASH_TYPE_SHA384:
00151         #ifdef WOLFSSL_SHA384
00152             oid = SHA384h;
00153         #endif
00154             break;
00155         case WC_HASH_TYPE_SHA512:
00156         #ifdef WOLFSSL_SHA512
00157             oid = SHA512h;
00158         #endif
00159             break;
00160 
00161         /* Not Supported */
00162         case WC_HASH_TYPE_MD4:
00163         case WC_HASH_TYPE_SHA3_224:
00164         case WC_HASH_TYPE_SHA3_256:
00165         case WC_HASH_TYPE_SHA3_384:
00166         case WC_HASH_TYPE_SHA3_512:
00167         case WC_HASH_TYPE_BLAKE2B:
00168         case WC_HASH_TYPE_NONE:
00169         default:
00170             oid = BAD_FUNC_ARG;
00171             break;
00172     }
00173     return oid;
00174 }
00175 
00176 enum wc_HashType wc_OidGetHash(int oid)
00177 {
00178     enum wc_HashType hash_type = WC_HASH_TYPE_NONE;
00179     switch (oid)
00180     {
00181         case MD2h:
00182         #ifdef WOLFSSL_MD2
00183             hash_type = WC_HASH_TYPE_MD2;
00184         #endif
00185             break;
00186         case MD5h:
00187         #ifndef NO_MD5
00188             hash_type = WC_HASH_TYPE_MD5;
00189         #endif
00190             break;
00191         case SHAh:
00192         #ifndef NO_SHA
00193             hash_type = WC_HASH_TYPE_SHA;
00194         #endif
00195             break;
00196         case SHA224h:
00197         #ifdef WOLFSSL_SHA224
00198             hash_type = WC_HASH_TYPE_SHA224;
00199         #endif
00200             break;
00201         case SHA256h:
00202         #ifndef NO_SHA256
00203             hash_type = WC_HASH_TYPE_SHA256;
00204         #endif
00205             break;
00206         case SHA384h:
00207         #ifdef WOLFSSL_SHA384
00208             hash_type = WC_HASH_TYPE_SHA384;
00209         #endif
00210             break;
00211         case SHA512h:
00212         #ifdef WOLFSSL_SHA512
00213             hash_type = WC_HASH_TYPE_SHA512;
00214         #endif
00215             break;
00216         default:
00217             break;
00218     }
00219     return hash_type;
00220 }
00221 #endif /* !NO_ASN || !NO_DH || HAVE_ECC */
00222 
00223 
00224 
00225 /* Get Hash digest size */
00226 int wc_HashGetDigestSize(enum wc_HashType hash_type)
00227 {
00228     int dig_size = HASH_TYPE_E; /* Default to hash type error */
00229     switch(hash_type)
00230     {
00231         case WC_HASH_TYPE_MD2:
00232         #ifdef WOLFSSL_MD2
00233             dig_size = MD2_DIGEST_SIZE;
00234         #endif
00235             break;
00236         case WC_HASH_TYPE_MD4:
00237         #ifndef NO_MD4
00238             dig_size = MD4_DIGEST_SIZE;
00239         #endif
00240             break;
00241         case WC_HASH_TYPE_MD5:
00242         #ifndef NO_MD5
00243             dig_size = WC_MD5_DIGEST_SIZE;
00244         #endif
00245             break;
00246         case WC_HASH_TYPE_SHA:
00247         #ifndef NO_SHA
00248             dig_size = WC_SHA_DIGEST_SIZE;
00249         #endif
00250             break;
00251         case WC_HASH_TYPE_SHA224:
00252         #ifdef WOLFSSL_SHA224
00253             dig_size = WC_SHA224_DIGEST_SIZE;
00254         #endif
00255             break;
00256         case WC_HASH_TYPE_SHA256:
00257         #ifndef NO_SHA256
00258             dig_size = WC_SHA256_DIGEST_SIZE;
00259         #endif
00260             break;
00261         case WC_HASH_TYPE_SHA384:
00262         #ifdef WOLFSSL_SHA384
00263             dig_size = WC_SHA384_DIGEST_SIZE;
00264         #endif
00265             break;
00266         case WC_HASH_TYPE_SHA512:
00267         #ifdef WOLFSSL_SHA512
00268             dig_size = WC_SHA512_DIGEST_SIZE;
00269         #endif
00270             break;
00271         case WC_HASH_TYPE_MD5_SHA: /* Old TLS Specific */
00272         #if !defined(NO_MD5) && !defined(NO_SHA)
00273             dig_size = (int)WC_MD5_DIGEST_SIZE + (int)WC_SHA_DIGEST_SIZE;
00274         #endif
00275             break;
00276 
00277         case WC_HASH_TYPE_SHA3_224:
00278         #ifdef WOLFSSL_SHA3
00279             dig_size = WC_SHA3_224_DIGEST_SIZE;
00280         #endif
00281             break;
00282         case WC_HASH_TYPE_SHA3_256:
00283         #ifdef WOLFSSL_SHA3
00284             dig_size = WC_SHA3_256_DIGEST_SIZE;
00285         #endif
00286             break;
00287         case WC_HASH_TYPE_SHA3_384:
00288         #ifdef WOLFSSL_SHA3
00289             dig_size = WC_SHA3_384_DIGEST_SIZE;
00290         #endif
00291             break;
00292         case WC_HASH_TYPE_SHA3_512:
00293         #ifdef WOLFSSL_SHA3
00294             dig_size = WC_SHA3_512_DIGEST_SIZE;
00295         #endif
00296             break;
00297 
00298         /* Not Supported */
00299         case WC_HASH_TYPE_BLAKE2B:
00300         case WC_HASH_TYPE_NONE:
00301         default:
00302             dig_size = BAD_FUNC_ARG;
00303             break;
00304     }
00305     return dig_size;
00306 }
00307 
00308 
00309 /* Get Hash block size */
00310 int wc_HashGetBlockSize(enum wc_HashType hash_type)
00311 {
00312     int block_size = HASH_TYPE_E; /* Default to hash type error */
00313     switch (hash_type)
00314     {
00315         case WC_HASH_TYPE_MD2:
00316         #ifdef WOLFSSL_MD2
00317             block_size = MD2_BLOCK_SIZE;
00318         #endif
00319             break;
00320         case WC_HASH_TYPE_MD4:
00321         #ifndef NO_MD4
00322             block_size = MD4_BLOCK_SIZE;
00323         #endif
00324             break;
00325         case WC_HASH_TYPE_MD5:
00326         #ifndef NO_MD5
00327             block_size = WC_MD5_BLOCK_SIZE;
00328         #endif
00329             break;
00330         case WC_HASH_TYPE_SHA:
00331         #ifndef NO_SHA
00332             block_size = WC_SHA_BLOCK_SIZE;
00333         #endif
00334             break;
00335         case WC_HASH_TYPE_SHA224:
00336         #ifdef WOLFSSL_SHA224
00337             block_size = WC_SHA224_BLOCK_SIZE;
00338         #endif
00339             break;
00340         case WC_HASH_TYPE_SHA256:
00341         #ifndef NO_SHA256
00342             block_size = WC_SHA256_BLOCK_SIZE;
00343         #endif
00344             break;
00345         case WC_HASH_TYPE_SHA384:
00346         #ifdef WOLFSSL_SHA384
00347             block_size = WC_SHA384_BLOCK_SIZE;
00348         #endif
00349             break;
00350         case WC_HASH_TYPE_SHA512:
00351         #ifdef WOLFSSL_SHA512
00352             block_size = WC_SHA512_BLOCK_SIZE;
00353         #endif
00354             break;
00355         case WC_HASH_TYPE_MD5_SHA: /* Old TLS Specific */
00356         #if !defined(NO_MD5) && !defined(NO_SHA)
00357             block_size = (int)WC_MD5_BLOCK_SIZE + (int)WC_SHA_BLOCK_SIZE;
00358         #endif
00359             break;
00360 
00361         case WC_HASH_TYPE_SHA3_224:
00362         #ifdef WOLFSSL_SHA3
00363             block_size = WC_SHA3_224_BLOCK_SIZE;
00364         #endif
00365             break;
00366         case WC_HASH_TYPE_SHA3_256:
00367         #ifdef WOLFSSL_SHA3
00368             block_size = WC_SHA3_256_BLOCK_SIZE;
00369         #endif
00370             break;
00371         case WC_HASH_TYPE_SHA3_384:
00372         #ifdef WOLFSSL_SHA3
00373             block_size = WC_SHA3_384_BLOCK_SIZE;
00374         #endif
00375             break;
00376         case WC_HASH_TYPE_SHA3_512:
00377         #ifdef WOLFSSL_SHA3
00378             block_size = WC_SHA3_512_BLOCK_SIZE;
00379         #endif
00380             break;
00381 
00382         /* Not Supported */
00383         case WC_HASH_TYPE_BLAKE2B:
00384         case WC_HASH_TYPE_NONE:
00385         default:
00386             block_size = BAD_FUNC_ARG;
00387             break;
00388     }
00389     return block_size;
00390 }
00391 
00392 /* Generic Hashing Wrapper */
00393 int wc_Hash(enum wc_HashType hash_type, const byte* data,
00394     word32 data_len, byte* hash, word32 hash_len)
00395 {
00396     int ret = HASH_TYPE_E; /* Default to hash type error */
00397     word32 dig_size;
00398 
00399     /* Validate hash buffer size */
00400     dig_size = wc_HashGetDigestSize(hash_type);
00401     if (hash_len < dig_size) {
00402         return BUFFER_E;
00403     }
00404 
00405     /* Suppress possible unused arg if all hashing is disabled */
00406     (void)data;
00407     (void)data_len;
00408     (void)hash;
00409     (void)hash_len;
00410 
00411     switch(hash_type)
00412     {
00413         case WC_HASH_TYPE_MD5:
00414 #ifndef NO_MD5
00415             ret = wc_Md5Hash(data, data_len, hash);
00416 #endif
00417             break;
00418         case WC_HASH_TYPE_SHA:
00419 #ifndef NO_SHA
00420             ret = wc_ShaHash(data, data_len, hash);
00421 #endif
00422             break;
00423         case WC_HASH_TYPE_SHA224:
00424 #ifdef WOLFSSL_SHA224
00425             ret = wc_Sha224Hash(data, data_len, hash);
00426 #endif
00427             break;
00428         case WC_HASH_TYPE_SHA256:
00429 #ifndef NO_SHA256
00430             ret = wc_Sha256Hash(data, data_len, hash);
00431 #endif
00432             break;
00433         case WC_HASH_TYPE_SHA384:
00434 #ifdef WOLFSSL_SHA384
00435             ret = wc_Sha384Hash(data, data_len, hash);
00436 #endif
00437             break;
00438         case WC_HASH_TYPE_SHA512:
00439 #ifdef WOLFSSL_SHA512
00440             ret = wc_Sha512Hash(data, data_len, hash);
00441 #endif
00442             break;
00443         case WC_HASH_TYPE_MD5_SHA:
00444 #if !defined(NO_MD5) && !defined(NO_SHA)
00445             ret = wc_Md5Hash(data, data_len, hash);
00446             if (ret == 0) {
00447                 ret = wc_ShaHash(data, data_len, &hash[WC_MD5_DIGEST_SIZE]);
00448             }
00449 #endif
00450             break;
00451 
00452         /* Not Supported */
00453         case WC_HASH_TYPE_MD2:
00454         case WC_HASH_TYPE_MD4:
00455         case WC_HASH_TYPE_SHA3_224:
00456         case WC_HASH_TYPE_SHA3_256:
00457         case WC_HASH_TYPE_SHA3_384:
00458         case WC_HASH_TYPE_SHA3_512:
00459         case WC_HASH_TYPE_BLAKE2B:
00460         case WC_HASH_TYPE_NONE:
00461         default:
00462             ret = BAD_FUNC_ARG;
00463             break;
00464     }
00465     return ret;
00466 }
00467 
00468 int wc_HashInit(wc_HashAlg* hash, enum wc_HashType type)
00469 {
00470     int ret = HASH_TYPE_E; /* Default to hash type error */
00471 
00472     if (hash == NULL)
00473         return BAD_FUNC_ARG;
00474 
00475     switch (type) {
00476         case WC_HASH_TYPE_MD5:
00477 #ifndef NO_MD5
00478             wc_InitMd5(&hash->md5);
00479             ret = 0;
00480 #endif
00481             break;
00482         case WC_HASH_TYPE_SHA:
00483 #ifndef NO_SHA
00484             ret = wc_InitSha(&hash->sha);
00485 #endif
00486             break;
00487         case WC_HASH_TYPE_SHA224:
00488 #ifdef WOLFSSL_SHA224
00489             ret = wc_InitSha224(&hash->sha224);
00490 #endif
00491             break;
00492         case WC_HASH_TYPE_SHA256:
00493 #ifndef NO_SHA256
00494             ret = wc_InitSha256(&hash->sha256);
00495 #endif
00496             break;
00497         case WC_HASH_TYPE_SHA384:
00498 #ifdef WOLFSSL_SHA384
00499             ret = wc_InitSha384(&hash->sha384);
00500 #endif
00501             break;
00502         case WC_HASH_TYPE_SHA512:
00503 #ifdef WOLFSSL_SHA512
00504             ret = wc_InitSha512(&hash->sha512);
00505 #endif
00506             break;
00507 
00508         /* not supported */
00509         case WC_HASH_TYPE_MD5_SHA:
00510         case WC_HASH_TYPE_MD2:
00511         case WC_HASH_TYPE_MD4:
00512         case WC_HASH_TYPE_SHA3_224:
00513         case WC_HASH_TYPE_SHA3_256:
00514         case WC_HASH_TYPE_SHA3_384:
00515         case WC_HASH_TYPE_SHA3_512:
00516         case WC_HASH_TYPE_BLAKE2B:
00517         case WC_HASH_TYPE_NONE:
00518         default:
00519             ret = BAD_FUNC_ARG;
00520     };
00521 
00522     return ret;
00523 }
00524 
00525 int wc_HashUpdate(wc_HashAlg* hash, enum wc_HashType type, const byte* data,
00526                   word32 dataSz)
00527 {
00528     int ret = HASH_TYPE_E; /* Default to hash type error */
00529 
00530     if (hash == NULL || data == NULL)
00531         return BAD_FUNC_ARG;
00532 
00533     switch (type) {
00534         case WC_HASH_TYPE_MD5:
00535 #ifndef NO_MD5
00536             wc_Md5Update(&hash->md5, data, dataSz);
00537             ret = 0;
00538 #endif
00539             break;
00540         case WC_HASH_TYPE_SHA:
00541 #ifndef NO_SHA
00542             ret = wc_ShaUpdate(&hash->sha, data, dataSz);
00543             if (ret != 0)
00544                 return ret;
00545 #endif
00546             break;
00547         case WC_HASH_TYPE_SHA224:
00548 #ifdef WOLFSSL_SHA224
00549             ret = wc_Sha224Update(&hash->sha224, data, dataSz);
00550 #endif
00551             break;
00552         case WC_HASH_TYPE_SHA256:
00553 #ifndef NO_SHA256
00554             ret = wc_Sha256Update(&hash->sha256, data, dataSz);
00555 #endif
00556             break;
00557         case WC_HASH_TYPE_SHA384:
00558 #ifdef WOLFSSL_SHA384
00559             ret = wc_Sha384Update(&hash->sha384, data, dataSz);
00560 #endif
00561             break;
00562         case WC_HASH_TYPE_SHA512:
00563 #ifdef WOLFSSL_SHA512
00564             ret = wc_Sha512Update(&hash->sha512, data, dataSz);
00565 #endif
00566             break;
00567 
00568         /* not supported */
00569         case WC_HASH_TYPE_MD5_SHA:
00570         case WC_HASH_TYPE_MD2:
00571         case WC_HASH_TYPE_MD4:
00572         case WC_HASH_TYPE_SHA3_224:
00573         case WC_HASH_TYPE_SHA3_256:
00574         case WC_HASH_TYPE_SHA3_384:
00575         case WC_HASH_TYPE_SHA3_512:
00576         case WC_HASH_TYPE_BLAKE2B:
00577         case WC_HASH_TYPE_NONE:
00578         default:
00579             ret = BAD_FUNC_ARG;
00580     };
00581 
00582     return ret;
00583 }
00584 
00585 int wc_HashFinal(wc_HashAlg* hash, enum wc_HashType type, byte* out)
00586 {
00587     int ret = HASH_TYPE_E; /* Default to hash type error */
00588 
00589     if (hash == NULL || out == NULL)
00590         return BAD_FUNC_ARG;
00591 
00592     switch (type) {
00593         case WC_HASH_TYPE_MD5:
00594 #ifndef NO_MD5
00595             wc_Md5Final(&hash->md5, out);
00596             ret = 0;
00597 #endif
00598             break;
00599         case WC_HASH_TYPE_SHA:
00600 #ifndef NO_SHA
00601             ret = wc_ShaFinal(&hash->sha, out);
00602 #endif
00603             break;
00604         case WC_HASH_TYPE_SHA224:
00605 #ifdef WOLFSSL_SHA224
00606             ret = wc_Sha224Final(&hash->sha224, out);
00607 #endif
00608             break;
00609         case WC_HASH_TYPE_SHA256:
00610 #ifndef NO_SHA256
00611             ret = wc_Sha256Final(&hash->sha256, out);
00612 #endif
00613             break;
00614         case WC_HASH_TYPE_SHA384:
00615 #ifdef WOLFSSL_SHA384
00616             ret = wc_Sha384Final(&hash->sha384, out);
00617 #endif
00618             break;
00619         case WC_HASH_TYPE_SHA512:
00620 #ifdef WOLFSSL_SHA512
00621             ret = wc_Sha512Final(&hash->sha512, out);
00622 #endif
00623             break;
00624 
00625         /* not supported */
00626         case WC_HASH_TYPE_MD5_SHA:
00627         case WC_HASH_TYPE_MD2:
00628         case WC_HASH_TYPE_MD4:
00629         case WC_HASH_TYPE_SHA3_224:
00630         case WC_HASH_TYPE_SHA3_256:
00631         case WC_HASH_TYPE_SHA3_384:
00632         case WC_HASH_TYPE_SHA3_512:
00633         case WC_HASH_TYPE_BLAKE2B:
00634         case WC_HASH_TYPE_NONE:
00635         default:
00636             ret = BAD_FUNC_ARG;
00637     };
00638 
00639     return ret;
00640 }
00641 
00642 
00643 #if !defined(WOLFSSL_TI_HASH)
00644 
00645 #if !defined(NO_MD5)
00646     int wc_Md5Hash(const byte* data, word32 len, byte* hash)
00647     {
00648         int ret;
00649     #ifdef WOLFSSL_SMALL_STACK
00650         wc_Md5* md5;
00651     #else
00652         wc_Md5  md5[1];
00653     #endif
00654 
00655     #ifdef WOLFSSL_SMALL_STACK
00656         md5 = (wc_Md5*)XMALLOC(sizeof(wc_Md5), NULL, DYNAMIC_TYPE_TMP_BUFFER);
00657         if (md5 == NULL)
00658             return MEMORY_E;
00659     #endif
00660 
00661         ret = wc_InitMd5(md5);
00662         if (ret == 0) {
00663             ret = wc_Md5Update(md5, data, len);
00664             if (ret == 0) {
00665                 ret = wc_Md5Final(md5, hash);
00666             }
00667         }
00668 
00669     #ifdef WOLFSSL_SMALL_STACK
00670         XFREE(md5, NULL, DYNAMIC_TYPE_TMP_BUFFER);
00671     #endif
00672 
00673         return ret;
00674     }
00675 #endif /* !NO_MD5 */
00676 
00677 #if !defined(NO_SHA)
00678     int wc_ShaHash(const byte* data, word32 len, byte* hash)
00679     {
00680         int ret = 0;
00681     #ifdef WOLFSSL_SMALL_STACK
00682         wc_Sha* sha;
00683     #else
00684         wc_Sha sha[1];
00685     #endif
00686 
00687     #ifdef WOLFSSL_SMALL_STACK
00688         sha = (wc_Sha*)XMALLOC(sizeof(wc_Sha), NULL, DYNAMIC_TYPE_TMP_BUFFER);
00689         if (sha == NULL)
00690             return MEMORY_E;
00691     #endif
00692 
00693         if ((ret = wc_InitSha(sha)) != 0) {
00694             WOLFSSL_MSG("wc_InitSha failed");
00695         }
00696         else {
00697             wc_ShaUpdate(sha, data, len);
00698             wc_ShaFinal(sha, hash);
00699         }
00700 
00701     #ifdef WOLFSSL_SMALL_STACK
00702         XFREE(sha, NULL, DYNAMIC_TYPE_TMP_BUFFER);
00703     #endif
00704 
00705         return ret;
00706     }
00707 #endif /* !NO_SHA */
00708 
00709 #if defined(WOLFSSL_SHA224)
00710     int wc_Sha224Hash(const byte* data, word32 len, byte* hash)
00711     {
00712         int ret = 0;
00713     #ifdef WOLFSSL_SMALL_STACK
00714         wc_Sha224* sha224;
00715     #else
00716         wc_Sha224 sha224[1];
00717     #endif
00718 
00719     #ifdef WOLFSSL_SMALL_STACK
00720         sha224 = (wc_Sha224*)XMALLOC(sizeof(wc_Sha224), NULL,
00721             DYNAMIC_TYPE_TMP_BUFFER);
00722         if (sha224 == NULL)
00723             return MEMORY_E;
00724     #endif
00725 
00726         if ((ret = wc_InitSha224(sha224)) != 0) {
00727             WOLFSSL_MSG("InitSha224 failed");
00728         }
00729         else {
00730             if ((ret = wc_Sha224Update(sha224, data, len)) != 0) {
00731                 WOLFSSL_MSG("Sha224Update failed");
00732             }
00733             else if ((ret = wc_Sha224Final(sha224, hash)) != 0) {
00734                 WOLFSSL_MSG("Sha224Final failed");
00735             }
00736             wc_Sha224Free(sha224);
00737         }
00738 
00739     #ifdef WOLFSSL_SMALL_STACK
00740         XFREE(sha224, NULL, DYNAMIC_TYPE_TMP_BUFFER);
00741     #endif
00742 
00743     return ret;
00744 }
00745 #endif /* WOLFSSL_SHA224 */
00746 
00747 #if !defined(NO_SHA256)
00748     int wc_Sha256Hash(const byte* data, word32 len, byte* hash)
00749     {
00750         int ret = 0;
00751     #ifdef WOLFSSL_SMALL_STACK
00752         wc_Sha256* sha256;
00753     #else
00754         wc_Sha256 sha256[1];
00755     #endif
00756 
00757     #ifdef WOLFSSL_SMALL_STACK
00758         sha256 = (wc_Sha256*)XMALLOC(sizeof(wc_Sha256), NULL,
00759             DYNAMIC_TYPE_TMP_BUFFER);
00760         if (sha256 == NULL)
00761             return MEMORY_E;
00762     #endif
00763 
00764         if ((ret = wc_InitSha256(sha256)) != 0) {
00765             WOLFSSL_MSG("InitSha256 failed");
00766         }
00767         else {
00768             if ((ret = wc_Sha256Update(sha256, data, len)) != 0) {
00769                 WOLFSSL_MSG("Sha256Update failed");
00770             }
00771             else if ((ret = wc_Sha256Final(sha256, hash)) != 0) {
00772                 WOLFSSL_MSG("Sha256Final failed");
00773             }
00774             wc_Sha256Free(sha256);
00775         }
00776 
00777 
00778     #ifdef WOLFSSL_SMALL_STACK
00779         XFREE(sha256, NULL, DYNAMIC_TYPE_TMP_BUFFER);
00780     #endif
00781 
00782         return ret;
00783     }
00784 #endif /* !NO_SHA256 */
00785 
00786 #endif /* !defined(WOLFSSL_TI_HASH) */
00787 
00788 
00789 #if defined(WOLFSSL_SHA512)
00790     int wc_Sha512Hash(const byte* data, word32 len, byte* hash)
00791     {
00792         int ret = 0;
00793     #ifdef WOLFSSL_SMALL_STACK
00794         wc_Sha512* sha512;
00795     #else
00796         wc_Sha512 sha512[1];
00797     #endif
00798 
00799     #ifdef WOLFSSL_SMALL_STACK
00800         sha512 = (wc_Sha512*)XMALLOC(sizeof(wc_Sha512), NULL,
00801             DYNAMIC_TYPE_TMP_BUFFER);
00802         if (sha512 == NULL)
00803             return MEMORY_E;
00804     #endif
00805 
00806         if ((ret = wc_InitSha512(sha512)) != 0) {
00807             WOLFSSL_MSG("InitSha512 failed");
00808         }
00809         else {
00810             if ((ret = wc_Sha512Update(sha512, data, len)) != 0) {
00811                 WOLFSSL_MSG("Sha512Update failed");
00812             }
00813             else if ((ret = wc_Sha512Final(sha512, hash)) != 0) {
00814                 WOLFSSL_MSG("Sha512Final failed");
00815             }
00816             wc_Sha512Free(sha512);
00817         }
00818 
00819     #ifdef WOLFSSL_SMALL_STACK
00820         XFREE(sha512, NULL, DYNAMIC_TYPE_TMP_BUFFER);
00821     #endif
00822 
00823         return ret;
00824     }
00825 #endif /* WOLFSSL_SHA512 */
00826 
00827 #if defined(WOLFSSL_SHA384)
00828     int wc_Sha384Hash(const byte* data, word32 len, byte* hash)
00829     {
00830         int ret = 0;
00831     #ifdef WOLFSSL_SMALL_STACK
00832         wc_Sha384* sha384;
00833     #else
00834         wc_Sha384 sha384[1];
00835     #endif
00836 
00837     #ifdef WOLFSSL_SMALL_STACK
00838         sha384 = (wc_Sha384*)XMALLOC(sizeof(wc_Sha384), NULL,
00839             DYNAMIC_TYPE_TMP_BUFFER);
00840         if (sha384 == NULL)
00841             return MEMORY_E;
00842     #endif
00843 
00844         if ((ret = wc_InitSha384(sha384)) != 0) {
00845             WOLFSSL_MSG("InitSha384 failed");
00846         }
00847         else {
00848             if ((ret = wc_Sha384Update(sha384, data, len)) != 0) {
00849                 WOLFSSL_MSG("Sha384Update failed");
00850             }
00851             else if ((ret = wc_Sha384Final(sha384, hash)) != 0) {
00852                 WOLFSSL_MSG("Sha384Final failed");
00853             }
00854             wc_Sha384Free(sha384);
00855         }
00856 
00857     #ifdef WOLFSSL_SMALL_STACK
00858         XFREE(sha384, NULL, DYNAMIC_TYPE_TMP_BUFFER);
00859     #endif
00860 
00861         return ret;
00862     }
00863 #endif /* WOLFSSL_SHA384 */
00864