Add a command line string field to verified boot kernel config image.

src/platform/vboot_reference/utils/firmware_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 firmware image.
  */
 
 #include "firmware_image.h"
 
 #include <fcntl.h>
@@ skipping 69 matching lines @@
   if (image->firmware_sign_algorithm >= kNumAlgorithms) {
     Free(firmware_buf);
     return NULL;
   }
 
   /* Compute size of pre-processed RSA public key and signature. */
   firmware_sign_key_len = RSAProcessedKeySize(image->firmware_sign_algorithm);
   signature_len = siglen_map[image->firmware_sign_algorithm];
 
   /* Check whether the header length is correct. */
-  header_len = (FIELD_LEN(header_len) +
-                FIELD_LEN(firmware_sign_algorithm) +
-                firmware_sign_key_len +
-                FIELD_LEN(firmware_key_version) +
-                FIELD_LEN(header_checksum));
+  header_len = GetFirmwareHeaderLen(image);
   if (header_len != image->header_len) {
     fprintf(stderr, "Header length mismatch. Got: %d Expected: %d\n",
             image->header_len, header_len);
     Free(firmware_buf);
     return NULL;
   }
 
   /* Read pre-processed public half of the sign key. */
   image->firmware_sign_key = (uint8_t*) Malloc(firmware_sign_key_len);
   StatefulMemcpy(&st, image->firmware_sign_key, firmware_sign_key_len);
@@ skipping 103 matching lines @@
   firmware_blob = (uint8_t*) Malloc(*blob_len);
   st.remaining_len = *blob_len;
   st.remaining_buf = firmware_blob;
 
   header_blob = GetFirmwareHeaderBlob(image);
   preamble_blob = GetFirmwarePreambleBlob(image);
 
   StatefulMemcpy_r(&st, image->magic, FIELD_LEN(magic));
   StatefulMemcpy_r(&st, header_blob, GetFirmwareHeaderLen(image));
   StatefulMemcpy_r(&st, image->firmware_key_signature,
-                 FIELD_LEN(firmware_key_signature));
+                   FIELD_LEN(firmware_key_signature));
   StatefulMemcpy_r(&st, preamble_blob, GetFirmwarePreambleLen(image));
   StatefulMemcpy_r(&st, image->preamble_signature, firmware_signature_len);
   StatefulMemcpy_r(&st, image->firmware_signature, firmware_signature_len);
   StatefulMemcpy_r(&st, image->firmware_data, image->firmware_len);
 
   Free(preamble_blob);
   Free(header_blob);
 
   if (st.remaining_len != 0) { /* Underrun or Overrun. */
     Free(firmware_blob);
@@ skipping 198 matching lines @@
   preamble_ptr = (header_ptr + header_len +
                   FIELD_LEN(firmware_key_signature));
   if ((error_code = VerifyFirmwarePreamble(firmware_sign_key, preamble_ptr,
                                            algorithm,
                                            &firmware_len))) {
     RSAPublicKeyFree(firmware_sign_key);
     return error_code;  /* AKA jump to recovery. */
   }
   /* Only continue if firmware data verification succeeds. */
   firmware_ptr = (preamble_ptr +
-                  FIELD_LEN(firmware_version) +
-                  FIELD_LEN(firmware_len) +
-                  FIELD_LEN(preamble) +
+                  GetFirmwarePreambleLen(NULL) + 
                   signature_len);
 
   if ((error_code = VerifyFirmwareData(firmware_sign_key, firmware_ptr,
                                        firmware_len,
                                        algorithm))) {
     RSAPublicKeyFree(firmware_sign_key);
     return error_code;  /* AKA jump to recovery. */
   }
 
   RSAPublicKeyFree(firmware_sign_key);
@@ skipping 134 matching lines @@
   if (!(firmware_signature = SignatureBuf(image->firmware_data,
                                           image->firmware_len,
                                           signing_key_file,
                                           image->firmware_sign_algorithm)))
     return 0;
   image->firmware_signature = (uint8_t*) Malloc(signature_len);
   Memcpy(image->firmware_signature, firmware_signature, signature_len);
   Free(firmware_signature);
   return 1;
 }