VBoot Reference: Fix splicing bugs in Firmware and Kernel verification.

src/platform/vboot_reference/utils/kernel_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 kernel image.
  */
 
 #include "kernel_image.h"
 
 #include <fcntl.h>
@@ skipping 202 matching lines @@
                    RSAProcessedKeySize(image->kernel_sign_algorithm));
   StatefulMemcpy_r(&st, &image->header_checksum, FIELD_LEN(header_checksum));
 
   if (st.remaining_len != 0) {  /* Underrun or Overrun. */
     Free(header_blob);
     return NULL;
   }
   return header_blob;
 }
 
-int GetKernelConfigLen(const KernelImage* image) {
+int GetKernelConfigLen() {
   return (FIELD_LEN(kernel_version) +
           FIELD_LEN(options.version) + FIELD_LEN(options.cmd_line) +
           FIELD_LEN(options.kernel_len) + FIELD_LEN(options.kernel_load_addr) +
           FIELD_LEN(options.kernel_entry_addr));
 }
 
 uint8_t* GetKernelConfigBlob(const KernelImage* image) {
   uint8_t* config_blob = NULL;
   MemcpyState st;
 
-  config_blob = (uint8_t*) Malloc(GetKernelConfigLen(image));
-  st.remaining_len = GetKernelConfigLen(image);
+  config_blob = (uint8_t*) Malloc(GetKernelConfigLen());
+  st.remaining_len = GetKernelConfigLen();
   st.remaining_buf = config_blob;
 
   StatefulMemcpy_r(&st, &image->kernel_version, FIELD_LEN(kernel_version));
   StatefulMemcpy_r(&st, image->options.version, FIELD_LEN(options.version));
   StatefulMemcpy_r(&st, image->options.cmd_line, FIELD_LEN(options.cmd_line));
   StatefulMemcpy_r(&st, &image->options.kernel_len,
                    FIELD_LEN(options.kernel_len));
   StatefulMemcpy_r(&st, &image->options.kernel_load_addr,
         FIELD_LEN(options.kernel_load_addr));
   StatefulMemcpy_r(&st, &image->options.kernel_entry_addr,
@@ skipping 13 matching lines @@
   uint8_t* config_blob = NULL;
   MemcpyState st;
 
   if (!image)
     return NULL;
   kernel_key_signature_len = siglen_map[image->firmware_sign_algorithm];
   kernel_signature_len = siglen_map[image->kernel_sign_algorithm];
   *blob_len = (FIELD_LEN(magic) +
                GetKernelHeaderLen(image) +
                kernel_key_signature_len +
-               GetKernelConfigLen(image) +
+               GetKernelConfigLen() +
                2 * kernel_signature_len +
                image->options.kernel_len);
   kernel_blob = (uint8_t*) Malloc(*blob_len);
   st.remaining_len = *blob_len;
   st.remaining_buf = kernel_blob;
 
   header_blob = GetKernelHeaderBlob(image);
   config_blob = GetKernelConfigBlob(image);
 
   StatefulMemcpy_r(&st, image->magic, FIELD_LEN(magic));
   StatefulMemcpy_r(&st, header_blob, GetKernelHeaderLen(image));
   StatefulMemcpy_r(&st, image->kernel_key_signature, kernel_key_signature_len);
-  StatefulMemcpy_r(&st, config_blob, GetKernelConfigLen(image));
+  StatefulMemcpy_r(&st, config_blob, GetKernelConfigLen());
   StatefulMemcpy_r(&st, image->config_signature, kernel_signature_len);
   StatefulMemcpy_r(&st, image->kernel_signature, kernel_signature_len);
   StatefulMemcpy_r(&st, image->kernel_data, image->options.kernel_len);
 
   Free(config_blob);
   Free(header_blob);
 
   if (st.remaining_len != 0) {  /* Underrun or Overrun. */
     Free(kernel_blob);
     return NULL;
@@ skipping 153 matching lines @@
       return VERIFY_KERNEL_KEY_SIGNATURE_FAILED;
   }
   return 0;
 }
 
 int VerifyKernelConfig(RSAPublicKey* kernel_sign_key,
                        const uint8_t* config_blob,
                        int algorithm,
                        int* kernel_len) {
   uint32_t len, config_len;
-  config_len = GetKernelConfigLen(NULL);
+  config_len = GetKernelConfigLen();
   if (!RSAVerifyBinary_f(NULL, kernel_sign_key,  /* Key to use */
                          config_blob,  /* Data to verify */
                          config_len,  /* Length of data */
                          config_blob + config_len,  /* Expected Signature */
                          algorithm))
     return VERIFY_KERNEL_CONFIG_SIGNATURE_FAILED;
 
   Memcpy(&len,
          config_blob + (FIELD_LEN(kernel_version) + FIELD_LEN(options.version) +
                               FIELD_LEN(options.cmd_line)),
          sizeof(len));
   *kernel_len = (int) len;
   return 0;
 }
 
 int VerifyKernelData(RSAPublicKey* kernel_sign_key,
+                     const uint8_t* kernel_config_start,
                      const uint8_t* kernel_data_start,
                      int kernel_len,
                      int algorithm) {
   int signature_len = siglen_map[algorithm];
-  if (!RSAVerifyBinary_f(NULL, kernel_sign_key,  /* Key to use. */
-                         kernel_data_start + signature_len,  /* Data to
-                                                              * verify */
-                         kernel_len,  /* Length of data. */
-                         kernel_data_start,  /* Expected Signature */
-                         algorithm))
+  uint8_t* digest;
+  DigestContext ctx;
+
+  /* Since the kernel signature is computed over the kernel version, options
+   * and data, which does not form a contiguous region of memory, we calculate
+   * the message digest ourselves. */
+  DigestInit(&ctx, algorithm);
+  DigestUpdate(&ctx, kernel_config_start, GetKernelConfigLen());
+  DigestUpdate(&ctx, kernel_data_start + signature_len, kernel_len);
+  digest = DigestFinal(&ctx);
+  if (!RSAVerifyBinaryWithDigest_f(
+          NULL, kernel_sign_key,  /* Key to use. */
+          digest, /* Digest of the data to verify. */
+          kernel_data_start,  /* Expected Signature */
+          algorithm)) {
+    Free(digest);
     return VERIFY_KERNEL_SIGNATURE_FAILED;
+  }
+  Free(digest);
   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;
@@ skipping 35 matching lines @@
   /* Only continue if config verification succeeds. */
   config_ptr = (header_ptr + header_len + kernel_key_signature_len);
   if ((error_code = VerifyKernelConfig(kernel_sign_key, config_ptr,
                                        kernel_sign_algorithm,
                                        &kernel_len))) {
     RSAPublicKeyFree(kernel_sign_key);
     return error_code;  /* AKA jump to recovery. */
   }
   /* Only continue if kernel data verification succeeds. */
   kernel_ptr = (config_ptr +
-                GetKernelConfigLen(NULL) +  /* Skip config block/signature. */
+                GetKernelConfigLen() +  /* Skip config block/signature. */
                 kernel_signature_len);
 
-  if ((error_code = VerifyKernelData(kernel_sign_key, kernel_ptr, kernel_len,
+  if ((error_code = VerifyKernelData(kernel_sign_key, config_ptr, kernel_ptr,
+                                     kernel_len,
                                      kernel_sign_algorithm))) {
     RSAPublicKeyFree(kernel_sign_key);
     return error_code;  /* AKA jump to recovery. */
   }
   RSAPublicKeyFree(kernel_sign_key);
   return 0;  /* Success! */
 }
 
 int VerifyKernelImage(const RSAPublicKey* firmware_key,
                       const KernelImage* image,
                       const int dev_mode) {
   RSAPublicKey* kernel_sign_key = NULL;
   uint8_t* header_digest = NULL;
   uint8_t* config_digest = NULL;
   uint8_t* kernel_digest = NULL;
   int kernel_sign_key_size;
   int kernel_signature_size;
   int error_code = 0;
   DigestContext ctx;
-
+  DigestContext kernel_ctx;
   if (!image)
     return VERIFY_KERNEL_INVALID_IMAGE;
 
   /* Verify kernel key signature on the key header if we
    * are not in dev mode.
    *
    * TODO(gauravsh): Add additional sanity checks here for:
    *  1) verifying the header length is correct.
    *  2) header_checksum is correct.
    */
@@ skipping 51 matching lines @@
   DigestUpdate(&ctx, (uint8_t*) &image->options.kernel_entry_addr,
                FIELD_LEN(options.kernel_entry_addr));
   config_digest = DigestFinal(&ctx);
   if (!RSAVerify(kernel_sign_key, image->config_signature,
                  kernel_signature_size, image->kernel_sign_algorithm,
                  config_digest)) {
     error_code = VERIFY_KERNEL_CONFIG_SIGNATURE_FAILED;
     goto verify_failure;
   }
 
-  /* Verify firmware signature. */
-  kernel_digest = DigestBuf(image->kernel_data,
-                            image->options.kernel_len,
-                            image->kernel_sign_algorithm);
+  /* Verify kernel signature - kernel signature is computed on the contents
+     of kernel version + kernel options + kernel_data. */
+  DigestInit(&kernel_ctx, image->kernel_sign_algorithm);
+  DigestUpdate(&kernel_ctx, (uint8_t*) &image->kernel_version,
+               FIELD_LEN(kernel_version));
+  DigestUpdate(&kernel_ctx, (uint8_t*) image->options.version,
+               FIELD_LEN(options.version));
+  DigestUpdate(&kernel_ctx, (uint8_t*) image->options.cmd_line,
+               FIELD_LEN(options.cmd_line));
+  DigestUpdate(&kernel_ctx, (uint8_t*) &image->options.kernel_len,
+               FIELD_LEN(options.kernel_len));
+  DigestUpdate(&kernel_ctx, (uint8_t*) &image->options.kernel_load_addr,
+               FIELD_LEN(options.kernel_load_addr));
+  DigestUpdate(&kernel_ctx, (uint8_t*) &image->options.kernel_entry_addr,
+               FIELD_LEN(options.kernel_entry_addr));
+  DigestUpdate(&kernel_ctx, image->kernel_data, image->options.kernel_len);
+  kernel_digest = DigestFinal(&kernel_ctx);
   if (!RSAVerify(kernel_sign_key, image->kernel_signature,
                  kernel_signature_size, image->kernel_sign_algorithm,
                  kernel_digest)) {
     error_code = VERIFY_KERNEL_SIGNATURE_FAILED;
     goto verify_failure;
   }
 
 verify_failure:
   RSAPublicKeyFree(kernel_sign_key);
   Free(kernel_digest);
@@ skipping 27 matching lines @@
   Free(signature);
   Free(header_blob);
   return 1;
 }
 
 int AddKernelSignature(KernelImage* image,
                        const char* kernel_signing_key_file) {
   uint8_t* config_blob = NULL;
   uint8_t* config_signature = NULL;
   uint8_t* kernel_signature = NULL;
+  uint8_t* kernel_buf;
   int signature_len = siglen_map[image->kernel_sign_algorithm];
 
   config_blob = GetKernelConfigBlob(image);
   if (!(config_signature = SignatureBuf(config_blob,
-                                        GetKernelConfigLen(image),
+                                        GetKernelConfigLen(),
                                         kernel_signing_key_file,
                                         image->kernel_sign_algorithm))) {
     fprintf(stderr, "Could not compute signature on the kernel config.\n");
     Free(config_blob);
     return 0;
   }
-  Free(config_blob);
 
   image->config_signature = (uint8_t*) Malloc(signature_len);
   Memcpy(image->config_signature, config_signature, signature_len);
   Free(config_signature);
-
-  if (!(kernel_signature = SignatureBuf(image->kernel_data,
+  /* Kernel signature muse be calculated on the kernel version, options and
+   * kernel data to avoid splicing attacks. */
+  kernel_buf = (uint8_t*) Malloc(GetKernelConfigLen() +
+                                 image->options.kernel_len);
+  Memcpy(kernel_buf, config_blob, GetKernelConfigLen());
+  Memcpy(kernel_buf + GetKernelConfigLen(), image->kernel_data,
+         image->options.kernel_len);
+  if (!(kernel_signature = SignatureBuf(kernel_buf,
+                                        GetKernelConfigLen() +
                                         image->options.kernel_len,
                                         kernel_signing_key_file,
                                         image->kernel_sign_algorithm))) {
+    Free(config_blob);
+    Free(kernel_buf);
     fprintf(stderr, "Could not compute signature on the kernel.\n");
     return 0;
   }
   image->kernel_signature = (uint8_t*) Malloc(signature_len);
   Memcpy(image->kernel_signature, kernel_signature, signature_len);
   Free(kernel_signature);
+  Free(kernel_buf);
+  Free(config_blob);
   return 1;
 }
 
 uint32_t GetLogicalKernelVersion(uint8_t* kernel_blob) {
   uint8_t* kernel_ptr;
   uint16_t kernel_key_version;
   uint16_t kernel_version;
   uint16_t firmware_sign_algorithm;
   uint16_t kernel_sign_algorithm;
   int kernel_key_signature_len;
@@ 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;
 }