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

src/platform/vboot_reference/utils/firmware_utility.cc

 // 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.
 //
 // Utility for manipulating verified boot firmware images.
 //
 
 #include "firmware_utility.h"
 
 #include <errno.h>
@@ skipping 19 matching lines @@
 
 namespace vboot_reference {
 
 FirmwareUtility::FirmwareUtility():
     image_(NULL),
     root_key_pub_(NULL),
     firmware_version_(-1),
     firmware_key_version_(-1),
     firmware_sign_algorithm_(-1),
     is_generate_(false),
-    is_verify_(false) {
+    is_verify_(false),
+    is_describe_(false) {
 }
 
 FirmwareUtility::~FirmwareUtility() {
   RSAPublicKeyFree(root_key_pub_);
   FirmwareImageFree(image_);
 }
 
 void FirmwareUtility::PrintUsage(void) {
   cerr <<
       "Utility to generate/verify a verified boot firmware image\n\n"
@@ skipping 26 matching lines @@
     {"root_key_pub", 1, 0, 0},
     {"firmware_sign_key", 1, 0, 0},
     {"firmware_sign_key_pub", 1, 0, 0},
     {"firmware_sign_algorithm", 1, 0, 0},
     {"firmware_key_version", 1, 0, 0},
     {"firmware_version", 1, 0, 0},
     {"in", 1, 0, 0},
     {"out", 1, 0, 0},
     {"generate", 0, 0, 0},
     {"verify", 0, 0, 0},
+    {"describe", 0, 0, 0},
     {NULL, 0, 0, 0}
   };
   while (1) {
     int i = getopt_long(argc, argv, "", long_options, &option_index);
     if (-1 == i)  // Done with option processing.
       break;
     if ('?' == i)  // Invalid option found.
       return false;
 
     if (0 == i) {
@@ skipping 33 matching lines @@
           break;
         case 7:  // in
           in_file_ = optarg;
           break;
         case 8:  // out
           out_file_ = optarg;
           break;
         case 9:  // generate
           is_generate_ = true;
           break;
-        case 10: // verify
+        case 10:  // verify
           is_verify_ = true;
           break;
+        case 11:  // describe
+          is_describe_ = true;
+          break;
       }
     }
   }
   return CheckOptions();
 }
 
 
 void FirmwareUtility::OutputSignedImage(void) {
   if (image_) {
     if (!WriteFirmwareImage(out_file_.c_str(), image_)) {
         cerr << "Couldn't write verified boot image to file "
                   << out_file_ <<".\n";
     }
   }
 }
 
+void FirmwareUtility::DescribeSignedImage(void) {
+  image_ = ReadFirmwareImage(in_file_.c_str());
+  if (!image_) {
+    cerr << "Couldn't read firmware image or malformed image.\n";
+  }
+  PrintFirmwareImage(image_);
+}
+
 bool FirmwareUtility::GenerateSignedImage(void) {
   uint64_t firmware_sign_key_pub_len;
-  uint8_t* header_checksum;
-  DigestContext ctx;
   image_ = FirmwareImageNew();
 
   Memcpy(image_->magic, FIRMWARE_MAGIC, FIRMWARE_MAGIC_SIZE);
 
   // Copy pre-processed public signing key.
   image_->firmware_sign_algorithm = (uint16_t) firmware_sign_algorithm_;
   image_->firmware_sign_key = BufferFromFile(
       firmware_key_pub_file_.c_str(),
       &firmware_sign_key_pub_len);
   if (!image_->firmware_sign_key)
     return false;
   image_->firmware_key_version = firmware_key_version_;
 
   // Update header length.
   image_->header_len = GetFirmwareHeaderLen(image_);
 
   // Calculate header checksum.
-  DigestInit(&ctx, SHA512_DIGEST_ALGORITHM);
-  DigestUpdate(&ctx, reinterpret_cast<uint8_t*>(&image_->header_len),
-               sizeof(image_->header_len));
-  DigestUpdate(&ctx,
-               reinterpret_cast<uint8_t*>(&image_->firmware_sign_algorithm),
-               sizeof(image_->firmware_sign_algorithm));
-  DigestUpdate(&ctx, image_->firmware_sign_key,
-               RSAProcessedKeySize(image_->firmware_sign_algorithm));
-  DigestUpdate(&ctx, reinterpret_cast<uint8_t*>(&image_->firmware_key_version),
-               sizeof(image_->firmware_key_version));
-  header_checksum = DigestFinal(&ctx);
-  Memcpy(image_->header_checksum, header_checksum, SHA512_DIGEST_SIZE);
-  Free(header_checksum);
+  CalculateFirmwareHeaderChecksum(image_, image_->header_checksum);
 
   image_->firmware_version = firmware_version_;
   image_->firmware_len = 0;
   // TODO(gauravsh): Populate this with the right bytes once we decide
   // what goes into the preamble.
   Memset(image_->preamble, 'P', FIRMWARE_PREAMBLE_SIZE);
   image_->firmware_data = BufferFromFile(in_file_.c_str(),
                                          &image_->firmware_len);
   if (!image_)
     return false;
@@ skipping 25 matching lines @@
     return false;
   }
   if (!(error = VerifyFirmwareImage(root_key_pub_, image_,
                                     0)))  // Trusted Mode.
     return true;
   cerr << VerifyFirmwareErrorString(error) << "\n";
   return false;;
 }
 
 bool FirmwareUtility::CheckOptions(void) {
-  if (is_generate_ == is_verify_) {
-    cerr << "One of --generate or --verify must be specified.\n";
+  // Ensure that only one of --{describe|generate|verify} is set.
+  if (!((is_describe_ && !is_generate_ && !is_verify_) ||
+        (!is_describe_ && is_generate_ && !is_verify_) ||
+        (!is_describe_ && !is_generate_ && is_verify_))) {
+    cerr << "One (and only one) of --describe, --generate or --verify "
+         << "must be specified.\n";
     return false;
   }
   // Common required options.
   if (in_file_.empty()) {
     cerr << "No input file specified." << "\n";
     return false;
   }
   // Required options for --verify.
   if (is_verify_ && root_key_pub_file_.empty()) {
     cerr << "No pre-processed public root key file specified." << "\n";
@@ skipping 36 matching lines @@
 
 
 }  // namespace vboot_reference
 
 int main(int argc, char* argv[]) {
   vboot_reference::FirmwareUtility fu;
   if (!fu.ParseCmdLineOptions(argc, argv)) {
     fu.PrintUsage();
     return -1;
   }
+  if (fu.is_describe()) {
+    fu.DescribeSignedImage();
+  }
   if (fu.is_generate()) {
     if (!fu.GenerateSignedImage())
       return -1;
     fu.OutputSignedImage();
   }
   if (fu.is_verify()) {
     cerr << "Verification ";
     if (fu.VerifySignedImage())
       cerr << "SUCCESS.\n";
     else
       cerr << "FAILURE.\n";
   }
   return 0;
 }