vboot: save GBB header in workbuf during firmware verification

Since GBB header will be needed for subsequent GBB reads later on
(in kernel verification stage), and since GBB header is
relatively small (128 bytes), save the full GBB header onto
workbuf during firmware verification stage, and store an offset
pointer to it in vb2_shared_data.  vb2_gbb_header object may be
accessed via the vb2_get_gbb function.

Additionally, update functions in firmware/lib/region-init.c to
read GBB data from flash, rather than using cparams passed in by
depthcharge, which is slated for deprecation.

BUG=b:124141368, chromium:954774
TEST=make clean && make runtests
BRANCH=none

Change-Id: I6e6218231299ce3a5b383663bc3480b20f929840
Signed-off-by: Joel Kitching <kitching@google.com>
Cq-Depend: chromium:1585500
Reviewed-on: https://chromium-review.googlesource.com/1627430
Commit-Ready: Joel Kitching <kitching@chromium.org>
Tested-by: Joel Kitching <kitching@chromium.org>
Legacy-Commit-Queue: Commit Bot <commit-bot@chromium.org>
Reviewed-by: Julius Werner <jwerner@chromium.org>
Reviewed-by: Joel Kitching <kitching@chromium.org>

14 files changed, 201 insertions, 99 deletions

diff --git a/tests/ec_sync_tests.c b/tests/ec_sync_tests.c
index 45764048..f73886a9 100644
--- a/tests/ec_sync_tests.c
+++ b/tests/ec_sync_tests.c
@@ -51,6 +51,7 @@ static int want_ec_hash_size;
 static struct vb2_context ctx;
 static uint8_t workbuf[VB2_KERNEL_WORKBUF_RECOMMENDED_SIZE];
 static struct vb2_shared_data *sd;
+static struct vb2_gbb_header gbb;
 
 static uint32_t screens_displayed[8];
 static uint32_t screens_count = 0;
@@ -75,6 +76,8 @@ static void ResetMocks(void)
 	sd->vbsd = shared;
 	sd->flags |= VB2_SD_FLAG_DISPLAY_AVAILABLE;
 
+	memset(&gbb, 0, sizeof(gbb));
+
 	memset(&shared_data, 0, sizeof(shared_data));
 	VbSharedDataInit(shared, sizeof(shared_data));
 
@@ -118,6 +121,10 @@ static void ResetMocks(void)
 }
 
 /* Mock functions */
+struct vb2_gbb_header *vb2_get_gbb(struct vb2_context *c)
+{
+	return &gbb;
+}
 
 uint32_t VbExIsShutdownRequested(void)
 {
@@ -420,7 +427,7 @@ static void VbSoftwareSyncTest(void)
 	test_ssync(0, 0, "AP-RW shutdown requested");
 
 	ResetMocks();
-	sd->gbb_flags |= VB2_GBB_FLAG_DISABLE_EC_SOFTWARE_SYNC;
+	gbb.flags |= VB2_GBB_FLAG_DISABLE_EC_SOFTWARE_SYNC;
 	ec_aux_fw_mock_severity = VB_AUX_FW_FAST_UPDATE;
 	test_ssync(VBERROR_SUCCESS, 0,
 		   "VB2_GBB_FLAG_DISABLE_EC_SOFTWARE_SYNC"
@@ -429,7 +436,7 @@ static void VbSoftwareSyncTest(void)
 	TEST_EQ(ec_aux_fw_protected, 1, "  aux fw protected");
 
 	ResetMocks();
-	sd->gbb_flags |= VB2_GBB_FLAG_DISABLE_PD_SOFTWARE_SYNC;
+	gbb.flags |= VB2_GBB_FLAG_DISABLE_PD_SOFTWARE_SYNC;
 	ec_aux_fw_mock_severity = VB_AUX_FW_FAST_UPDATE;
 	test_ssync(VBERROR_SUCCESS, 0,
 		   "VB2_GBB_FLAG_DISABLE_PD_SOFTWARE_SYNC"
diff --git a/tests/vb20_misc_tests.c b/tests/vb20_misc_tests.c
index 84e8e96e..4cd11b6f 100644
--- a/tests/vb20_misc_tests.c
+++ b/tests/vb20_misc_tests.c
@@ -22,6 +22,7 @@ static uint8_t workbuf[VB2_FIRMWARE_WORKBUF_RECOMMENDED_SIZE]
 	__attribute__ ((aligned (VB2_WORKBUF_ALIGN)));
 static struct vb2_context ctx;
 static struct vb2_shared_data *sd;
+static struct vb2_gbb_header gbb;
 
 /* Mocked function data */
 
@@ -68,6 +69,8 @@ static void reset_common_data(enum reset_type t)
 	ctx.workbuf = workbuf;
 	ctx.workbuf_size = sizeof(workbuf);
 
+	memset(&gbb, 0, sizeof(gbb));
+
 	vb2_init_context(&ctx);
 	sd = vb2_get_sd(&ctx);
 
@@ -85,8 +88,8 @@ static void reset_common_data(enum reset_type t)
 	sd->fw_version_secdata = 0x20002;
 	vb2_secdata_set(&ctx, VB2_SECDATA_VERSIONS, sd->fw_version_secdata);
 
-	sd->gbb_rootkey_offset = vb2_offset_of(&mock_gbb, &mock_gbb.rootkey);
-	sd->gbb_rootkey_size = sizeof(mock_gbb.rootkey_data);
+	gbb.rootkey_offset = vb2_offset_of(&mock_gbb, &mock_gbb.rootkey);
+	gbb.rootkey_size = sizeof(mock_gbb.rootkey_data);
 	sd->last_fw_result = VB2_FW_RESULT_SUCCESS;
 
 	mock_gbb.rootkey.algorithm = 11;
@@ -113,6 +116,10 @@ static void reset_common_data(enum reset_type t)
 };
 
 /* Mocked functions */
+struct vb2_gbb_header *vb2_get_gbb(struct vb2_context *c)
+{
+	return &gbb;
+}
 
 int vb2ex_read_resource(struct vb2_context *c,
 			enum vb2_resource_index index,
@@ -210,13 +217,13 @@ static void verify_keyblock_tests(void)
 	/* Test failures */
 	reset_common_data(FOR_KEYBLOCK);
 	ctx.workbuf_used = ctx.workbuf_size + VB2_WORKBUF_ALIGN -
-			vb2_wb_round_up(sd->gbb_rootkey_size);
+			vb2_wb_round_up(gbb.rootkey_size);
 	TEST_EQ(vb2_load_fw_keyblock(&ctx),
 		VB2_ERROR_FW_KEYBLOCK_WORKBUF_ROOT_KEY,
 		"keyblock not enough workbuf for root key");
 
 	reset_common_data(FOR_KEYBLOCK);
-	sd->gbb_rootkey_size = sizeof(mock_gbb);
+	gbb.rootkey_size = sizeof(mock_gbb);
 	TEST_EQ(vb2_load_fw_keyblock(&ctx),
 		VB2_ERROR_EX_READ_RESOURCE_SIZE,
 		"keyblock read root key");
@@ -229,7 +236,7 @@ static void verify_keyblock_tests(void)
 
 	reset_common_data(FOR_KEYBLOCK);
 	ctx.workbuf_used = ctx.workbuf_size -
-			vb2_wb_round_up(sd->gbb_rootkey_size);
+			vb2_wb_round_up(gbb.rootkey_size);
 	TEST_EQ(vb2_load_fw_keyblock(&ctx),
 		VB2_ERROR_FW_KEYBLOCK_WORKBUF_HEADER,
 		"keyblock not enough workbuf for header");
@@ -242,7 +249,7 @@ static void verify_keyblock_tests(void)
 
 	reset_common_data(FOR_KEYBLOCK);
 	ctx.workbuf_used = ctx.workbuf_size -
-			vb2_wb_round_up(sd->gbb_rootkey_size) -
+			vb2_wb_round_up(gbb.rootkey_size) -
 			vb2_wb_round_up(sizeof(struct vb2_keyblock));
 	TEST_EQ(vb2_load_fw_keyblock(&ctx),
 		VB2_ERROR_FW_KEYBLOCK_WORKBUF,
@@ -274,7 +281,7 @@ static void verify_keyblock_tests(void)
 
 	reset_common_data(FOR_KEYBLOCK);
 	kb->data_key.key_version = 1;
-	sd->gbb_flags |= VB2_GBB_FLAG_DISABLE_FW_ROLLBACK_CHECK;
+	gbb.flags |= VB2_GBB_FLAG_DISABLE_FW_ROLLBACK_CHECK;
 	TEST_SUCC(vb2_load_fw_keyblock(&ctx), "keyblock rollback with GBB flag");
 }
 
@@ -356,7 +363,7 @@ static void verify_preamble_tests(void)
 
 	reset_common_data(FOR_PREAMBLE);
 	pre->firmware_version = 1;
-	sd->gbb_flags |= VB2_GBB_FLAG_DISABLE_FW_ROLLBACK_CHECK;
+	gbb.flags |= VB2_GBB_FLAG_DISABLE_FW_ROLLBACK_CHECK;
 	TEST_SUCC(vb2_load_fw_preamble(&ctx), "version rollback with GBB flag");
 
 	reset_common_data(FOR_PREAMBLE);
diff --git a/tests/vb20_verify_fw.c b/tests/vb20_verify_fw.c
index 2e098f38..5fd232a5 100644
--- a/tests/vb20_verify_fw.c
+++ b/tests/vb20_verify_fw.c
@@ -9,8 +9,8 @@
 #include <stdlib.h>
 #include <string.h>
 
+#include "2common.h"
 #include "2sysincludes.h"
-#include "2api.h"
 
 const char *gbb_fname;
 const char *vblock_fname;
diff --git a/tests/vb21_host_sig_tests.c b/tests/vb21_host_sig_tests.c
index f4ca1a67..f275d2f3 100644
--- a/tests/vb21_host_sig_tests.c
+++ b/tests/vb21_host_sig_tests.c
@@ -8,14 +8,14 @@
 #include <stdio.h>
 #include <unistd.h>
 
-#include "2sysincludes.h"
 #include "2common.h"
 #include "2rsa.h"
-#include "vb21_common.h"
+#include "2sysincludes.h"
 #include "host_common.h"
 #include "host_key2.h"
 #include "host_signature2.h"
 #include "test_common.h"
+#include "vb21_common.h"
 
 /* Test only the algorithms we use */
 struct alg_combo {
diff --git a/tests/vb21_misc_tests.c b/tests/vb21_misc_tests.c
index 8cc3bbbc..7eaf0546 100644
--- a/tests/vb21_misc_tests.c
+++ b/tests/vb21_misc_tests.c
@@ -23,6 +23,7 @@ static uint8_t workbuf[VB2_FIRMWARE_WORKBUF_RECOMMENDED_SIZE]
 	__attribute__ ((aligned (VB2_WORKBUF_ALIGN)));
 static struct vb2_context ctx;
 static struct vb2_shared_data *sd;
+static struct vb2_gbb_header gbb;
 
 /* Mocked function data */
 
@@ -70,6 +71,8 @@ static void reset_common_data(enum reset_type t)
 	ctx.workbuf = workbuf;
 	ctx.workbuf_size = sizeof(workbuf);
 
+	memset(&gbb, 0, sizeof(gbb));
+
 	vb2_init_context(&ctx);
 	sd = vb2_get_sd(&ctx);
 
@@ -87,8 +90,8 @@ static void reset_common_data(enum reset_type t)
 	sd->fw_version_secdata = 0x20002;
 	vb2_secdata_set(&ctx, VB2_SECDATA_VERSIONS, sd->fw_version_secdata);
 
-	sd->gbb_rootkey_offset = vb2_offset_of(&mock_gbb, &mock_gbb.rootkey);
-	sd->gbb_rootkey_size = sizeof(mock_gbb.rootkey_data);
+	gbb.rootkey_offset = vb2_offset_of(&mock_gbb, &mock_gbb.rootkey);
+	gbb.rootkey_size = sizeof(mock_gbb.rootkey_data);
 	sd->last_fw_result = VB2_FW_RESULT_SUCCESS;
 
 	mock_gbb.rootkey.sig_alg = VB2_SIG_RSA8192;
@@ -118,6 +121,10 @@ static void reset_common_data(enum reset_type t)
 };
 
 /* Mocked functions */
+struct vb2_gbb_header *vb2_get_gbb(struct vb2_context *c)
+{
+	return &gbb;
+}
 
 int vb2ex_read_resource(struct vb2_context *c,
 			enum vb2_resource_index index,
@@ -216,13 +223,13 @@ static void load_keyblock_tests(void)
 	/* Test failures */
 	reset_common_data(FOR_KEYBLOCK);
 	ctx.workbuf_used = ctx.workbuf_size + VB2_WORKBUF_ALIGN -
-			vb2_wb_round_up(sd->gbb_rootkey_size);
+			vb2_wb_round_up(gbb.rootkey_size);
 	TEST_EQ(vb21_load_fw_keyblock(&ctx),
 		VB2_ERROR_FW_KEYBLOCK_WORKBUF_ROOT_KEY,
 		"keyblock not enough workbuf for root key");
 
 	reset_common_data(FOR_KEYBLOCK);
-	sd->gbb_rootkey_size = sizeof(mock_gbb);
+	gbb.rootkey_size = sizeof(mock_gbb);
 	TEST_EQ(vb21_load_fw_keyblock(&ctx),
 		VB2_ERROR_EX_READ_RESOURCE_SIZE,
 		"keyblock read root key");
@@ -235,7 +242,7 @@ static void load_keyblock_tests(void)
 
 	reset_common_data(FOR_KEYBLOCK);
 	ctx.workbuf_used = ctx.workbuf_size -
-			vb2_wb_round_up(sd->gbb_rootkey_size);
+			vb2_wb_round_up(gbb.rootkey_size);
 	TEST_EQ(vb21_load_fw_keyblock(&ctx),
 		VB2_ERROR_READ_RESOURCE_OBJECT_BUF,
 		"keyblock not enough workbuf for header");
@@ -248,7 +255,7 @@ static void load_keyblock_tests(void)
 
 	reset_common_data(FOR_KEYBLOCK);
 	ctx.workbuf_used = ctx.workbuf_size -
-			vb2_wb_round_up(sd->gbb_rootkey_size) -
+			vb2_wb_round_up(gbb.rootkey_size) -
 			vb2_wb_round_up(sizeof(struct vb21_keyblock));
 	TEST_EQ(vb21_load_fw_keyblock(&ctx),
 		VB2_ERROR_READ_RESOURCE_OBJECT_BUF,
@@ -280,7 +287,7 @@ static void load_keyblock_tests(void)
 
 	reset_common_data(FOR_KEYBLOCK);
 	dk->key_version = 1;
-	sd->gbb_flags |= VB2_GBB_FLAG_DISABLE_FW_ROLLBACK_CHECK;
+	gbb.flags |= VB2_GBB_FLAG_DISABLE_FW_ROLLBACK_CHECK;
 	TEST_SUCC(vb21_load_fw_keyblock(&ctx), "keyblock rollback + GBB flag");
 }
 
@@ -364,7 +371,7 @@ static void load_preamble_tests(void)
 
 	reset_common_data(FOR_PREAMBLE);
 	pre->fw_version = 1;
-	sd->gbb_flags |= VB2_GBB_FLAG_DISABLE_FW_ROLLBACK_CHECK;
+	gbb.flags |= VB2_GBB_FLAG_DISABLE_FW_ROLLBACK_CHECK;
 	TEST_SUCC(vb21_load_fw_preamble(&ctx), "version rollback with GBB flag");
 
 	reset_common_data(FOR_PREAMBLE);
diff --git a/tests/vb2_api_tests.c b/tests/vb2_api_tests.c
index 97fc6d97..c261f963 100644
--- a/tests/vb2_api_tests.c
+++ b/tests/vb2_api_tests.c
@@ -7,13 +7,13 @@
 
 #include <stdio.h>
 
-#include "2sysincludes.h"
 #include "2api.h"
 #include "2common.h"
 #include "2misc.h"
 #include "2nvstorage.h"
 #include "2rsa.h"
 #include "2secdata.h"
+#include "2sysincludes.h"
 #include "test_common.h"
 
 /* Common context for tests */
@@ -21,6 +21,7 @@ static uint8_t workbuf[VB2_FIRMWARE_WORKBUF_RECOMMENDED_SIZE]
 	__attribute__ ((aligned (VB2_WORKBUF_ALIGN)));
 static struct vb2_context ctx;
 static struct vb2_shared_data *sd;
+static struct vb2_gbb_header gbb;
 
 const char mock_body[320] = "Mock body";
 const int mock_body_size = sizeof(mock_body);
@@ -67,11 +68,15 @@ static void reset_common_data(enum reset_type t)
 	retval_vb2_check_tpm_clear = VB2_SUCCESS;
 	retval_vb2_select_fw_slot = VB2_SUCCESS;
 
-	memcpy(sd->gbb_hwid_digest, mock_hwid_digest,
-	       sizeof(sd->gbb_hwid_digest));
+	memcpy(&gbb.hwid_digest, mock_hwid_digest,
+	       sizeof(gbb.hwid_digest));
 };
 
 /* Mocked functions */
+struct vb2_gbb_header *vb2_get_gbb(struct vb2_context *c)
+{
+	return &gbb;
+}
 
 int vb2_fw_parse_gbb(struct vb2_context *c)
 {
diff --git a/tests/vb2_misc_tests.c b/tests/vb2_misc_tests.c
index 0f3f0c58..d36dd44f 100644
--- a/tests/vb2_misc_tests.c
+++ b/tests/vb2_misc_tests.c
@@ -19,6 +19,7 @@ static uint8_t workbuf[VB2_FIRMWARE_WORKBUF_RECOMMENDED_SIZE]
 	__attribute__ ((aligned (VB2_WORKBUF_ALIGN)));
 static struct vb2_context ctx;
 static struct vb2_shared_data *sd;
+static struct vb2_gbb_header gbb;
 
 /* Mocked function data */
 enum vb2_resource_index mock_resource_index;
@@ -39,6 +40,8 @@ static void reset_common_data(void)
 	vb2_init_context(&ctx);
 	sd = vb2_get_sd(&ctx);
 
+	memset(&gbb, 0, sizeof(gbb));
+
 	vb2_nv_init(&ctx);
 
 	vb2_secdata_create(&ctx);
@@ -74,6 +77,10 @@ int vb2ex_tpm_clear_owner(struct vb2_context *c)
 }
 
 /* Tests */
+struct vb2_gbb_header *vb2_get_gbb(struct vb2_context *c)
+{
+	return &gbb;
+}
 
 static void init_context_tests(void)
 {
@@ -160,7 +167,7 @@ static void misc_tests(void)
 
 static void gbb_tests(void)
 {
-	struct vb2_gbb_header gbb = {
+	struct vb2_gbb_header gbbsrc = {
 		.signature = {'$', 'G', 'B', 'B'},
 		.major_version = VB2_GBB_MAJOR_VER,
 		.minor_version = VB2_GBB_MINOR_VER,
@@ -180,49 +187,56 @@ static void gbb_tests(void)
 
 	/* Good contents */
 	mock_resource_index = VB2_RES_GBB;
-	mock_resource_ptr = &gbb;
-	mock_resource_size = sizeof(gbb);
+	mock_resource_ptr = &gbbsrc;
+	mock_resource_size = sizeof(gbbsrc);
 	TEST_SUCC(vb2_read_gbb_header(&ctx, &gbbdest), "read gbb header good");
-	TEST_SUCC(memcmp(&gbb, &gbbdest, sizeof(gbb)), "read gbb contents");
+	TEST_SUCC(memcmp(&gbbsrc, &gbbdest, sizeof(gbbsrc)),
+		  "read gbb contents");
 
 	mock_resource_index = VB2_RES_GBB + 1;
 	TEST_EQ(vb2_read_gbb_header(&ctx, &gbbdest),
 		VB2_ERROR_EX_READ_RESOURCE_INDEX, "read gbb header missing");
 	mock_resource_index = VB2_RES_GBB;
 
-	gbb.signature[0]++;
+	gbbsrc.signature[0]++;
 	TEST_EQ(vb2_read_gbb_header(&ctx, &gbbdest),
 		VB2_ERROR_GBB_MAGIC, "read gbb header bad magic");
-	gbb.signature[0]--;
+	gbbsrc.signature[0]--;
 
-	gbb.major_version = VB2_GBB_MAJOR_VER + 1;
+	gbbsrc.major_version = VB2_GBB_MAJOR_VER + 1;
 	TEST_EQ(vb2_read_gbb_header(&ctx, &gbbdest),
 		VB2_ERROR_GBB_VERSION, "read gbb header major version");
-	gbb.major_version = VB2_GBB_MAJOR_VER;
+	gbbsrc.major_version = VB2_GBB_MAJOR_VER;
 
-	gbb.minor_version = VB2_GBB_MINOR_VER + 1;
+	gbbsrc.minor_version = VB2_GBB_MINOR_VER + 1;
 	TEST_SUCC(vb2_read_gbb_header(&ctx, &gbbdest),
 		  "read gbb header minor++");
-	gbb.minor_version = 1;
+	gbbsrc.minor_version = 1;
 	TEST_EQ(vb2_read_gbb_header(&ctx, &gbbdest),
 		VB2_ERROR_GBB_TOO_OLD, "read gbb header 1.1 fails");
-	gbb.minor_version = 0;
+	gbbsrc.minor_version = 0;
 	TEST_EQ(vb2_read_gbb_header(&ctx, &gbbdest),
 		VB2_ERROR_GBB_TOO_OLD, "read gbb header 1.0 fails");
-	gbb.minor_version = VB2_GBB_MINOR_VER;
+	gbbsrc.minor_version = VB2_GBB_MINOR_VER;
 
-	gbb.header_size--;
+	gbbsrc.header_size--;
 	TEST_EQ(vb2_read_gbb_header(&ctx, &gbbdest),
 		VB2_ERROR_GBB_HEADER_SIZE, "read gbb header size");
 	TEST_EQ(vb2_fw_parse_gbb(&ctx),
 		VB2_ERROR_GBB_HEADER_SIZE, "parse gbb failure");
-	gbb.header_size++;
+	gbbsrc.header_size++;
 
 	/* Parse GBB */
+	int used_before = ctx.workbuf_used;
 	TEST_SUCC(vb2_fw_parse_gbb(&ctx), "parse gbb");
-	TEST_EQ(sd->gbb_flags, gbb.flags, "gbb flags");
-	TEST_EQ(sd->gbb_rootkey_offset, gbb.rootkey_offset, "rootkey offset");
-	TEST_EQ(sd->gbb_rootkey_size, gbb.rootkey_size, "rootkey size");
+	/* Manually calculate the location of GBB since we have mocked out the
+	   original definition of vb2_get_gbb. */
+	struct vb2_gbb_header *current_gbb =
+		(struct vb2_gbb_header *)((void *)sd + sd->gbb_offset);
+	TEST_SUCC(memcmp(&gbbsrc, current_gbb, sizeof(gbbsrc)),
+		  "copy gbb contents");
+	TEST_EQ(used_before, ctx.workbuf_used - sizeof(gbbsrc),
+		"unexpected workbuf size");
 
 	/* Workbuf failure */
 	reset_common_data();
@@ -407,7 +421,7 @@ static void dev_switch_tests(void)
 
 	/* Force enabled by GBB */
 	reset_common_data();
-	sd->gbb_flags |= VB2_GBB_FLAG_FORCE_DEV_SWITCH_ON;
+	gbb.flags |= VB2_GBB_FLAG_FORCE_DEV_SWITCH_ON;
 	TEST_SUCC(vb2_check_dev_switch(&ctx), "dev on via gbb");
 	TEST_NEQ(sd->flags & VB2_SD_FLAG_DEV_MODE_ENABLED, 0, "  sd in dev");
 	vb2_secdata_get(&ctx, VB2_SECDATA_FLAGS, &v);
@@ -475,7 +489,7 @@ static void dev_switch_tests(void)
 	reset_common_data();
 	ctx.flags |= VB2_CONTEXT_RECOVERY_MODE;
 	sd->status &= ~VB2_SD_STATUS_SECDATA_INIT;
-	sd->gbb_flags |= VB2_GBB_FLAG_FORCE_DEV_SWITCH_ON;
+	gbb.flags |= VB2_GBB_FLAG_FORCE_DEV_SWITCH_ON;
 	TEST_SUCC(vb2_check_dev_switch(&ctx), "secdata fail recovery gbb");
 	TEST_NEQ(sd->flags & VB2_SD_FLAG_DEV_MODE_ENABLED, 0, "  sd in dev");
 	TEST_NEQ(ctx.flags & VB2_CONTEXT_DEVELOPER_MODE, 0, "  ctx in dev");
diff --git a/tests/vboot_api_devmode_tests.c b/tests/vboot_api_devmode_tests.c
index ccd4c617..53373bda 100644
--- a/tests/vboot_api_devmode_tests.c
+++ b/tests/vboot_api_devmode_tests.c
@@ -95,6 +95,7 @@ test_case_t test[] = {
 static uint8_t workbuf[VB2_KERNEL_WORKBUF_RECOMMENDED_SIZE];
 static struct vb2_context ctx;
 static struct vb2_shared_data *sd;
+static struct vb2_gbb_header gbb;
 static uint8_t shared_data[VB_SHARED_DATA_MIN_SIZE];
 static VbSharedDataHeader* shared = (VbSharedDataHeader*)shared_data;
 static int current_time;
@@ -122,6 +123,8 @@ static void ResetMocks(void)
 	sd = vb2_get_sd(&ctx);
 	sd->vbsd = shared;
 
+	memset(&gbb, 0, sizeof(gbb));
+
 	memset(&shared_data, 0, sizeof(shared_data));
 	VbSharedDataInit(shared, sizeof(shared_data));
 	shared->fw_keyblock_flags = 0xABCDE0;
@@ -142,6 +145,10 @@ static void ResetMocks(void)
 
 /****************************************************************************/
 /* Mocked verification functions */
+struct vb2_gbb_header *vb2_get_gbb(struct vb2_context *c)
+{
+	return &gbb;
+}
 
 VbError_t VbExNvStorageRead(uint8_t* buf)
 {
@@ -271,7 +278,7 @@ static void VbBootDeveloperSoundTest(void)
 	for (i=0; i<num_tests; i++) {
 		VB2_DEBUG("STARTING %s ...\n", test[i].name);
 		ResetMocks();
-		sd->gbb_flags = test[i].gbb_flags;
+		gbb.flags = test[i].gbb_flags;
 		beep_return = test[i].beep_return;
 		kbd_fire_key = test[i].keypress_key;
 		kbd_fire_at = test[i].keypress_at_count;
diff --git a/tests/vboot_api_kernel2_tests.c b/tests/vboot_api_kernel2_tests.c
index 3203bf05..fcace7a1 100644
--- a/tests/vboot_api_kernel2_tests.c
+++ b/tests/vboot_api_kernel2_tests.c
@@ -9,8 +9,7 @@
 #include <stdio.h>
 #include <stdlib.h>
 
-#include "2sysincludes.h"
-#include "2api.h"
+#include "2common.h"
 #include "2misc.h"
 #include "2nvstorage.h"
 #include "host_common.h"
@@ -31,6 +30,7 @@ static LoadKernelParams lkp;
 static uint8_t workbuf[VB2_KERNEL_WORKBUF_RECOMMENDED_SIZE];
 static struct vb2_context ctx;
 static struct vb2_shared_data *sd;
+static struct vb2_gbb_header gbb;
 
 static int audio_looping_calls_left;
 static uint32_t vbtlk_retval;
@@ -99,6 +99,8 @@ static void ResetMocks(void)
 	sd->vbsd = shared;
 	sd->flags |= VB2_SD_FLAG_DISPLAY_AVAILABLE;
 
+	memset(&gbb, 0, sizeof(gbb));
+
 	audio_looping_calls_left = 30;
 	vbtlk_retval = 1000;
 	vbexlegacy_called = 0;
@@ -125,6 +127,10 @@ static void ResetMocks(void)
 }
 
 /* Mock functions */
+struct vb2_gbb_header *vb2_get_gbb(struct vb2_context *c)
+{
+	return &gbb;
+}
 
 uint32_t VbExIsShutdownRequested(void)
 {
@@ -481,7 +487,7 @@ static void VbBootDevTest(void)
 
 	/* Proceed to legacy after timeout if GBB flag set */
 	ResetMocks();
-	sd->gbb_flags |= VB2_GBB_FLAG_DEFAULT_DEV_BOOT_LEGACY |
+	gbb.flags |= VB2_GBB_FLAG_DEFAULT_DEV_BOOT_LEGACY |
 			VB2_GBB_FLAG_FORCE_DEV_BOOT_LEGACY;
 	TEST_EQ(VbBootDeveloper(&ctx), 1002, "Timeout");
 	TEST_EQ(vbexlegacy_called, 1, "  try legacy");
@@ -489,7 +495,7 @@ static void VbBootDevTest(void)
 
 	/* Proceed to legacy after timeout if GBB flag set */
 	ResetMocks();
-	sd->gbb_flags |= VB2_GBB_FLAG_DEFAULT_DEV_BOOT_LEGACY |
+	gbb.flags |= VB2_GBB_FLAG_DEFAULT_DEV_BOOT_LEGACY |
 			VB2_GBB_FLAG_FORCE_DEV_BOOT_LEGACY;
 	TEST_EQ(VbBootDeveloper(&ctx), 1002, "Timeout");
 	TEST_EQ(vbexlegacy_called, 1, "  try legacy");
@@ -606,7 +612,7 @@ static void VbBootDevTest(void)
 	/* Enter does if GBB flag set */
 	ResetMocks();
 	shared->flags = VBSD_BOOT_DEV_SWITCH_ON;
-	sd->gbb_flags |= VB2_GBB_FLAG_ENTER_TRIGGERS_TONORM;
+	gbb.flags |= VB2_GBB_FLAG_ENTER_TRIGGERS_TONORM;
 	mock_keypress[0] = VB_KEY_ENTER;
 	mock_keypress[1] = VB_KEY_ENTER;
 	TEST_EQ(VbBootDeveloper(&ctx), VBERROR_REBOOT_REQUIRED,
@@ -615,7 +621,7 @@ static void VbBootDevTest(void)
 	/* Tonorm ignored if GBB forces dev switch on */
 	ResetMocks();
 	shared->flags = VBSD_BOOT_DEV_SWITCH_ON;
-	sd->gbb_flags |= VB2_GBB_FLAG_FORCE_DEV_SWITCH_ON;
+	gbb.flags |= VB2_GBB_FLAG_FORCE_DEV_SWITCH_ON;
 	mock_keypress[0] = ' ';
 	mock_keypress[1] = VB_KEY_ENTER;
 	TEST_EQ(VbBootDeveloper(&ctx), 1002,
@@ -654,7 +660,7 @@ static void VbBootDevTest(void)
 	/* Ctrl+D doesn't boot legacy even if GBB flag is set */
 	ResetMocks();
 	mock_keypress[0] = VB_KEY_CTRL('D');
-	sd->gbb_flags |= VB2_GBB_FLAG_DEFAULT_DEV_BOOT_LEGACY;
+	gbb.flags |= VB2_GBB_FLAG_DEFAULT_DEV_BOOT_LEGACY;
 	TEST_EQ(VbBootDeveloper(&ctx), 1002, "Ctrl+D");
 	TEST_EQ(vbexlegacy_called, 0, "  not legacy");
 
@@ -667,7 +673,7 @@ static void VbBootDevTest(void)
 	/* Enter altfw menu and time out */
 	ResetMocks();
 	MockGpioAfter(1000, GPIO_SHUTDOWN);
-	sd->gbb_flags |= VB2_GBB_FLAG_FORCE_DEV_BOOT_LEGACY;
+	gbb.flags |= VB2_GBB_FLAG_FORCE_DEV_BOOT_LEGACY;
 	mock_keypress[0] = VB_KEY_CTRL('L');
 	TEST_EQ(VbBootDeveloper(&ctx), VBERROR_SHUTDOWN_REQUESTED,
 		"Ctrl+L force legacy");
@@ -675,7 +681,7 @@ static void VbBootDevTest(void)
 
 	/* Enter altfw menu and select firmware 0 */
 	ResetMocks();
-	sd->gbb_flags |= VB2_GBB_FLAG_FORCE_DEV_BOOT_LEGACY;
+	gbb.flags |= VB2_GBB_FLAG_FORCE_DEV_BOOT_LEGACY;
 	mock_keypress[0] = VB_KEY_CTRL('L');
 	mock_keypress[1] = '0';
 	TEST_EQ(VbBootDeveloper(&ctx), 1002,
@@ -720,7 +726,7 @@ static void VbBootDevTest(void)
 		TEST_EQ(vbexlegacy_called, 0, "  not legacy");
 
 		ResetMocks();
-		sd->gbb_flags |= VB2_GBB_FLAG_FORCE_DEV_BOOT_LEGACY;
+		gbb.flags |= VB2_GBB_FLAG_FORCE_DEV_BOOT_LEGACY;
 		mock_keypress[0] = key;
 		TEST_EQ(VbBootDeveloper(&ctx), 1002,
 			"Ctrl+L force legacy");
@@ -758,7 +764,7 @@ static void VbBootDevTest(void)
 
 	/* Ctrl+U enabled via GBB */
 	ResetMocks();
-	sd->gbb_flags |= VB2_GBB_FLAG_FORCE_DEV_BOOT_USB;
+	gbb.flags |= VB2_GBB_FLAG_FORCE_DEV_BOOT_USB;
 	mock_keypress[0] = VB_KEY_CTRL('U');
 	vbtlk_retval = VBERROR_SUCCESS - VB_DISK_FLAG_REMOVABLE;
 	TEST_EQ(VbBootDeveloper(&ctx), 0, "Ctrl+U force USB");
@@ -1118,7 +1124,7 @@ static void VbBootRecTest(void)
 	/* Force insert screen with GBB flag */
 	ResetMocks();
 	MockGpioAfter(100, GPIO_SHUTDOWN);
-	sd->gbb_flags |= VB2_GBB_FLAG_FORCE_MANUAL_RECOVERY;
+	gbb.flags |= VB2_GBB_FLAG_FORCE_MANUAL_RECOVERY;
 	vbtlk_retval = VBERROR_NO_DISK_FOUND - VB_DISK_FLAG_REMOVABLE;
 	TEST_EQ(VbBootRecovery(&ctx),
 		VBERROR_SHUTDOWN_REQUESTED,
diff --git a/tests/vboot_api_kernel4_tests.c b/tests/vboot_api_kernel4_tests.c
index a4bc6bec..9ac71de4 100644
--- a/tests/vboot_api_kernel4_tests.c
+++ b/tests/vboot_api_kernel4_tests.c
@@ -50,8 +50,6 @@ static void ResetMocks(void)
 	memset(&cparams, 0, sizeof(cparams));
 	cparams.shared_data_size = sizeof(shared_data);
 	cparams.shared_data_blob = shared_data;
-	cparams.gbb_data = &gbb;
-	cparams.gbb_size = sizeof(gbb);
 
 	memset(&kparams, 0, sizeof(kparams));
 
diff --git a/tests/vboot_api_kernel5_tests.c b/tests/vboot_api_kernel5_tests.c
index a0f89466..8fd432e3 100644
--- a/tests/vboot_api_kernel5_tests.c
+++ b/tests/vboot_api_kernel5_tests.c
@@ -34,8 +34,7 @@ static VbCommonParams cparams;
 static VbSelectAndLoadKernelParams kparams;
 static uint8_t shared_data[VB_SHARED_DATA_MIN_SIZE];
 static VbSharedDataHeader *shared = (VbSharedDataHeader *)shared_data;
-static uint8_t gbb_buf[4096];
-static struct vb2_gbb_header *gbb = (struct vb2_gbb_header *)gbb_buf;
+static struct vb2_gbb_header gbb;
 
 static uint8_t kernel_buffer[80000];
 static int key_block_verify_fail;  /* 0=ok, 1=sig, 2=hash */
@@ -56,17 +55,15 @@ static void ResetMocks(void)
 	memset(&cparams, 0, sizeof(cparams));
 	cparams.shared_data_size = sizeof(shared_data);
 	cparams.shared_data_blob = shared_data;
-	cparams.gbb_data = gbb_buf;
-	cparams.gbb_size = sizeof(gbb_buf);
 
 	memset(&kparams, 0, sizeof(kparams));
 
-	memset(gbb_buf, 0, sizeof(gbb_buf));
-	gbb->major_version = VB2_GBB_MAJOR_VER;
-	gbb->minor_version = VB2_GBB_MINOR_VER;
-	gbb->flags = 0;
-	gbb->rootkey_offset = sizeof(*gbb);
-	gbb->rootkey_size = sizeof(VbPublicKey);
+	memset(&gbb, 0, sizeof(gbb));
+	gbb.major_version = VB2_GBB_MAJOR_VER;
+	gbb.minor_version = VB2_GBB_MINOR_VER;
+	gbb.flags = 0;
+	gbb.rootkey_offset = sizeof(gbb);
+	gbb.rootkey_size = sizeof(VbPublicKey);
 
 	/* ctx.workbuf will be initialized by VbVerifyMemoryBootImage. */
 	memset(&ctx, 0, sizeof(ctx));
@@ -114,6 +111,21 @@ static void copy_kbh(void)
 }
 
 /* Mocks */
+struct vb2_gbb_header *vb2_get_gbb(struct vb2_context *c)
+{
+	return &gbb;
+}
+
+int vb2ex_read_resource(struct vb2_context *c,
+			enum vb2_resource_index index,
+			uint32_t offset,
+			void *buf,
+			uint32_t size)
+{
+	memset(buf, 0, size);
+	return VB2_SUCCESS;
+}
+
 int vb2_unpack_key_buffer(struct vb2_public_key *key,
 		   const uint8_t *buf,
 		   uint32_t size)
@@ -234,7 +246,7 @@ static void VerifyMemoryBootImageTest(void)
 	/* Key Block Hash Failure */
 	ResetMocks();
 	shared->flags = VBSD_BOOT_DEV_SWITCH_ON;
-	gbb->flags = VB2_GBB_FLAG_FORCE_DEV_BOOT_FASTBOOT_FULL_CAP;
+	gbb.flags = VB2_GBB_FLAG_FORCE_DEV_BOOT_FASTBOOT_FULL_CAP;
 	key_block_verify_fail = 1;
 	TEST_EQ(VbVerifyMemoryBootImage(&ctx, &cparams, &kparams, kernel_buffer,
 					kernel_buffer_size),
@@ -267,7 +279,7 @@ static void VerifyMemoryBootImageTest(void)
 	kbh.key_block_flags = KEY_BLOCK_FLAG_DEVELOPER_0 |
 		KEY_BLOCK_FLAG_RECOVERY_1;
 	copy_kbh();
-	gbb->flags = VB2_GBB_FLAG_FORCE_DEV_BOOT_FASTBOOT_FULL_CAP;
+	gbb.flags = VB2_GBB_FLAG_FORCE_DEV_BOOT_FASTBOOT_FULL_CAP;
 	shared->flags = VBSD_BOOT_DEV_SWITCH_ON;
 	TEST_EQ(VbVerifyMemoryBootImage(&ctx, &cparams, &kparams, kernel_buffer,
 					kernel_buffer_size),
@@ -280,7 +292,7 @@ static void VerifyMemoryBootImageTest(void)
 		KEY_BLOCK_FLAG_RECOVERY_0;
 	copy_kbh();
 	shared->flags = VBSD_BOOT_DEV_SWITCH_ON;
-	gbb->flags = VB2_GBB_FLAG_FORCE_DEV_BOOT_FASTBOOT_FULL_CAP;
+	gbb.flags = VB2_GBB_FLAG_FORCE_DEV_BOOT_FASTBOOT_FULL_CAP;
 	TEST_EQ(VbVerifyMemoryBootImage(&ctx, &cparams, &kparams, kernel_buffer,
 					kernel_buffer_size),
 		VBERROR_SUCCESS,
diff --git a/tests/vboot_detach_menu_tests.c b/tests/vboot_detach_menu_tests.c
index 05785848..6949bedb 100644
--- a/tests/vboot_detach_menu_tests.c
+++ b/tests/vboot_detach_menu_tests.c
@@ -9,8 +9,7 @@
 #include <stdio.h>
 #include <stdlib.h>
 
-#include "2sysincludes.h"
-#include "2api.h"
+#include "2common.h"
 #include "2misc.h"
 #include "2nvstorage.h"
 #include "host_common.h"
@@ -33,6 +32,7 @@ static LoadKernelParams lkp;
 static uint8_t workbuf[VB2_KERNEL_WORKBUF_RECOMMENDED_SIZE];
 static struct vb2_context ctx;
 static struct vb2_shared_data *sd;
+static struct vb2_gbb_header gbb;
 
 static int shutdown_request_calls_left;
 static int audio_looping_calls_left;
@@ -79,6 +79,8 @@ static void ResetMocks(void)
 	sd = vb2_get_sd(&ctx);
 	sd->vbsd = shared;
 
+	memset(&gbb, 0, sizeof(gbb));
+
 	/* In recovery we have 50 keyscans per disk scan, this must be high. */
 	shutdown_request_calls_left = 301;
 	audio_looping_calls_left = 60;
@@ -127,6 +129,10 @@ static void ResetMocksForManualRecovery(void)
 }
 
 /* Mock functions */
+struct vb2_gbb_header *vb2_get_gbb(struct vb2_context *c)
+{
+	return &gbb;
+}
 
 uint32_t VbExGetAltFwIdxMask() {
 
@@ -279,8 +285,8 @@ static void VbBootDevTest(void)
 
 	/* Proceed to legacy after timeout if GBB flag set */
 	ResetMocksForDeveloper();
-	sd->gbb_flags |= VB2_GBB_FLAG_DEFAULT_DEV_BOOT_LEGACY |
-			 VB2_GBB_FLAG_FORCE_DEV_BOOT_LEGACY;
+	gbb.flags |= VB2_GBB_FLAG_DEFAULT_DEV_BOOT_LEGACY |
+		     VB2_GBB_FLAG_FORCE_DEV_BOOT_LEGACY;
 	TEST_EQ(VbBootDeveloperMenu(&ctx), vbtlk_retval_fixed,
 		"default legacy GBB");
 	TEST_EQ(vbexlegacy_called, 1, "  try legacy");
@@ -465,7 +471,7 @@ static void VbBootDevTest(void)
 
 	/* ENTER functionality is unaffected by GBB flag in detachable UI. */
 	ResetMocksForDeveloper();
-	sd->gbb_flags |= VB2_GBB_FLAG_ENTER_TRIGGERS_TONORM;
+	gbb.flags |= VB2_GBB_FLAG_ENTER_TRIGGERS_TONORM;
 	mock_keypress[0] = VB_KEY_ENTER;
 	TEST_EQ(VbBootDeveloperMenu(&ctx), VBERROR_SHUTDOWN_REQUESTED,
 		"dev warning menu: ENTER unaffected by GBB");
@@ -520,7 +526,7 @@ static void VbBootDevTest(void)
 	/* Tonorm ignored if GBB forces dev switch on */
 	ResetMocksForDeveloper();
 	shared->flags |= VBSD_BOOT_DEV_SWITCH_ON;
-	sd->gbb_flags |= VB2_GBB_FLAG_FORCE_DEV_SWITCH_ON;
+	gbb.flags |= VB2_GBB_FLAG_FORCE_DEV_SWITCH_ON;
 	mock_keypress[0] = VB_BUTTON_VOL_UP_SHORT_PRESS;
 	mock_keypress[1] = VB_BUTTON_POWER_SHORT_PRESS;
 	mock_keypress[2] = VB_BUTTON_POWER_SHORT_PRESS;
@@ -581,7 +587,7 @@ static void VbBootDevTest(void)
 	/* Ctrl+D doesn't boot legacy even if GBB flag is set */
 	ResetMocksForDeveloper();
 	mock_keypress[0] = VB_KEY_CTRL('D');
-	sd->gbb_flags |= VB2_GBB_FLAG_DEFAULT_DEV_BOOT_LEGACY;
+	gbb.flags |= VB2_GBB_FLAG_DEFAULT_DEV_BOOT_LEGACY;
 	TEST_EQ(VbBootDeveloperMenu(&ctx), vbtlk_retval_fixed, "Ctrl+D");
 	TEST_EQ(vbexlegacy_called, 0, "  not legacy");
 
@@ -621,7 +627,7 @@ static void VbBootDevTest(void)
 
 	/* Ctrl+L boots legacy if enabled by GBB flag */
 	ResetMocksForDeveloper();
-	sd->gbb_flags |= VB2_GBB_FLAG_FORCE_DEV_BOOT_LEGACY;
+	gbb.flags |= VB2_GBB_FLAG_FORCE_DEV_BOOT_LEGACY;
 	mock_keypress[0] = VB_KEY_CTRL('L');
 	mock_keypress[1] = VB_BUTTON_POWER_SHORT_PRESS;
 	TEST_EQ(VbBootDeveloperMenu(&ctx), vbtlk_retval_fixed,
@@ -736,7 +742,7 @@ static void VbBootDevTest(void)
 
 	/* Ctrl+U enabled via GBB */
 	ResetMocksForDeveloper();
-	sd->gbb_flags |= VB2_GBB_FLAG_FORCE_DEV_BOOT_USB;
+	gbb.flags |= VB2_GBB_FLAG_FORCE_DEV_BOOT_USB;
 	mock_keypress[0] = VB_KEY_CTRL('U');
 	vbtlk_retval[0] = VBERROR_SUCCESS - VB_DISK_FLAG_REMOVABLE;
 	TEST_EQ(VbBootDeveloperMenu(&ctx), VBERROR_SUCCESS, "Ctrl+U force USB");
@@ -1360,7 +1366,7 @@ static void VbBootRecTest(void)
 	/* go to INSERT if forced by GBB flag */
 	ResetMocks();
 	vbtlk_retval[0] = VBERROR_NO_DISK_FOUND - VB_DISK_FLAG_REMOVABLE;
-	sd->gbb_flags |= VB2_GBB_FLAG_FORCE_MANUAL_RECOVERY;
+	gbb.flags |= VB2_GBB_FLAG_FORCE_MANUAL_RECOVERY;
 	TEST_EQ(VbBootRecoveryMenu(&ctx), VBERROR_SHUTDOWN_REQUESTED,
 		"Shutdown requested in INSERT forced by GBB flag");
 	TEST_EQ(vb2_nv_get(&ctx, VB2_NV_RECOVERY_REQUEST), 0, "  no recovery");
diff --git a/tests/vboot_display_tests.c b/tests/vboot_display_tests.c
index 16ccd36e..3d65825e 100644
--- a/tests/vboot_display_tests.c
+++ b/tests/vboot_display_tests.c
@@ -69,8 +69,6 @@ static void ResetMocks(void)
 
 	sd = vb2_get_sd(&ctx);
 	sd->vbsd = shared;
-	sd->gbb = (struct vb2_gbb_header *)gbb_data;
-	sd->gbb_size = sizeof(gbb_data);
 
 	memset(&shared_data, 0, sizeof(shared_data));
 	VbSharedDataInit(shared, sizeof(shared_data));
@@ -79,6 +77,35 @@ static void ResetMocks(void)
 }
 
 /* Mocks */
+struct vb2_gbb_header *vb2_get_gbb(struct vb2_context *c)
+{
+	return gbb;
+}
+
+int vb2ex_read_resource(struct vb2_context *c,
+			enum vb2_resource_index index,
+			uint32_t offset,
+			void *buf,
+			uint32_t size)
+{
+	uint8_t *rptr;
+	uint32_t rsize;
+
+	switch(index) {
+	case VB2_RES_GBB:
+		rptr = (uint8_t *)&gbb_data;
+		rsize = sizeof(gbb_data);
+		break;
+	default:
+		return VB2_ERROR_EX_READ_RESOURCE_INDEX;
+	}
+
+	if (offset > rsize || offset + size > rsize)
+		return VB2_ERROR_EX_READ_RESOURCE_SIZE;
+
+	memcpy(buf, rptr + offset, size);
+	return VB2_SUCCESS;
+}
 
 VbError_t VbExGetLocalizationCount(uint32_t *count) {
 
@@ -116,22 +143,17 @@ static void DebugInfoTest(void)
 	TEST_EQ(strcmp(hwid, "Test HWID"), 0, "HWID");
 
 	ResetMocks();
-	sd->gbb_size = 0;
-	VbGbbReadHWID(&ctx, hwid, sizeof(hwid));
-	TEST_EQ(strcmp(hwid, "{INVALID}"), 0, "HWID bad gbb");
-
-	ResetMocks();
-	sd->gbb->hwid_size = 0;
+	gbb->hwid_size = 0;
 	VbGbbReadHWID(&ctx, hwid, sizeof(hwid));
 	TEST_EQ(strcmp(hwid, "{INVALID}"), 0, "HWID missing");
 
 	ResetMocks();
-	sd->gbb->hwid_offset = sd->gbb_size + 1;
+	gbb->hwid_offset = sizeof(gbb_data) + 1;
 	VbGbbReadHWID(&ctx, hwid, sizeof(hwid));
 	TEST_EQ(strcmp(hwid, "{INVALID}"), 0, "HWID past end");
 
 	ResetMocks();
-	sd->gbb->hwid_size = sd->gbb_size;
+	gbb->hwid_size = sizeof(gbb_data);
 	VbGbbReadHWID(&ctx, hwid, sizeof(hwid));
 	TEST_EQ(strcmp(hwid, "{INVALID}"), 0, "HWID overflow");
 
diff --git a/tests/vboot_kernel_tests.c b/tests/vboot_kernel_tests.c
index 4fd78a82..1711ceed 100644
--- a/tests/vboot_kernel_tests.c
+++ b/tests/vboot_kernel_tests.c
@@ -59,8 +59,7 @@ static int verify_data_fail;
 static int unpack_key_fail;
 static int gpt_flag_external;
 
-static uint8_t gbb_data[sizeof(struct vb2_gbb_header) + 2048];
-static struct vb2_gbb_header *gbb = (struct vb2_gbb_header*)gbb_data;
+static struct vb2_gbb_header gbb;
 static VbExDiskHandle_t handle;
 static uint8_t shared_data[VB_SHARED_DATA_MIN_SIZE];
 static VbSharedDataHeader *shared = (VbSharedDataHeader *)shared_data;
@@ -137,10 +136,10 @@ static void ResetMocks(void)
 
 	gpt_flag_external = 0;
 
-	memset(gbb, 0, sizeof(*gbb));
-	gbb->major_version = VB2_GBB_MAJOR_VER;
-	gbb->minor_version = VB2_GBB_MINOR_VER;
-	gbb->flags = 0;
+	memset(&gbb, 0, sizeof(gbb));
+	gbb.major_version = VB2_GBB_MAJOR_VER;
+	gbb.minor_version = VB2_GBB_MINOR_VER;
+	gbb.flags = 0;
 
 	memset(&shared_data, 0, sizeof(shared_data));
 	VbSharedDataInit(shared, sizeof(shared_data));
@@ -181,13 +180,25 @@ static void ResetMocks(void)
 
 	struct vb2_shared_data *sd = vb2_get_sd(&ctx);
 	sd->vbsd = shared;
-	sd->gbb = (struct vb2_gbb_header *)gbb_data;
-	sd->gbb_size = sizeof(gbb_data);
 
 	// TODO: more workbuf fields - flags, secdata, secdatak
 }
 
 /* Mocks */
+struct vb2_gbb_header *vb2_get_gbb(struct vb2_context *c)
+{
+	return &gbb;
+}
+
+int vb2ex_read_resource(struct vb2_context *c,
+			enum vb2_resource_index index,
+			uint32_t offset,
+			void *buf,
+			uint32_t size)
+{
+	memset(buf, 0, size);
+	return VB2_SUCCESS;
+}
 
 VbError_t VbExDiskRead(VbExDiskHandle_t h, uint64_t lba_start,
 		       uint64_t lba_count, void *buffer)