Move test utility functions to a common place.

src/platform/vboot_reference/include/firmware_image.h

 /* 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.
  *
  * Data structure and API definitions for a verified boot firmware image.
  */
 
 #ifndef VBOOT_REFERENCE_FIRMWARE_IMAGE_H_
 #define VBOOT_REFERENCE_FIRMWARE_IMAGE_H_
 
@@ skipping 103 matching lines @@
 #define VERIFY_FIRMWARE_SIGNATURE_FAILED 5
 #define VERIFY_FIRMWARE_WRONG_MAGIC 6
 #define VERIFY_FIRMWARE_WRONG_HEADER_CHECKSUM 7
 #define VERIFY_FIRMWARE_KEY_ROLLBACK 8
 #define VERIFY_FIRMWARE_VERSION_ROLLBACK 9
 #define VERIFY_FIRMWARE_MAX 10  /* Total number of error codes. */
 
 extern char* kVerifyFirmwareErrors[VERIFY_FIRMWARE_MAX];
 
 /* Checks for the sanity of the firmware header pointed by [header_blob].
- * If [dev_mode] is enabled, also checks the root key signature using the
- * pre-processed public root key [root_key_blob].
  *
  * On success, put signature algorithm in [algorithm], header length
  * in [header_len], and return 0.
  * Else, return error code on failure.
  */
 int VerifyFirmwareHeader(const uint8_t* root_key_blob,
                          const uint8_t* header_blob,
-                         const int dev_mode,
                          int* algorithm,
                          int* header_len);
 
 /* Checks the preamble signature on firmware preamble pointed by
  * [preamble_blob] using the signing key [sign_key].
  *
  * On success, put firmware length into [firmware_len], and return 0.
  * Else, return error code on failure.
  */
 int VerifyFirmwarePreamble(RSAPublicKey* sign_key,
                            const uint8_t* preamble_blob,
                            int algorithm,
                            int* firmware_len);
 
 /* Checks the signature on the firmware data at location [firmware_data_start].
  * The length of the actual firmware data is firmware_len and it is assumed to
  * be prepended with the signature whose size depends on the signature_algorithm
  * [algorithm].
  *
  * Return 0 on success, error code on failure.
  */
 int VerifyFirmwareData(RSAPublicKey* sign_key,
                        const uint8_t* firmware_data_start,
                        int firmware_len,
                        int algorithm);
 
-/* Performs a chained verify of the firmware blob [firmware_blob]. If
- * [dev_mode] is 0 [inactive], then the pre-processed public root key
- * [root_key_blob] is used the verify the signature of the signing key,
- * else the check is skipped.
+/* Performs a chained verify of the firmware blob [firmware_blob].
  *
  * Returns 0 on success, error code on failure.
  *
  * NOTE: The length of the firmware blob is derived from reading the fields
  * in the first few bytes of the buffer. This might look risky but in firmware
  * land, the start address of the firmware_blob will always be fixed depending
  * on the memory map on the particular platform. In addition, the signature on
  * length itself is checked early in the verification process for extra safety.
  */
 int VerifyFirmware(const uint8_t* root_key_blob,
-                   const uint8_t* firmware_blob,
-                   const int dev_mode);
+                   const uint8_t* firmware_blob);
 
-/* Performs a chained verify of the firmware [image]. If [dev_mode] is
- * 0 (inactive), then the [root_key] is used to verify the signature of
- * the signing key, else the check is skipped.
+/* Performs a chained verify of the firmware [image].
  *
  * Returns 0 on success, error code on failure.
  */
 int VerifyFirmwareImage(const RSAPublicKey* root_key,
-                        const FirmwareImage* image,
-                        const int dev_mode);
+                        const FirmwareImage* image);
 
 /* Maps error codes from VerifyFirmware() to error description. */
 const char* VerifyFirmwareErrorString(int error);
 
 /* Add a root key signature to the key header to a firmware image [image]
  * using the private root key in file [root_key_file].
  *
  * Return 1 on success, 0 on failure.
  */
 int AddFirmwareKeySignature(FirmwareImage* image, const char* root_key_file);
@@ skipping 21 matching lines @@
  * Returns the code path to follow. It is one of:
  * BOOT_FIRMWARE_A_CONTINUE          Boot from Firmware A
  * BOOT_FIRMWARE_B_CONTINUE          Boot from Firmware B
  * BOOT_FIRMWARE_RECOVERY_CONTINUE   Jump to recovery mode
  */
 int VerifyFirmwareDriver_f(uint8_t* root_key_blob,
                            uint8_t* firmwareA,
                            uint8_t* firmwareB);
 
 #endif  /* VBOOT_REFERENCE_FIRMWARE_IMAGE_H_ */