VBoot Reference: 18 Exabytes ought to be enough for everybody

src/platform/vboot_reference/crypto/rsa_utility.c

 /* Copyright (c) 2010 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.
  *
  * Utility functions for message digest functions.
  */
 
 #include "padding.h"
 #include "rsa_utility.h"
 #include "sha_utility.h"
@@ skipping 24 matching lines @@
   }
 }
 
 RSAPublicKey* RSAPublicKeyFromBuf(const uint8_t* buf, int len) {
   RSAPublicKey* key = RSAPublicKeyNew();
   MemcpyState st;
   int key_len;
 
   st.remaining_buf = (uint8_t*) buf;
   st.remaining_len = len;
+  st.overrun = 0;
+
   StatefulMemcpy(&st, &key->len, sizeof(key->len));
   key_len = key->len * sizeof(uint32_t);  /* key length in bytes. */
 
   /* Sanity Check the key length. */
   if (RSA1024NUMBYTES != key_len &&
       RSA2048NUMBYTES != key_len &&
       RSA4096NUMBYTES != key_len &&
       RSA8192NUMBYTES != key_len) {
     RSAPublicKeyFree(key);
     return NULL;
   }
 
   key->n = (uint32_t*) Malloc(key_len);
   key->rr = (uint32_t*) Malloc(key_len);
 
   StatefulMemcpy(&st, &key->n0inv, sizeof(key->n0inv));
   StatefulMemcpy(&st, key->n, key_len);
   StatefulMemcpy(&st, key->rr, key_len);
-  if (st.remaining_len != 0) {  /* Underrun or overrun. */
+  if (st.overrun || st.remaining_len != 0) {  /* Underrun or overrun. */
     RSAPublicKeyFree(key);
     return NULL;
   }
 
   return key;
 }
 
 int RSAVerifyBinary_f(const uint8_t* key_blob,
                       const RSAPublicKey* key,
                       const uint8_t* buf,
-                      int len,
+                      uint64_t len,
                       const uint8_t* sig,
                       int algorithm) {
   RSAPublicKey* verification_key = NULL;
   uint8_t* digest = NULL;
   int key_size;
   int sig_size;
   int success;
 
   if (algorithm >= kNumAlgorithms)
     return 0;  /* Invalid algorithm. */
@@ skipping 39 matching lines @@
     verification_key = (RSAPublicKey*) key;  /* Supress const warning. */
   else
     return 0; /* Both can't be NULL or non-NULL. */
 
   success = RSAVerify(verification_key, sig, sig_size, algorithm, digest);
 
   if (!key)
     RSAPublicKeyFree(verification_key);  /* Only free if we allocated it. */
   return success;
 }