tests/vb2_gbb_tests.c - third_party/vboot_reference - Git at Google

 /* Copyright 2019 The ChromiumOS Authors
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  *
  * Tests for GBB library.
  */

 #include "2common.h"
 #include "2misc.h"
 #include "common/tests.h"

 /* Mock data */
 static char gbb_data[4096 + sizeof(struct vb2_gbb_header)];
 static struct vb2_gbb_header *gbb = (struct vb2_gbb_header *)gbb_data;
 static struct vb2_packed_key *rootkey;
 static struct vb2_context *ctx;
 static struct vb2_workbuf wb;
 static uint8_t workbuf[VB2_KERNEL_WORKBUF_RECOMMENDED_SIZE]
 	__attribute__((aligned(VB2_WORKBUF_ALIGN)));

 static void set_gbb_hwid(const char *hwid, size_t size)
 {
 	memcpy(gbb_data + gbb->hwid_offset, hwid, size);
 	gbb->hwid_size = size;
 }

 static void reset_common_data(void)
 {
 	int gbb_used;

 	memset(gbb_data, 0, sizeof(gbb_data));
 	gbb->header_size = sizeof(*gbb);
 	gbb->major_version = VB2_GBB_MAJOR_VER;
 	gbb->minor_version = VB2_GBB_MINOR_VER;
 	gbb->flags = 0;
 	gbb_used = sizeof(struct vb2_gbb_header);

 	gbb->recovery_key_offset = gbb_used;
 	gbb->recovery_key_size = 64;
 	gbb_used += gbb->recovery_key_size;
 	gbb->rootkey_offset = gbb_used;
 	gbb->rootkey_size = sizeof(struct vb2_packed_key);
 	gbb_used += gbb->rootkey_size;

 	rootkey = ((void *)gbb + gbb->rootkey_offset);
 	rootkey->key_offset = sizeof(*rootkey);

 	gbb->hwid_offset = gbb_used;
 	const char hwid_src[] = "Test HWID";
 	set_gbb_hwid(hwid_src, sizeof(hwid_src));

 	TEST_SUCC(vb2api_init(workbuf, sizeof(workbuf), &ctx),
 		  "vb2api_init failed");
 	vb2_workbuf_from_ctx(ctx, &wb);
 }

 /* Mocks */
 struct vb2_gbb_header *vb2_get_gbb(struct vb2_context *c)
 {
 	return gbb;
 }

 vb2_error_t 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 + size >= rsize)
 		return VB2_ERROR_EX_READ_RESOURCE_SIZE;

 	memcpy(buf, rptr + offset, size);
 	return VB2_SUCCESS;
 }

 /* Tests */
 static void flag_tests(void)
 {
 	reset_common_data();
 	gbb->flags = 0xdeadbeef;
 	TEST_EQ(vb2api_gbb_get_flags(ctx), gbb->flags,
 		"retrieve GBB flags");
 }

 static void key_tests(void)
 {
 	/* Assume that root key and recovery key are dealt with using the same
 	   code in our GBB library functions. */
 	struct vb2_packed_key *keyp;
 	struct vb2_workbuf wborig;
 	const char key_data[] = "HELLOWORLD";
 	uint32_t size;

 	/* gbb.offset < sizeof(vb2_gbb_header) */
 	reset_common_data();
 	wborig = wb;
 	gbb->rootkey_offset = sizeof(*gbb) - 1;
 	TEST_EQ(vb2_gbb_read_root_key(ctx, &keyp, &size, &wb),
 		VB2_ERROR_GBB_INVALID,
 		"gbb.rootkey offset too small");
 	TEST_TRUE(wb.buf == wborig.buf,
 		  "  workbuf restored on error");

 	/* gbb.offset > gbb_data */
 	reset_common_data();
 	wborig = wb;
 	gbb->rootkey_offset = sizeof(gbb_data) + 1;
 	TEST_EQ(vb2_gbb_read_root_key(ctx, &keyp, &size, &wb),
 		VB2_ERROR_EX_READ_RESOURCE_SIZE,
 		"gbb.rootkey offset too large");
 	TEST_TRUE(wb.buf == wborig.buf,
 		  "  workbuf restored on error");

 	/* gbb.size < sizeof(vb2_packed_key) */
 	reset_common_data();
 	wborig = wb;
 	gbb->rootkey_size = sizeof(*rootkey) - 1;
 	TEST_EQ(vb2_gbb_read_root_key(ctx, &keyp, &size, &wb),
 		VB2_ERROR_GBB_INVALID,
 		"gbb.rootkey size too small");
 	TEST_TRUE(wb.buf == wborig.buf,
 		  "  workbuf restored on error");

 	/* sizeof(vb2_packed_key) > workbuf.size */
 	reset_common_data();
 	wborig = wb;
 	wb.size = sizeof(*rootkey) - 1;
 	TEST_EQ(vb2_gbb_read_root_key(ctx, &keyp, &size, &wb),
 		VB2_ERROR_GBB_WORKBUF,
 		"workbuf size too small for vb2_packed_key header");
 	TEST_TRUE(wb.buf == wborig.buf,
 		  "  workbuf restored on error");

 	/* packed_key.offset < sizeof(vb2_packed_key) */
 	reset_common_data();
 	wborig = wb;
 	rootkey->key_size = 1;
 	rootkey->key_offset = sizeof(*rootkey) - 1;
 	TEST_EQ(vb2_gbb_read_root_key(ctx, &keyp, &size, &wb),
 		VB2_ERROR_INSIDE_DATA_OVERLAP,
 		"rootkey offset too small");
 	TEST_TRUE(wb.buf == wborig.buf,
 		  "  workbuf restored on error");

 	/* packed_key.offset > gbb_data */
 	reset_common_data();
 	wborig = wb;
 	rootkey->key_size = 1;
 	rootkey->key_offset = sizeof(gbb_data) + 1;
 	gbb->rootkey_size = rootkey->key_offset + rootkey->key_size;
 	TEST_EQ(vb2_gbb_read_root_key(ctx, &keyp, &size, &wb),
 		VB2_ERROR_EX_READ_RESOURCE_SIZE,
 		"rootkey size too large");
 	TEST_TRUE(wb.buf == wborig.buf,
 		  "  workbuf restored on error");

 	/* packed_key.size > workbuf.size */
 	reset_common_data();
 	wborig = wb;
 	rootkey->key_size = wb.size + 1;
 	gbb->rootkey_size = rootkey->key_offset + rootkey->key_size + 1;
 	TEST_EQ(vb2_gbb_read_root_key(ctx, &keyp, &size, &wb),
 		VB2_ERROR_GBB_WORKBUF,
 		"workbuf size too small for vb2_packed_key contents");
 	TEST_TRUE(wb.buf == wborig.buf,
 		  "  workbuf restored on error");

 	/* gbb.size < sizeof(vb2_packed_key) + packed_key.size */
 	reset_common_data();
 	wborig = wb;
 	rootkey->key_size = 2;
 	gbb->rootkey_size = rootkey->key_offset + rootkey->key_size - 1;
 	TEST_EQ(vb2_gbb_read_root_key(ctx, &keyp, &size, &wb),
 		VB2_ERROR_INSIDE_DATA_OUTSIDE,
 		"rootkey size exceeds gbb.rootkey size");
 	TEST_TRUE(wb.buf == wborig.buf,
 		  "  workbuf restored on error");

 	/* gbb.size == sizeof(vb2_packed_key) + packed_key.size */
 	reset_common_data();
 	wborig = wb;
 	rootkey->key_size = sizeof(key_data);
 	memcpy((void *)rootkey + rootkey->key_offset,
 	       key_data, sizeof(key_data));
 	gbb->rootkey_size = rootkey->key_offset + rootkey->key_size;
 	TEST_SUCC(vb2_gbb_read_root_key(ctx, &keyp, &size, &wb),
 		  "succeeds when gbb.rootkey and rootkey sizes agree");
 	TEST_TRUE(wb.size < wborig.size,
 		  "  workbuf shrank on success");
 	TEST_EQ(memcmp(rootkey, keyp, rootkey->key_offset + rootkey->key_size),
 		0, "  copied key data successfully");
 	TEST_EQ(size, rootkey->key_offset + rootkey->key_size,
 		"  correct size returned");

 	/* gbb.size > sizeof(vb2_packed_key) + packed_key.size
 	   packed_key.offset = +0 */
 	reset_common_data();
 	wborig = wb;
 	rootkey->key_size = 1;
 	gbb->rootkey_size = rootkey->key_offset + rootkey->key_size + 1;
 	TEST_SUCC(vb2_gbb_read_root_key(ctx, &keyp, &size, &wb),
 		  "succeeds when gbb.rootkey is padded after key");
 	TEST_TRUE(wb.size < wborig.size,
 		  "  workbuf shrank on success");
 	TEST_EQ(size, rootkey->key_offset + rootkey->key_size,
 		"  correct size returned");

 	/* gbb.size > sizeof(vb2_packed_key) + packed_key.size
 	   packed_key.offset = +1 */
 	reset_common_data();
 	wborig = wb;
 	rootkey->key_offset = sizeof(*rootkey) + 1;
 	rootkey->key_size = 1;
 	gbb->rootkey_size = rootkey->key_offset + rootkey->key_size;
 	TEST_SUCC(vb2_gbb_read_root_key(ctx, &keyp, &size, &wb),
 		  "succeeds when gbb.rootkey is padded before key");
 	TEST_TRUE(wb.size < wborig.size,
 		  "  workbuf shrank on success");
 	TEST_EQ(size, rootkey->key_offset + rootkey->key_size,
 		"  correct size returned");

 	/* packed_key.size = 0, packed_key.offset = +1 */
 	reset_common_data();
 	wborig = wb;
 	rootkey->key_offset = sizeof(*rootkey) + 1;
 	rootkey->key_size = 0;
 	gbb->rootkey_size = rootkey->key_offset + rootkey->key_size + 1;
 	TEST_SUCC(vb2_gbb_read_root_key(ctx, &keyp, &size, &wb),
 		  "succeeds when gbb.rootkey is padded; empty test key");
 	TEST_TRUE(wb.size < wborig.size,
 		  "  workbuf shrank on success");
 	TEST_EQ(size, rootkey->key_offset + rootkey->key_size,
 		"  correct size returned");

 	/* packed_key.size = 0, packed_key.offset = -1 */
 	reset_common_data();
 	wborig = wb;
 	rootkey->key_offset = sizeof(*rootkey) - 1;
 	rootkey->key_size = 0;
 	gbb->rootkey_size = sizeof(*rootkey) + rootkey->key_size + 1;
 	TEST_SUCC(vb2_gbb_read_root_key(ctx, &keyp, &size, &wb),
 		  "succeeds when gbb.rootkey is padded; empty test key");
 	TEST_TRUE(wb.size < wborig.size,
 		  "  workbuf shrank on success");
 	TEST_EQ(size, sizeof(*rootkey), "  correct size returned");
 }

 static void hwid_tests(void)
 {
 	char hwid[VB2_GBB_HWID_MAX_SIZE];
 	uint32_t size;

 	/* GBB HWID size = 0 */
 	{
 		reset_common_data();
 		gbb->hwid_size = 0;
 		size = VB2_GBB_HWID_MAX_SIZE;
 		TEST_EQ(vb2api_gbb_read_hwid(ctx, hwid, &size),
 			VB2_ERROR_GBB_INVALID,
 			"GBB HWID size invalid (HWID missing)");
 	}

 	/* GBB HWID offset > GBB size */
 	{
 		reset_common_data();
 		gbb->hwid_offset = sizeof(gbb_data) + 1;
 		size = VB2_GBB_HWID_MAX_SIZE;
 		TEST_EQ(vb2api_gbb_read_hwid(ctx, hwid, &size),
 			VB2_ERROR_EX_READ_RESOURCE_SIZE,
 			"GBB HWID offset invalid");
 	}

 	/* buffer size < HWID size */
 	{
 		const char hwid_src[] = "Test HWID";
 		reset_common_data();
 		set_gbb_hwid(hwid_src, sizeof(hwid_src));
 		size = sizeof(hwid_src) - 1;
 		TEST_EQ(vb2api_gbb_read_hwid(ctx, hwid, &size),
 			VB2_ERROR_INVALID_PARAMETER,
 			"HWID too large for buffer");
 	}

 	/* GBB HWID size < HWID size */
 	{
 		const char hwid_src[] = "Test HWID";
 		reset_common_data();
 		set_gbb_hwid(hwid_src, sizeof(hwid_src) - 1);
 		size = sizeof(hwid_src);
 		TEST_EQ(vb2api_gbb_read_hwid(ctx, hwid, &size),
 			VB2_ERROR_INVALID_PARAMETER,
 			"HWID larger than GBB HWID size");
 	}

 	/* buffer size == HWID size */
 	{
 		const char hwid_src[] = "Test HWID";
 		reset_common_data();
 		set_gbb_hwid(hwid_src, sizeof(hwid_src));
 		size = sizeof(hwid_src);
 		TEST_SUCC(vb2api_gbb_read_hwid(ctx, hwid, &size),
 			  "read normal HWID");
 		TEST_EQ(strcmp(hwid, "Test HWID"), 0, "  HWID correct");
 		TEST_EQ(strlen(hwid) + 1, size, "  HWID size consistent");
 		TEST_EQ(strlen(hwid), strlen("Test HWID"),
 			"  HWID size correct");
 	}

 	/* buffer size > HWID size */
 	{
 		const char hwid_src[] = "Test HWID";
 		reset_common_data();
 		set_gbb_hwid(hwid_src, sizeof(hwid_src));
 		size = sizeof(hwid_src) + 1;
 		TEST_SUCC(vb2api_gbb_read_hwid(ctx, hwid, &size),
 			  "read normal HWID");
 		TEST_EQ(strcmp(hwid, "Test HWID"), 0, "  HWID correct");
 		TEST_EQ(strlen(hwid) + 1, size, "  HWID size consistent");
 		TEST_EQ(strlen(hwid), strlen("Test HWID"),
 			"  HWID size correct");
 	}

 	/* HWID with garbage */
 	{
 		const char hwid_src[] = "Test HWID\0garbagegarbage";
 		reset_common_data();
 		set_gbb_hwid(hwid_src, sizeof(hwid_src));
 		size = VB2_GBB_HWID_MAX_SIZE;
 		TEST_SUCC(vb2api_gbb_read_hwid(ctx, hwid, &size),
 			  "read HWID with garbage");
 		TEST_EQ(strcmp(hwid, "Test HWID"), 0, "  HWID correct");
 		TEST_EQ(strlen(hwid) + 1, size, "  HWID size consistent");
 		TEST_EQ(strlen(hwid), strlen("Test HWID"),
 			"  HWID size correct");
 	}
 }

 int main(int argc, char* argv[])
 {
 	flag_tests();
 	key_tests();
 	hwid_tests();

 	return gTestSuccess ? 0 : 255;
 }
	/* Copyright 2019 The ChromiumOS Authors
	* Use of this source code is governed by a BSD-style license that can be
	* found in the LICENSE file.
	*
	* Tests for GBB library.
	*/

	#include "2common.h"
	#include "2misc.h"
	#include "common/tests.h"

	/* Mock data */
	static char gbb_data[4096 + sizeof(struct vb2_gbb_header)];
	static struct vb2_gbb_header gbb = (struct vb2_gbb_header )gbb_data;
	static struct vb2_packed_key *rootkey;
	static struct vb2_context *ctx;
	static struct vb2_workbuf wb;
	static uint8_t workbuf[VB2_KERNEL_WORKBUF_RECOMMENDED_SIZE]
	__attribute__((aligned(VB2_WORKBUF_ALIGN)));

	static void set_gbb_hwid(const char *hwid, size_t size)
	{
	memcpy(gbb_data + gbb->hwid_offset, hwid, size);
	gbb->hwid_size = size;
	}

	static void reset_common_data(void)
	{
	int gbb_used;

	memset(gbb_data, 0, sizeof(gbb_data));
	gbb->header_size = sizeof(*gbb);
	gbb->major_version = VB2_GBB_MAJOR_VER;
	gbb->minor_version = VB2_GBB_MINOR_VER;
	gbb->flags = 0;
	gbb_used = sizeof(struct vb2_gbb_header);

	gbb->recovery_key_offset = gbb_used;
	gbb->recovery_key_size = 64;
	gbb_used += gbb->recovery_key_size;
	gbb->rootkey_offset = gbb_used;
	gbb->rootkey_size = sizeof(struct vb2_packed_key);
	gbb_used += gbb->rootkey_size;

	rootkey = ((void *)gbb + gbb->rootkey_offset);
	rootkey->key_offset = sizeof(*rootkey);

	gbb->hwid_offset = gbb_used;
	const char hwid_src[] = "Test HWID";
	set_gbb_hwid(hwid_src, sizeof(hwid_src));

	TEST_SUCC(vb2api_init(workbuf, sizeof(workbuf), &ctx),
	"vb2api_init failed");
	vb2_workbuf_from_ctx(ctx, &wb);
	}

	/* Mocks */
	struct vb2_gbb_header vb2_get_gbb(struct vb2_context c)
	{
	return gbb;
	}

	vb2_error_t 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 + size >= rsize)
	return VB2_ERROR_EX_READ_RESOURCE_SIZE;

	memcpy(buf, rptr + offset, size);
	return VB2_SUCCESS;
	}

	/* Tests */
	static void flag_tests(void)
	{
	reset_common_data();
	gbb->flags = 0xdeadbeef;
	TEST_EQ(vb2api_gbb_get_flags(ctx), gbb->flags,
	"retrieve GBB flags");
	}

	static void key_tests(void)
	{
	/* Assume that root key and recovery key are dealt with using the same
	code in our GBB library functions. */
	struct vb2_packed_key *keyp;
	struct vb2_workbuf wborig;
	const char key_data[] = "HELLOWORLD";
	uint32_t size;

	/* gbb.offset < sizeof(vb2_gbb_header) */
	reset_common_data();
	wborig = wb;
	gbb->rootkey_offset = sizeof(*gbb) - 1;
	TEST_EQ(vb2_gbb_read_root_key(ctx, &keyp, &size, &wb),
	VB2_ERROR_GBB_INVALID,
	"gbb.rootkey offset too small");
	TEST_TRUE(wb.buf == wborig.buf,
	" workbuf restored on error");

	/* gbb.offset > gbb_data */
	reset_common_data();
	wborig = wb;
	gbb->rootkey_offset = sizeof(gbb_data) + 1;
	TEST_EQ(vb2_gbb_read_root_key(ctx, &keyp, &size, &wb),
	VB2_ERROR_EX_READ_RESOURCE_SIZE,
	"gbb.rootkey offset too large");
	TEST_TRUE(wb.buf == wborig.buf,
	" workbuf restored on error");

	/* gbb.size < sizeof(vb2_packed_key) */
	reset_common_data();
	wborig = wb;
	gbb->rootkey_size = sizeof(*rootkey) - 1;
	TEST_EQ(vb2_gbb_read_root_key(ctx, &keyp, &size, &wb),
	VB2_ERROR_GBB_INVALID,
	"gbb.rootkey size too small");
	TEST_TRUE(wb.buf == wborig.buf,
	" workbuf restored on error");

	/* sizeof(vb2_packed_key) > workbuf.size */
	reset_common_data();
	wborig = wb;
	wb.size = sizeof(*rootkey) - 1;
	TEST_EQ(vb2_gbb_read_root_key(ctx, &keyp, &size, &wb),
	VB2_ERROR_GBB_WORKBUF,
	"workbuf size too small for vb2_packed_key header");
	TEST_TRUE(wb.buf == wborig.buf,
	" workbuf restored on error");

	/* packed_key.offset < sizeof(vb2_packed_key) */
	reset_common_data();
	wborig = wb;
	rootkey->key_size = 1;
	rootkey->key_offset = sizeof(*rootkey) - 1;
	TEST_EQ(vb2_gbb_read_root_key(ctx, &keyp, &size, &wb),
	VB2_ERROR_INSIDE_DATA_OVERLAP,
	"rootkey offset too small");
	TEST_TRUE(wb.buf == wborig.buf,
	" workbuf restored on error");

	/* packed_key.offset > gbb_data */
	reset_common_data();
	wborig = wb;
	rootkey->key_size = 1;
	rootkey->key_offset = sizeof(gbb_data) + 1;
	gbb->rootkey_size = rootkey->key_offset + rootkey->key_size;
	TEST_EQ(vb2_gbb_read_root_key(ctx, &keyp, &size, &wb),
	VB2_ERROR_EX_READ_RESOURCE_SIZE,
	"rootkey size too large");
	TEST_TRUE(wb.buf == wborig.buf,
	" workbuf restored on error");

	/* packed_key.size > workbuf.size */
	reset_common_data();
	wborig = wb;
	rootkey->key_size = wb.size + 1;
	gbb->rootkey_size = rootkey->key_offset + rootkey->key_size + 1;
	TEST_EQ(vb2_gbb_read_root_key(ctx, &keyp, &size, &wb),
	VB2_ERROR_GBB_WORKBUF,
	"workbuf size too small for vb2_packed_key contents");
	TEST_TRUE(wb.buf == wborig.buf,
	" workbuf restored on error");

	/* gbb.size < sizeof(vb2_packed_key) + packed_key.size */
	reset_common_data();
	wborig = wb;
	rootkey->key_size = 2;
	gbb->rootkey_size = rootkey->key_offset + rootkey->key_size - 1;
	TEST_EQ(vb2_gbb_read_root_key(ctx, &keyp, &size, &wb),
	VB2_ERROR_INSIDE_DATA_OUTSIDE,
	"rootkey size exceeds gbb.rootkey size");
	TEST_TRUE(wb.buf == wborig.buf,
	" workbuf restored on error");

	/* gbb.size == sizeof(vb2_packed_key) + packed_key.size */
	reset_common_data();
	wborig = wb;
	rootkey->key_size = sizeof(key_data);
	memcpy((void *)rootkey + rootkey->key_offset,
	key_data, sizeof(key_data));
	gbb->rootkey_size = rootkey->key_offset + rootkey->key_size;
	TEST_SUCC(vb2_gbb_read_root_key(ctx, &keyp, &size, &wb),
	"succeeds when gbb.rootkey and rootkey sizes agree");
	TEST_TRUE(wb.size < wborig.size,
	" workbuf shrank on success");
	TEST_EQ(memcmp(rootkey, keyp, rootkey->key_offset + rootkey->key_size),
	0, " copied key data successfully");
	TEST_EQ(size, rootkey->key_offset + rootkey->key_size,
	" correct size returned");

	/* gbb.size > sizeof(vb2_packed_key) + packed_key.size
	packed_key.offset = +0 */
	reset_common_data();
	wborig = wb;
	rootkey->key_size = 1;
	gbb->rootkey_size = rootkey->key_offset + rootkey->key_size + 1;
	TEST_SUCC(vb2_gbb_read_root_key(ctx, &keyp, &size, &wb),
	"succeeds when gbb.rootkey is padded after key");
	TEST_TRUE(wb.size < wborig.size,
	" workbuf shrank on success");
	TEST_EQ(size, rootkey->key_offset + rootkey->key_size,
	" correct size returned");

	/* gbb.size > sizeof(vb2_packed_key) + packed_key.size
	packed_key.offset = +1 */
	reset_common_data();
	wborig = wb;
	rootkey->key_offset = sizeof(*rootkey) + 1;
	rootkey->key_size = 1;
	gbb->rootkey_size = rootkey->key_offset + rootkey->key_size;
	TEST_SUCC(vb2_gbb_read_root_key(ctx, &keyp, &size, &wb),
	"succeeds when gbb.rootkey is padded before key");
	TEST_TRUE(wb.size < wborig.size,
	" workbuf shrank on success");
	TEST_EQ(size, rootkey->key_offset + rootkey->key_size,
	" correct size returned");

	/* packed_key.size = 0, packed_key.offset = +1 */
	reset_common_data();
	wborig = wb;
	rootkey->key_offset = sizeof(*rootkey) + 1;
	rootkey->key_size = 0;
	gbb->rootkey_size = rootkey->key_offset + rootkey->key_size + 1;
	TEST_SUCC(vb2_gbb_read_root_key(ctx, &keyp, &size, &wb),
	"succeeds when gbb.rootkey is padded; empty test key");
	TEST_TRUE(wb.size < wborig.size,
	" workbuf shrank on success");
	TEST_EQ(size, rootkey->key_offset + rootkey->key_size,
	" correct size returned");

	/* packed_key.size = 0, packed_key.offset = -1 */
	reset_common_data();
	wborig = wb;
	rootkey->key_offset = sizeof(*rootkey) - 1;
	rootkey->key_size = 0;
	gbb->rootkey_size = sizeof(*rootkey) + rootkey->key_size + 1;
	TEST_SUCC(vb2_gbb_read_root_key(ctx, &keyp, &size, &wb),
	"succeeds when gbb.rootkey is padded; empty test key");
	TEST_TRUE(wb.size < wborig.size,
	" workbuf shrank on success");
	TEST_EQ(size, sizeof(*rootkey), " correct size returned");
	}

	static void hwid_tests(void)
	{
	char hwid[VB2_GBB_HWID_MAX_SIZE];
	uint32_t size;

	/* GBB HWID size = 0 */
	{
	reset_common_data();
	gbb->hwid_size = 0;
	size = VB2_GBB_HWID_MAX_SIZE;
	TEST_EQ(vb2api_gbb_read_hwid(ctx, hwid, &size),
	VB2_ERROR_GBB_INVALID,
	"GBB HWID size invalid (HWID missing)");
	}

	/* GBB HWID offset > GBB size */
	{
	reset_common_data();
	gbb->hwid_offset = sizeof(gbb_data) + 1;
	size = VB2_GBB_HWID_MAX_SIZE;
	TEST_EQ(vb2api_gbb_read_hwid(ctx, hwid, &size),
	VB2_ERROR_EX_READ_RESOURCE_SIZE,
	"GBB HWID offset invalid");
	}

	/* buffer size < HWID size */
	{
	const char hwid_src[] = "Test HWID";
	reset_common_data();
	set_gbb_hwid(hwid_src, sizeof(hwid_src));
	size = sizeof(hwid_src) - 1;
	TEST_EQ(vb2api_gbb_read_hwid(ctx, hwid, &size),
	VB2_ERROR_INVALID_PARAMETER,
	"HWID too large for buffer");
	}

	/* GBB HWID size < HWID size */
	{
	const char hwid_src[] = "Test HWID";
	reset_common_data();
	set_gbb_hwid(hwid_src, sizeof(hwid_src) - 1);
	size = sizeof(hwid_src);
	TEST_EQ(vb2api_gbb_read_hwid(ctx, hwid, &size),
	VB2_ERROR_INVALID_PARAMETER,
	"HWID larger than GBB HWID size");
	}

	/* buffer size == HWID size */
	{
	const char hwid_src[] = "Test HWID";
	reset_common_data();
	set_gbb_hwid(hwid_src, sizeof(hwid_src));
	size = sizeof(hwid_src);
	TEST_SUCC(vb2api_gbb_read_hwid(ctx, hwid, &size),
	"read normal HWID");
	TEST_EQ(strcmp(hwid, "Test HWID"), 0, " HWID correct");
	TEST_EQ(strlen(hwid) + 1, size, " HWID size consistent");
	TEST_EQ(strlen(hwid), strlen("Test HWID"),
	" HWID size correct");
	}

	/* buffer size > HWID size */
	{
	const char hwid_src[] = "Test HWID";
	reset_common_data();
	set_gbb_hwid(hwid_src, sizeof(hwid_src));
	size = sizeof(hwid_src) + 1;
	TEST_SUCC(vb2api_gbb_read_hwid(ctx, hwid, &size),
	"read normal HWID");
	TEST_EQ(strcmp(hwid, "Test HWID"), 0, " HWID correct");
	TEST_EQ(strlen(hwid) + 1, size, " HWID size consistent");
	TEST_EQ(strlen(hwid), strlen("Test HWID"),
	" HWID size correct");
	}

	/* HWID with garbage */
	{
	const char hwid_src[] = "Test HWID\0garbagegarbage";
	reset_common_data();
	set_gbb_hwid(hwid_src, sizeof(hwid_src));
	size = VB2_GBB_HWID_MAX_SIZE;
	TEST_SUCC(vb2api_gbb_read_hwid(ctx, hwid, &size),
	"read HWID with garbage");
	TEST_EQ(strcmp(hwid, "Test HWID"), 0, " HWID correct");
	TEST_EQ(strlen(hwid) + 1, size, " HWID size consistent");
	TEST_EQ(strlen(hwid), strlen("Test HWID"),
	" HWID size correct");
	}
	}

	int main(int argc, char* argv[])
	{
	flag_tests();
	key_tests();
	hwid_tests();

	return gTestSuccess ? 0 : 255;
	}