Add fuzz testing driver programs for kernel and firmware verification.

src/platform/vboot_reference/utils/kernel_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.
+// Utility for manipulating verified boot kernel images.
 //
 
 #include "kernel_utility.h"
 
 #include <errno.h>
 #include <getopt.h>
 #include <stdio.h>
 #include <stdint.h>  // Needed for UINT16_MAX.
 #include <stdlib.h>
 #include <unistd.h>
@@ skipping 32 matching lines @@
 }
 
 KernelUtility::~KernelUtility() {
   RSAPublicKeyFree(firmware_key_pub_);
   KernelImageFree(image_);
 }
 
 void KernelUtility::PrintUsage(void) {
   cerr <<
       "Utility to generate/verify a verified boot kernel image\n\n"
-      "Usage: firmware_utility <--generate|--verify> [OPTIONS]\n\n"
+      "Usage: kernel_utility <--generate|--verify> [OPTIONS]\n\n"
       "For \"--verify\",  required OPTIONS are:\n"
       "--in <infile>\t\t\tVerified boot kernel image to verify.\n"
       "--firmware_key_pub <pubkeyfile>\tPre-processed public firmware key "
       "to use for verification.\n\n"
       "For \"--generate\", required OPTIONS are:\n"
       "--firmware_key <privkeyfile>\tPrivate firmware signing key file\n"
       "--kernel_key <privkeyfile>\tPrivate kernel signing key file\n"
       "--kernel_key_pub <pubkeyfile>\tPre-processed public kernel signing"
       " key\n"
       "--firmware_sign_algorithm <algoid>\tSigning algorithm used by "
@@ skipping 151 matching lines @@
 
   // Update header length.
   image_->header_len = GetKernelHeaderLen(image_);
 
   // Calculate header checksum.
   DigestInit(&ctx, SHA512_DIGEST_ALGORITHM);
   DigestUpdate(&ctx, reinterpret_cast<uint8_t*>(&image_->header_version),
                sizeof(image_->header_version));
   DigestUpdate(&ctx, reinterpret_cast<uint8_t*>(&image_->header_len),
                sizeof(image_->header_len));
-  DigestUpdate(&ctx, reinterpret_cast<uint8_t*>(&image_->kernel_sign_algorithm),
+  DigestUpdate(&ctx,
+               reinterpret_cast<uint8_t*>(&image_->firmware_sign_algorithm),
+               sizeof(image_->firmware_sign_algorithm));
+  DigestUpdate(&ctx,
+               reinterpret_cast<uint8_t*>(&image_->kernel_sign_algorithm),
                sizeof(image_->kernel_sign_algorithm));
   DigestUpdate(&ctx, reinterpret_cast<uint8_t*>(&image_->kernel_key_version),
                sizeof(image_->kernel_key_version));
   DigestUpdate(&ctx, image_->kernel_sign_key,
                RSAProcessedKeySize(image_->kernel_sign_algorithm));
   header_checksum = DigestFinal(&ctx);
   Memcpy(image_->header_checksum, header_checksum, SHA512_DIGEST_SIZE);
   Free(header_checksum);
 
   image_->kernel_version = kernel_version_;
   image_->options.version[0] = options_.version[0];
   image_->options.version[1] = options_.version[1];
   image_->options.kernel_load_addr = options_.kernel_load_addr;
   image_->options.kernel_entry_addr = options_.kernel_entry_addr;
   image_->kernel_data = BufferFromFile(in_file_.c_str(),
                                        &image_->options.kernel_len);
   if (!image_)
     return false;
   // Generate and add the signatures.
   if (!AddKernelKeySignature(image_, firmware_key_file_.c_str())) {
-    cerr << "Couldn't write key signature to verified boot image.\n";
+    cerr << "Couldn't write key signature to verified boot kernel image.\n";
     return false;
   }
 
   if (!AddKernelSignature(image_, kernel_key_file_.c_str())) {
-    cerr << "Couldn't write firmware signature to verified boot image.\n";
+    cerr << "Couldn't write firmware signature to verified boot kernel image.\n";
     return false;
   }
   return true;
 }
 
 bool KernelUtility::VerifySignedImage(void) {
   int error;
   firmware_key_pub_ = RSAPublicKeyFromFile(firmware_key_pub_file_.c_str());
   image_ = ReadKernelImage(in_file_.c_str());
 
   if (!firmware_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";
+    cerr << "Couldn't read kernel image or malformed image.\n";
     return false;
   }
   if (!(error = VerifyKernelImage(firmware_key_pub_, image_, 0)))
     return true;
   cerr << VerifyKernelErrorString(error) << "\n";
   return false;
 }
 
 bool KernelUtility::CheckOptions(void) {
   if (is_generate_ == is_verify_) {
@@ skipping 65 matching lines @@
   }
   if (fu.is_verify()) {
     cerr << "Verification ";
     if (fu.VerifySignedImage())
       cerr << "SUCCESS.\n";
     else
       cerr << "FAILURE.\n";
   }
   return 0;
 }