diff options
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) |