Added size param to VerifyData()

firmware/lib/vboot_common.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.
  *
  * Common functions between firmware and kernel verified boot.
  * (Firmware portion)
  */
 
 
 #include "vboot_common.h"
@@ skipping 108 matching lines @@
 
   rsa = RSAPublicKeyFromBuf(GetPublicKeyDataC(key), (int)key->key_size);
   if (!rsa)
     return NULL;
 
   rsa->algorithm = (int)key->algorithm;
   return rsa;
 }
 
 
-int VerifyData(const uint8_t* data, const VbSignature *sig,
+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;
   }
+  if (sig->data_size > size) {
+    VBDEBUG(("Data buffer smaller than length of signed data.\n"));
+    return 1;
+  }
 
   if (!RSAVerifyBinary_f(NULL, key, data, sig->data_size,
                          GetSignatureDataC(sig), key->algorithm))
     return 1;
 
   return 0;
 }
 
 
 int VerifyDigest(const uint8_t* digest, const VbSignature *sig,
@@ skipping 48 matching lines @@
     if (!rsa) {
       VBDEBUG(("Invalid public key\n"));
       return VBOOT_PUBLIC_KEY_INVALID;
     }
 
     /* Make sure advertised signature data sizes are sane. */
     if (block->key_block_size < sig->data_size) {
       VBDEBUG(("Signature calculated past end of the block\n"));
       return VBOOT_KEY_BLOCK_INVALID;
     }
-    rv = VerifyData((const uint8_t*)block, sig, rsa);
+    rv = VerifyData((const uint8_t*)block, size, sig, rsa);
     RSAPublicKeyFree(rsa);
     if (rv)
       return VBOOT_KEY_BLOCK_SIGNATURE;
   } else {
     /* Check hash */
     uint8_t* header_checksum = NULL;
     int rv;
 
     sig = &block->key_block_checksum;
 
@@ skipping 31 matching lines @@
   if (VerifyPublicKeyInside(block, sig->data_size, &block->data_key)) {
     VBDEBUG(("Data key off end of signed data\n"));
     return VBOOT_KEY_BLOCK_INVALID;
   }
 
   /* Success */
   return VBOOT_SUCCESS;
 }
 
 
-int VerifyFirmwarePreamble2(const VbFirmwarePreambleHeader* preamble,
+int VerifyFirmwarePreamble(const VbFirmwarePreambleHeader* preamble,
                            uint64_t size, const RSAPublicKey* key) {
 
   const VbSignature* sig = &preamble->preamble_signature;
 
   /* Sanity checks before attempting signature of data */
   if (preamble->header_version_major !=
       FIRMWARE_PREAMBLE_HEADER_VERSION_MAJOR) {
     VBDEBUG(("Incompatible firmware preamble header version.\n"));
     return VBOOT_PREAMBLE_INVALID;
   }
   if (size < preamble->preamble_size) {
     VBDEBUG(("Not enough data for preamble.\n"));
     return VBOOT_PREAMBLE_INVALID;
   }
 
   /* Check signature */
   if (VerifySignatureInside(preamble, preamble->preamble_size, sig)) {
     VBDEBUG(("Preamble signature off end of preamble\n"));
     return VBOOT_PREAMBLE_INVALID;
   }
 
   /* Make sure advertised signature data sizes are sane. */
   if (preamble->preamble_size < sig->data_size) {
     VBDEBUG(("Signature calculated past end of the block\n"));
     return VBOOT_PREAMBLE_INVALID;
   }
 
-  if (VerifyData((const uint8_t*)preamble, sig, key)) {
+  if (VerifyData((const uint8_t*)preamble, size, sig, key)) {
     VBDEBUG(("Preamble signature validation failed\n"));
     return VBOOT_PREAMBLE_SIGNATURE;
   }
 
   /* Verify we signed enough data */
   if (sig->data_size < sizeof(VbFirmwarePreambleHeader)) {
     VBDEBUG(("Didn't sign enough data\n"));
     return VBOOT_PREAMBLE_INVALID;
   }
 
   /* Verify body signature is inside the block */
   if (VerifySignatureInside(preamble, preamble->preamble_size,
                             &preamble->body_signature)) {
     VBDEBUG(("Firmware body signature off end of preamble\n"));
     return VBOOT_PREAMBLE_INVALID;
   }
 
   /* Verify kernel subkey is inside the block */
   if (VerifyPublicKeyInside(preamble, preamble->preamble_size,
                             &preamble->kernel_subkey)) {
     VBDEBUG(("Kernel subkey off end of preamble\n"));
     return VBOOT_PREAMBLE_INVALID;
   }
 
   /* Success */
   return VBOOT_SUCCESS;
 }
 
 
-int VerifyKernelPreamble2(const VbKernelPreambleHeader* preamble,
+int VerifyKernelPreamble(const VbKernelPreambleHeader* preamble,
                          uint64_t size, const RSAPublicKey* key) {
 
   const VbSignature* sig = &preamble->preamble_signature;
 
   /* Sanity checks before attempting signature of data */
   if (preamble->header_version_major != KERNEL_PREAMBLE_HEADER_VERSION_MAJOR) {
     VBDEBUG(("Incompatible kernel preamble header version.\n"));
     return VBOOT_PREAMBLE_INVALID;
   }
   if (size < preamble->preamble_size) {
     VBDEBUG(("Not enough data for preamble.\n"));
     return VBOOT_PREAMBLE_INVALID;
   }
 
   /* Check signature */
   if (VerifySignatureInside(preamble, preamble->preamble_size, sig)) {
     VBDEBUG(("Preamble signature off end of preamble\n"));
     return VBOOT_PREAMBLE_INVALID;
   }
-  if (VerifyData((const uint8_t*)preamble, sig, key)) {
+  if (VerifyData((const uint8_t*)preamble, size, sig, key)) {
     VBDEBUG(("Preamble signature validation failed\n"));
     return VBOOT_PREAMBLE_SIGNATURE;
   }
 
   /* Verify we signed enough data */
   if (sig->data_size < sizeof(VbKernelPreambleHeader)) {
     VBDEBUG(("Didn't sign enough data\n"));
     return VBOOT_PREAMBLE_INVALID;
   }
 
   /* Verify body signature is inside the block */
   if (VerifySignatureInside(preamble, preamble->preamble_size,
                             &preamble->body_signature)) {
     VBDEBUG(("Kernel body signature off end of preamble\n"));
     return VBOOT_PREAMBLE_INVALID;
   }
 
   /* Success */
   return VBOOT_SUCCESS;
 }