Use uint64_t and avoid down casting as much as possible.

firmware/lib/vboot_common.c

 /* Copyright (c) 2011 The Chromium OS Authors. All rights reserved.
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  *
  * Common functions between firmware and kernel verified boot.
  * (Firmware portion)
  */
 
 
 #include "vboot_common.h"
@@ skipping 97 matching lines @@
   dest->key_size = src->key_size;
   dest->algorithm = src->algorithm;
   dest->key_version = src->key_version;
   Memcpy(GetPublicKeyData(dest), GetPublicKeyDataC(src), src->key_size);
   return 0;
 }
 
 
 RSAPublicKey* PublicKeyToRSA(const VbPublicKey* key) {
   RSAPublicKey *rsa;
-  int key_size;
+  uint64_t key_size;
 
   if (kNumAlgorithms <= key->algorithm) {
     VBDEBUG(("Invalid algorithm.\n"));
     return NULL;
   }
-  if (!RSAProcessedKeySize((int)key->algorithm, &key_size) ||
-      key_size != (int)key->key_size) {
+  if (!RSAProcessedKeySize(key->algorithm, &key_size) ||
+      key_size != key->key_size) {
     VBDEBUG(("Wrong key size for algorithm\n"));
     return NULL;
   }
 
-  rsa = RSAPublicKeyFromBuf(GetPublicKeyDataC(key), (int)key->key_size);
+  rsa = RSAPublicKeyFromBuf(GetPublicKeyDataC(key), key->key_size);
   if (!rsa)
     return NULL;
 
-  rsa->algorithm = (int)key->algorithm;
+  rsa->algorithm = (unsigned int)key->algorithm;
   return rsa;
 }
 
 
 int VerifyData(const uint8_t* data, uint64_t size, const VbSignature *sig,
                const RSAPublicKey* key) {
 
   if (sig->sig_size != siglen_map[key->algorithm]) {
     VBDEBUG(("Wrong signature size for algorithm.\n"));
     return 1;
@@ skipping 298 matching lines @@
       return VBOOT_SHARED_DATA_INVALID;
     header->kernel_subkey_data_size = src->key_size;
   }
 
   /* Copy the kernel sign key blob into the destination buffer */
   PublicKeyInit(kdest, (uint8_t*)header + header->kernel_subkey_data_offset,
                 header->kernel_subkey_data_size);
 
   return PublicKeyCopy(kdest, src);
 }