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