Implemented pipelined hash calculation in LoadFirmware()

vboot_firmware/lib/vboot_firmware.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.
  *
  * High-level firmware API for loading and verifying rewritable firmware.
  * (Firmware portion)
  */
 
 #include "vboot_firmware.h"
 
 #include "load_firmware_fw.h"
 #include "rollback_index.h"
 #include "utility.h"
 #include "vboot_common.h"
 
+/* Static variables for UpdateFirmwareBodyHash().  It's less than
+ * optimal to have static variables in a library, but in UEFI the
+ * caller is deep inside a different firmware stack and doesn't have a
+ * good way to pass the params struct back to us. */
+static DigestContext ctx;
+static uint64_t body_size_accum = 0;
+static int inside_load_firmware = 0;
 
 void UpdateFirmwareBodyHash2(uint8_t* data, uint64_t size) {
-  /* TODO: actually update the hash. */
+
+  if (!inside_load_firmware) {
+    debug("UpdateFirmwareBodyHash() called outside LoadFirmware()\n");
+    return;
+  }
+
+  DigestUpdate(&ctx, data, size);
+  body_size_accum += size;
 }
 
 
 int LoadFirmware2(LoadFirmwareParams* params) {
 
   VbPublicKey* root_key = (VbPublicKey*)params->firmware_root_key_blob;
 
   uint16_t tpm_key_version = 0;
   uint16_t tpm_fw_version = 0;
   uint64_t lowest_key_version = 0xFFFF;
@@ skipping 20 matching lines @@
 
   /* Loop over indices */
   for (index = 0; index < 2; index++) {
     VbKeyBlockHeader* key_block;
     uint64_t vblock_size;
     VbFirmwarePreambleHeader* preamble;
     RSAPublicKey* data_key;
     uint64_t key_version;
     uint8_t* body_data;
     uint64_t body_size;
+    uint8_t* body_digest;
 
     /* Verify the key block */
     if (0 == index) {
       key_block = (VbKeyBlockHeader*)params->verification_block_0;
       vblock_size = params->verification_size_0;
     } else {
       key_block = (VbKeyBlockHeader*)params->verification_block_1;
       vblock_size = params->verification_size_1;
     }
     if ((0 != KeyBlockVerify(key_block, vblock_size, root_key)))
@@ skipping 36 matching lines @@
       lowest_fw_version = preamble->firmware_version;
     }
 
     /* If we already have good firmware, no need to read another one;
      * we only needed to look at the versions to check for
      * rollback. */
     if (-1 != good_index)
       continue;
 
     /* Read the firmware data */
-    /* TODO: should set up hash for UpdateFirmwareBodyHash(). */
+    DigestInit(&ctx, data_key->algorithm);
+    body_size_accum = 0;
+    inside_load_firmware = 1;
     body_data = GetFirmwareBody(index, &body_size);
-    if (!body_data || (body_size != preamble->body_signature.data_size)) {
+    inside_load_firmware = 0;
+    body_digest = DigestFinal(&ctx);
+    if (!body_data || (body_size != preamble->body_signature.data_size) ||
+        (body_size_accum != body_size)) {
       RSAPublicKeyFree(data_key);
+      Free(body_digest);
       continue;
     }
 
     /* Verify firmware data */
-    /* TODO: should use hash from UpdateFirmwareBodyHash() rather than
-     * recalculating it in VerifyData().  */
-    if (0 != VerifyData(body_data, &preamble->body_signature, data_key)) {
+    if (0 != VerifyDigest(body_digest, &preamble->body_signature, data_key)) {
       RSAPublicKeyFree(data_key);
+      Free(body_digest);
       continue;
     }
 
-    /* Done with the data key, so can free it now */
+    /* Done with the digest and data key, so can free them now */
     RSAPublicKeyFree(data_key);
+    Free(body_digest);
 
     /* If we're still here, the firmware is valid. */
     /* Save the first good firmware we find; that's the one we'll boot */
     if (-1 == good_index) {
       good_index = index;
       params->firmware_index = index;
       params->kernel_sign_key_blob = &preamble->kernel_subkey;
       params->kernel_sign_key_size = (preamble->kernel_subkey.key_offset +
                                       preamble->kernel_subkey.key_size);
 
@@ skipping 23 matching lines @@
     /* Lock Firmware TPM rollback indices from further writes.  In
      * this design, this is done by setting the globalLock bit, which
      * is cleared only by TPM_Init at reboot.  */
     if (0 != LockFirmwareVersions())
       return LOAD_FIRMWARE_RECOVERY;
   }
 
   /* If we're still here, no good firmware, so go to recovery mode. */
   return LOAD_FIRMWARE_RECOVERY;
 }