137 lines
4.4 KiB
C
137 lines
4.4 KiB
C
/* Copyright (c) 2013 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 firmware vboot_common.c
|
|
*/
|
|
|
|
#include <stdint.h>
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
|
|
#include "2common.h"
|
|
#include "host_common.h"
|
|
#include "test_common.h"
|
|
#include "utility.h"
|
|
#include "vboot_common.h"
|
|
|
|
/*
|
|
* Test struct packing for vboot_struct.h structs which are passed between
|
|
* firmware and OS, or passed between different phases of firmware.
|
|
*/
|
|
static void StructPackingTest(void)
|
|
{
|
|
TEST_EQ(EXPECTED_VBKERNELPREAMBLEHEADER2_2_SIZE,
|
|
sizeof(VbKernelPreambleHeader),
|
|
"sizeof(VbKernelPreambleHeader)");
|
|
|
|
TEST_EQ(VB_SHARED_DATA_HEADER_SIZE_V1,
|
|
(long)&((VbSharedDataHeader*)NULL)->recovery_reason,
|
|
"sizeof(VbSharedDataHeader) V1");
|
|
|
|
TEST_EQ(VB_SHARED_DATA_HEADER_SIZE_V2,
|
|
sizeof(VbSharedDataHeader),
|
|
"sizeof(VbSharedDataHeader) V2");
|
|
}
|
|
|
|
/* Public key utility functions */
|
|
static void PublicKeyTest(void)
|
|
{
|
|
struct vb2_packed_key k[3];
|
|
struct vb2_packed_key j[5];
|
|
|
|
/* Fill some bits of the public key data */
|
|
memset(j, 0, sizeof(j));
|
|
memset(k, 0x42, sizeof(k));
|
|
k[1].key_size = 12345;
|
|
k[2].key_version = 67;
|
|
|
|
PublicKeyInit(k, (uint8_t*)(k + 1), 2 * sizeof(struct vb2_packed_key));
|
|
TEST_EQ(k->key_offset, sizeof(struct vb2_packed_key),
|
|
"PublicKeyInit key_offset");
|
|
TEST_EQ(k->key_size, 2 * sizeof(struct vb2_packed_key),
|
|
"PublicKeyInit key_size");
|
|
TEST_EQ(k->algorithm, VB2_ALG_COUNT, "PublicKeyInit algorithm");
|
|
TEST_EQ(k->key_version, 0, "PublicKeyInit key_version");
|
|
|
|
/* Set algorithm and version, so we can tell if they get copied */
|
|
k->algorithm = 3;
|
|
k->key_version = 21;
|
|
|
|
/* Copying to a smaller destination should fail */
|
|
PublicKeyInit(j, (uint8_t*)(j + 1),
|
|
2 * sizeof(struct vb2_packed_key) - 1);
|
|
TEST_NEQ(0, PublicKeyCopy(j, k), "PublicKeyCopy too small");
|
|
|
|
/* Copying to same or larger size should succeed */
|
|
PublicKeyInit(j, (uint8_t*)(j + 2),
|
|
2 * sizeof(struct vb2_packed_key) + 1);
|
|
TEST_EQ(0, PublicKeyCopy(j, k), "PublicKeyCopy same");
|
|
/* Offset in destination shouldn't have been modified */
|
|
TEST_EQ(j->key_offset, 2 * sizeof(struct vb2_packed_key),
|
|
"PublicKeyCopy key_offset");
|
|
/* Size should have been reduced to match the source */
|
|
TEST_EQ(k->key_size, 2 * sizeof(struct vb2_packed_key),
|
|
"PublicKeyCopy key_size");
|
|
/* Other fields should have been copied */
|
|
TEST_EQ(k->algorithm, j->algorithm, "PublicKeyCopy algorithm");
|
|
TEST_EQ(k->key_version, j->key_version, "PublicKeyCopy key_version");
|
|
/* Data should have been copied */
|
|
TEST_EQ(0,
|
|
memcmp(vb2_packed_key_data(k),
|
|
vb2_packed_key_data(j), k->key_size),
|
|
"PublicKeyCopy data");
|
|
}
|
|
|
|
/* VbSharedData utility tests */
|
|
static void VbSharedDataTest(void)
|
|
{
|
|
uint8_t buf[VB_SHARED_DATA_MIN_SIZE + 1];
|
|
VbSharedDataHeader* d = (VbSharedDataHeader*)buf;
|
|
|
|
TEST_NEQ(VB2_SUCCESS,
|
|
VbSharedDataInit(d, sizeof(VbSharedDataHeader) - 1),
|
|
"VbSharedDataInit too small");
|
|
TEST_NEQ(VB2_SUCCESS,
|
|
VbSharedDataInit(d, VB_SHARED_DATA_MIN_SIZE - 1),
|
|
"VbSharedDataInit too small 2");
|
|
TEST_NEQ(VB2_SUCCESS,
|
|
VbSharedDataInit(NULL, VB_SHARED_DATA_MIN_SIZE),
|
|
"VbSharedDataInit null");
|
|
|
|
memset(buf, 0x68, sizeof(buf));
|
|
TEST_EQ(VB2_SUCCESS, VbSharedDataInit(d, VB_SHARED_DATA_MIN_SIZE),
|
|
"VbSharedDataInit");
|
|
|
|
/* Check fields that should have been initialized */
|
|
TEST_EQ(d->magic, VB_SHARED_DATA_MAGIC, "VbSharedDataInit magic");
|
|
TEST_EQ(d->struct_version, VB_SHARED_DATA_VERSION,
|
|
"VbSharedDataInit version");
|
|
TEST_EQ(d->struct_size, sizeof(VbSharedDataHeader),
|
|
"VbSharedDataInit struct_size");
|
|
TEST_EQ(d->data_size, VB_SHARED_DATA_MIN_SIZE,
|
|
"VbSharedDataInit data_size");
|
|
TEST_EQ(d->data_used, d->struct_size, "VbSharedDataInit data_used");
|
|
TEST_EQ(d->firmware_index, 0xFF, "VbSharedDataInit firmware index");
|
|
|
|
/* Sample some other fields to make sure they were zeroed */
|
|
TEST_EQ(d->flags, 0, "VbSharedDataInit firmware flags");
|
|
TEST_EQ(d->lk_call_count, 0, "VbSharedDataInit lk_call_count");
|
|
TEST_EQ(d->kernel_version_lowest, 0,
|
|
"VbSharedDataInit kernel_version_lowest");
|
|
|
|
TEST_EQ(VBOOT_SHARED_DATA_INVALID, VbSharedDataSetKernelKey(NULL, NULL),
|
|
"VbSharedDataSetKernelKey sd null");
|
|
TEST_EQ(VBOOT_PUBLIC_KEY_INVALID, VbSharedDataSetKernelKey(d, NULL),
|
|
"VbSharedDataSetKernelKey pubkey null");
|
|
}
|
|
|
|
int main(int argc, char* argv[])
|
|
{
|
|
StructPackingTest();
|
|
PublicKeyTest();
|
|
VbSharedDataTest();
|
|
|
|
return gTestSuccess ? 0 : 255;
|
|
}
|