Pass VbSharedData between LoadFirmware() and LoadKernel()

utility/load_firmware_test.c

 /* Copyright (c) 2011 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.
  *
  * Routines for verifying a firmware image's signature.
  */
 
 #include <stdio.h>
 
 #include "fmap.h"
@@ skipping 26 matching lines @@
   if (firmware_index != 0 && firmware_index != 1)
     return 1;
 
   UpdateFirmwareBodyHash(params,
                          ci->firmware[firmware_index].fw,
                          ci->firmware[firmware_index].size);
 
   return 0;
 }
 
-/* Get firmware root key
+/* Get GBB
  *
- * Return pointer to firmware root key of firmware image, or NULL if not found
+ * Return pointer to GBB from firmware image, or NULL if not found.
  *
  * [base_of_rom] pointer to firmware image
  * [fmap] pointer to Flash Map of firmware image
+ * [gbb_size] GBB size will be stored here if GBB is found
  */
-void* GetFirmwareRootKey(const void* base_of_rom, const void* fmap) {
+void* GetFirmwareGBB(const void* base_of_rom, const void* fmap,
+                     uint64_t* gbb_size) {
   const FmapHeader* fh = (const FmapHeader*) fmap;
   const FmapAreaHeader* ah = (const FmapAreaHeader*)
     (fmap + sizeof(FmapHeader));
   int i = FmapAreaIndexOrError(fh, ah, "GBB Area");
-  const void* gbb;
-  const GoogleBinaryBlockHeader* gbbh;
 
   if (i < 0)
     return NULL;
 
-  gbb = base_of_rom + ah[i].area_offset;
-  gbbh = (const GoogleBinaryBlockHeader*) gbb;
-  return (void*) gbb + gbbh->rootkey_offset;
+  *gbb_size = ah[i].area_size;
+  return (void*)(base_of_rom + ah[i].area_offset);
 }
 
 /* Get verification block
  *
  * Return zero if succeed, or non-zero if failed
  *
  * [base_of_rom] pointer to firmware image
  * [fmap] pointer to Flash Map of firmware image
  * [index] index of verification block
  * [verification_block_ptr] pointer to storing the found verification block
@@ skipping 66 matching lines @@
   void** vblock_ptr[2] = {
     &lfp.verification_block_0, &lfp.verification_block_1
   };
   uint64_t* vsize_ptr[2] = {
     &lfp.verification_size_0, &lfp.verification_size_1
   };
 
   /* Initialize LoadFirmwareParams lfp */
 
   lfp.caller_internal = &ci;
-
-  lfp.firmware_root_key_blob = GetFirmwareRootKey(base_of_rom, fmap);
-  if (!lfp.firmware_root_key_blob) {
-    printf("ERROR: cannot get firmware root key blob\n");
+  lfp.gbb_data = GetFirmwareGBB(base_of_rom, fmap, &lfp.gbb_size);
+  if (!lfp.gbb_data) {
+    printf("ERROR: cannot get firmware GBB\n");
     return 1;
   }
 
-  printf("firmware root key blob at 0x%08" PRIx64 "\n",
-      (uint64_t) (lfp.firmware_root_key_blob - base_of_rom));
+  printf("firmware GBB at 0x%08" PRIx64 "\n",
+      (uint64_t) (lfp.gbb_data - base_of_rom));
 
   /* Loop to initialize firmware key and data A / B */
   for (index = 0; index < 2; ++index) {
     if (GetVerificationBlock(base_of_rom, fmap, index,
           vblock_ptr[index], vsize_ptr[index])) {
       printf("ERROR: cannot get key block %d\n", index);
       return 1;
     }
 
     printf("verification block %d at 0x%08" PRIx64 "\n", index,
         (uint64_t) (*vblock_ptr[index] - base_of_rom));
     printf("verification block %d size is 0x%08" PRIx64 "\n", index,
         *vsize_ptr[index]);
 
     if (GetFirmwareData(base_of_rom, fmap, index, *vblock_ptr[index],
           &(ci.firmware[index].fw), &(ci.firmware[index].size))) {
       printf("ERROR: cannot get firmware body %d\n", index);
       return 1;
     }
 
     printf("firmware %c at 0x%08" PRIx64 "\n", "AB"[index],
         (uint64_t) ((void*) ci.firmware[index].fw - base_of_rom));
     printf("firmware %c size is 0x%08" PRIx64 "\n", "AB"[index],
         ci.firmware[index].size);
   }
 
-  lfp.kernel_sign_key_blob = Malloc(LOAD_FIRMWARE_KEY_BLOB_REC_SIZE);
-  lfp.kernel_sign_key_size = LOAD_FIRMWARE_KEY_BLOB_REC_SIZE;
-  printf("kernel sign key size is 0x%08" PRIx64 "\n", lfp.kernel_sign_key_size);
+  lfp.shared_data_blob = Malloc(VB_SHARED_DATA_MIN_SIZE);
+  lfp.shared_data_size = VB_SHARED_DATA_MIN_SIZE;
+  printf("shared data size 0x%08" PRIx64 "\n", lfp.shared_data_size);
 
   lfp.boot_flags = 0;
   printf("boot flags is 0x%08" PRIx64 "\n", lfp.boot_flags);
 
   status = LoadFirmware(&lfp);
   status_str = status_string(status);
   if (status_str)
     printf("LoadFirmware returns %s\n", status_str);
   else
     printf("LoadFirmware returns unknown status code: %d\n", status);
   if (status == LOAD_FIRMWARE_SUCCESS)
     printf("firmwiare index is %" PRIu64 "\n", lfp.firmware_index);
 
-  Free(lfp.kernel_sign_key_blob);
+  Free(lfp.shared_data_blob);
 
   return 0;
 }
 
 /* wrap FmapAreaIndex; print error when not found */
 int FmapAreaIndexOrError(const FmapHeader* fh, const FmapAreaHeader* ah,
     const char* name) {
   int i = FmapAreaIndex(fh, ah, name);
   if (i < 0)
     fprintf(stderr, "%s: can't find %s in firmware image\n", progname, name);
@@ skipping 38 matching lines @@
   printf("opened %s\n", image_path);
 
   fmap = FmapFind((char*) base_of_rom, rom_size);
 
   retval = DriveLoadFirmware(base_of_rom, fmap);
 
   Free((void*) base_of_rom);
 
   return retval;
 }