Revert "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 314 matching lines @@
     ctx->h[0] += wv[0]; ctx->h[1] += wv[1];
     ctx->h[2] += wv[2]; ctx->h[3] += wv[3];
     ctx->h[4] += wv[4]; ctx->h[5] += wv[5];
     ctx->h[6] += wv[6]; ctx->h[7] += wv[7];
 #endif /* !UNROLL_LOOPS */
   }
 }
 
 
 
-void SHA256_update(SHA256_CTX* ctx, const uint8_t* data, uint32_t len) {
+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;
 
     tmp_len = SHA256_BLOCK_SIZE - ctx->len;
-    rem_len = len < tmp_len ? len : tmp_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 += len;
+        ctx->len += (uint32_t)len;
         return;
     }
 
-    new_len = len - rem_len;
+    new_len = (unsigned int)len - rem_len;
     block_nb = new_len / SHA256_BLOCK_SIZE;
 
     shifted_data = data + rem_len;
 
     SHA256_transform(ctx, ctx->block, 1);
     SHA256_transform(ctx, shifted_data, block_nb);
 
     rem_len = new_len % SHA256_BLOCK_SIZE;
 
     Memcpy(ctx->block, &shifted_data[block_nb << 6],
@@ skipping 56 matching lines @@
     ctx->h[4] = sha512_h0[4]; ctx->h[5] = sha512_h0[5];
     ctx->h[6] = sha512_h0[6]; ctx->h[7] = sha512_h0[7];
 #endif /* !UNROLL_LOOPS */
 
     ctx->len = 0;
     ctx->tot_len = 0;
 }
 
 
 static void SHA512_transform(SHA512_CTX* ctx, const uint8_t* message,
-                             unsigned int block_nb) {
+                   unsigned int block_nb)
+{
   uint64_t w[80];
   uint64_t wv[8];
   uint64_t t1, t2;
   const uint8_t *sub_block;
   int i, j;
 
   for (i = 0; i < (int) block_nb; i++) {
     sub_block = message + (i << 7);
 
 #ifndef UNROLL_LOOPS
@@ skipping 74 matching lines @@
     ctx->h[0] += wv[0]; ctx->h[1] += wv[1];
     ctx->h[2] += wv[2]; ctx->h[3] += wv[3];
     ctx->h[4] += wv[4]; ctx->h[5] += wv[5];
     ctx->h[6] += wv[6]; ctx->h[7] += wv[7];
 #endif /* !UNROLL_LOOPS */
   }
 }
 
 
 void SHA512_update(SHA512_CTX* ctx, const uint8_t* data,
-                   uint32_t len) {
+                   uint64_t len) {
     unsigned int block_nb;
     unsigned int new_len, rem_len, tmp_len;
     const uint8_t* shifted_data;
 
     tmp_len = SHA512_BLOCK_SIZE - ctx->len;
-    rem_len = len < tmp_len ? len : tmp_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 += len;
+        ctx->len += (uint32_t)len;
         return;
     }
 
-    new_len = len - rem_len;
+    new_len = (unsigned int)len - rem_len;
     block_nb = new_len / SHA512_BLOCK_SIZE;
 
     shifted_data = data + rem_len;
 
     SHA512_transform(ctx, ctx->block, 1);
     SHA512_transform(ctx, shifted_data, block_nb);
 
     rem_len = new_len % SHA512_BLOCK_SIZE;
 
     Memcpy(ctx->block, &shifted_data[block_nb << 7],
@@ skipping 37 matching lines @@
     UNPACK64(ctx->h[4], &ctx->buf[32]);
     UNPACK64(ctx->h[5], &ctx->buf[40]);
     UNPACK64(ctx->h[6], &ctx->buf[48]);
     UNPACK64(ctx->h[7], &ctx->buf[56]);
 #endif /* !UNROLL_LOOPS */
 
     return ctx->buf;
 }
 
 
+
+/* Convenient functions. */
 uint8_t* SHA256(const uint8_t* data, uint64_t len, uint8_t* digest) {
-  const uint8_t* input_ptr;
-  const uint8_t* result;
-  uint64_t remaining_len;
+  const uint8_t* p;
   int i;
   SHA256_CTX ctx;
-
   SHA256_init(&ctx);
-
-  input_ptr = data;
-  remaining_len = len;
-
-  /* Process data in at most UINT32_MAX byte chunks at a time. */
-  while (remaining_len) {
-    uint32_t block_size;
-    block_size = (uint32_t) ((remaining_len >= UINT32_MAX) ?
-                             UINT32_MAX : remaining_len);
-    SHA256_update(&ctx, input_ptr, block_size);
-    remaining_len -= block_size;
-    input_ptr += block_size;
-  }
-
-  result = SHA256_final(&ctx);
+  SHA256_update(&ctx, data, len);
+  p = SHA256_final(&ctx);
   for (i = 0; i < SHA256_DIGEST_SIZE; ++i) {
-    digest[i] = *result++;
+    digest[i] = *p++;
   }
   return digest;
 }
 
 
 uint8_t* SHA512(const uint8_t* data, uint64_t len, uint8_t* digest) {
-  const uint8_t* input_ptr;
-  const uint8_t* result;
-  uint64_t remaining_len;
+  const uint8_t* p;
   int i;
   SHA512_CTX ctx;
   SHA512_init(&ctx);
-
-  input_ptr = data;
-  remaining_len = len;
-
-  /* Process data in at most UINT32_MAX byte chunks at a time. */
-  while (remaining_len) {
-    uint32_t block_size;
-    block_size = (uint32_t) ((remaining_len >= UINT32_MAX) ?
-                             UINT32_MAX : remaining_len);
-       SHA512_update(&ctx, input_ptr, block_size);
-    remaining_len -= block_size;
-    input_ptr += block_size;
-  }
-
-  result = SHA512_final(&ctx);
+  SHA512_update(&ctx, data, len);
+  p = SHA512_final(&ctx);
   for (i = 0; i < SHA512_DIGEST_SIZE; ++i) {
-    digest[i] = *result++;
+    digest[i] = *p++;
   }
   return digest;
 }