hash.c

00001 /* hash.c
00002  *
00003  * Copyright (C) 2006-2016 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 <wolfssl/wolfcrypt/settings.h>
00028 #include <wolfssl/wolfcrypt/logging.h>
00029 #include <wolfssl/wolfcrypt/error-crypt.h>
00030 #ifndef NO_ASN
00031 #include <wolfssl/wolfcrypt/asn.h>
00032 #endif
00033 
00034 #include <wolfssl/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
00050 
00051 int wc_HashGetOID(enum wc_HashType hash_type)
00052 {
00053     int oid = HASH_TYPE_E; /* Default to hash type error */
00054     switch(hash_type)
00055     {
00056         case WC_HASH_TYPE_MD2:
00057         #ifdef WOLFSSL_MD2
00058             oid = MD2h;
00059         #endif
00060             break;
00061         case WC_HASH_TYPE_MD5_SHA:
00062         case WC_HASH_TYPE_MD5:
00063         #ifndef NO_MD5
00064             oid = MD5h;
00065         #endif
00066             break;
00067         case WC_HASH_TYPE_SHA:
00068         #ifndef NO_SHA
00069             oid = SHAh;
00070         #endif
00071             break;
00072         case WC_HASH_TYPE_SHA224:
00073         #if defined(WOLFSSL_SHA224)
00074             oid = SHA224h;
00075         #endif
00076             break;
00077         case WC_HASH_TYPE_SHA256:
00078         #ifndef NO_SHA256
00079             oid = SHA256h;
00080         #endif
00081             break;
00082         case WC_HASH_TYPE_SHA384:
00083         #if defined(WOLFSSL_SHA512) && defined(WOLFSSL_SHA384)
00084             oid = SHA384h;
00085         #endif
00086             break;
00087         case WC_HASH_TYPE_SHA512:
00088         #ifdef WOLFSSL_SHA512
00089             oid = SHA512h;
00090         #endif
00091             break;
00092 
00093         /* Not Supported */
00094         case WC_HASH_TYPE_MD4:
00095         case WC_HASH_TYPE_NONE:
00096         default:
00097             oid = BAD_FUNC_ARG;
00098             break;
00099     }
00100     return oid;
00101 }
00102 #endif
00103 
00104 /* Get Hash digest size */
00105 int wc_HashGetDigestSize(enum wc_HashType hash_type)
00106 {
00107     int dig_size = HASH_TYPE_E; /* Default to hash type error */
00108     switch(hash_type)
00109     {
00110         case WC_HASH_TYPE_MD5:
00111 #ifndef NO_MD5
00112             dig_size = MD5_DIGEST_SIZE;
00113 #endif
00114             break;
00115         case WC_HASH_TYPE_SHA:
00116 #ifndef NO_SHA
00117             dig_size = SHA_DIGEST_SIZE;
00118 #endif
00119             break;
00120         case WC_HASH_TYPE_SHA224:
00121 #ifdef WOLFSSL_SHA224
00122             dig_size = SHA224_DIGEST_SIZE;
00123 #endif
00124             break;
00125         case WC_HASH_TYPE_SHA256:
00126 #ifndef NO_SHA256
00127             dig_size = SHA256_DIGEST_SIZE;
00128 #endif
00129             break;
00130         case WC_HASH_TYPE_SHA384:
00131 #if defined(WOLFSSL_SHA512) && defined(WOLFSSL_SHA384)
00132             dig_size = SHA384_DIGEST_SIZE;
00133 #endif
00134             break;
00135         case WC_HASH_TYPE_SHA512:
00136 #ifdef WOLFSSL_SHA512
00137             dig_size = SHA512_DIGEST_SIZE;
00138 #endif
00139             break;
00140         case WC_HASH_TYPE_MD5_SHA:
00141 #if !defined(NO_MD5) && !defined(NO_SHA)
00142             dig_size = MD5_DIGEST_SIZE + SHA_DIGEST_SIZE;
00143 #endif
00144             break;
00145 
00146         /* Not Supported */
00147         case WC_HASH_TYPE_MD2:
00148         case WC_HASH_TYPE_MD4:
00149         case WC_HASH_TYPE_NONE:
00150         default:
00151             dig_size = BAD_FUNC_ARG;
00152             break;
00153     }
00154     return dig_size;
00155 }
00156 
00157 /* Generic Hashing Wrapper */
00158 int wc_Hash(enum wc_HashType hash_type, const byte* data,
00159     word32 data_len, byte* hash, word32 hash_len)
00160 {
00161     int ret = HASH_TYPE_E; /* Default to hash type error */
00162     word32 dig_size;
00163 
00164     /* Validate hash buffer size */
00165     dig_size = wc_HashGetDigestSize(hash_type);
00166     if (hash_len < dig_size) {
00167         return BUFFER_E;
00168     }
00169 
00170     /* Suppress possible unused arg if all hashing is disabled */
00171     (void)data;
00172     (void)data_len;
00173     (void)hash;
00174     (void)hash_len;
00175 
00176     switch(hash_type)
00177     {
00178         case WC_HASH_TYPE_MD5:
00179 #ifndef NO_MD5
00180             ret = wc_Md5Hash(data, data_len, hash);
00181 #endif
00182             break;
00183         case WC_HASH_TYPE_SHA:
00184 #ifndef NO_SHA
00185             ret = wc_ShaHash(data, data_len, hash);
00186 #endif
00187             break;
00188         case WC_HASH_TYPE_SHA224:
00189 #ifdef WOLFSSL_SHA224
00190             ret = wc_Sha224Hash(data, data_len, hash);
00191 #endif
00192             break;
00193         case WC_HASH_TYPE_SHA256:
00194 #ifndef NO_SHA256
00195             ret = wc_Sha256Hash(data, data_len, hash);
00196 #endif
00197             break;
00198         case WC_HASH_TYPE_SHA384:
00199 #if defined(WOLFSSL_SHA512) && defined(WOLFSSL_SHA384)
00200             ret = wc_Sha384Hash(data, data_len, hash);
00201 #endif
00202             break;
00203         case WC_HASH_TYPE_SHA512:
00204 #ifdef WOLFSSL_SHA512
00205             ret = wc_Sha512Hash(data, data_len, hash);
00206 #endif
00207             break;
00208         case WC_HASH_TYPE_MD5_SHA:
00209 #if !defined(NO_MD5) && !defined(NO_SHA)
00210             ret = wc_Md5Hash(data, data_len, hash);
00211             if (ret == 0) {
00212                 ret = wc_ShaHash(data, data_len, &hash[MD5_DIGEST_SIZE]);
00213             }
00214 #endif
00215             break;
00216 
00217         /* Not Supported */
00218         case WC_HASH_TYPE_MD2:
00219         case WC_HASH_TYPE_MD4:
00220         case WC_HASH_TYPE_NONE:
00221         default:
00222             ret = BAD_FUNC_ARG;
00223             break;
00224     }
00225     return ret;
00226 }
00227 
00228 int wc_HashInit(wc_HashAlg* hash, enum wc_HashType type)
00229 {
00230     int ret = HASH_TYPE_E; /* Default to hash type error */
00231 
00232     if (hash == NULL)
00233         return BAD_FUNC_ARG;
00234 
00235     switch (type) {
00236         case WC_HASH_TYPE_MD5:
00237 #ifndef NO_MD5
00238             wc_InitMd5(&hash->md5);
00239             ret = 0;
00240 #endif
00241             break;
00242         case WC_HASH_TYPE_SHA:
00243 #ifndef NO_SHA
00244             ret = wc_InitSha(&hash->sha);
00245 #endif
00246             break;
00247         case WC_HASH_TYPE_SHA224:
00248 #ifdef WOLFSSL_SHA224
00249             ret = wc_InitSha224(&hash->sha224);
00250 #endif
00251             break;
00252         case WC_HASH_TYPE_SHA256:
00253 #ifndef NO_SHA256
00254             ret = wc_InitSha256(&hash->sha256);
00255 #endif
00256             break;
00257         case WC_HASH_TYPE_SHA384:
00258 #ifdef WOLFSSL_SHA384
00259             ret = wc_InitSha384(&hash->sha384);
00260 #endif
00261             break;
00262         case WC_HASH_TYPE_SHA512:
00263 #ifdef WOLFSSL_SHA512
00264             ret = wc_InitSha512(&hash->sha512);
00265 #endif
00266             break;
00267 
00268         /* not supported */
00269         case WC_HASH_TYPE_MD5_SHA:
00270         case WC_HASH_TYPE_MD2:
00271         case WC_HASH_TYPE_MD4:
00272         case WC_HASH_TYPE_NONE:
00273         default:
00274             ret = BAD_FUNC_ARG;
00275     };
00276 
00277     return ret;
00278 }
00279 
00280 int wc_HashUpdate(wc_HashAlg* hash, enum wc_HashType type, const byte* data,
00281                   word32 dataSz)
00282 {
00283     int ret = HASH_TYPE_E; /* Default to hash type error */
00284 
00285     if (hash == NULL || data == NULL)
00286         return BAD_FUNC_ARG;
00287 
00288     switch (type) {
00289         case WC_HASH_TYPE_MD5:
00290 #ifndef NO_MD5
00291             wc_Md5Update(&hash->md5, data, dataSz);
00292             ret = 0;
00293 #endif
00294             break;
00295         case WC_HASH_TYPE_SHA:
00296 #ifndef NO_SHA
00297             ret = wc_ShaUpdate(&hash->sha, data, dataSz);
00298             if (ret != 0)
00299                 return ret;
00300 #endif
00301             break;
00302         case WC_HASH_TYPE_SHA224:
00303 #ifdef WOLFSSL_SHA224
00304             ret = wc_Sha224Update(&hash->sha224, data, dataSz);
00305 #endif
00306             break;
00307         case WC_HASH_TYPE_SHA256:
00308 #ifndef NO_SHA256
00309             ret = wc_Sha256Update(&hash->sha256, data, dataSz);
00310 #endif
00311             break;
00312         case WC_HASH_TYPE_SHA384:
00313 #ifdef WOLFSSL_SHA384
00314             ret = wc_Sha384Update(&hash->sha384, data, dataSz);
00315 #endif
00316             break;
00317         case WC_HASH_TYPE_SHA512:
00318 #ifdef WOLFSSL_SHA512
00319             ret = wc_Sha512Update(&hash->sha512, data, dataSz);
00320 #endif
00321             break;
00322 
00323         /* not supported */
00324         case WC_HASH_TYPE_MD5_SHA:
00325         case WC_HASH_TYPE_MD2:
00326         case WC_HASH_TYPE_MD4:
00327         case WC_HASH_TYPE_NONE:
00328         default:
00329             ret = BAD_FUNC_ARG;
00330     };
00331 
00332     return ret;
00333 }
00334 
00335 int wc_HashFinal(wc_HashAlg* hash, enum wc_HashType type, byte* out)
00336 {
00337     int ret = HASH_TYPE_E; /* Default to hash type error */
00338 
00339     if (hash == NULL || out == NULL)
00340         return BAD_FUNC_ARG;
00341 
00342     switch (type) {
00343         case WC_HASH_TYPE_MD5:
00344 #ifndef NO_MD5
00345             wc_Md5Final(&hash->md5, out);
00346             ret = 0;
00347 #endif
00348             break;
00349         case WC_HASH_TYPE_SHA:
00350 #ifndef NO_SHA
00351             ret = wc_ShaFinal(&hash->sha, out);
00352 #endif
00353             break;
00354         case WC_HASH_TYPE_SHA224:
00355 #ifdef WOLFSSL_SHA224
00356             ret = wc_Sha224Final(&hash->sha224, out);
00357 #endif
00358             break;
00359         case WC_HASH_TYPE_SHA256:
00360 #ifndef NO_SHA256
00361             ret = wc_Sha256Final(&hash->sha256, out);
00362 #endif
00363             break;
00364         case WC_HASH_TYPE_SHA384:
00365 #ifdef WOLFSSL_SHA384
00366             ret = wc_Sha384Final(&hash->sha384, out);
00367 #endif
00368             break;
00369         case WC_HASH_TYPE_SHA512:
00370 #ifdef WOLFSSL_SHA512
00371             ret = wc_Sha512Final(&hash->sha512, out);
00372 #endif
00373             break;
00374 
00375         /* not supported */
00376         case WC_HASH_TYPE_MD5_SHA:
00377         case WC_HASH_TYPE_MD2:
00378         case WC_HASH_TYPE_MD4:
00379         case WC_HASH_TYPE_NONE:
00380         default:
00381             ret = BAD_FUNC_ARG;
00382     };
00383 
00384     return ret;
00385 }
00386 
00387 
00388 #if !defined(WOLFSSL_TI_HASH)
00389 
00390 #if !defined(NO_MD5)
00391     int wc_Md5Hash(const byte* data, word32 len, byte* hash)
00392     {
00393         int ret;
00394     #ifdef WOLFSSL_SMALL_STACK
00395         Md5* md5;
00396     #else
00397         Md5  md5[1];
00398     #endif
00399 
00400     #ifdef WOLFSSL_SMALL_STACK
00401         md5 = (Md5*)XMALLOC(sizeof(Md5), NULL, DYNAMIC_TYPE_TMP_BUFFER);
00402         if (md5 == NULL)
00403             return MEMORY_E;
00404     #endif
00405 
00406         ret = wc_InitMd5(md5);
00407         if (ret == 0) {
00408             ret = wc_Md5Update(md5, data, len);
00409             if (ret == 0) {
00410                 ret = wc_Md5Final(md5, hash);
00411             }
00412         }
00413 
00414     #ifdef WOLFSSL_SMALL_STACK
00415         XFREE(md5, NULL, DYNAMIC_TYPE_TMP_BUFFER);
00416     #endif
00417 
00418         return ret;
00419     }
00420 #endif /* !NO_MD5 */
00421 
00422 #if !defined(NO_SHA)
00423     int wc_ShaHash(const byte* data, word32 len, byte* hash)
00424     {
00425         int ret = 0;
00426     #ifdef WOLFSSL_SMALL_STACK
00427         Sha* sha;
00428     #else
00429         Sha sha[1];
00430     #endif
00431 
00432     #ifdef WOLFSSL_SMALL_STACK
00433         sha = (Sha*)XMALLOC(sizeof(Sha), NULL, DYNAMIC_TYPE_TMP_BUFFER);
00434         if (sha == NULL)
00435             return MEMORY_E;
00436     #endif
00437 
00438         if ((ret = wc_InitSha(sha)) != 0) {
00439             WOLFSSL_MSG("wc_InitSha failed");
00440         }
00441         else {
00442             wc_ShaUpdate(sha, data, len);
00443             wc_ShaFinal(sha, hash);
00444         }
00445 
00446     #ifdef WOLFSSL_SMALL_STACK
00447         XFREE(sha, NULL, DYNAMIC_TYPE_TMP_BUFFER);
00448     #endif
00449 
00450         return ret;
00451     }
00452 #endif /* !NO_SHA */
00453 
00454 #if defined(WOLFSSL_SHA224)
00455 int wc_Sha224Hash(const byte* data, word32 len, byte* hash)
00456 {
00457     int ret = 0;
00458 #ifdef WOLFSSL_SMALL_STACK
00459     Sha224* sha224;
00460 #else
00461     Sha224 sha224[1];
00462 #endif
00463 
00464 #ifdef WOLFSSL_SMALL_STACK
00465     sha224 = (Sha224*)XMALLOC(sizeof(Sha224), NULL, DYNAMIC_TYPE_TMP_BUFFER);
00466     if (sha224 == NULL)
00467         return MEMORY_E;
00468 #endif
00469 
00470     if ((ret = wc_InitSha224(sha224)) != 0) {
00471         WOLFSSL_MSG("InitSha224 failed");
00472     }
00473     else if ((ret = wc_Sha224Update(sha224, data, len)) != 0) {
00474         WOLFSSL_MSG("Sha224Update failed");
00475     }
00476     else if ((ret = wc_Sha224Final(sha224, hash)) != 0) {
00477         WOLFSSL_MSG("Sha224Final failed");
00478     }
00479 
00480 #ifdef WOLFSSL_SMALL_STACK
00481     XFREE(sha224, NULL, DYNAMIC_TYPE_TMP_BUFFER);
00482 #endif
00483 
00484     return ret;
00485 }
00486 #endif /* WOLFSSL_SHA224 */
00487 
00488 #if !defined(NO_SHA256)
00489     int wc_Sha256Hash(const byte* data, word32 len, byte* hash)
00490     {
00491         int ret = 0;
00492     #ifdef WOLFSSL_SMALL_STACK
00493         Sha256* sha256;
00494     #else
00495         Sha256 sha256[1];
00496     #endif
00497 
00498     #ifdef WOLFSSL_SMALL_STACK
00499         sha256 = (Sha256*)XMALLOC(sizeof(Sha256), NULL, DYNAMIC_TYPE_TMP_BUFFER);
00500         if (sha256 == NULL)
00501             return MEMORY_E;
00502     #endif
00503 
00504         if ((ret = wc_InitSha256(sha256)) != 0) {
00505             WOLFSSL_MSG("InitSha256 failed");
00506         }
00507         else if ((ret = wc_Sha256Update(sha256, data, len)) != 0) {
00508             WOLFSSL_MSG("Sha256Update failed");
00509         }
00510         else if ((ret = wc_Sha256Final(sha256, hash)) != 0) {
00511             WOLFSSL_MSG("Sha256Final failed");
00512         }
00513 
00514     #ifdef WOLFSSL_SMALL_STACK
00515         XFREE(sha256, NULL, DYNAMIC_TYPE_TMP_BUFFER);
00516     #endif
00517 
00518         return ret;
00519     }
00520 #endif /* !NO_SHA256 */
00521 
00522 #endif /* !defined(WOLFSSL_TI_HASH) */
00523 
00524 
00525 #if defined(WOLFSSL_SHA512)
00526     int wc_Sha512Hash(const byte* data, word32 len, byte* hash)
00527     {
00528         int ret = 0;
00529     #ifdef WOLFSSL_SMALL_STACK
00530         Sha512* sha512;
00531     #else
00532         Sha512 sha512[1];
00533     #endif
00534 
00535     #ifdef WOLFSSL_SMALL_STACK
00536         sha512 = (Sha512*)XMALLOC(sizeof(Sha512), NULL, DYNAMIC_TYPE_TMP_BUFFER);
00537         if (sha512 == NULL)
00538             return MEMORY_E;
00539     #endif
00540 
00541         if ((ret = wc_InitSha512(sha512)) != 0) {
00542             WOLFSSL_MSG("InitSha512 failed");
00543         }
00544         else if ((ret = wc_Sha512Update(sha512, data, len)) != 0) {
00545             WOLFSSL_MSG("Sha512Update failed");
00546         }
00547         else if ((ret = wc_Sha512Final(sha512, hash)) != 0) {
00548             WOLFSSL_MSG("Sha512Final failed");
00549         }
00550 
00551     #ifdef WOLFSSL_SMALL_STACK
00552         XFREE(sha512, NULL, DYNAMIC_TYPE_TMP_BUFFER);
00553     #endif
00554 
00555         return ret;
00556     }
00557 
00558     #if defined(WOLFSSL_SHA384)
00559         int wc_Sha384Hash(const byte* data, word32 len, byte* hash)
00560         {
00561             int ret = 0;
00562         #ifdef WOLFSSL_SMALL_STACK
00563             Sha384* sha384;
00564         #else
00565             Sha384 sha384[1];
00566         #endif
00567 
00568         #ifdef WOLFSSL_SMALL_STACK
00569             sha384 = (Sha384*)XMALLOC(sizeof(Sha384), NULL, DYNAMIC_TYPE_TMP_BUFFER);
00570             if (sha384 == NULL)
00571                 return MEMORY_E;
00572         #endif
00573 
00574             if ((ret = wc_InitSha384(sha384)) != 0) {
00575                 WOLFSSL_MSG("InitSha384 failed");
00576             }
00577             else if ((ret = wc_Sha384Update(sha384, data, len)) != 0) {
00578                 WOLFSSL_MSG("Sha384Update failed");
00579             }
00580             else if ((ret = wc_Sha384Final(sha384, hash)) != 0) {
00581                 WOLFSSL_MSG("Sha384Final failed");
00582             }
00583 
00584         #ifdef WOLFSSL_SMALL_STACK
00585             XFREE(sha384, NULL, DYNAMIC_TYPE_TMP_BUFFER);
00586         #endif
00587 
00588             return ret;
00589         }
00590     #endif /* WOLFSSL_SHA384 */
00591 #endif /* WOLFSSL_SHA512 */
00592