Vboot Reference: Make kernel signing utility more flexible.

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));
     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 249 matching lines @@
   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,
-                     const KernelImage* image) {
+                     const KernelImage* image,
+                     int is_only_vblock) {
   int fd;
+  int success = 1;
   uint8_t* kernel_blob;
   uint64_t blob_len;
 
   if (!image)
     return 0;
   if (-1 == (fd = creat(input_file, S_IRWXU))) {
     debug("Couldn't open file for writing kernel image: %s\n",
             input_file);
     return 0;
   }
   kernel_blob = GetKernelBlob(image, &blob_len);
   if (!kernel_blob) {
     debug("Couldn't create kernel blob from KernelImage.\n");
     return 0;
   }
-  if (blob_len != write(fd, kernel_blob, blob_len)) {
-    debug("Couldn't write Kernel Image to file: %s\n",
+  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);
-
-    Free(kernel_blob);
-    close(fd);
-    return 0;
+      success = 0;
+    }
+  } else {
+    /* Exclude the kernel_data. */
+    int vblock_len = blob_len - image->options.kernel_len;
+    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 1;
+  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"
@@ skipping 208 matching lines @@
   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);
 }