Fixes to compiler warnings in MSVC

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 54 matching lines @@
 #define PACK32(str, x)                          \
   {                                             \
     *(x) =   ((uint32_t) *((str) + 3)      )    \
         | ((uint32_t) *((str) + 2) <<  8)       \
         | ((uint32_t) *((str) + 1) << 16)       \
         | ((uint32_t) *((str) + 0) << 24);      \
   }
 
 #define UNPACK64(x, str)                        \
   {                                             \
-    *((str) + 7) = (uint8_t) ((x)      );       \
-    *((str) + 6) = (uint8_t) ((x) >>  8);       \
-    *((str) + 5) = (uint8_t) ((x) >> 16);       \
-    *((str) + 4) = (uint8_t) ((x) >> 24);       \
-    *((str) + 3) = (uint8_t) ((x) >> 32);       \
-    *((str) + 2) = (uint8_t) ((x) >> 40);       \
-    *((str) + 1) = (uint8_t) ((x) >> 48);       \
-    *((str) + 0) = (uint8_t) ((x) >> 56);       \
+    *((str) + 7) = (uint8_t) x;                 \
+    *((str) + 6) = (uint8_t) UINT64_RSHIFT(x,  8); \
+    *((str) + 5) = (uint8_t) UINT64_RSHIFT(x, 16); \
+    *((str) + 4) = (uint8_t) UINT64_RSHIFT(x, 24); \
+    *((str) + 3) = (uint8_t) UINT64_RSHIFT(x, 32); \
+    *((str) + 2) = (uint8_t) UINT64_RSHIFT(x, 40); \
+    *((str) + 1) = (uint8_t) UINT64_RSHIFT(x, 48); \
+    *((str) + 0) = (uint8_t) UINT64_RSHIFT(x, 56); \
   }
 
 #define PACK64(str, x)                          \
   {                                             \
     *(x) =   ((uint64_t) *((str) + 7)      )    \
         | ((uint64_t) *((str) + 6) <<  8)       \
         | ((uint64_t) *((str) + 5) << 16)       \
         | ((uint64_t) *((str) + 4) << 24)       \
         | ((uint64_t) *((str) + 3) << 32)       \
         | ((uint64_t) *((str) + 2) << 40)       \
@@ skipping 238 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;
 
     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 158 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;
 
     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 65 matching lines @@
   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;
 }