begriffs open source - freertos/blob - FreeRTOS-Plus/Source/WolfSSL/wolfcrypt/src/port/ti/ti-hash.c

   1 /* port/ti/ti-hash.c
   2  *
   3  * Copyright (C) 2006-2015 wolfSSL Inc.
   4  *
   5  * This file is part of wolfSSL. (formerly known as CyaSSL)
   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-1301, USA
  20  */
  21
  22
  23 #ifdef HAVE_CONFIG_H
  24     #include <config.h>
  25 #endif
  26
  27 #include <wolfssl/wolfcrypt/settings.h>
  28
  29 #include <wolfssl/wolfcrypt/types.h>
  30
  31 #if defined(WOLFSSL_TI_HASH)
  32
  33 #ifdef __cplusplus
  34     extern "C" {
  35 #endif
  36
  37 #include <stdbool.h>
  38 #include <stdint.h>
  39
  40 #include <wolfssl/wolfcrypt/error-crypt.h>
  41 #include <wolfssl/wolfcrypt/md5.h>
  42 #include <wolfssl/wolfcrypt/sha.h>
  43 #include <wolfssl/wolfcrypt/sha256.h>
  44 #include <wolfssl/wolfcrypt/port/ti/ti-hash.h>
  45 #include <wolfssl/wolfcrypt/port/ti/ti-ccm.h>
  46 #include <wolfssl/wolfcrypt/logging.h>
  47
  48 #ifndef TI_DUMMY_BUILD
  49 #include "inc/hw_memmap.h"
  50 #include "inc/hw_shamd5.h"
  51 #include "inc/hw_ints.h"
  52 #include "driverlib/shamd5.h"
  53 #include "driverlib/sysctl.h"
  54 #include "driverlib/rom_map.h"
  55 #include "driverlib/rom.h"
  56 #else
  57 #define SHAMD5_ALGO_MD5 1
  58 #define SHAMD5_ALGO_SHA1 2
  59 #define SHAMD5_ALGO_SHA256 3
  60 bool wolfSSL_TI_CCMInit(void) { return true ; }
  61 #endif
  62
  63 static int hashInit(wolfssl_TI_Hash *hash) {
  64     hash->used = 0 ;
  65     hash->msg  = 0 ;
  66     hash->len  = 0 ;
  67     return 0 ;
  68 }
  69
  70 static int hashUpdate(wolfssl_TI_Hash *hash, const byte* data, word32 len)
  71 {
  72     void *p ;
  73
  74     if((hash== NULL) || (data == NULL))return BAD_FUNC_ARG;
  75
  76     if(hash->len < hash->used+len) {
  77         if(hash->msg == NULL) {
  78             p = XMALLOC(hash->used+len, NULL, DYNAMIC_TYPE_TMP_BUFFER);
  79         } else {
  80             p = XREALLOC(hash->msg, hash->used+len, NULL, DYNAMIC_TYPE_TMP_BUFFER);
  81         }
  82         if(p == 0)return 1 ;
  83         hash->msg = p ;
  84         hash->len = hash->used+len ;
  85     }
  86     XMEMCPY(hash->msg+hash->used, data, len) ;
  87     hash->used += len ;
  88     return 0 ;
  89 }
  90
  91 static int hashGetHash(wolfssl_TI_Hash *hash, byte* result, word32 algo, word32 hsize)
  92 {
  93     uint32_t h[16] ;
  94 #ifndef TI_DUMMY_BUILD
  95     wolfSSL_TI_lockCCM() ;
  96     ROM_SHAMD5Reset(SHAMD5_BASE);
  97     ROM_SHAMD5ConfigSet(SHAMD5_BASE, algo);
  98     ROM_SHAMD5DataProcess(SHAMD5_BASE,
  99                    (uint32_t *)hash->msg, hash->used, h);
 100     wolfSSL_TI_unlockCCM() ;
 101 #else
 102     (void) hash ;
 103     (void) algo ;
 104 #endif
 105     XMEMCPY(result, h, hsize) ;
 106
 107     return 0 ;
 108 }
 109
 110 static void hashRestorePos(wolfssl_TI_Hash *h1, wolfssl_TI_Hash *h2) {
 111         h1->used = h2->used ;
 112 }
 113
 114 static int hashFinal(wolfssl_TI_Hash *hash, byte* result, word32 algo, word32 hsize)
 115 {
 116     hashGetHash(hash, result, algo, hsize) ;
 117     XFREE(hash->msg, NULL, DYNAMIC_TYPE_TMP_BUFFER);
 118     hashInit(hash) ;
 119     return 0 ;
 120 }
 121
 122 static int hashHash(const byte* data, word32 len, byte* hash, word32 algo, word32 hsize)
 123 {
 124     int ret = 0;
 125 #ifdef WOLFSSL_SMALL_STACK
 126     wolfssl_TI_Hash* hash_desc;
 127 #else
 128     wolfssl_TI_Hash  hash_desc[1];
 129 #endif
 130
 131 #ifdef WOLFSSL_SMALL_STACK
 132     hash_desc = (wolfssl_TI_Hash*)XMALLOC(sizeof(wolfssl_TI_Hash), NULL, DYNAMIC_TYPE_TMP_BUFFER);
 133     if (hash_desc == NULL)
 134         return MEMORY_E;
 135 #endif
 136
 137     if ((ret = hashInit(hash_desc)) != 0) {
 138         WOLFSSL_MSG("Hash Init failed");
 139     }
 140     else {
 141         hashUpdate(hash_desc, data, len);
 142         hashFinal(hash_desc, hash, algo, hsize);
 143     }
 144
 145 #ifdef WOLFSSL_SMALL_STACK
 146     XFREE(hash, NULL, DYNAMIC_TYPE_TMP_BUFFER);
 147 #endif
 148
 149     return ret;
 150 }
 151
 152 #if !defined(NO_MD5)
 153 WOLFSSL_API void wc_InitMd5(Md5* md5)
 154 {
 155     if (md5 == NULL)
 156         return ;
 157     if(!wolfSSL_TI_CCMInit())return  ;
 158     hashInit((wolfssl_TI_Hash *)md5) ;
 159 }
 160
 161 WOLFSSL_API void wc_Md5Update(Md5* md5, const byte* data, word32 len)
 162 {
 163     hashUpdate((wolfssl_TI_Hash *)md5, data, len) ;
 164 }
 165
 166 WOLFSSL_API void wc_Md5Final(Md5* md5, byte* hash)
 167 {
 168     hashFinal((wolfssl_TI_Hash *)md5, hash, SHAMD5_ALGO_MD5, MD5_DIGEST_SIZE) ;
 169 }
 170
 171 WOLFSSL_API void wc_Md5GetHash(Md5* md5, byte* hash)
 172 {
 173     hashGetHash((wolfssl_TI_Hash *)md5, hash, SHAMD5_ALGO_MD5, MD5_DIGEST_SIZE) ;
 174 }
 175
 176 WOLFSSL_API void wc_Md5RestorePos(Md5* m1, Md5* m2) {
 177         hashRestorePos((wolfssl_TI_Hash *)m1, (wolfssl_TI_Hash *)m2) ;
 178 }
 179
 180 WOLFSSL_API int wc_Md5Hash(const byte*data, word32 len, byte*hash)
 181 {
 182     return hashHash(data, len, hash, SHAMD5_ALGO_MD5, MD5_DIGEST_SIZE) ;
 183 }
 184
 185 #endif /* NO_MD5 */
 186
 187 #if !defined(NO_SHA)
 188 WOLFSSL_API int wc_InitSha(Sha* sha)
 189 {
 190     if (sha == NULL)
 191         return 1 ;
 192     if(!wolfSSL_TI_CCMInit())return 1 ;
 193     return hashInit((wolfssl_TI_Hash *)sha) ;
 194 }
 195
 196 WOLFSSL_API int wc_ShaUpdate(Sha* sha, const byte* data, word32 len)
 197 {
 198     return hashUpdate((wolfssl_TI_Hash *)sha, data, len) ;
 199 }
 200
 201 WOLFSSL_API int wc_ShaFinal(Sha* sha, byte* hash)
 202 {
 203     return hashFinal((wolfssl_TI_Hash *)sha, hash, SHAMD5_ALGO_SHA1, SHA_DIGEST_SIZE) ;
 204 }
 205
 206 WOLFSSL_API int wc_ShaGetHash(Sha* sha, byte* hash)
 207 {
 208     return hashGetHash(sha, hash, SHAMD5_ALGO_SHA1, SHA_DIGEST_SIZE) ;
 209 }
 210
 211 WOLFSSL_API void wc_ShaRestorePos(Sha* s1, Sha* s2) {
 212         hashRestorePos((wolfssl_TI_Hash *)s1, (wolfssl_TI_Hash *)s2) ;
 213 }
 214
 215 WOLFSSL_API int wc_ShaHash(const byte*data, word32 len, byte*hash)
 216 {
 217     return hashHash(data, len, hash, SHAMD5_ALGO_SHA1, SHA_DIGEST_SIZE) ;
 218 }
 219
 220 #endif /* NO_SHA */
 221
 222 #if defined(HAVE_SHA224)
 223 WOLFSSL_API int wc_InitSha224(Sha224* sha224)
 224 {
 225     if (sha224 == NULL)
 226         return 1 ;
 227     if(!wolfSSL_TI_CCMInit())return 1 ;
 228     return hashInit((wolfssl_TI_Hash *)sha224) ;
 229 }
 230
 231 WOLFSSL_API int wc_Sha224Update(Sha224* sha224, const byte* data, word32 len)
 232 {
 233     return hashUpdate((wolfssl_TI_Hash *)sha224, data, len) ;
 234 }
 235
 236 WOLFSSL_API int wc_Sha224Final(Sha224* sha224, byte* hash)
 237 {
 238     return hashFinal((wolfssl_TI_Hash *)sha224, hash, SHAMD5_ALGO_SHA224, SHA224_DIGEST_SIZE) ;
 239 }
 240
 241 WOLFSSL_API int wc_Sha224GetHash(Sha224* sha224, byte* hash)
 242 {
 243     return hashGetHash(sha224, hash, SHAMD5_ALGO_SHA224, SHA224_DIGEST_SIZE) ;
 244 }
 245
 246 WOLFSSL_API void wc_Sha224RestorePos(Sha224* s1, Sha224* s2) {
 247         hashRestorePos((wolfssl_TI_Hash *)s1, (wolfssl_TI_Hash *)s2) ;
 248 }
 249
 250 WOLFSSL_API int wc_Sha224Hash(const byte* data, word32 len, byte*hash)
 251 {
 252     return hashHash(data, len, hash, SHAMD5_ALGO_SHA224, SHA224_DIGEST_SIZE) ;
 253 }
 254
 255 #endif /* HAVE_SHA224 */
 256
 257 #if !defined(NO_SHA256)
 258 WOLFSSL_API int wc_InitSha256(Sha256* sha256)
 259 {
 260     if (sha256 == NULL)
 261         return 1 ;
 262     if(!wolfSSL_TI_CCMInit())return 1 ;
 263     return hashInit((wolfssl_TI_Hash *)sha256) ;
 264 }
 265
 266 WOLFSSL_API int wc_Sha256Update(Sha256* sha256, const byte* data, word32 len)
 267 {
 268     return hashUpdate((wolfssl_TI_Hash *)sha256, data, len) ;
 269 }
 270
 271 WOLFSSL_API int wc_Sha256Final(Sha256* sha256, byte* hash)
 272 {
 273     return hashFinal((wolfssl_TI_Hash *)sha256, hash, SHAMD5_ALGO_SHA256, SHA256_DIGEST_SIZE) ;
 274 }
 275
 276 WOLFSSL_API int wc_Sha256GetHash(Sha256* sha256, byte* hash)
 277 {
 278     return hashGetHash(sha256, hash, SHAMD5_ALGO_SHA256, SHA256_DIGEST_SIZE) ;
 279 }
 280
 281 WOLFSSL_API void wc_Sha256RestorePos(Sha256* s1, Sha256* s2) {
 282         hashRestorePos((wolfssl_TI_Hash *)s1, (wolfssl_TI_Hash *)s2) ;
 283 }
 284
 285 WOLFSSL_API int wc_Sha256Hash(const byte* data, word32 len, byte*hash)
 286 {
 287     return hashHash(data, len, hash, SHAMD5_ALGO_SHA256, SHA256_DIGEST_SIZE) ;
 288 }
 289 #endif
 290
 291 #endif