Add --describe flag to {firmware|kernel}_utility.

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 35 matching lines @@
   }
 }
 
 FirmwareImage* ReadFirmwareImage(const char* input_file) {
   uint64_t file_size;
   int image_len = 0;  /* Total size of the firmware image. */
   int header_len = 0;
   int firmware_sign_key_len;
   int signature_len;
   uint8_t* firmware_buf;
+  uint8_t header_checksum[FIELD_LEN(header_checksum)];
   MemcpyState st;
   FirmwareImage* image = FirmwareImageNew();
 
   if (!image)
     return NULL;
 
   firmware_buf = BufferFromFile(input_file, &file_size);
   image_len = file_size;
 
   st.remaining_len = image_len;
@@ skipping 29 matching lines @@
     return NULL;
   }
 
   /* Read pre-processed public half of the sign key. */
   image->firmware_sign_key = (uint8_t*) Malloc(firmware_sign_key_len);
   StatefulMemcpy(&st, image->firmware_sign_key, firmware_sign_key_len);
   StatefulMemcpy(&st, &image->firmware_key_version,
                  FIELD_LEN(firmware_key_version));
   StatefulMemcpy(&st, image->header_checksum, FIELD_LEN(header_checksum));
 
+  /* Check whether the header checksum matches. */
+  CalculateFirmwareHeaderChecksum(image, header_checksum);
+  if (SafeMemcmp(header_checksum, image->header_checksum,
+                 FIELD_LEN(header_checksum))) {
+    fprintf(stderr, "Invalid firmware header checksum!\n");
+    Free(firmware_buf);
+    return NULL;
+  }
+
   /* Read key signature. */
   StatefulMemcpy(&st, image->firmware_key_signature,
                  FIELD_LEN(firmware_key_signature));
 
   /* Read the firmware preamble. */
   StatefulMemcpy(&st,&image->firmware_version, FIELD_LEN(firmware_version));
   StatefulMemcpy(&st, &image->firmware_len, FIELD_LEN(firmware_len));
   StatefulMemcpy(&st, image->preamble, FIELD_LEN(preamble));
 
   /* Read firmware preamble signature. */
@@ skipping 14 matching lines @@
   Free(firmware_buf);
   return image;
 }
 
 int GetFirmwareHeaderLen(const FirmwareImage* image) {
   return (FIELD_LEN(header_len) + FIELD_LEN(firmware_sign_algorithm) +
           RSAProcessedKeySize(image->firmware_sign_algorithm) +
           FIELD_LEN(firmware_key_version) + FIELD_LEN(header_checksum));
 }
 
+void CalculateFirmwareHeaderChecksum(const FirmwareImage* image,
+                                     uint8_t* header_checksum) {
+  uint8_t* checksum;
+  DigestContext ctx;
+  DigestInit(&ctx, SHA512_DIGEST_ALGORITHM);
+  DigestUpdate(&ctx, (uint8_t*) &image->header_len,
+               sizeof(image->header_len));
+  DigestUpdate(&ctx, (uint8_t*) &image->firmware_sign_algorithm,
+               sizeof(image->firmware_sign_algorithm));
+  DigestUpdate(&ctx, image->firmware_sign_key,
+               RSAProcessedKeySize(image->firmware_sign_algorithm));
+  DigestUpdate(&ctx, (uint8_t*) &image->firmware_key_version,
+               sizeof(image->firmware_key_version));
+  checksum = DigestFinal(&ctx);
+  Memcpy(header_checksum, checksum, FIELD_LEN(header_checksum));
+  Free(checksum);
+  return;
+}
+
+
 uint8_t* GetFirmwareHeaderBlob(const FirmwareImage* image) {
   uint8_t* header_blob = NULL;
   MemcpyState st;
 
   header_blob = (uint8_t*) Malloc(GetFirmwareHeaderLen(image));
   st.remaining_len = GetFirmwareHeaderLen(image);
   st.remaining_buf = header_blob;
 
   StatefulMemcpy_r(&st, &image->header_len, FIELD_LEN(header_len));
   StatefulMemcpy_r(&st, &image->firmware_sign_algorithm, FIELD_LEN(header_len));
@@ skipping 106 matching lines @@
   close(fd);
   return 1;
 }
 
 void PrintFirmwareImage(const FirmwareImage* image) {
   if (!image)
     return;
 
   /* Print header. */
   printf("Header Length = %d\n"
-         "Algorithm Id = %d\n"
-         "Signature Algorithm = %s\n"
-         "Key Version = %d\n\n",
+         "Firmware Signature Algorithm = %s\n"
+         "Firmware Key Version = %d\n\n",
          image->header_len,
-         image->firmware_sign_algorithm,
          algo_strings[image->firmware_sign_algorithm],
          image->firmware_key_version);
   /* TODO(gauravsh): Output hash and key signature here? */
   /* Print preamble. */
   printf("Firmware Version = %d\n"
          "Firmware Length = %" PRIu64 "\n\n",
          image->firmware_version,
          image->firmware_len);
   /* Output key signature here? */
 }
@@ skipping 298 matching lines @@
   if (!(firmware_signature = SignatureBuf(image->firmware_data,
                                           image->firmware_len,
                                           signing_key_file,
                                           image->firmware_sign_algorithm)))
     return 0;
   image->firmware_signature = (uint8_t*) Malloc(signature_len);
   Memcpy(image->firmware_signature, firmware_signature, signature_len);
   Free(firmware_signature);
   return 1;
 }