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>

29 files changed, 291 insertions, 186 deletions

diff --git a/firmware/2lib/2api.c b/firmware/2lib/2api.c
index f10a1e69..008282b6 100644
--- a/firmware/2lib/2api.c
+++ b/firmware/2lib/2api.c
@@ -205,7 +205,7 @@ int vb2api_get_pcr_digest(struct vb2_context *ctx,
 		digest_size = VB2_SHA1_DIGEST_SIZE;
 		break;
 	case HWID_DIGEST_PCR:
-		digest = vb2_get_sd(ctx)->gbb_hwid_digest;
+		digest = vb2_get_gbb(ctx)->hwid_digest;
 		digest_size = VB2_GBB_HWID_DIGEST_SIZE;
 		break;
 	default:
diff --git a/firmware/2lib/2misc.c b/firmware/2lib/2misc.c
index 8b6a19f8..03e0353a 100644
--- a/firmware/2lib/2misc.c
+++ b/firmware/2lib/2misc.c
@@ -14,7 +14,8 @@
 #include "2sha.h"
 #include "2rsa.h"
 
-int vb2_validate_gbb_signature(uint8_t *sig) {
+int vb2_validate_gbb_signature(uint8_t *sig)
+{
 	const static uint8_t sig_xor[VB2_GBB_SIGNATURE_SIZE] =
 			VB2_GBB_XOR_SIGNATURE;
 	int i;
@@ -25,6 +26,13 @@ int vb2_validate_gbb_signature(uint8_t *sig) {
 	return VB2_SUCCESS;
 }
 
+test_mockable
+struct vb2_gbb_header *vb2_get_gbb(struct vb2_context *ctx)
+{
+	return (struct vb2_gbb_header *)
+	       ((void *)vb2_get_sd(ctx) + vb2_get_sd(ctx)->gbb_offset);
+}
+
 void vb2_workbuf_from_ctx(struct vb2_context *ctx, struct vb2_workbuf *wb)
 {
 	vb2_workbuf_init(wb, ctx->workbuf + ctx->workbuf_used,
@@ -218,11 +226,9 @@ int vb2_fw_parse_gbb(struct vb2_context *ctx)
 	if (rv)
 		return rv;
 
-	/* Extract the only things we care about at firmware time */
-	sd->gbb_flags = gbb->flags;
-	sd->gbb_rootkey_offset = gbb->rootkey_offset;
-	sd->gbb_rootkey_size = gbb->rootkey_size;
-	memcpy(sd->gbb_hwid_digest, gbb->hwid_digest, VB2_GBB_HWID_DIGEST_SIZE);
+	/* Keep on the work buffer permanently */
+	sd->gbb_offset = vb2_offset_of(sd, gbb);
+	ctx->workbuf_used = vb2_offset_of(ctx->workbuf, wb.buf);
 
 	return VB2_SUCCESS;
 }
@@ -230,6 +236,7 @@ int vb2_fw_parse_gbb(struct vb2_context *ctx)
 int vb2_check_dev_switch(struct vb2_context *ctx)
 {
 	struct vb2_shared_data *sd = vb2_get_sd(ctx);
+	struct vb2_gbb_header *gbb = vb2_get_gbb(ctx);
 	uint32_t flags = 0;
 	uint32_t old_flags;
 	int is_dev = 0;
@@ -275,7 +282,7 @@ int vb2_check_dev_switch(struct vb2_context *ctx)
 		is_dev = 1;
 
 	/* Check if GBB is forcing dev mode */
-	if (sd->gbb_flags & VB2_GBB_FLAG_FORCE_DEV_SWITCH_ON)
+	if (gbb->flags & VB2_GBB_FLAG_FORCE_DEV_SWITCH_ON)
 		is_dev = 1;
 
 	/* Handle whichever mode we end up in */
diff --git a/firmware/2lib/include/2misc.h b/firmware/2lib/include/2misc.h
index 853a1b40..3e1f1000 100644
--- a/firmware/2lib/include/2misc.h
+++ b/firmware/2lib/include/2misc.h
@@ -9,6 +9,7 @@
 #define VBOOT_REFERENCE_VBOOT_2MISC_H_
 
 #include "2api.h"
+#include "2struct.h"
 
 struct vb2_gbb_header;
 struct vb2_workbuf;
@@ -19,11 +20,20 @@ struct vb2_workbuf;
  * @param ctx		Vboot context
  * @return The shared data pointer.
  */
-static __inline struct vb2_shared_data *vb2_get_sd(struct vb2_context *ctx) {
+static __inline struct vb2_shared_data *vb2_get_sd(struct vb2_context *ctx)
+{
 	return (struct vb2_shared_data *)ctx->workbuf;
 }
 
 /**
+ * Get the GBB header pointer from a vboot context's shared data
+ *
+ * @param ctx		Vboot context
+ * @return The GBB header pointer.
+ */
+struct vb2_gbb_header *vb2_get_gbb(struct vb2_context *ctx);
+
+/**
  * Validate gbb signature (the magic number)
  *
  * @param sig		Pointer to the signature bytes to validate
diff --git a/firmware/2lib/include/2struct.h b/firmware/2lib/include/2struct.h
index a1f11a18..0b94c20a 100644
--- a/firmware/2lib/include/2struct.h
+++ b/firmware/2lib/include/2struct.h
@@ -95,9 +95,6 @@ struct vb2_shared_data {
 	/* Flags; see enum vb2_shared_data_flags */
 	uint32_t flags;
 
-	/* Flags from GBB header */
-	uint32_t gbb_flags;
-
 	/*
 	 * Reason we are in recovery mode this boot (enum vb2_nv_recovery), or
 	 * 0 if we aren't.
@@ -130,6 +127,9 @@ struct vb2_shared_data {
 	 */
 	uint32_t status;
 
+	/* Offset from start of this struct to GBB header */
+	uint32_t gbb_offset;
+
 	/**********************************************************************
 	 * Data from kernel verification stage.
 	 *
@@ -155,13 +155,6 @@ struct vb2_shared_data {
 	 * we can put them.
 	 */
 
-	/* Root key offset and size from GBB header */
-	uint32_t gbb_rootkey_offset;
-	uint32_t gbb_rootkey_size;
-
-	/* HWID digest from GBB header */
-	uint8_t gbb_hwid_digest[VB2_GBB_HWID_DIGEST_SIZE];
-
 	/* Offset of preamble from start of vblock */
 	uint32_t vblock_preamble_offset;
 
@@ -224,12 +217,6 @@ struct vb2_shared_data {
 	 */
 	uint32_t workbuf_kernel_key_offset;
 	uint32_t workbuf_kernel_key_size;
-
-	/* GBB data and size */
-	struct vb2_gbb_header *gbb;
-	uint32_t gbb_size;
-
-
 } __attribute__((packed));
 
 /****************************************************************************/
diff --git a/firmware/lib/ec_sync.c b/firmware/lib/ec_sync.c
index c8491551..bcd10e71 100644
--- a/firmware/lib/ec_sync.c
+++ b/firmware/lib/ec_sync.c
@@ -341,15 +341,16 @@ static VbError_t sync_one_ec(struct vb2_context *ctx, int devidx)
 VbError_t ec_sync_phase1(struct vb2_context *ctx)
 {
 	struct vb2_shared_data *sd = vb2_get_sd(ctx);
+	struct vb2_gbb_header *gbb = vb2_get_gbb(ctx);
 
 	/* Reasons not to do sync at all */
 	if (!(ctx->flags & VB2_CONTEXT_EC_SYNC_SUPPORTED))
 		return VBERROR_SUCCESS;
-	if (sd->gbb_flags & VB2_GBB_FLAG_DISABLE_EC_SOFTWARE_SYNC)
+	if (gbb->flags & VB2_GBB_FLAG_DISABLE_EC_SOFTWARE_SYNC)
 		return VBERROR_SUCCESS;
 
 #ifdef PD_SYNC
-	const int do_pd_sync = !(sd->gbb_flags &
+	const int do_pd_sync = !(gbb->flags &
 				 VB2_GBB_FLAG_DISABLE_PD_SOFTWARE_SYNC);
 #else
 	const int do_pd_sync = 0;
@@ -412,11 +413,12 @@ int ec_will_update_slowly(struct vb2_context *ctx)
 static int ec_sync_allowed(struct vb2_context *ctx)
 {
 	struct vb2_shared_data *sd = vb2_get_sd(ctx);
+	struct vb2_gbb_header *gbb = vb2_get_gbb(ctx);
 
 	/* Reasons not to do sync at all */
 	if (!(ctx->flags & VB2_CONTEXT_EC_SYNC_SUPPORTED))
 		return 0;
-	if (sd->gbb_flags & VB2_GBB_FLAG_DISABLE_EC_SOFTWARE_SYNC)
+	if (gbb->flags & VB2_GBB_FLAG_DISABLE_EC_SOFTWARE_SYNC)
 		return 0;
 	if (sd->recovery_reason)
 		return 0;
@@ -426,11 +428,11 @@ static int ec_sync_allowed(struct vb2_context *ctx)
 VbError_t ec_sync_check_aux_fw(struct vb2_context *ctx,
 			       VbAuxFwUpdateSeverity_t *severity)
 {
-	struct vb2_shared_data *sd = vb2_get_sd(ctx);
+	struct vb2_gbb_header *gbb = vb2_get_gbb(ctx);
 
 	/* If we're not updating the EC, skip aux fw syncs as well */
 	if (!ec_sync_allowed(ctx) ||
-	    (sd->gbb_flags & VB2_GBB_FLAG_DISABLE_PD_SOFTWARE_SYNC)) {
+	    (gbb->flags & VB2_GBB_FLAG_DISABLE_PD_SOFTWARE_SYNC)) {
 		*severity = VB_AUX_FW_NO_UPDATE;
 		return VBERROR_SUCCESS;
 	}
@@ -463,8 +465,8 @@ VbError_t ec_sync_phase2(struct vb2_context *ctx)
 
 #ifdef PD_SYNC
 	/* Handle updates and jumps for PD */
-	struct vb2_shared_data *sd = vb2_get_sd(ctx);
-	if (!(sd->gbb_flags & VB2_GBB_FLAG_DISABLE_PD_SOFTWARE_SYNC)) {
+	struct vb2_gbb_header *gbb = vb2_get_gbb(ctx);
+	if (!(gbb->flags & VB2_GBB_FLAG_DISABLE_PD_SOFTWARE_SYNC)) {
 		retval = sync_one_ec(ctx, 1);
 		if (retval != VBERROR_SUCCESS)
 			return retval;
diff --git a/firmware/lib/region-init.c b/firmware/lib/region-init.c
index e34a3d15..9e3c2bc3 100644
--- a/firmware/lib/region-init.c
+++ b/firmware/lib/region-init.c
@@ -20,22 +20,14 @@
 static VbError_t VbGbbReadData(struct vb2_context *ctx,
 			       uint32_t offset, uint32_t size, void *buf)
 {
-	struct vb2_shared_data *sd = vb2_get_sd(ctx);
-
-	/* This is the old API, for backwards compatibility */
-	if (!sd->gbb)
-		return VBERROR_INVALID_GBB;
-
-	if (offset + size > sd->gbb_size)
+	if (vb2ex_read_resource(ctx, VB2_RES_GBB, offset, buf, size))
 		return VBERROR_INVALID_GBB;
-
-	memcpy(buf, ((uint8_t *)sd->gbb) + offset, size);
 	return VBERROR_SUCCESS;
 }
 
 VbError_t VbGbbReadHWID(struct vb2_context *ctx, char *hwid, uint32_t max_size)
 {
-	struct vb2_shared_data *sd = vb2_get_sd(ctx);
+	struct vb2_gbb_header *gbb = vb2_get_gbb(ctx);
 
 	if (!max_size)
 		return VBERROR_INVALID_PARAMETER;
@@ -44,18 +36,18 @@ VbError_t VbGbbReadHWID(struct vb2_context *ctx, char *hwid, uint32_t max_size)
 	if (!ctx)
 		return VBERROR_INVALID_GBB;
 
-	if (0 == sd->gbb->hwid_size) {
+	if (0 == gbb->hwid_size) {
 		VB2_DEBUG("VbHWID(): invalid hwid size\n");
 		return VBERROR_SUCCESS; /* oddly enough! */
 	}
 
-	if (sd->gbb->hwid_size > max_size) {
+	if (gbb->hwid_size > max_size) {
 		VB2_DEBUG("VbDisplayDebugInfo(): invalid hwid offset/size\n");
 		return VBERROR_INVALID_PARAMETER;
 	}
 
-	return VbGbbReadData(ctx, sd->gbb->hwid_offset,
-			     sd->gbb->hwid_size, hwid);
+	return VbGbbReadData(ctx, gbb->hwid_offset,
+			     gbb->hwid_size, hwid);
 }
 
 static VbError_t VbGbbReadKey(struct vb2_context *ctx, uint32_t offset,
@@ -86,14 +78,14 @@ static VbError_t VbGbbReadKey(struct vb2_context *ctx, uint32_t offset,
 
 VbError_t VbGbbReadRootKey(struct vb2_context *ctx, VbPublicKey **keyp)
 {
-	struct vb2_shared_data *sd = vb2_get_sd(ctx);
+	struct vb2_gbb_header *gbb = vb2_get_gbb(ctx);
 
-	return VbGbbReadKey(ctx, sd->gbb->rootkey_offset, keyp);
+	return VbGbbReadKey(ctx, gbb->rootkey_offset, keyp);
 }
 
 VbError_t VbGbbReadRecoveryKey(struct vb2_context *ctx, VbPublicKey **keyp)
 {
-	struct vb2_shared_data *sd = vb2_get_sd(ctx);
+	struct vb2_gbb_header *gbb = vb2_get_gbb(ctx);
 
-	return VbGbbReadKey(ctx, sd->gbb->recovery_key_offset, keyp);
+	return VbGbbReadKey(ctx, gbb->recovery_key_offset, keyp);
 }
diff --git a/firmware/lib/vboot_api_kernel.c b/firmware/lib/vboot_api_kernel.c
index 2be3e938..5d4c7c09 100644
--- a/firmware/lib/vboot_api_kernel.c
+++ b/firmware/lib/vboot_api_kernel.c
@@ -261,6 +261,7 @@ static VbError_t vb2_kernel_setup(struct vb2_context *ctx,
 	vb2_nv_init(ctx);
 
 	struct vb2_shared_data *sd = vb2_get_sd(ctx);
+	struct vb2_gbb_header *gbb = vb2_get_gbb(ctx);
 	sd->recovery_reason = shared->recovery_reason;
 
 	/*
@@ -294,11 +295,6 @@ static VbError_t vb2_kernel_setup(struct vb2_context *ctx,
 	kparams->flags = 0;
 	memset(kparams->partition_guid, 0, sizeof(kparams->partition_guid));
 
-	/* Point to GBB data from cparams */
-	sd->gbb = cparams->gbb_data;
-	sd->gbb_size = cparams->gbb_size;
-	sd->gbb_flags = sd->gbb->flags;
-
 	/* Read kernel version from the TPM.  Ignore errors in recovery mode. */
 	if (RollbackKernelRead(&shared->kernel_version_tpm)) {
 		VB2_DEBUG("Unable to get kernel versions from TPM\n");
@@ -311,7 +307,7 @@ static VbError_t vb2_kernel_setup(struct vb2_context *ctx,
 	shared->kernel_version_tpm_start = shared->kernel_version_tpm;
 
 	/* Read FWMP.  Ignore errors in recovery mode. */
-	if (sd->gbb_flags & VB2_GBB_FLAG_DISABLE_FWMP) {
+	if (gbb->flags & VB2_GBB_FLAG_DISABLE_FWMP) {
 		memset(&fwmp, 0, sizeof(fwmp));
 	} else if (RollbackFwmpRead(&fwmp)) {
 		VB2_DEBUG("Unable to get FWMP from TPM\n");
@@ -473,6 +469,7 @@ VbError_t VbVerifyMemoryBootImage(
 		goto fail;
 
 	struct vb2_shared_data *sd = vb2_get_sd(ctx);
+	struct vb2_gbb_header *gbb = vb2_get_gbb(ctx);
 	VbSharedDataHeader *shared = sd->vbsd;
 
 	if ((boot_image == NULL) || (image_size == 0)) {
@@ -495,7 +492,7 @@ VbError_t VbVerifyMemoryBootImage(
 			vb2_nv_get(ctx, VB2_NV_DEV_BOOT_FASTBOOT_FULL_CAP);
 
 	if (0 == allow_fastboot_full_cap) {
-		allow_fastboot_full_cap = !!(sd->gbb_flags &
+		allow_fastboot_full_cap = !!(gbb->flags &
 				VB2_GBB_FLAG_FORCE_DEV_BOOT_FASTBOOT_FULL_CAP);
 	}
 
diff --git a/firmware/lib/vboot_audio.c b/firmware/lib/vboot_audio.c
index e2a2655e..ba0f98c2 100644
--- a/firmware/lib/vboot_audio.c
+++ b/firmware/lib/vboot_audio.c
@@ -25,7 +25,7 @@ static int beep_count;		/* Number of beeps so far */
  */
 void vb2_audio_start(struct vb2_context *ctx)
 {
-	struct vb2_shared_data *sd = vb2_get_sd(ctx);
+	struct vb2_gbb_header *gbb = vb2_get_gbb(ctx);
 
 	open_time = VbExGetTimer(); /* "zero" starts now */
 	beep_count = 0;
@@ -34,7 +34,7 @@ void vb2_audio_start(struct vb2_context *ctx)
 	 * Use a short developer screen delay on the first audio if indicated
 	 * by GBB flags.
 	 */
-	if ((sd->gbb_flags & VB2_GBB_FLAG_DEV_SCREEN_SHORT_DELAY) &&
+	if ((gbb->flags & VB2_GBB_FLAG_DEV_SCREEN_SHORT_DELAY) &&
 	    (audio_open_count++ == 0)) {
 		VB2_DEBUG("vb2_audio_start() - using short dev screen delay\n");
 		audio_use_short = 1;
diff --git a/firmware/lib/vboot_common.c b/firmware/lib/vboot_common.c
index f0c4ea6a..fc32917b 100644
--- a/firmware/lib/vboot_common.c
+++ b/firmware/lib/vboot_common.c
@@ -214,8 +214,9 @@ int VbSharedDataSetKernelKey(VbSharedDataHeader *header, const VbPublicKey *src)
 
 int vb2_allow_recovery(struct vb2_context *ctx)
 {
-	/* GBB_FLAG_FORCE_MANUAL_RECOVERY forces this to always return true. */
-	if (vb2_get_sd(ctx)->gbb_flags & VB2_GBB_FLAG_FORCE_MANUAL_RECOVERY)
+	/* VB2_GBB_FLAG_FORCE_MANUAL_RECOVERY forces this to always return
+	   true. */
+	if (vb2_get_gbb(ctx)->flags & VB2_GBB_FLAG_FORCE_MANUAL_RECOVERY)
 		return 1;
 
 	/*
diff --git a/firmware/lib/vboot_display.c b/firmware/lib/vboot_display.c
index d735cb41..1f80a651 100644
--- a/firmware/lib/vboot_display.c
+++ b/firmware/lib/vboot_display.c
@@ -273,6 +273,7 @@ const char *RecoveryReasonString(uint8_t code)
 VbError_t VbDisplayDebugInfo(struct vb2_context *ctx)
 {
 	struct vb2_shared_data *sd = vb2_get_sd(ctx);
+	struct vb2_gbb_header *gbb = vb2_get_gbb(ctx);
 	VbSharedDataHeader *shared = sd->vbsd;
 	char buf[DEBUG_INFO_SIZE] = "";
 	char sha1sum[VB2_SHA1_DIGEST_SIZE * 2 + 1];
@@ -355,7 +356,7 @@ VbError_t VbDisplayDebugInfo(struct vb2_context *ctx)
 	used += StrnAppend(buf + used,
 			   "\ngbb.flags: 0x", DEBUG_INFO_SIZE - used);
 	used += Uint64ToString(buf + used, DEBUG_INFO_SIZE - used,
-			       sd->gbb_flags, 16, 8);
+			       gbb->flags, 16, 8);
 
 	/* Add sha1sum for Root & Recovery keys */
 	ret = VbGbbReadRootKey(ctx, &key);
diff --git a/firmware/lib/vboot_ui.c b/firmware/lib/vboot_ui.c
index 14508a63..8321fbbb 100644
--- a/firmware/lib/vboot_ui.c
+++ b/firmware/lib/vboot_ui.c
@@ -55,7 +55,7 @@ static void VbAllowUsbBoot(struct vb2_context *ctx)
  */
 static int VbWantShutdown(struct vb2_context *ctx, uint32_t key)
 {
-	struct vb2_shared_data *sd = vb2_get_sd(ctx);
+	struct vb2_gbb_header *gbb = vb2_get_gbb(ctx);
 	uint32_t shutdown_request = VbExIsShutdownRequested();
 
 	/*
@@ -78,7 +78,7 @@ static int VbWantShutdown(struct vb2_context *ctx, uint32_t key)
 		shutdown_request |= VB_SHUTDOWN_REQUEST_POWER_BUTTON;
 
 	/* If desired, ignore shutdown request due to lid closure. */
-	if (sd->gbb_flags & VB2_GBB_FLAG_DISABLE_LID_SHUTDOWN)
+	if (gbb->flags & VB2_GBB_FLAG_DISABLE_LID_SHUTDOWN)
 		shutdown_request &= ~VB_SHUTDOWN_REQUEST_LID_CLOSED;
 
 	return shutdown_request;
@@ -518,6 +518,7 @@ static const char dev_disable_msg[] =
 static VbError_t vb2_developer_ui(struct vb2_context *ctx)
 {
 	struct vb2_shared_data *sd = vb2_get_sd(ctx);
+	struct vb2_gbb_header *gbb = vb2_get_gbb(ctx);
 	VbSharedDataHeader *shared = sd->vbsd;
 
 	uint32_t disable_dev_boot = 0;
@@ -540,11 +541,11 @@ static VbError_t vb2_developer_ui(struct vb2_context *ctx)
 		use_legacy = 1;
 
 	/* Handle GBB flag override */
-	if (sd->gbb_flags & VB2_GBB_FLAG_FORCE_DEV_BOOT_USB)
+	if (gbb->flags & VB2_GBB_FLAG_FORCE_DEV_BOOT_USB)
 		allow_usb = 1;
-	if (sd->gbb_flags & VB2_GBB_FLAG_FORCE_DEV_BOOT_LEGACY)
+	if (gbb->flags & VB2_GBB_FLAG_FORCE_DEV_BOOT_LEGACY)
 		allow_legacy = 1;
-	if (sd->gbb_flags & VB2_GBB_FLAG_DEFAULT_DEV_BOOT_LEGACY) {
+	if (gbb->flags & VB2_GBB_FLAG_DEFAULT_DEV_BOOT_LEGACY) {
 		use_legacy = 1;
 		use_usb = 0;
 	}
@@ -556,7 +557,7 @@ static VbError_t vb2_developer_ui(struct vb2_context *ctx)
 	if (fwmp_flags & FWMP_DEV_ENABLE_LEGACY)
 		allow_legacy = 1;
 	if (fwmp_flags & FWMP_DEV_DISABLE_BOOT) {
-		if (sd->gbb_flags & VB2_GBB_FLAG_FORCE_DEV_SWITCH_ON) {
+		if (gbb->flags & VB2_GBB_FLAG_FORCE_DEV_SWITCH_ON) {
 			VB2_DEBUG("FWMP_DEV_DISABLE_BOOT rejected by "
 				  "FORCE_DEV_SWITCH_ON\n");
 		} else {
@@ -609,15 +610,14 @@ static VbError_t vb2_developer_ui(struct vb2_context *ctx)
 			break;
 		case VB_KEY_ENTER:
 			/* Only disable virtual dev switch if allowed by GBB */
-			if (!(sd->gbb_flags &
-			      VB2_GBB_FLAG_ENTER_TRIGGERS_TONORM))
+			if (!(gbb->flags & VB2_GBB_FLAG_ENTER_TRIGGERS_TONORM))
 				break;
 		case ' ':
 			/* See if we should disable virtual dev-mode switch. */
 			VB2_DEBUG("shared->flags=0x%x\n", shared->flags);
 			if (shared->flags & VBSD_BOOT_DEV_SWITCH_ON) {
 				/* Stop the countdown while we go ask... */
-				if (sd->gbb_flags &
+				if (gbb->flags &
 				    VB2_GBB_FLAG_FORCE_DEV_SWITCH_ON) {
 					/*
 					 * TONORM won't work (only for
diff --git a/firmware/lib/vboot_ui_menu.c b/firmware/lib/vboot_ui_menu.c
index 42494772..3fdf77cb 100644
--- a/firmware/lib/vboot_ui_menu.c
+++ b/firmware/lib/vboot_ui_menu.c
@@ -45,11 +45,11 @@ static const char no_legacy[] = "Legacy boot failed. Missing BIOS?\n";
  */
 static int VbWantShutdownMenu(struct vb2_context *ctx)
 {
-	struct vb2_shared_data *sd = vb2_get_sd(ctx);
+	struct vb2_gbb_header *gbb = vb2_get_gbb(ctx);
 	uint32_t shutdown_request = VbExIsShutdownRequested();
 
 	/* If desired, ignore shutdown request due to lid closure. */
-	if (sd->gbb_flags & VB2_GBB_FLAG_DISABLE_LID_SHUTDOWN)
+	if (gbb->flags & VB2_GBB_FLAG_DISABLE_LID_SHUTDOWN)
 		shutdown_request &= ~VB_SHUTDOWN_REQUEST_LID_CLOSED;
 
 	/*
@@ -181,7 +181,7 @@ static VbError_t boot_usb_action(struct vb2_context *ctx)
 	}
 
 	if (!vb2_nv_get(ctx, VB2_NV_DEV_BOOT_USB) &&
-	    !(vb2_get_sd(ctx)->gbb_flags & VB2_GBB_FLAG_FORCE_DEV_BOOT_USB) &&
+	    !(vb2_get_gbb(ctx)->flags & VB2_GBB_FLAG_FORCE_DEV_BOOT_USB) &&
 	    !(vb2_get_fwmp_flags() & FWMP_DEV_ENABLE_USB)) {
 		vb2_flash_screen(ctx);
 		vb2_error_notify("WARNING: Booting from external media "
@@ -377,7 +377,7 @@ static VbError_t to_dev_action(struct vb2_context *ctx)
 /* Action that disables developer mode, shows TO_NORM_CONFIRMED and reboots. */
 static VbError_t to_norm_action(struct vb2_context *ctx)
 {
-	if (vb2_get_sd(ctx)->gbb_flags & VB2_GBB_FLAG_FORCE_DEV_SWITCH_ON) {
+	if (vb2_get_gbb(ctx)->flags & VB2_GBB_FLAG_FORCE_DEV_SWITCH_ON) {
 		vb2_flash_screen(ctx);
 		vb2_error_notify("WARNING: TONORM prohibited by "
 				 "GBB FORCE_DEV_SWITCH_ON.\n", NULL,
@@ -741,18 +741,18 @@ static VbError_t vb2_init_menus(struct vb2_context *ctx)
  */
 static VbError_t vb2_developer_menu(struct vb2_context *ctx)
 {
-	struct vb2_shared_data *sd = vb2_get_sd(ctx);
+	struct vb2_gbb_header *gbb = vb2_get_gbb(ctx);
 	VbError_t ret;
 
 	/* Check if the default is to boot using disk, usb, or legacy */
 	default_boot = vb2_nv_get(ctx, VB2_NV_DEV_DEFAULT_BOOT);
-	if (sd->gbb_flags & VB2_GBB_FLAG_DEFAULT_DEV_BOOT_LEGACY)
+	if (gbb->flags & VB2_GBB_FLAG_DEFAULT_DEV_BOOT_LEGACY)
 		default_boot = VB2_DEV_DEFAULT_BOOT_LEGACY;
 
 	/* Check if developer mode is disabled by FWMP */
 	disable_dev_boot = 0;
 	if (vb2_get_fwmp_flags() & FWMP_DEV_DISABLE_BOOT) {
-		if (sd->gbb_flags & VB2_GBB_FLAG_FORCE_DEV_SWITCH_ON) {
+		if (gbb->flags & VB2_GBB_FLAG_FORCE_DEV_SWITCH_ON) {
 			VB2_DEBUG("FWMP_DEV_DISABLE_BOOT rejected by"
 				  "FORCE_DEV_SWITCH_ON\n");
 		} else {
@@ -762,7 +762,7 @@ static VbError_t vb2_developer_menu(struct vb2_context *ctx)
 		}
 	}
 	altfw_allowed = vb2_nv_get(ctx, VB2_NV_DEV_BOOT_LEGACY) ||
-	    (vb2_get_sd(ctx)->gbb_flags & VB2_GBB_FLAG_FORCE_DEV_BOOT_LEGACY) ||
+	    (gbb->flags & VB2_GBB_FLAG_FORCE_DEV_BOOT_LEGACY) ||
 	    (vb2_get_fwmp_flags() & FWMP_DEV_ENABLE_LEGACY);
 
 	/* Show appropriate initial menu */
diff --git a/firmware/lib20/kernel.c b/firmware/lib20/kernel.c
index e06c20eb..f169e7eb 100644
--- a/firmware/lib20/kernel.c
+++ b/firmware/lib20/kernel.c
@@ -438,6 +438,7 @@ int vb2_load_kernel_preamble(struct vb2_context *ctx)
 	 *
 	 * Work buffer now contains:
 	 *   - vb2_shared_data
+	 *   - vb2_gbb_header
 	 *   - kernel key
 	 *   - packed kernel data key
 	 *   - kernel preamble
diff --git a/firmware/lib20/misc.c b/firmware/lib20/misc.c
index d7a905a9..bc479ab7 100644
--- a/firmware/lib20/misc.c
+++ b/firmware/lib20/misc.c
@@ -68,6 +68,7 @@ static void vb2_report_dev_firmware(struct vb2_public_key *root)
 int vb2_load_fw_keyblock(struct vb2_context *ctx)
 {
 	struct vb2_shared_data *sd = vb2_get_sd(ctx);
+	struct vb2_gbb_header *gbb = vb2_get_gbb(ctx);
 	struct vb2_workbuf wb;
 
 	uint8_t *key_data;
@@ -83,12 +84,12 @@ int vb2_load_fw_keyblock(struct vb2_context *ctx)
 	vb2_workbuf_from_ctx(ctx, &wb);
 
 	/* Read the root key */
-	key_size = sd->gbb_rootkey_size;
+	key_size = gbb->rootkey_size;
 	key_data = vb2_workbuf_alloc(&wb, key_size);
 	if (!key_data)
 		return VB2_ERROR_FW_KEYBLOCK_WORKBUF_ROOT_KEY;
 
-	rv = vb2ex_read_resource(ctx, VB2_RES_GBB, sd->gbb_rootkey_offset,
+	rv = vb2ex_read_resource(ctx, VB2_RES_GBB, gbb->rootkey_offset,
 				 key_data, key_size);
 	if (rv)
 		return rv;
@@ -137,7 +138,7 @@ int vb2_load_fw_keyblock(struct vb2_context *ctx)
 	if (kb->data_key.key_version > VB2_MAX_KEY_VERSION)
 		rv = VB2_ERROR_FW_KEYBLOCK_VERSION_RANGE;
 	if (!rv && kb->data_key.key_version < (sd->fw_version_secdata >> 16)) {
-		if (sd->gbb_flags & VB2_GBB_FLAG_DISABLE_FW_ROLLBACK_CHECK)
+		if (gbb->flags & VB2_GBB_FLAG_DISABLE_FW_ROLLBACK_CHECK)
 			VB2_DEBUG("Ignoring FW key rollback due to GBB flag\n");
 		else
 			rv = VB2_ERROR_FW_KEYBLOCK_VERSION_ROLLBACK;
@@ -194,6 +195,7 @@ int vb2_load_fw_keyblock(struct vb2_context *ctx)
 int vb2_load_fw_preamble(struct vb2_context *ctx)
 {
 	struct vb2_shared_data *sd = vb2_get_sd(ctx);
+	struct vb2_gbb_header *gbb = vb2_get_gbb(ctx);
 	struct vb2_workbuf wb;
 
 	uint8_t *key_data = ctx->workbuf + sd->workbuf_data_key_offset;
@@ -258,7 +260,7 @@ int vb2_load_fw_preamble(struct vb2_context *ctx)
 	/* Combine with the key version from vb2_load_fw_keyblock() */
 	sd->fw_version |= pre->firmware_version;
 	if (!rv && sd->fw_version < sd->fw_version_secdata) {
-		if (sd->gbb_flags & VB2_GBB_FLAG_DISABLE_FW_ROLLBACK_CHECK)
+		if (gbb->flags & VB2_GBB_FLAG_DISABLE_FW_ROLLBACK_CHECK)
 			VB2_DEBUG("Ignoring FW rollback due to GBB flag\n");
 		else
 			rv = VB2_ERROR_FW_PREAMBLE_VERSION_ROLLBACK;
@@ -298,6 +300,7 @@ int vb2_load_fw_preamble(struct vb2_context *ctx)
 	 *
 	 * Work buffer now contains:
 	 *   - vb2_shared_data
+	 *   - vb2_gbb_header
 	 *   - packed firmware data key
 	 *   - firmware preamble
 	 *
diff --git a/firmware/lib21/misc.c b/firmware/lib21/misc.c
index 361d6eda..c1d0169c 100644
--- a/firmware/lib21/misc.c
+++ b/firmware/lib21/misc.c
@@ -65,6 +65,7 @@ static int vb21_read_resource_object(struct vb2_context *ctx,
 int vb21_load_fw_keyblock(struct vb2_context *ctx)
 {
 	struct vb2_shared_data *sd = vb2_get_sd(ctx);
+	struct vb2_gbb_header *gbb = vb2_get_gbb(ctx);
 	struct vb2_workbuf wb;
 
 	uint8_t *key_data;
@@ -78,12 +79,12 @@ int vb21_load_fw_keyblock(struct vb2_context *ctx)
 	vb2_workbuf_from_ctx(ctx, &wb);
 
 	/* Read the root key */
-	key_size = sd->gbb_rootkey_size;
+	key_size = gbb->rootkey_size;
 	key_data = vb2_workbuf_alloc(&wb, key_size);
 	if (!key_data)
 		return VB2_ERROR_FW_KEYBLOCK_WORKBUF_ROOT_KEY;
 
-	rv = vb2ex_read_resource(ctx, VB2_RES_GBB, sd->gbb_rootkey_offset,
+	rv = vb2ex_read_resource(ctx, VB2_RES_GBB, gbb->rootkey_offset,
 				 key_data, key_size);
 	if (rv)
 		return rv;
@@ -118,7 +119,7 @@ int vb21_load_fw_keyblock(struct vb2_context *ctx)
 	if (packed_key->key_version > 0xffff)
 		rv = VB2_ERROR_FW_KEYBLOCK_VERSION_RANGE;
 	if (!rv && packed_key->key_version < (sd->fw_version_secdata >> 16)) {
-		if (sd->gbb_flags & VB2_GBB_FLAG_DISABLE_FW_ROLLBACK_CHECK)
+		if (gbb->flags & VB2_GBB_FLAG_DISABLE_FW_ROLLBACK_CHECK)
 			VB2_DEBUG("Ignoring FW key rollback due to GBB flag\n");
 		else
 			rv = VB2_ERROR_FW_KEYBLOCK_VERSION_ROLLBACK;
@@ -157,6 +158,7 @@ int vb21_load_fw_keyblock(struct vb2_context *ctx)
 int vb21_load_fw_preamble(struct vb2_context *ctx)
 {
 	struct vb2_shared_data *sd = vb2_get_sd(ctx);
+	struct vb2_gbb_header *gbb = vb2_get_gbb(ctx);
 	struct vb2_workbuf wb;
 
 	uint8_t *key_data = ctx->workbuf + sd->workbuf_data_key_offset;
@@ -210,7 +212,7 @@ int vb21_load_fw_preamble(struct vb2_context *ctx)
 	/* Combine with the key version from vb2_load_fw_keyblock() */
 	sd->fw_version |= pre->fw_version;
 	if (!rv && sd->fw_version < sd->fw_version_secdata) {
-		if (sd->gbb_flags & VB2_GBB_FLAG_DISABLE_FW_ROLLBACK_CHECK)
+		if (gbb->flags & VB2_GBB_FLAG_DISABLE_FW_ROLLBACK_CHECK)
 			VB2_DEBUG("Ignoring FW rollback due to GBB flag\n");
 		else
 			rv = VB2_ERROR_FW_PREAMBLE_VERSION_ROLLBACK;
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)