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 #ifndef NO_ASN
00038 int wc_HashGetOID(enum wc_HashType hash_type)
00039 {
00040     int oid = HASH_TYPE_E; /* Default to hash type error */
00041     switch(hash_type)
00042     {
00043         case WC_HASH_TYPE_MD2:
00044 #ifdef WOLFSSL_MD2
00045             oid = MD2h;
00046 #endif
00047             break;
00048         case WC_HASH_TYPE_MD5:
00049 #ifndef NO_MD5
00050             oid = MD5h;
00051 #endif
00052             break;
00053         case WC_HASH_TYPE_SHA:
00054 #ifndef NO_SHA
00055             oid = SHAh;
00056 #endif
00057             break;
00058         case WC_HASH_TYPE_SHA256:
00059 #ifndef NO_SHA256
00060             oid = SHA256h;
00061 #endif
00062             break;
00063         case WC_HASH_TYPE_SHA384:
00064 #if defined(WOLFSSL_SHA512) && defined(WOLFSSL_SHA384)
00065             oid = SHA384h;
00066 #endif
00067             break;
00068         case WC_HASH_TYPE_SHA512:
00069 #ifdef WOLFSSL_SHA512
00070             oid = SHA512h;
00071 #endif
00072             break;
00073 
00074         /* Not Supported */
00075         case WC_HASH_TYPE_MD4:
00076         case WC_HASH_TYPE_NONE:
00077         default:
00078             oid = BAD_FUNC_ARG;
00079             break;
00080     }
00081     return oid;
00082 }
00083 #endif
00084 
00085 /* Get Hash digest size */
00086 int wc_HashGetDigestSize(enum wc_HashType hash_type)
00087 {
00088     int dig_size = HASH_TYPE_E; /* Default to hash type error */
00089     switch(hash_type)
00090     {
00091         case WC_HASH_TYPE_MD5:
00092 #ifndef NO_MD5
00093             dig_size = MD5_DIGEST_SIZE;
00094 #endif
00095             break;
00096         case WC_HASH_TYPE_SHA:
00097 #ifndef NO_SHA
00098             dig_size = SHA_DIGEST_SIZE;
00099 #endif
00100             break;
00101         case WC_HASH_TYPE_SHA256:
00102 #ifndef NO_SHA256
00103             dig_size = SHA256_DIGEST_SIZE;
00104 #endif
00105             break;
00106         case WC_HASH_TYPE_SHA384:
00107 #if defined(WOLFSSL_SHA512) && defined(WOLFSSL_SHA384)
00108             dig_size = SHA384_DIGEST_SIZE;
00109 #endif
00110             break;
00111         case WC_HASH_TYPE_SHA512:
00112 #ifdef WOLFSSL_SHA512
00113             dig_size = SHA512_DIGEST_SIZE;
00114 #endif
00115             break;
00116 
00117         /* Not Supported */
00118         case WC_HASH_TYPE_MD2:
00119         case WC_HASH_TYPE_MD4:
00120         case WC_HASH_TYPE_NONE:
00121         default:
00122             dig_size = BAD_FUNC_ARG;
00123             break;
00124     }
00125     return dig_size;
00126 }
00127 
00128 /* Generic Hashing Wrapper */
00129 int wc_Hash(enum wc_HashType hash_type, const byte* data,
00130     word32 data_len, byte* hash, word32 hash_len)
00131 {
00132     int ret = HASH_TYPE_E; /* Default to hash type error */
00133     word32 dig_size;
00134 
00135     /* Validate hash buffer size */
00136     dig_size = wc_HashGetDigestSize(hash_type);
00137     if (hash_len < dig_size) {
00138         return BUFFER_E;
00139     }
00140     
00141     /* Suppress possible unused arg if all hashing is disabled */
00142     (void)data;
00143     (void)data_len;
00144     (void)hash;
00145     (void)hash_len;
00146 
00147     switch(hash_type)
00148     {
00149         case WC_HASH_TYPE_MD5:
00150 #ifndef NO_MD5
00151             ret = wc_Md5Hash(data, data_len, hash);
00152 #endif
00153             break;
00154         case WC_HASH_TYPE_SHA:
00155 #ifndef NO_SHA
00156             ret = wc_ShaHash(data, data_len, hash);
00157 #endif
00158             break;
00159         case WC_HASH_TYPE_SHA256:
00160 #ifndef NO_SHA256
00161             ret = wc_Sha256Hash(data, data_len, hash);
00162 #endif
00163             break;
00164         case WC_HASH_TYPE_SHA384:
00165 #if defined(WOLFSSL_SHA512) && defined(WOLFSSL_SHA384)
00166             ret = wc_Sha384Hash(data, data_len, hash);
00167 #endif
00168             break;
00169         case WC_HASH_TYPE_SHA512:
00170 #ifdef WOLFSSL_SHA512
00171             ret = wc_Sha512Hash(data, data_len, hash);
00172 #endif
00173             break;
00174 
00175         /* Not Supported */
00176         case WC_HASH_TYPE_MD2:
00177         case WC_HASH_TYPE_MD4:
00178         case WC_HASH_TYPE_NONE:
00179         default:
00180             ret = BAD_FUNC_ARG;
00181             break;
00182     }
00183     return ret;
00184 }
00185 
00186 
00187 #if !defined(WOLFSSL_TI_HASH)
00188 
00189 #if !defined(NO_MD5)
00190 void wc_Md5GetHash(Md5* md5, byte* hash)
00191 {
00192     Md5 save = *md5 ;
00193     wc_Md5Final(md5, hash) ;
00194     *md5 = save ;
00195 }
00196 
00197 WOLFSSL_API void wc_Md5RestorePos(Md5* m1, Md5* m2) {
00198     *m1 = *m2 ;
00199 }
00200 
00201 #endif
00202 
00203 #if !defined(NO_SHA)
00204 int wc_ShaGetHash(Sha* sha, byte* hash)
00205 {
00206     int ret ;
00207     Sha save = *sha ;
00208     ret = wc_ShaFinal(sha, hash) ;
00209     *sha = save ;
00210     return ret ;
00211 }
00212 
00213 void wc_ShaRestorePos(Sha* s1, Sha* s2) {
00214     *s1 = *s2 ;
00215 }
00216 
00217 int wc_ShaHash(const byte* data, word32 len, byte* hash)
00218 {
00219     int ret = 0;
00220 #ifdef WOLFSSL_SMALL_STACK
00221     Sha* sha;
00222 #else
00223     Sha sha[1];
00224 #endif
00225 
00226 #ifdef WOLFSSL_SMALL_STACK
00227     sha = (Sha*)XMALLOC(sizeof(Sha), NULL, DYNAMIC_TYPE_TMP_BUFFER);
00228     if (sha == NULL)
00229         return MEMORY_E;
00230 #endif
00231 
00232     if ((ret = wc_InitSha(sha)) != 0) {
00233         WOLFSSL_MSG("wc_InitSha failed");
00234     }
00235     else {
00236         wc_ShaUpdate(sha, data, len);
00237         wc_ShaFinal(sha, hash);
00238     }
00239 
00240 #ifdef WOLFSSL_SMALL_STACK
00241     XFREE(sha, NULL, DYNAMIC_TYPE_TMP_BUFFER);
00242 #endif
00243 
00244     return ret;
00245 
00246 }
00247 
00248 #endif /* !defined(NO_SHA) */
00249 
00250 #if !defined(NO_SHA256)
00251 int wc_Sha256GetHash(Sha256* sha256, byte* hash)
00252 {
00253     int ret ;
00254     Sha256 save = *sha256 ;
00255     ret = wc_Sha256Final(sha256, hash) ;
00256     *sha256 = save ;
00257     return ret ;
00258 }
00259 
00260 void wc_Sha256RestorePos(Sha256* s1, Sha256* s2) {
00261     *s1 = *s2 ;
00262 }
00263 
00264 int wc_Sha256Hash(const byte* data, word32 len, byte* hash)
00265 {
00266     int ret = 0;
00267 #ifdef WOLFSSL_SMALL_STACK
00268     Sha256* sha256;
00269 #else
00270     Sha256 sha256[1];
00271 #endif
00272 
00273 #ifdef WOLFSSL_SMALL_STACK
00274     sha256 = (Sha256*)XMALLOC(sizeof(Sha256), NULL, DYNAMIC_TYPE_TMP_BUFFER);
00275     if (sha256 == NULL)
00276         return MEMORY_E;
00277 #endif
00278 
00279     if ((ret = wc_InitSha256(sha256)) != 0) {
00280         WOLFSSL_MSG("InitSha256 failed");
00281     }
00282     else if ((ret = wc_Sha256Update(sha256, data, len)) != 0) {
00283         WOLFSSL_MSG("Sha256Update failed");
00284     }
00285     else if ((ret = wc_Sha256Final(sha256, hash)) != 0) {
00286         WOLFSSL_MSG("Sha256Final failed");
00287     }
00288 
00289 #ifdef WOLFSSL_SMALL_STACK
00290     XFREE(sha256, NULL, DYNAMIC_TYPE_TMP_BUFFER);
00291 #endif
00292 
00293     return ret;
00294 }
00295 
00296 #endif /* !defined(NO_SHA256) */
00297 
00298 #endif /* !defined(WOLFSSL_TI_HASH) */
00299 
00300 #if defined(WOLFSSL_SHA512)
00301 int wc_Sha512Hash(const byte* data, word32 len, byte* hash)
00302 {
00303     int ret = 0;
00304 #ifdef WOLFSSL_SMALL_STACK
00305     Sha512* sha512;
00306 #else
00307     Sha512 sha512[1];
00308 #endif
00309 
00310 #ifdef WOLFSSL_SMALL_STACK
00311     sha512 = (Sha512*)XMALLOC(sizeof(Sha512), NULL, DYNAMIC_TYPE_TMP_BUFFER);
00312     if (sha512 == NULL)
00313         return MEMORY_E;
00314 #endif
00315 
00316     if ((ret = wc_InitSha512(sha512)) != 0) {
00317         WOLFSSL_MSG("InitSha512 failed");
00318     }
00319     else if ((ret = wc_Sha512Update(sha512, data, len)) != 0) {
00320         WOLFSSL_MSG("Sha512Update failed");
00321     }
00322     else if ((ret = wc_Sha512Final(sha512, hash)) != 0) {
00323         WOLFSSL_MSG("Sha512Final failed");
00324     }
00325 
00326 #ifdef WOLFSSL_SMALL_STACK
00327     XFREE(sha512, NULL, DYNAMIC_TYPE_TMP_BUFFER);
00328 #endif
00329 
00330     return ret;
00331 }
00332 
00333 #if defined(WOLFSSL_SHA384)
00334 int wc_Sha384Hash(const byte* data, word32 len, byte* hash)
00335 {
00336     int ret = 0;
00337 #ifdef WOLFSSL_SMALL_STACK
00338     Sha384* sha384;
00339 #else
00340     Sha384 sha384[1];
00341 #endif
00342 
00343 #ifdef WOLFSSL_SMALL_STACK
00344     sha384 = (Sha384*)XMALLOC(sizeof(Sha384), NULL, DYNAMIC_TYPE_TMP_BUFFER);
00345     if (sha384 == NULL)
00346         return MEMORY_E;
00347 #endif
00348 
00349     if ((ret = wc_InitSha384(sha384)) != 0) {
00350         WOLFSSL_MSG("InitSha384 failed");
00351     }
00352     else if ((ret = wc_Sha384Update(sha384, data, len)) != 0) {
00353         WOLFSSL_MSG("Sha384Update failed");
00354     }
00355     else if ((ret = wc_Sha384Final(sha384, hash)) != 0) {
00356         WOLFSSL_MSG("Sha384Final failed");
00357     }
00358 
00359 #ifdef WOLFSSL_SMALL_STACK
00360     XFREE(sha384, NULL, DYNAMIC_TYPE_TMP_BUFFER);
00361 #endif
00362 
00363     return ret;
00364 }
00365 
00366 #endif /* defined(WOLFSSL_SHA384) */
00367 #endif /* defined(WOLFSSL_SHA512) */
00368