Add a kernel subkey signing algorithm key and algorithm fields to firmware preamble.

src/platform/vboot_reference/vfirmware/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 <sys/types.h>
 #include <sys/stat.h>
 #include <fcntl.h>
 #include <unistd.h>
 
 #include "cryptolib.h"
 #include "file_keys.h"
 #include "signature_digest.h"
 #include "stateful_util.h"
 
 /* Macro to determine the size of a field structure in the FirmwareImage
  * structure. */
 #define FIELD_LEN(field) (sizeof(((FirmwareImage*)0)->field))
 
 FirmwareImage* FirmwareImageNew(void) {
   FirmwareImage* image = (FirmwareImage*) Malloc(sizeof(FirmwareImage));
   if (image) {
     image->firmware_sign_key = NULL;
+    image->kernel_subkey_sign_key = NULL;
     image->preamble_signature = NULL;
     image->firmware_signature = NULL;
     image->firmware_data = NULL;
   }
   return image;
 }
 
 void FirmwareImageFree(FirmwareImage* image) {
   if (image) {
     Free(image->firmware_sign_key);
+    Free(image->kernel_subkey_sign_key);
     Free(image->preamble_signature);
     Free(image->firmware_signature);
     Free(image->firmware_data);
     Free(image);
   }
 }
 
 FirmwareImage* ReadFirmwareImage(const char* input_file) {
   uint64_t file_size;
   int image_len = 0;  /* Total size of the firmware image. */
@@ skipping 61 matching lines @@
     return NULL;
   }
 
   /* Read key signature. */
   StatefulMemcpy(&st, image->firmware_key_signature,
                  FIELD_LEN(firmware_key_signature));
 
   /* Read the firmware preamble. */
   StatefulMemcpy(&st,&image->firmware_version, FIELD_LEN(firmware_version));
   StatefulMemcpy(&st, &image->firmware_len, FIELD_LEN(firmware_len));
+  StatefulMemcpy(&st, &image->kernel_subkey_sign_algorithm,
+                 FIELD_LEN(kernel_subkey_sign_algorithm));
+  StatefulMemcpy(&st, image->kernel_subkey_sign_key,
+                 RSAProcessedKeySize(image->kernel_subkey_sign_algorithm));
   StatefulMemcpy(&st, image->preamble, FIELD_LEN(preamble));
 
   /* Read firmware preamble signature. */
   image->preamble_signature = (uint8_t*) Malloc(signature_len);
   StatefulMemcpy(&st, image->preamble_signature, signature_len);
 
   image->firmware_signature = (uint8_t*) Malloc(signature_len);
   StatefulMemcpy(&st, image->firmware_signature, signature_len);
 
   image->firmware_data = (uint8_t*) Malloc(image->firmware_len);
@@ skipping 51 matching lines @@
                  RSAProcessedKeySize(image->firmware_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 GetFirmwarePreambleLen(void) {
-  return (FIELD_LEN(firmware_version) + FIELD_LEN(firmware_len) +
-          FIELD_LEN(preamble));
-}
 
 uint8_t* GetFirmwarePreambleBlob(const FirmwareImage* image) {
   uint8_t* preamble_blob = NULL;
   MemcpyState st;
+  uint64_t preamble_len = GetFirmwarePreambleLen(
+      image->kernel_subkey_sign_algorithm);
 
-  preamble_blob = (uint8_t*) Malloc(GetFirmwarePreambleLen());
-  st.remaining_len = GetFirmwarePreambleLen();
+  preamble_blob = (uint8_t*) Malloc(preamble_len);
+  st.remaining_len = preamble_len;
   st.remaining_buf = preamble_blob;
   st.overrun = 0;
 
   StatefulMemcpy_r(&st, &image->firmware_version, FIELD_LEN(firmware_version));
   StatefulMemcpy_r(&st, &image->firmware_len, FIELD_LEN(firmware_len));
+  StatefulMemcpy_r(&st, &image->kernel_subkey_sign_algorithm,
+                   FIELD_LEN(kernel_subkey_sign_algorithm));
+  StatefulMemcpy_r(&st, image->kernel_subkey_sign_key,
+                   RSAProcessedKeySize(image->kernel_subkey_sign_algorithm));
   StatefulMemcpy_r(&st, image->preamble, FIELD_LEN(preamble));
 
   if (st.overrun || st.remaining_len != 0 ) {  /* Underrun or Overrun. */
     Free(preamble_blob);
     return NULL;
   }
   return preamble_blob;
 }
 
 
 uint8_t* GetFirmwareBlob(const FirmwareImage* image, uint64_t* blob_len) {
   int firmware_signature_len;
   uint8_t* firmware_blob = NULL;
   uint8_t* header_blob = NULL;
   uint8_t* preamble_blob = NULL;
   MemcpyState st;
 
   if (!image)
     return NULL;
 
   firmware_signature_len = siglen_map[image->firmware_sign_algorithm];
   *blob_len = (FIELD_LEN(magic) +
                GetFirmwareHeaderLen(image) +
                FIELD_LEN(firmware_key_signature) +
-               GetFirmwarePreambleLen() +
+               GetFirmwarePreambleLen(image->kernel_subkey_sign_algorithm) +
                2 * firmware_signature_len +
                image->firmware_len);
   firmware_blob = (uint8_t*) Malloc(*blob_len);
   st.remaining_len = *blob_len;
   st.remaining_buf = firmware_blob;
   st.overrun = 0;
 
   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));
-  StatefulMemcpy_r(&st, preamble_blob, GetFirmwarePreambleLen());
+  StatefulMemcpy_r(&st, preamble_blob,
+                   GetFirmwarePreambleLen(image->kernel_subkey_sign_algorithm));
   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.overrun || st.remaining_len != 0) { /* Underrun or Overrun. */
     Free(firmware_blob);
     return NULL;
@@ skipping 134 matching lines @@
 
   if (image->firmware_sign_algorithm >= kNumAlgorithms)
     return VERIFY_FIRMWARE_INVALID_ALGORITHM;
 
   /* Verify firmware preamble signature. */
   DigestInit(&ctx, image->firmware_sign_algorithm);
   DigestUpdate(&ctx, (uint8_t*) &image->firmware_version,
                FIELD_LEN(firmware_version));
   DigestUpdate(&ctx, (uint8_t*) &image->firmware_len,
                FIELD_LEN(firmware_len));
+  DigestUpdate(&ctx, (uint8_t*) &image->kernel_subkey_sign_algorithm,
+               FIELD_LEN(kernel_subkey_sign_algorithm));
+  DigestUpdate(&ctx, (uint8_t*) image->kernel_subkey_sign_key,
+               RSAProcessedKeySize(image->kernel_subkey_sign_algorithm));
   DigestUpdate(&ctx, (uint8_t*) &image->preamble,
                FIELD_LEN(preamble));
   preamble_digest = DigestFinal(&ctx);
   if (!RSAVerify(firmware_sign_key, image->preamble_signature,
                  signature_size, image->firmware_sign_algorithm,
                  preamble_digest)) {
     error_code = VERIFY_FIRMWARE_PREAMBLE_SIGNATURE_FAILED;
     goto verify_failure;
   }
 
   /* Verify firmware signature - firmware signature is on the contents
    of firmware preamble + firmware_data. */
   DigestInit(&firmware_ctx, image->firmware_sign_algorithm);
   DigestUpdate(&firmware_ctx, (uint8_t*) &image->firmware_version,
                FIELD_LEN(firmware_version));
   DigestUpdate(&firmware_ctx, (uint8_t*) &image->firmware_len,
                FIELD_LEN(firmware_len));
+  DigestUpdate(&firmware_ctx, (uint8_t*) &image->kernel_subkey_sign_algorithm,
+               FIELD_LEN(kernel_subkey_sign_algorithm));
+  DigestUpdate(&firmware_ctx, (uint8_t*) image->kernel_subkey_sign_key,
+               RSAProcessedKeySize(image->kernel_subkey_sign_algorithm));
   DigestUpdate(&firmware_ctx, (uint8_t*) &image->preamble,
                FIELD_LEN(preamble));
   DigestUpdate(&firmware_ctx, image->firmware_data, image->firmware_len);
   firmware_digest = DigestFinal(&firmware_ctx);
   if (!RSAVerify(firmware_sign_key, image->firmware_signature,
                  signature_size, image->firmware_sign_algorithm,
                  firmware_digest)) {
     error_code = VERIFY_FIRMWARE_SIGNATURE_FAILED;
     goto verify_failure;
   }
@@ skipping 30 matching lines @@
   Free(signature);
   return 1;
 }
 
 int AddFirmwareSignature(FirmwareImage* image, const char* signing_key_file) {
   uint8_t* preamble_blob = NULL;
   uint8_t* preamble_signature = NULL;
   uint8_t* firmware_signature = NULL;
   uint8_t* firmware_buf = NULL;
   int signature_len = siglen_map[image->firmware_sign_algorithm];
+  uint64_t preamble_len = GetFirmwarePreambleLen(
+      image->kernel_subkey_sign_algorithm);
 
   preamble_blob = GetFirmwarePreambleBlob(image);
   if (!preamble_blob)
     return 0;
   if (!(preamble_signature = SignatureBuf(preamble_blob,
-                                          GetFirmwarePreambleLen(),
+                                          preamble_len,
                                           signing_key_file,
                                           image->firmware_sign_algorithm))) {
     Free(preamble_blob);
     return 0;
   }
   image->preamble_signature = (uint8_t*) Malloc(signature_len);
   Memcpy(image->preamble_signature, preamble_signature, signature_len);
   Free(preamble_signature);
   /* Firmware signature must be calculated on preamble + firmware_data
    * to avoid splicing attacks. */
-  firmware_buf = (uint8_t*) Malloc(GetFirmwarePreambleLen() +
+  firmware_buf = (uint8_t*) Malloc(preamble_len +
                                    image->firmware_len);
-  Memcpy(firmware_buf, preamble_blob, GetFirmwarePreambleLen());
-  Memcpy(firmware_buf + GetFirmwarePreambleLen(), image->firmware_data,
+  Memcpy(firmware_buf, preamble_blob, preamble_len);
+  Memcpy(firmware_buf + preamble_len, image->firmware_data,
          image->firmware_len);
   if (!(firmware_signature = SignatureBuf(firmware_buf,
-                                          GetFirmwarePreambleLen() +
+                                          preamble_len +
                                           image->firmware_len,
                                           signing_key_file,
                                           image->firmware_sign_algorithm))) {
     Free(preamble_blob);
     Free(firmware_buf);
     return 0;
   }
   image->firmware_signature = (uint8_t*) Malloc(signature_len);
   Memcpy(image->firmware_signature, firmware_signature, signature_len);
   Free(firmware_signature);
   Free(firmware_buf);
   Free(preamble_blob);
   return 1;
 }