Move test utility functions to a common place.

src/platform/vboot_reference/utils/firmware_image.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 generating and manipulating a verified boot firmware image.
  */
 
 #include "firmware_image.h"
 
 #include <fcntl.h>
@@ skipping 304 matching lines @@
   "Preamble Signature Failed.",
   "Firmware Signature Failed.",
   "Wrong Firmware Magic.",
   "Invalid Firmware Header Checksum.",
   "Firmware Signing Key Rollback.",
   "Firmware Version Rollback."
 };
 
 int VerifyFirmwareHeader(const uint8_t* root_key_blob,
                          const uint8_t* header_blob,
-                         const int dev_mode,
                          int* algorithm,
                          int* header_len) {
   int firmware_sign_key_len;
   int root_key_len;
   uint16_t hlen, algo;
   uint8_t* header_checksum = NULL;
 
   /* Base Offset for the header_checksum field. Actual offset is
    * this + firmware_sign_key_len. */
   int base_header_checksum_offset = (FIELD_LEN(header_len) +
@@ skipping 78 matching lines @@
                          firmware_data_start + signature_len,  /* Data to
                                                                 * verify */
                          firmware_len,  /* Length of data. */
                          firmware_data_start,  /* Expected Signature */
                          algorithm))
     return VERIFY_FIRMWARE_SIGNATURE_FAILED;
   return 0;
 }
 
 int VerifyFirmware(const uint8_t* root_key_blob,
-                   const uint8_t* firmware_blob,
-                   const int dev_mode) {
+                   const uint8_t* firmware_blob) {
   int error_code;
   int algorithm;  /* Signing key algorithm. */
   RSAPublicKey* firmware_sign_key = NULL;
   int firmware_sign_key_len, signature_len, header_len, 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. */
 
   /* Compare magic bytes. */
   if (SafeMemcmp(firmware_blob, FIRMWARE_MAGIC, FIRMWARE_MAGIC_SIZE))
     return VERIFY_FIRMWARE_WRONG_MAGIC;
   header_ptr = firmware_blob + FIRMWARE_MAGIC_SIZE;
 
   /* Only continue if header verification succeeds. */
-  if ((error_code = VerifyFirmwareHeader(root_key_blob, header_ptr, dev_mode,
+  if ((error_code = VerifyFirmwareHeader(root_key_blob, header_ptr,
                                          &algorithm, &header_len)))
     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,
@@ skipping 19 matching lines @@
                                        algorithm))) {
     RSAPublicKeyFree(firmware_sign_key);
     return error_code;  /* AKA jump to recovery. */
   }
 
   RSAPublicKeyFree(firmware_sign_key);
   return 0;  /* Success! */
 }
 
 int VerifyFirmwareImage(const RSAPublicKey* root_key,
-                        const FirmwareImage* image,
-                        const int dev_mode) {
+                        const FirmwareImage* image) {
   RSAPublicKey* firmware_sign_key = NULL;
   uint8_t* header_digest = NULL;
   uint8_t* preamble_digest = NULL;
   uint8_t* firmware_digest = NULL;
   int firmware_sign_key_size;
   int signature_size;
   int error_code = 0;
   DigestContext ctx;
 
   if (!image)
     return VERIFY_FIRMWARE_INVALID_IMAGE;
 
   /* Verify root key signature on the sign key header if we
    * are not in dev mode.
    *
    * TODO(gauravsh): Add additional sanity checks here for:
    *  1) verifying the header length is correct.
    *  2) header_checksum is correct.
    */
-  /* TODO(gauravsh): The [dev_mode] switch is actually irrelevant
-   * for the firmware verification.
-   * Change this to always verify the root key signature and change
-   * test expectations appropriately.
-   */
-  if (!dev_mode) {
-    DigestInit(&ctx, ROOT_SIGNATURE_ALGORITHM);
-    DigestUpdate(&ctx, (uint8_t*) &image->header_len,
-                 FIELD_LEN(header_len));
-    DigestUpdate(&ctx, (uint8_t*) &image->firmware_sign_algorithm,
-                 FIELD_LEN(firmware_sign_algorithm));
-    DigestUpdate(&ctx, (uint8_t*) &image->firmware_key_version,
-                 FIELD_LEN(firmware_key_version));
-    DigestUpdate(&ctx, image->firmware_sign_key,
-                 RSAProcessedKeySize(image->firmware_sign_algorithm));
-    DigestUpdate(&ctx, image->header_checksum,
-                 FIELD_LEN(header_checksum));
-    header_digest = DigestFinal(&ctx);
-    if (!RSAVerify(root_key, image->firmware_key_signature,
-                    FIELD_LEN(firmware_key_signature),
-                    ROOT_SIGNATURE_ALGORITHM,
-                    header_digest)) {
-      error_code =  VERIFY_FIRMWARE_ROOT_SIGNATURE_FAILED;
-      goto verify_failure;
-    }
+
+  /* Check key signature. */
+  DigestInit(&ctx, ROOT_SIGNATURE_ALGORITHM);
+  DigestUpdate(&ctx, (uint8_t*) &image->header_len,
+               FIELD_LEN(header_len));
+  DigestUpdate(&ctx, (uint8_t*) &image->firmware_sign_algorithm,
+               FIELD_LEN(firmware_sign_algorithm));
+  DigestUpdate(&ctx, (uint8_t*) &image->firmware_key_version,
+               FIELD_LEN(firmware_key_version));
+  DigestUpdate(&ctx, image->firmware_sign_key,
+               RSAProcessedKeySize(image->firmware_sign_algorithm));
+  DigestUpdate(&ctx, image->header_checksum,
+               FIELD_LEN(header_checksum));
+  header_digest = DigestFinal(&ctx);
+  if (!RSAVerify(root_key, image->firmware_key_signature,
+                 FIELD_LEN(firmware_key_signature),
+                 ROOT_SIGNATURE_ALGORITHM,
+                 header_digest)) {
+    error_code =  VERIFY_FIRMWARE_ROOT_SIGNATURE_FAILED;
+    goto verify_failure;
   }
 
   /* Get sign key to verify the rest of the firmware. */
   firmware_sign_key_size = RSAProcessedKeySize(image->firmware_sign_algorithm);
   firmware_sign_key = RSAPublicKeyFromBuf(image->firmware_sign_key,
                                  firmware_sign_key_size);
   signature_size = siglen_map[image->firmware_sign_algorithm];
 
   if (image->firmware_sign_algorithm >= kNumAlgorithms)
     return VERIFY_FIRMWARE_INVALID_ALGORITHM;
@@ skipping 135 matching lines @@
    * 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);
   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,
-                                                0))
+  if (VERIFY_FIRMWARE_SUCCESS == VerifyFirmware(root_key_blob, 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 (VERIFY_FIRMWARE_SUCCESS == VerifyFirmware(root_key_blob, firmwareB,
-                                                    0)) {
+    if (VERIFY_FIRMWARE_SUCCESS == VerifyFirmware(root_key_blob, firmwareB)) {
         if (stored_lversion < firmwareB_lversion) {
           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. */
         }
     }
   }
@@ skipping 22 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,
-                                                   0)))
+        (VERIFY_FIRMWARE_SUCCESS == VerifyFirmware(root_key_blob, firmwareB)))
       return BOOT_FIRMWARE_B_CONTINUE;
   }
   /* D'oh: No bootable firmware. */
   return BOOT_FIRMWARE_RECOVERY_CONTINUE;
 }