Change VerifyFirmware() to take separate pointers to firmware verification header and firmware data.

src/platform/vboot_reference/vfirmware/firmware_image_fw.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.
  *
  * Functions for verifying a verified boot firmware image.
  * (Firmware Portion)
  */
 
 #include "firmware_image_fw.h"
 
@@ skipping 97 matching lines @@
     return VERIFY_FIRMWARE_PREAMBLE_SIGNATURE_FAILED;
 
   Memcpy(&len, preamble_blob + FIELD_LEN(firmware_version),
          sizeof(len));
   *firmware_len = len;
   return 0;
 }
 
 int VerifyFirmwareData(RSAPublicKey* firmware_sign_key,
                        const uint8_t* preamble_start,
-                       const uint8_t* firmware_data_start,
+                       const uint8_t* firmware_data,
                        uint64_t firmware_len,
                        int algorithm) {
   int signature_len = siglen_map[algorithm];
-  uint8_t* digest;
+  int preamble_len = (FIELD_LEN(firmware_version) +
+                      FIELD_LEN(firmware_len) +
+                      FIELD_LEN(preamble));;
+  uint8_t* digest = NULL;
+  const uint8_t* firmware_signature = NULL;
   DigestContext ctx;
 
   /* Since the firmware signature is over the preamble and the firmware data,
    * which does not form a contiguous region of memory, we calculate the
    * message digest ourselves. */
   DigestInit(&ctx, algorithm);
-  DigestUpdate(&ctx, preamble_start,
-               (FIELD_LEN(firmware_version) +
-                FIELD_LEN(firmware_len) +
-                FIELD_LEN(preamble)));
-  DigestUpdate(&ctx, firmware_data_start + signature_len, firmware_len);
+  DigestUpdate(&ctx, preamble_start, preamble_len);
+  DigestUpdate(&ctx, firmware_data, firmware_len);
   digest = DigestFinal(&ctx);
+  /* Firmware signature is at the end of preamble and preamble signature. */
+  firmware_signature = preamble_start + preamble_len + signature_len;
   if (!RSAVerifyBinaryWithDigest_f(
           NULL, firmware_sign_key,  /* Key to use. */
           digest,  /* Digest of the data to verify. */
-          firmware_data_start,  /* Expected Signature */
+          firmware_signature,  /* Expected Signature */
           algorithm)) {
     Free(digest);
     return VERIFY_FIRMWARE_SIGNATURE_FAILED;
   }
   Free(digest);
   return 0;
 }
 
 int VerifyFirmware(const uint8_t* root_key_blob,
+                   const uint8_t* verification_header_blob,
                    const uint8_t* firmware_blob) {
   int error_code = 0;
   int algorithm;  /* Signing key algorithm. */
   RSAPublicKey* firmware_sign_key = NULL;
   int firmware_sign_key_len, signature_len, header_len;
   uint64_t firmware_len;
   const uint8_t* header_ptr = NULL;  /* Pointer to header. */
   const uint8_t* firmware_sign_key_ptr = NULL;  /* Pointer to signing key. */
   const uint8_t* preamble_ptr = NULL;  /* Pointer to preamble block. */
-  const uint8_t* firmware_ptr = NULL;  /* Pointer to firmware signature/data. */
 
   /* Note: All the offset calculations are based on struct FirmwareImage which
-   * is defined in include/firmware_image.h. */
+   * is defined in include/firmware_image_fw.h. */
 
   /* Compare magic bytes. */
-  if (SafeMemcmp(firmware_blob, FIRMWARE_MAGIC, FIRMWARE_MAGIC_SIZE))
+  if (SafeMemcmp(verification_header_blob, FIRMWARE_MAGIC,
+                 FIRMWARE_MAGIC_SIZE)) {
+    debug("Wrong Firmware Magic.\n");
     return VERIFY_FIRMWARE_WRONG_MAGIC;
-  header_ptr = firmware_blob + FIRMWARE_MAGIC_SIZE;
+  }
+  header_ptr = verification_header_blob + FIRMWARE_MAGIC_SIZE;
 
   /* Only continue if header verification succeeds. */
   if ((error_code = VerifyFirmwareHeader(root_key_blob, header_ptr,
-                                         &algorithm, &header_len)))
+                                         &algorithm, &header_len))) {
+    debug("Couldn't verify Firmware header.\n");
     return error_code;  /* AKA jump to revovery. */
-
+  }
   /* Parse signing key into RSAPublicKey structure since it is required multiple
    * times. */
   firmware_sign_key_len = RSAProcessedKeySize(algorithm);
   firmware_sign_key_ptr = header_ptr + (FIELD_LEN(header_len) +
                                         FIELD_LEN(firmware_sign_algorithm) +
                                         FIELD_LEN(firmware_key_version));
   firmware_sign_key = RSAPublicKeyFromBuf(firmware_sign_key_ptr,
                                           firmware_sign_key_len);
   signature_len = siglen_map[algorithm];
 
   /* Only continue if preamble verification succeeds. */
   preamble_ptr = (header_ptr + header_len +
                   FIELD_LEN(firmware_key_signature));
   if ((error_code = VerifyFirmwarePreamble(firmware_sign_key, preamble_ptr,
                                            algorithm,
                                            &firmware_len))) {
     RSAPublicKeyFree(firmware_sign_key);
     debug("Couldn't verify Firmware preamble.\n");
     return error_code;  /* AKA jump to recovery. */
   }
-  /* Only continue if firmware data verification succeeds. */
-  firmware_ptr = (preamble_ptr +
-                  (FIELD_LEN(firmware_version) +  /* Skip the preamble. */
-                   FIELD_LEN(firmware_len) +
-                   FIELD_LEN(preamble)) +
-                  signature_len);
 
   if ((error_code = VerifyFirmwareData(firmware_sign_key, preamble_ptr,
-                                       firmware_ptr,
+                                       firmware_blob,
                                        firmware_len,
                                        algorithm))) {
     RSAPublicKeyFree(firmware_sign_key);
     debug("Couldn't verify Firmware data.\n");
     return error_code;  /* AKA jump to recovery. */
   }
 
   RSAPublicKeyFree(firmware_sign_key);
-  return 0;  /* Success! */
+  return VERIFY_FIRMWARE_SUCCESS;  /* Success! */
 }
 
-uint32_t GetLogicalFirmwareVersion(uint8_t* firmware_blob) {
+uint32_t GetLogicalFirmwareVersion(uint8_t* verification_header_blob) {
   uint16_t firmware_key_version;
   uint16_t firmware_version;
   uint16_t firmware_sign_algorithm;
   int firmware_sign_key_len;
   Memcpy(&firmware_sign_algorithm,
-         firmware_blob + (FIELD_LEN(magic) +  /* Offset to field. */
-                          FIELD_LEN(header_len)),
+         verification_header_blob + (FIELD_LEN(magic) +  /* Offset to field. */
+                                      FIELD_LEN(header_len)),
          sizeof(firmware_sign_algorithm));
   Memcpy(&firmware_key_version,
-         firmware_blob + (FIELD_LEN(magic) +  /* Offset to field. */
-                          FIELD_LEN(header_len) +
-                          FIELD_LEN(firmware_sign_algorithm)),
+         verification_header_blob + (FIELD_LEN(magic) +  /* Offset to field. */
+                                     FIELD_LEN(header_len) +
+                                     FIELD_LEN(firmware_sign_algorithm)),
          sizeof(firmware_key_version));
   if (firmware_sign_algorithm >= kNumAlgorithms)
     return 0;
   firmware_sign_key_len = RSAProcessedKeySize(firmware_sign_algorithm);
   Memcpy(&firmware_version,
-         firmware_blob +  (FIELD_LEN(magic) +  /* Offset to field. */
-                           FIELD_LEN(header_len) +
-                           FIELD_LEN(firmware_key_version) +
-                           firmware_sign_key_len +
-                           FIELD_LEN(header_checksum) +
-                           FIELD_LEN(firmware_key_signature)),
+         verification_header_blob +  (FIELD_LEN(magic) +  /* Offset to field. */
+                                      FIELD_LEN(header_len) +
+                                      FIELD_LEN(firmware_key_version) +
+                                      firmware_sign_key_len +
+                                      FIELD_LEN(header_checksum) +
+                                      FIELD_LEN(firmware_key_signature)),
          sizeof(firmware_version));
   return CombineUint16Pair(firmware_key_version, firmware_version);
 }
 
 int VerifyFirmwareDriver_f(uint8_t* root_key_blob,
+                           uint8_t* verification_headerA,
                            uint8_t* firmwareA,
+                           uint8_t* verification_headerB,
                            uint8_t* firmwareB) {
   /* Contains the logical firmware version (32-bit) which is calculated as
    * (firmware_key_version << 16 | firmware_version) where
    * [firmware_key_version] [firmware_version] are both 16-bit.
    */
   uint32_t firmwareA_lversion, firmwareB_lversion;
   uint8_t firmwareA_is_verified = 0;  /* Whether firmwareA verify succeeded. */
   uint32_t min_lversion;  /* Minimum of firmware A and firmware lversion. */
   uint32_t stored_lversion;  /* Stored logical version in the TPM. */
 
   /* Initialize the TPM since we'll be reading the rollback indices. */
   SetupTPM();
 
   /* We get the key versions by reading directly from the image blobs without
    * any additional (expensive) sanity checking on the blob since it's faster to
    * outright reject a firmware with an older firmware key version. A malformed
    * or corrupted firmware blob will still fail when VerifyFirmware() is called
    * on it.
    */
-  firmwareA_lversion = GetLogicalFirmwareVersion(firmwareA);
-  firmwareB_lversion = GetLogicalFirmwareVersion(firmwareB);
+  firmwareA_lversion = GetLogicalFirmwareVersion(verification_headerA);
+  firmwareB_lversion = GetLogicalFirmwareVersion(verification_headerB);
   min_lversion  = Min(firmwareA_lversion, firmwareB_lversion);
   stored_lversion = CombineUint16Pair(GetStoredVersion(FIRMWARE_KEY_VERSION),
                                       GetStoredVersion(FIRMWARE_VERSION));
   /* Always try FirmwareA first. */
-  if (VERIFY_FIRMWARE_SUCCESS == VerifyFirmware(root_key_blob, firmwareA))
+  if (VERIFY_FIRMWARE_SUCCESS == VerifyFirmware(root_key_blob,
+                                                verification_headerA,
+                                                firmwareA))
     firmwareA_is_verified = 1;
   if (firmwareA_is_verified && (stored_lversion < firmwareA_lversion)) {
     /* Stored version may need to be updated but only if FirmwareB
      * is successfully verified and has a logical version greater than
      * the stored logical version. */
     if (stored_lversion < firmwareB_lversion) {
-      if (VERIFY_FIRMWARE_SUCCESS == VerifyFirmware(root_key_blob, firmwareB)) {
+      if (VERIFY_FIRMWARE_SUCCESS == VerifyFirmware(root_key_blob,
+                                                    verification_headerB,
+                                                    firmwareB)) {
         WriteStoredVersion(FIRMWARE_KEY_VERSION,
                            (uint16_t) (min_lversion >> 16));
         WriteStoredVersion(FIRMWARE_VERSION,
                            (uint16_t) (min_lversion & 0x00FFFF));
         stored_lversion = min_lversion;  /* Update stored version as it's used
                                           * later. */
       }
     }
   }
   /* Lock Firmware TPM rollback indices from further writes. */
@@ skipping 21 matching lines @@
   if (firmwareA_is_verified) {
     if (stored_lversion <= firmwareA_lversion)
       return BOOT_FIRMWARE_A_CONTINUE;
   } else {
     /* If FirmwareA was not valid, then we skipped over the
      * check to update the rollback indices and a Verify of FirmwareB wasn't
      * attempted.
      * If FirmwareB is not a rollback, then we attempt to do the verification.
      */
     if (stored_lversion <= firmwareB_lversion &&
-        (VERIFY_FIRMWARE_SUCCESS == VerifyFirmware(root_key_blob, firmwareB)))
+        (VERIFY_FIRMWARE_SUCCESS == VerifyFirmware(root_key_blob,
+                                                   verification_headerB,
+                                                   firmwareB)))
         return BOOT_FIRMWARE_B_CONTINUE;
   }
   /* D'oh: No bootable firmware. */
   return BOOT_FIRMWARE_RECOVERY_CONTINUE;
 }