Make SHA256_update and SHA512_update if the passed in length is greater than UINT32_MAX

firmware/lib/cryptolib/sha2.c

 /* SHA-256 and SHA-512 implementation based on code by Oliver Gay
  * <olivier.gay@a3.epfl.ch> under a BSD-style license. See below.
  */
 
 /*
  * FIPS 180-2 SHA-224/256/384/512 implementation
  * Last update: 02/02/2007
  * Issue date:  04/30/2005
  *
  * Copyright (C) 2005, 2007 Olivier Gay <olivier.gay@a3.epfl.ch>
@@ skipping 319 matching lines @@
   }
 }
 
 
 
 void SHA256_update(SHA256_CTX* ctx, const uint8_t* data, uint64_t len) {
     unsigned int block_nb;
     unsigned int new_len, rem_len, tmp_len;
     const uint8_t *shifted_data;
 
+    if (len > UINT32_MAX)
+      return;
+
     tmp_len = SHA256_BLOCK_SIZE - ctx->len;
     rem_len = len < tmp_len ? (unsigned int)len : tmp_len;
 
     Memcpy(&ctx->block[ctx->len], data, rem_len);
 
     if (ctx->len + len < SHA256_BLOCK_SIZE) {
         ctx->len += (uint32_t)len;
         return;
     }
 
@@ skipping 168 matching lines @@
   }
 }
 
 
 void SHA512_update(SHA512_CTX* ctx, const uint8_t* data,
                    uint64_t len) {
     unsigned int block_nb;
     unsigned int new_len, rem_len, tmp_len;
     const uint8_t* shifted_data;
 
+    if (len > UINT32_MAX)
+      return;
+
     tmp_len = SHA512_BLOCK_SIZE - ctx->len;
     rem_len = len < tmp_len ? (unsigned int)len : tmp_len;
 
     Memcpy(&ctx->block[ctx->len], data, rem_len);
 
     if (ctx->len + len < SHA512_BLOCK_SIZE) {
         ctx->len += (uint32_t)len;
         return;
     }
 
@@ skipping 55 matching lines @@
 }
 
 
 
 /* Convenient functions. */
 uint8_t* SHA256(const uint8_t* data, uint64_t len, uint8_t* digest) {
   const uint8_t* p;
   int i;
   SHA256_CTX ctx;
   SHA256_init(&ctx);
   SHA256_update(&ctx, data, len);

[Randall Spangler, 2011/03/26 02:02:46]

Is SHA256_update() used anywhere else?  If not, we could change its input arg to
uint32_t, and then have a while() loop here that passes in UINT32_MAX bytes at a
time.  

Otherwise, it seems like the early return in SHA256_update() will cause SHA256()
to return the same digest for all len > UINT32_MAX, regardless of data.

Alternately, SHA256() could return an error if len > UINT32_MAX.

(same comment for SHA512)

[gauravsh, 2011/03/26 23:21:41]

Well, I figured that we will pretty much never try to hash more than UINT32_MAX
bytes of data, so it doesn't matter how it fails.

In any case, I think hashing 32-byte chunks is reasonable. So I have done it
that way.

   p = SHA256_final(&ctx);
   for (i = 0; i < SHA256_DIGEST_SIZE; ++i) {
     digest[i] = *p++;
   }
   return digest;
 }
 
 
 uint8_t* SHA512(const uint8_t* data, uint64_t len, uint8_t* digest) {
   const uint8_t* p;
   int i;
   SHA512_CTX ctx;
   SHA512_init(&ctx);
   SHA512_update(&ctx, data, len);
   p = SHA512_final(&ctx);
   for (i = 0; i < SHA512_DIGEST_SIZE; ++i) {
     digest[i] = *p++;
   }
   return digest;
 }