VBoot Reference: Make kernel_config a 4K byte block, and move it after the verified boot block.

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 11 matching lines @@
 
 /* Macro to determine the size of a field structure in the KernelImage
  * structure. */
 #define FIELD_LEN(field) (sizeof(((KernelImage*)0)->field))
 
 KernelImage* KernelImageNew(void) {
   KernelImage* image = (KernelImage*) Malloc(sizeof(KernelImage));
   if (image) {
     image->kernel_sign_key = NULL;
     image->kernel_key_signature = NULL;
-    Memset(image->options.cmd_line, 0, sizeof(image->options.cmd_line));
+    Memset(image->kernel_config,
+           0,
+           sizeof(image->kernel_config));
     image->config_signature = NULL;
     image->kernel_signature = NULL;
     image->kernel_data = NULL;
   }
   return image;
 }
 
 void KernelImageFree(KernelImage* image) {
   if (image) {
     Free(image->kernel_sign_key);
@@ skipping 86 matching lines @@
     return NULL;
   }
 
   /* Read key signature. */
   image->kernel_key_signature = (uint8_t*) Malloc(kernel_key_signature_len);
   StatefulMemcpy(&st, image->kernel_key_signature,
                  kernel_key_signature_len);
 
   /* Read the kernel config. */
   StatefulMemcpy(&st, &image->kernel_version, FIELD_LEN(kernel_version));
-  StatefulMemcpy(&st, &image->options.version, FIELD_LEN(options.version));
-  StatefulMemcpy(&st, &image->options.cmd_line, FIELD_LEN(options.cmd_line));
-  StatefulMemcpy(&st, &image->options.kernel_len,
-                 FIELD_LEN(options.kernel_len));
-  StatefulMemcpy(&st, &image->options.kernel_load_addr,
-                 FIELD_LEN(options.kernel_load_addr));
-  StatefulMemcpy(&st, &image->options.kernel_entry_addr,
-                 FIELD_LEN(options.kernel_entry_addr));
+  StatefulMemcpy(&st, &image->kernel_len, FIELD_LEN(kernel_len));
 
-  /* Read kernel config signature. */
+  /* Read config and kernel signatures. */
   image->config_signature = (uint8_t*) Malloc(kernel_signature_len);
   StatefulMemcpy(&st, image->config_signature, kernel_signature_len);
-
   image->kernel_signature = (uint8_t*) Malloc(kernel_signature_len);
   StatefulMemcpy(&st, image->kernel_signature, kernel_signature_len);
 
-  image->kernel_data = (uint8_t*) Malloc(image->options.kernel_len);
-  StatefulMemcpy(&st, image->kernel_data, image->options.kernel_len);
+  /* Read kernel config command line and kernel image data. */
+  StatefulMemcpy(&st, image->kernel_config, FIELD_LEN(kernel_config));
+  image->kernel_data = (uint8_t*) Malloc(image->kernel_len);
+  StatefulMemcpy(&st, image->kernel_data, image->kernel_len);
 
   if(st.overrun || st.remaining_len != 0) {  /* Overrun or underrun. */
     Free(kernel_buf);
     return NULL;
   }
   Free(kernel_buf);
   return image;
 }
 
 int GetKernelHeaderLen(const KernelImage* image) {
@@ skipping 48 matching lines @@
                    RSAProcessedKeySize(image->kernel_sign_algorithm));
   StatefulMemcpy_r(&st, &image->header_checksum, FIELD_LEN(header_checksum));
 
   if (st.overrun || st.remaining_len != 0) {  /* Underrun or Overrun. */
     Free(header_blob);
     return NULL;
   }
   return header_blob;
 }
 
-int GetKernelConfigLen() {
+int GetKernelConfigLen(const KernelImage* image) {
   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));
+          FIELD_LEN(kernel_len) +
+          FIELD_LEN(kernel_config));
 }
 
 uint8_t* GetKernelConfigBlob(const KernelImage* image) {
   uint8_t* config_blob = NULL;
   MemcpyState st;
 
-  config_blob = (uint8_t*) Malloc(GetKernelConfigLen());
-  st.remaining_len = GetKernelConfigLen();
+  config_blob = (uint8_t*) Malloc(GetKernelConfigLen(image));
+  st.remaining_len = GetKernelConfigLen(image);
   st.remaining_buf = config_blob;
   st.overrun = 0;
 
   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,
-        FIELD_LEN(options.kernel_entry_addr));
+  StatefulMemcpy_r(&st, &image->kernel_len, FIELD_LEN(kernel_len));
+  StatefulMemcpy_r(&st, image->kernel_config, FIELD_LEN(kernel_config));
+
   if (st.overrun || st.remaining_len != 0) {  /* Overrun or Underrun. */
     Free(config_blob);
     return NULL;
   }
   return config_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;
-  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() +
+               GetKernelConfigLen(image) +
                2 * kernel_signature_len +
-               image->options.kernel_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);
-  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());
+  /* Copy over kernel config 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->config_signature, kernel_signature_len);
   StatefulMemcpy_r(&st, image->kernel_signature, kernel_signature_len);
-  StatefulMemcpy_r(&st, image->kernel_data, image->options.kernel_len);
+  StatefulMemcpy_r(&st, image->kernel_config, FIELD_LEN(kernel_config));
+  StatefulMemcpy_r(&st, image->kernel_data, image->kernel_len);
 
-  Free(config_blob);
   Free(header_blob);
 
   if (st.overrun || st.remaining_len != 0) {  /* Underrun or Overrun. */
     Free(kernel_blob);
     return NULL;
   }
   return kernel_blob;
 }
 
 int WriteKernelImage(const char* input_file,
@@ skipping 16 matching lines @@
     debug("Couldn't create kernel blob from KernelImage.\n");
     return 0;
   }
   if (!is_only_vblock) {
     if (blob_len != write(fd, kernel_blob, blob_len)) {
       debug("Couldn't write Kernel Image to file: %s\n",
             input_file);
       success = 0;
     }
   } else {
-    /* Exclude the kernel_data. */
-    int vblock_len = blob_len - image->options.kernel_len;
+    /* Exclude kernel_config and kernel_data. */
+    int vblock_len = blob_len - (image->kernel_len +
+                                 sizeof(image->kernel_config));
     if (vblock_len != write(fd, kernel_blob, vblock_len)) {
       debug("Couldn't write Kernel Image Verification block to file: %s\n",
             input_file);
       success = 0;
     }
   }
   Free(kernel_blob);
   close(fd);
   return success;
 }
 
 void PrintKernelImage(const KernelImage* image) {
   if (!image)
     return;
 
   /* Print header. */
   printf("Header Version = %d\n"
          "Header Length = %d\n"
          "Kernel Key Signature Algorithm = %s\n"
          "Kernel Signature Algorithm = %s\n"
          "Kernel Key Version = %d\n\n",
          image->header_version,
          image->header_len,
          algo_strings[image->firmware_sign_algorithm],
          algo_strings[image->kernel_sign_algorithm],
          image->kernel_key_version);
   /* TODO(gauravsh): Output hash and key signature here? */
   /* Print preamble. */
   printf("Kernel Version = %d\n"
-         "Kernel Config Version = %d.%d\n"
          "Kernel Config command line = \"%s\"\n"
-         "kernel Length = %" PRId64 "\n"
-         "Kernel Load Address = %" PRId64 "\n"
-         "Kernel Entry Address = %" PRId64 "\n\n",
+         "kernel Length = %" PRId64 "\n",
          image->kernel_version,
-         image->options.version[0], image->options.version[1],
-         image->options.cmd_line,
-         image->options.kernel_len,
-         image->options.kernel_load_addr,
-         image->options.kernel_entry_addr);
+         image->kernel_config,
+         image->kernel_len);
   /* TODO(gauravsh): Output kernel signature here? */
 }
 
 
 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;
@@ skipping 49 matching lines @@
   /* Get kernel signing key to verify the rest of the kernel. */
   kernel_sign_key_size = RSAProcessedKeySize(image->kernel_sign_algorithm);
   kernel_sign_key = RSAPublicKeyFromBuf(image->kernel_sign_key,
                                         kernel_sign_key_size);
   kernel_signature_size = siglen_map[image->kernel_sign_algorithm];
 
   /* Verify kernel config signature. */
   DigestInit(&ctx, image->kernel_sign_algorithm);
   DigestUpdate(&ctx, (uint8_t*) &image->kernel_version,
                FIELD_LEN(kernel_version));
-  DigestUpdate(&ctx, (uint8_t*) image->options.version,
-               FIELD_LEN(options.version));
-  DigestUpdate(&ctx, (uint8_t*) image->options.cmd_line,
-               FIELD_LEN(options.cmd_line));
-  DigestUpdate(&ctx, (uint8_t*) &image->options.kernel_len,
-               FIELD_LEN(options.kernel_len));
-  DigestUpdate(&ctx, (uint8_t*) &image->options.kernel_load_addr,
-               FIELD_LEN(options.kernel_load_addr));
-  DigestUpdate(&ctx, (uint8_t*) &image->options.kernel_entry_addr,
-               FIELD_LEN(options.kernel_entry_addr));
+  DigestUpdate(&ctx, (uint8_t*) &image->kernel_len,
+               FIELD_LEN(kernel_len));
+  DigestUpdate(&ctx, (uint8_t*) image->kernel_config,
+               FIELD_LEN(kernel_config));
   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 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);
+  DigestUpdate(&kernel_ctx, (uint8_t*) &image->kernel_len,
+               FIELD_LEN(kernel_len));
+  DigestUpdate(&kernel_ctx, (uint8_t*) image->kernel_config,
+               FIELD_LEN(kernel_config));
+  DigestUpdate(&kernel_ctx, image->kernel_data, image->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);
@@ skipping 33 matching lines @@
 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(),
+                                        GetKernelConfigLen(image),
                                         kernel_signing_key_file,
                                         image->kernel_sign_algorithm))) {
     debug("Could not compute signature on the kernel config.\n");
     Free(config_blob);
     return 0;
   }
 
   image->config_signature = (uint8_t*) Malloc(signature_len);
   Memcpy(image->config_signature, config_signature, signature_len);
   Free(config_signature);
   /* 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);
+  kernel_buf = (uint8_t*) Malloc(GetKernelConfigLen(image) +
+                                 image->kernel_len);
+  Memcpy(kernel_buf, config_blob, GetKernelConfigLen(image));
+  Memcpy(kernel_buf + GetKernelConfigLen(image), image->kernel_data,
+         image->kernel_len);
   if (!(kernel_signature = SignatureBuf(kernel_buf,
-                                        GetKernelConfigLen() +
-                                        image->options.kernel_len,
+                                        GetKernelConfigLen(image) +
+                                        image->kernel_len,
                                         kernel_signing_key_file,
                                         image->kernel_sign_algorithm))) {
     Free(config_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);
   Free(kernel_signature);
   Free(kernel_buf);
   Free(config_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);
 }