Make kernel signature a part of the kernel preamble.

src/platform/vboot_reference/vboot_firmware/lib/kernel_image_fw.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 verifying a verified boot kernel image.
  * (Firmware portion)
  */
 
 #include "kernel_image_fw.h"
 
 #include "cryptolib.h"
 #include "rollback_index.h"
 #include "utility.h"
 
 /* Macro to determine the size of a field structure in the KernelImage
  * structure. */
 #define FIELD_LEN(field) (sizeof(((KernelImage*)0)->field))
 
 char* kVerifyKernelErrors[VERIFY_KERNEL_MAX] = {
   "Success.",
   "Invalid Image.",
   "Kernel Key Signature Failed.",
   "Invalid Kernel Verification Algorithm.",
   "Preamble Signature Failed.",
   "Kernel Signature Failed.",
   "Wrong Kernel Magic.",
 };
 
-inline uint64_t GetKernelPreambleLen(void) {
+inline uint64_t GetKernelPreambleLen(int algorithm) {
   return (FIELD_LEN(kernel_version) +
           FIELD_LEN(kernel_len) +
           FIELD_LEN(bootloader_offset) +
           FIELD_LEN(bootloader_size) +
-          FIELD_LEN(padded_header_size));
+          FIELD_LEN(padded_header_size) +
+          siglen_map[algorithm]);
 }
 
 uint64_t GetVblockHeaderSize(const uint8_t* vkernel_blob) {
   uint64_t len = 0;
   uint16_t firmware_sign_algorithm;
   uint16_t kernel_sign_algorithm;
   int algorithms_offset = (FIELD_LEN(magic) +
                            FIELD_LEN(header_version) +
                            FIELD_LEN(header_len));
   if (SafeMemcmp(vkernel_blob, KERNEL_MAGIC, KERNEL_MAGIC_SIZE)) {
@@ skipping 14 matching lines @@
     debug("Invalid kernel signing algorithm.\n");
     return 0;
   }
   len = algorithms_offset;  /* magic, header length and version. */
   len += (FIELD_LEN(firmware_sign_algorithm) +
           FIELD_LEN(kernel_sign_algorithm) +
           FIELD_LEN(kernel_key_version) +
           RSAProcessedKeySize(kernel_sign_algorithm) +  /* kernel_sign_key */
           FIELD_LEN(header_checksum) +
           siglen_map[firmware_sign_algorithm] +  /* kernel_key_signature */
-          GetKernelPreambleLen() +
-          siglen_map[kernel_sign_algorithm] +  /* preamble_signature */
-          siglen_map[kernel_sign_algorithm]);  /* kernel_signature */
+          GetKernelPreambleLen(kernel_sign_algorithm) +
+          siglen_map[kernel_sign_algorithm]);  /* preamble_signature */
   return len;
 }
 
 int VerifyKernelKeyHeader(const uint8_t* firmware_key_blob,
                           const uint8_t* header_blob,
                           const int dev_mode,
                           int* firmware_algorithm,
                           int* kernel_algorithm,
                           int* kernel_header_len) {
   int kernel_sign_key_len;
@@ skipping 68 matching lines @@
                            firmware_sign_algorithm))
       return VERIFY_KERNEL_KEY_SIGNATURE_FAILED;
   }
   return 0;
 }
 
 int VerifyKernelPreamble(RSAPublicKey* kernel_sign_key,
                          const uint8_t* preamble_blob,
                          int algorithm,
                          uint64_t* kernel_len) {
-  int preamble_len = GetKernelPreambleLen();
+  int preamble_len = GetKernelPreambleLen(algorithm);
   if (!RSAVerifyBinary_f(NULL, kernel_sign_key, /* Key to use */
                          preamble_blob,  /* Data to verify */
                          preamble_len, /* Length of data */
                          preamble_blob + preamble_len,  /* Expected Signature */
                          algorithm))
     return VERIFY_KERNEL_PREAMBLE_SIGNATURE_FAILED;
   Memcpy(kernel_len,
          preamble_blob + FIELD_LEN(kernel_version),
          FIELD_LEN(kernel_len));
   return 0;
 }
 
 int VerifyKernelData(RSAPublicKey* kernel_sign_key,
-                     const uint8_t* preamble_blob,
+                     const uint8_t* kernel_signature,
                      const uint8_t* kernel_data,
                      uint64_t kernel_len,
                      int algorithm) {
-  int signature_len = siglen_map[algorithm];
-  const uint8_t* kernel_signature = NULL;
-  uint8_t* digest = NULL;
-  DigestContext ctx;
 
-  kernel_signature = preamble_blob + (GetKernelPreambleLen() +
-                                      signature_len);
-
-  /* Since the kernel signature is computed over the kernel preamble
-   * and kernel image data, which does not form a contiguous
-   * region of memory, we calculate the message digest ourselves. */
-  DigestInit(&ctx, algorithm);
-  DigestUpdate(&ctx,
-               preamble_blob,
-               GetKernelPreambleLen());
-  DigestUpdate(&ctx, kernel_data, kernel_len);
-  digest = DigestFinal(&ctx);
-  if (!RSAVerifyBinaryWithDigest_f(
-          NULL, kernel_sign_key,  /* Key to use. */
-          digest, /* Digest of the data to verify. */
-          kernel_signature,  /* Expected Signature */
-          algorithm)) {
-    Free(digest);
+  if (!RSAVerifyBinary_f(NULL, kernel_sign_key, /* Key to use */
+                         kernel_data,  /* Data to verify */
+                         kernel_len, /* Length of data */
+                         kernel_signature,  /* Expected Signature */
+                         algorithm))
     return VERIFY_KERNEL_SIGNATURE_FAILED;
-  }
-  Free(digest);
   return 0;
 }
 
 int VerifyKernelHeader(const uint8_t* firmware_key_blob,
                        const uint8_t* kernel_header_blob,
                        const int dev_mode,
-                       const uint8_t** preamble_blob,
                        const uint8_t** expected_kernel_signature,
                        RSAPublicKey** kernel_sign_key,
                        int* kernel_sign_algorithm,
                        uint64_t* kernel_len) {
   int error_code;
   int firmware_sign_algorithm;  /* Firmware signing key algorithm. */
   int kernel_sign_key_len, kernel_key_signature_len, kernel_signature_len,
       header_len;
-  const uint8_t* header_ptr;  /* Pointer to header. */
-  const uint8_t* kernel_sign_key_ptr;  /* Pointer to signing key. */
+  const uint8_t* header_ptr = NULL;  /* Pointer to key header. */
+  const uint8_t* preamble_ptr = NULL;  /* Pointer to start of preamble. */
+  const uint8_t* kernel_sign_key_ptr = NULL;  /* Pointer to signing key. */
 
   /* Note: All the offset calculations are based on struct FirmwareImage which
    * is defined in include/firmware_image.h. */
 
   /* Compare magic bytes. */
   if (SafeMemcmp(kernel_header_blob, KERNEL_MAGIC, KERNEL_MAGIC_SIZE))
     return VERIFY_KERNEL_WRONG_MAGIC;
   header_ptr = kernel_header_blob + KERNEL_MAGIC_SIZE;
 
   /* Only continue if header verification succeeds. */
@@ skipping 12 matching lines @@
                                       FIELD_LEN(header_len) +
                                       FIELD_LEN(firmware_sign_algorithm) +
                                       FIELD_LEN(kernel_sign_algorithm) +
                                       FIELD_LEN(kernel_key_version));
   *kernel_sign_key = RSAPublicKeyFromBuf(kernel_sign_key_ptr,
                                         kernel_sign_key_len);
   kernel_signature_len = siglen_map[*kernel_sign_algorithm];
   kernel_key_signature_len = siglen_map[firmware_sign_algorithm];
 
   /* Only continue if preamble verification succeeds. */
-  *preamble_blob = (header_ptr + header_len + kernel_key_signature_len);
-  if ((error_code = VerifyKernelPreamble(*kernel_sign_key, *preamble_blob,
+  preamble_ptr = (header_ptr + header_len + kernel_key_signature_len);
+  if ((error_code = VerifyKernelPreamble(*kernel_sign_key, preamble_ptr,
                                          *kernel_sign_algorithm,
                                          kernel_len))) {
     RSAPublicKeyFree(*kernel_sign_key);
     return error_code;  /* AKA jump to recovery. */
   }
-  *expected_kernel_signature = (*preamble_blob +
-                                GetKernelPreambleLen() +
-                                kernel_signature_len);  /* Skip preamble. */
+  *expected_kernel_signature = (preamble_ptr +
+                                GetKernelPreambleLen(*kernel_sign_algorithm) -
+                                kernel_signature_len);  /* Skip beginning of
+                                                         * preamble. */
   return 0;
 }
 
 int VerifyKernel(const uint8_t* firmware_key_blob,
                  const uint8_t* kernel_blob,
                  const int dev_mode) {
   int error_code;
   int firmware_sign_algorithm;  /* Firmware signing key algorithm. */
   int kernel_sign_algorithm;  /* Kernel Signing key algorithm. */
   RSAPublicKey* kernel_sign_key;
   int kernel_sign_key_len, kernel_key_signature_len, kernel_signature_len,
       header_len;
   uint64_t kernel_len;
   const uint8_t* header_ptr;  /* Pointer to header. */
   const uint8_t* kernel_sign_key_ptr;  /* Pointer to signing key. */
   const uint8_t* preamble_ptr;  /* Pointer to kernel preamble block. */
   const uint8_t* kernel_ptr;  /* Pointer to kernel signature/data. */
+  const uint8_t* kernel_signature;
 
   /* Note: All the offset calculations are based on struct FirmwareImage which
    * is defined in include/firmware_image.h. */
 
   /* Compare magic bytes. */
-  if (SafeMemcmp(kernel_blob, KERNEL_MAGIC, KERNEL_MAGIC_SIZE))
+  if (SafeMemcmp(kernel_blob, KERNEL_MAGIC, KERNEL_MAGIC_SIZE)) {
+    debug("VerifyKernel: Kernel magic bytes not found.\n");
     return VERIFY_KERNEL_WRONG_MAGIC;
+  }
   header_ptr = kernel_blob + KERNEL_MAGIC_SIZE;
 
   /* Only continue if header verification succeeds. */
   if ((error_code = VerifyKernelKeyHeader(firmware_key_blob, header_ptr, dev_mode,
                                           &firmware_sign_algorithm,
                                           &kernel_sign_algorithm, &header_len))) {
     debug("VerifyKernel: Kernel header verification failed.\n");
     return error_code;  /* AKA jump to recovery. */
   }
   /* Parse signing key into RSAPublicKey structure since it is required multiple
    * times. */
   kernel_sign_key_len = RSAProcessedKeySize(kernel_sign_algorithm);
   kernel_sign_key_ptr = header_ptr + (FIELD_LEN(header_version) +
                                       FIELD_LEN(header_len) +
                                       FIELD_LEN(firmware_sign_algorithm) +
                                       FIELD_LEN(kernel_sign_algorithm) +
                                       FIELD_LEN(kernel_key_version));
   kernel_sign_key = RSAPublicKeyFromBuf(kernel_sign_key_ptr,
                                         kernel_sign_key_len);
   kernel_signature_len = siglen_map[kernel_sign_algorithm];
   kernel_key_signature_len = siglen_map[firmware_sign_algorithm];
 
   /* Only continue if preamble verification succeeds. */
   preamble_ptr = (header_ptr + header_len + kernel_key_signature_len);
   if ((error_code = VerifyKernelPreamble(kernel_sign_key, preamble_ptr,
                                          kernel_sign_algorithm,
                                          &kernel_len))) {
+    debug("VerifyKernel: Kernel preamble verification failed.\n");
     RSAPublicKeyFree(kernel_sign_key);
     return error_code;  /* AKA jump to recovery. */
   }
   /* Only continue if kernel data verification succeeds. */
   kernel_ptr = (preamble_ptr +
-                GetKernelPreambleLen() +
-                2 * kernel_signature_len);  /* preamble and kernel signature. */
+                GetKernelPreambleLen(kernel_sign_algorithm) +
+                kernel_signature_len);  /* preamble signature. */
+  kernel_signature = kernel_ptr - 2 * kernel_signature_len; /* end of kernel
+                                                             * preamble. */
 
   if ((error_code = VerifyKernelData(kernel_sign_key,  /* Verification key */
-                                     preamble_ptr,  /* Start of preamble */
-                                     kernel_ptr,  /* Start of kernel image */
-                                     kernel_len,  /* Length of kernel image. */
+                                     kernel_signature,  /* kernel signature */
+                                     kernel_ptr,  /* Start of kernel data */
+                                     kernel_len,  /* Length of kernel data. */
                                      kernel_sign_algorithm))) {
     RSAPublicKeyFree(kernel_sign_key);
     return error_code;  /* AKA jump to recovery. */
   }
   RSAPublicKeyFree(kernel_sign_key);
   return 0;  /* Success! */
 }
 
 uint32_t GetLogicalKernelVersion(uint8_t* kernel_blob) {
   uint8_t* kernel_ptr;
@@ skipping 126 matching lines @@
   /* Lock Kernel TPM rollback indices from further writes.
    * TODO(gauravsh): Figure out if these can be combined into one
    * 32-bit location since we seem to always use them together. This can help
    * us minimize the number of NVRAM writes/locks (which are limited over flash
    * memory lifetimes.
    */
   LockStoredVersion(KERNEL_KEY_VERSION);
   LockStoredVersion(KERNEL_VERSION);
   return kernel_to_boot;
 }