blob: 047fa423658c4fd99cbce778a3f10bcefabd48eb [file] [log] [blame]
/* Copyright 2019 The Chromium OS Authors. All rights reserved.
* 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 "test_common.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;
}