Vboot Reference: Kernel Boot signing 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 75 matching lines @@
     {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) {
-      switch(option_index) {
+      switch (option_index) {
         case 0:  // root_key
           root_key_file_ = optarg;
           break;
         case 1:  // root_key_pub
           root_key_pub_file_ = optarg;
           break;
         case 2:  // firmware_sign_key
-          firmware_sign_key_file_ = optarg;
+          firmware_key_file_ = optarg;
           break;
         case 3:  // firmware_sign_key_pub
-          firmware_sign_key_pub_file_ = optarg;
+          firmware_key_pub_file_ = optarg;
           break;
         case 4:  // firmware_sign_algorithm
           errno = 0;  // strtol() returns an error via errno
-          firmware_sign_algorithm_ = strtol(optarg, (char**) NULL, 10);
+          firmware_sign_algorithm_ = strtol(optarg,
+                                            reinterpret_cast<char**>(NULL), 10);
           if (errno)
             return false;
           break;
         case 5:  // firmware_key_version
           errno = 0;
-          firmware_key_version_ = strtol(optarg, (char**) NULL, 10);
+          firmware_key_version_ = strtol(optarg,
+                                         reinterpret_cast<char**>(NULL), 10);
           if (errno)
             return false;
           break;
         case 6:  // firmware_version
           errno = 0;
-          firmware_version_ = strtol(optarg, (char**) NULL, 10);
+          firmware_version_ = strtol(optarg,
+                                     reinterpret_cast<char**>(NULL), 10);
           if (errno)
             return false;
           break;
         case 7:  // in
           in_file_ = optarg;
           break;
         case 8:  // out
           out_file_ = optarg;
           break;
         case 9:  // generate
@@ skipping 22 matching lines @@
   uint32_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_sign_key_pub_file_.c_str(),
+      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 = (sizeof(image_->header_len) +
-                        sizeof(image_->firmware_sign_algorithm) +
-                        firmware_sign_key_pub_len +
-                        sizeof(image_->firmware_key_version) +
-                        sizeof(image_->header_checksum));
+  image_->header_len = GetFirmwareHeaderLen(image_);
 
   // Calculate header checksum.
   DigestInit(&ctx, SHA512_DIGEST_ALGORITHM);
-  DigestUpdate(&ctx, (uint8_t*) &image_->header_len,
+  DigestUpdate(&ctx, reinterpret_cast<uint8_t*>(&image_->header_len),
                sizeof(image_->header_len));
-  DigestUpdate(&ctx, (uint8_t*) &image_->firmware_sign_algorithm,
+  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, (uint8_t*) &image_->firmware_key_version,
+  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);
 
   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;
   // Generate and add the signatures.
   if (!AddFirmwareKeySignature(image_, root_key_file_.c_str())) {
     cerr << "Couldn't write key signature to verified boot image.\n";
     return false;
   }
 
-  if (!AddFirmwareSignature(image_, firmware_sign_key_file_.c_str())) {
+  if (!AddFirmwareSignature(image_, firmware_key_file_.c_str())) {
     cerr << "Couldn't write firmware signature to verified boot image.\n";
     return false;
   }
   return true;
 }
 
 bool FirmwareUtility::VerifySignedImage(void) {
   int error;
   root_key_pub_ = RSAPublicKeyFromFile(root_key_pub_file_.c_str());
   image_ = ReadFirmwareImage(in_file_.c_str());
 
   if (!root_key_pub_) {
     cerr << "Couldn't read pre-processed public root key.\n";
     return false;
   }
 
   if (!image_) {
     cerr << "Couldn't read firmware image or malformed image.\n";
     return false;
   }
-  if(!(error = VerifyFirmwareImage(root_key_pub_, image_, 0)))  // Trusted Mode.
+  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";
     return false;
   }
@@ skipping 10 matching lines @@
   // Required options for --generate.
   if (is_generate_) {
     if (root_key_file_.empty()) {
       cerr << "No root key file specified." << "\n";
       return false;
     }
     if (firmware_version_ <= 0 || firmware_version_ > UINT16_MAX) {
       cerr << "Invalid or no firmware version specified." << "\n";
       return false;
     }
-    if (firmware_sign_key_file_.empty()) {
+    if (firmware_key_file_.empty()) {
       cerr << "No signing key file specified." << "\n";
       return false;
     }
-    if (firmware_sign_key_pub_file_.empty()) {
+    if (firmware_key_pub_file_.empty()) {
       cerr << "No pre-processed public signing key file specified." << "\n";
       return false;
     }
     if (firmware_key_version_ <= 0 || firmware_key_version_ > UINT16_MAX) {
       cerr << "Invalid or no key version specified." << "\n";
       return false;
     }
     if (firmware_sign_algorithm_ < 0 ||
         firmware_sign_algorithm_ >= kNumAlgorithms) {
       cerr << "Invalid or no signing key algorithm specified." << "\n";
@@ skipping 16 matching lines @@
     fu.PrintUsage();
     return -1;
   }
   if (fu.is_generate()) {
     if (!fu.GenerateSignedImage())
       return -1;
     fu.OutputSignedImage();
   }
   if (fu.is_verify()) {
     cerr << "Verification ";
-    if(fu.VerifySignedImage())
+    if (fu.VerifySignedImage())
       cerr << "SUCCESS.\n";
     else
       cerr << "FAILURE.\n";
   }
   return 0;
 }