Make kernel signature a part of the kernel preamble.

src/platform/vboot_reference/vkernel/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.
  * (Userland portion)
  */
 
 #include "kernel_image.h"
 
@@ skipping 204 matching lines @@
     Free(header_blob);
     return NULL;
   }
   return header_blob;
 }
 
 uint8_t* GetKernelPreambleBlob(const KernelImage* image) {
   uint8_t* preamble_blob = NULL;
   MemcpyState st;
 
-  preamble_blob = (uint8_t*) Malloc(GetKernelPreambleLen());
-  st.remaining_len = GetKernelPreambleLen();
+  preamble_blob = (uint8_t*) Malloc(
+      GetKernelPreambleLen(image->kernel_sign_algorithm));
+  st.remaining_len = GetKernelPreambleLen(image->kernel_sign_algorithm);
   st.remaining_buf = preamble_blob;
   st.overrun = 0;
 
   StatefulMemcpy_r(&st, &image->kernel_version, FIELD_LEN(kernel_version));
   StatefulMemcpy_r(&st, &image->kernel_len, FIELD_LEN(kernel_len));
   StatefulMemcpy_r(&st, &image->bootloader_offset, FIELD_LEN(bootloader_offset));
   StatefulMemcpy_r(&st, &image->bootloader_size, FIELD_LEN(bootloader_size));
   StatefulMemcpy_r(&st, &image->padded_header_size,
                    FIELD_LEN(padded_header_size));
+  StatefulMemcpy_r(&st, image->kernel_signature,
+                   siglen_map[image->kernel_sign_algorithm]);
 
   if (st.overrun || st.remaining_len != 0) {  /* Overrun or Underrun. */
     Free(preamble_blob);
     return NULL;
   }
   return preamble_blob;
 }
 
 uint8_t* GetKernelBlob(const KernelImage* image, uint64_t* blob_len) {
   int kernel_key_signature_len;
   int kernel_signature_len;
   uint8_t* kernel_blob = NULL;
   uint8_t* header_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 +
-               GetKernelPreambleLen() +
-               2 * kernel_signature_len +
+               GetKernelPreambleLen(image->kernel_sign_algorithm) +
+               kernel_signature_len +
                image->kernel_len);
   kernel_blob = (uint8_t*) Malloc(*blob_len);
   st.remaining_len = *blob_len;
   st.remaining_buf = kernel_blob;
   st.overrun = 0;
 
   header_blob = GetKernelHeaderBlob(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);
   /* Copy over kernel preamble blob (including signatures.) */
   StatefulMemcpy_r(&st, &image->kernel_version, FIELD_LEN(kernel_version));
   StatefulMemcpy_r(&st, &image->kernel_len, FIELD_LEN(kernel_len));
   StatefulMemcpy_r(&st, &image->bootloader_offset,
                    FIELD_LEN(bootloader_offset));
   StatefulMemcpy_r(&st, &image->bootloader_size, FIELD_LEN(bootloader_size));
   StatefulMemcpy_r(&st, &image->padded_header_size,
                    FIELD_LEN(padded_header_size));
+  StatefulMemcpy_r(&st, image->kernel_signature, kernel_signature_len);
   StatefulMemcpy_r(&st, image->preamble_signature, kernel_signature_len);
-  StatefulMemcpy_r(&st, image->kernel_signature, kernel_signature_len);
   StatefulMemcpy_r(&st, image->kernel_data, image->kernel_len);
 
   Free(header_blob);
 
   if (st.overrun || st.remaining_len != 0) {  /* Underrun or Overrun. */
+    debug("GetKernelBlob() failed.\n");
     Free(kernel_blob);
     return NULL;
   }
   return kernel_blob;
 }
 
 int WriteKernelImage(const char* input_file,
                      const KernelImage* image,
                      int is_only_vblock) {
   int fd;
@@ skipping 68 matching lines @@
                       const KernelImage* image,
                       const int dev_mode) {
   RSAPublicKey* kernel_sign_key = NULL;
   uint8_t* header_digest = NULL;
   uint8_t* preamble_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 41 matching lines @@
   DigestUpdate(&ctx, (uint8_t*) &image->kernel_version,
                FIELD_LEN(kernel_version));
   DigestUpdate(&ctx, (uint8_t*) &image->kernel_len,
                FIELD_LEN(kernel_len));
   DigestUpdate(&ctx, (uint8_t*) &image->bootloader_offset,
                FIELD_LEN(bootloader_offset));
   DigestUpdate(&ctx, (uint8_t*) &image->bootloader_size,
                FIELD_LEN(bootloader_size));
   DigestUpdate(&ctx, (uint8_t*) &image->padded_header_size,
                FIELD_LEN(padded_header_size));
+  DigestUpdate(&ctx, (uint8_t*) image->kernel_signature,
+               kernel_signature_size);
   preamble_digest = DigestFinal(&ctx);
   if (!RSAVerify(kernel_sign_key, image->preamble_signature,
                  kernel_signature_size, image->kernel_sign_algorithm,
                  preamble_digest)) {
     error_code = VERIFY_KERNEL_PREAMBLE_SIGNATURE_FAILED;
     goto verify_failure;
   }
 
   /* 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->kernel_len,
-               FIELD_LEN(kernel_len));
-  DigestUpdate(&kernel_ctx, (uint8_t*) &image->bootloader_offset,
-               FIELD_LEN(bootloader_offset));
-  DigestUpdate(&kernel_ctx, (uint8_t*) &image->bootloader_size,
-               FIELD_LEN(bootloader_size));
-  DigestUpdate(&kernel_ctx, (uint8_t*) &image->padded_header_size,
-               FIELD_LEN(padded_header_size));
-  DigestUpdate(&kernel_ctx, (uint8_t*) image->kernel_data,
-               image->kernel_len);
-  kernel_digest = DigestFinal(&kernel_ctx);
+   * of kernel_data.
+   * Association between the kernel_data and preamble is maintained by making
+   * the kernel signature a part of the preamble and verifying it as part
+   * of preamble signature checking. */
+
+  kernel_digest = DigestBuf(image->kernel_data,
+                            image->kernel_len,
+                            image->kernel_sign_algorithm);
   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 28 matching lines @@
   Free(header_blob);
   return 1;
 }
 
 int AddKernelSignature(KernelImage* image,
                        const char* kernel_signing_key_file) {
   uint8_t* preamble_blob = NULL;
   uint8_t* preamble_signature = NULL;
   uint8_t* kernel_signature = NULL;
   uint8_t* kernel_buf;
-  int signature_len = siglen_map[image->kernel_sign_algorithm];
+  int algorithm = image->kernel_sign_algorithm;
+  int signature_len = siglen_map[algorithm];
 
-  preamble_blob = GetKernelPreambleBlob(image);
-  if (!(preamble_signature = SignatureBuf(preamble_blob,
-                                          GetKernelPreambleLen(),
-                                          kernel_signing_key_file,
-                                          image->kernel_sign_algorithm))) {
-    debug("Could not compute signature on the kernel preamble.\n");
-    Free(preamble_blob);
-    return 0;
-  }
-
-  image->preamble_signature = (uint8_t*) Malloc(signature_len);
-  Memcpy(image->preamble_signature, preamble_signature, signature_len);
-  Free(preamble_signature);
-  /* Kernel signature muse be calculated on the kernel version, options and
-   * kernel data to avoid splicing attacks. */
-  kernel_buf = (uint8_t*) Malloc(GetKernelPreambleLen() +
-                                 image->kernel_len);
-  Memcpy(kernel_buf, preamble_blob, GetKernelPreambleLen());
-  Memcpy(kernel_buf + GetKernelPreambleLen(), image->kernel_data,
-         image->kernel_len);
+  /* Kernel signature must be calculated first as its used for computing the
+   * preamble signature. */
+  kernel_buf = (uint8_t*) Malloc(image->kernel_len);
+  Memcpy(kernel_buf, image->kernel_data, image->kernel_len);
   if (!(kernel_signature = SignatureBuf(kernel_buf,
-                                        GetKernelPreambleLen() +
                                         image->kernel_len,
                                         kernel_signing_key_file,
-                                        image->kernel_sign_algorithm))) {
+                                        algorithm))) {
     Free(preamble_blob);
     Free(kernel_buf);
     debug("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);
+
+
+  preamble_blob = GetKernelPreambleBlob(image);
+  if (!(preamble_signature = SignatureBuf(preamble_blob,
+                                          GetKernelPreambleLen(algorithm),
+                                          kernel_signing_key_file,
+                                          algorithm))) {
+    debug("Could not compute signature on the kernel preamble.\n");
+    Free(preamble_blob);
+    return 0;
+  }
+  image->preamble_signature = (uint8_t*) Malloc(signature_len);
+  Memcpy(image->preamble_signature, preamble_signature, signature_len);
+
+  Free(preamble_signature);
+  Free(preamble_blob);
   Free(kernel_signature);
   Free(kernel_buf);
-  Free(preamble_blob);
   return 1;
 }
 
 void PrintKernelEntry(kernel_entry* entry) {
   debug("Boot Priority = %d\n", entry->boot_priority);
   debug("Boot Tries Remaining = %d\n", entry->boot_tries_remaining);
   debug("Boot Success Flag = %d\n", entry->boot_success_flag);
 }