blob: 65792e9237187e403945d55c5afbf519036248ae [file] [log] [blame]
/* 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.
*
* Functions for loading a kernel from disk.
* (Firmware portion)
*/
#include "sysincludes.h"
#include "2sysincludes.h"
#include "2common.h"
#include "2rsa.h"
#include "2sha.h"
#include "cgptlib.h"
#include "cgptlib_internal.h"
#include "region.h"
#include "gbb_access.h"
#include "gbb_header.h"
#include "gpt_misc.h"
#include "load_kernel_fw.h"
#include "rollback_index.h"
#include "utility.h"
#include "vb2_common.h"
#include "vboot_api.h"
#include "vboot_common.h"
#include "vboot_kernel.h"
#define KBUF_SIZE 65536 /* Bytes to read at start of kernel partition */
#define LOWEST_TPM_VERSION 0xffffffff
typedef enum BootMode {
kBootRecovery = 0, /* Recovery firmware, any dev switch position */
kBootNormal = 1, /* Normal boot - kernel must be verified */
kBootDev = 2 /* Developer boot - self-signed kernel ok */
} BootMode;
VbError_t LoadKernel(LoadKernelParams *params, VbCommonParams *cparams)
{
VbSharedDataHeader *shared =
(VbSharedDataHeader *)params->shared_data_blob;
VbSharedDataKernelCall *shcall = NULL;
VbNvContext *vnc = params->nv_context;
VbPublicKey *kernel_subkey = NULL;
int free_kernel_subkey = 0;
GptData gpt;
uint64_t part_start, part_size;
uint64_t blba;
uint64_t kbuf_sectors;
uint8_t *kbuf = NULL;
int found_partitions = 0;
int good_partition = -1;
int good_partition_key_block_valid = 0;
uint32_t lowest_version = LOWEST_TPM_VERSION;
int rec_switch, dev_switch;
BootMode boot_mode;
uint32_t require_official_os = 0;
uint32_t body_toread;
uint8_t *body_readptr;
VbError_t retval = VBERROR_UNKNOWN;
int recovery = VBNV_RECOVERY_LK_UNSPECIFIED;
uint8_t *workbuf = NULL;
struct vb2_workbuf wb;
/* Sanity Checks */
if (!params->bytes_per_lba ||
!params->streaming_lba_count) {
VBDEBUG(("LoadKernel() called with invalid params\n"));
retval = VBERROR_INVALID_PARAMETER;
goto LoadKernelExit;
}
/* Clear output params in case we fail */
params->partition_number = 0;
params->bootloader_address = 0;
params->bootloader_size = 0;
params->flags = 0;
/* Calculate switch positions and boot mode */
rec_switch = (BOOT_FLAG_RECOVERY & params->boot_flags ? 1 : 0);
dev_switch = (BOOT_FLAG_DEVELOPER & params->boot_flags ? 1 : 0);
if (rec_switch) {
boot_mode = kBootRecovery;
} else if (dev_switch) {
boot_mode = kBootDev;
VbNvGet(vnc, VBNV_DEV_BOOT_SIGNED_ONLY, &require_official_os);
if (params->fwmp &&
(params->fwmp->flags & FWMP_DEV_ENABLE_OFFICIAL_ONLY))
require_official_os = 1;
} else {
boot_mode = kBootNormal;
}
/*
* Set up tracking for this call. This wraps around if called many
* times, so we need to initialize the call entry each time.
*/
shcall = shared->lk_calls + (shared->lk_call_count
& (VBSD_MAX_KERNEL_CALLS - 1));
memset(shcall, 0, sizeof(VbSharedDataKernelCall));
shcall->boot_flags = (uint32_t)params->boot_flags;
shcall->boot_mode = boot_mode;
shcall->sector_size = (uint32_t)params->bytes_per_lba;
shcall->sector_count = params->streaming_lba_count;
shared->lk_call_count++;
/* Initialization */
blba = params->bytes_per_lba;
kbuf_sectors = KBUF_SIZE / blba;
if (0 == kbuf_sectors) {
VBDEBUG(("LoadKernel() called with sector size > KBUF_SIZE\n"));
retval = VBERROR_INVALID_PARAMETER;
goto LoadKernelExit;
}
if (kBootRecovery == boot_mode) {
/* Use the recovery key to verify the kernel */
retval = VbGbbReadRecoveryKey(cparams, &kernel_subkey);
if (VBERROR_SUCCESS != retval)
goto LoadKernelExit;
free_kernel_subkey = 1;
} else {
/* Use the kernel subkey passed from LoadFirmware(). */
kernel_subkey = &shared->kernel_subkey;
}
/* Read GPT data */
gpt.sector_bytes = (uint32_t)blba;
gpt.streaming_drive_sectors = params->streaming_lba_count;
gpt.gpt_drive_sectors = params->gpt_lba_count;
gpt.flags = params->boot_flags & BOOT_FLAG_EXTERNAL_GPT
? GPT_FLAG_EXTERNAL : 0;
if (0 != AllocAndReadGptData(params->disk_handle, &gpt)) {
VBDEBUG(("Unable to read GPT data\n"));
shcall->check_result = VBSD_LKC_CHECK_GPT_READ_ERROR;
goto bad_gpt;
}
/* Initialize GPT library */
if (GPT_SUCCESS != GptInit(&gpt)) {
VBDEBUG(("Error parsing GPT\n"));
shcall->check_result = VBSD_LKC_CHECK_GPT_PARSE_ERROR;
goto bad_gpt;
}
/* Allocate kernel header buffers */
kbuf = (uint8_t *)malloc(KBUF_SIZE);
if (!kbuf)
goto bad_gpt;
/* Allocate work buffer */
workbuf = (uint8_t *)malloc(VB2_KERNEL_WORKBUF_RECOMMENDED_SIZE);
if (!workbuf)
goto bad_gpt;
vb2_workbuf_init(&wb, workbuf, VB2_KERNEL_WORKBUF_RECOMMENDED_SIZE);
/* Unpack kernel subkey */
struct vb2_public_key kernel_subkey2;
if (VB2_SUCCESS != vb2_unpack_key(&kernel_subkey2,
(const uint8_t *)kernel_subkey,
kernel_subkey->key_offset +
kernel_subkey->key_size)) {
VBDEBUG(("Unable to unpack kernel subkey\n"));
goto bad_gpt;
}
/* Loop over candidate kernel partitions */
while (GPT_SUCCESS ==
GptNextKernelEntry(&gpt, &part_start, &part_size)) {
VbSharedDataKernelPart *shpart = NULL;
VbKeyBlockHeader *key_block;
VbKernelPreambleHeader *preamble;
VbExStream_t stream = NULL;
uint64_t key_version;
uint32_t combined_version;
uint64_t body_offset;
int key_block_valid = 1;
VBDEBUG(("Found kernel entry at %" PRIu64 " size %" PRIu64 "\n",
part_start, part_size));
/*
* Set up tracking for this partition. This wraps around if
* called many times, so initialize the partition entry each
* time.
*/
shpart = shcall->parts + (shcall->kernel_parts_found
& (VBSD_MAX_KERNEL_PARTS - 1));
memset(shpart, 0, sizeof(VbSharedDataKernelPart));
shpart->sector_start = part_start;
shpart->sector_count = part_size;
/*
* TODO: GPT partitions start at 1, but cgptlib starts them at
* 0. Adjust here, until cgptlib is fixed.
*/
shpart->gpt_index = (uint8_t)(gpt.current_kernel + 1);
shcall->kernel_parts_found++;
/* Found at least one kernel partition. */
found_partitions++;
/* Set up the stream */
if (VbExStreamOpen(params->disk_handle,
part_start, part_size, &stream)) {
VBDEBUG(("Partition error getting stream.\n"));
shpart->check_result = VBSD_LKP_CHECK_TOO_SMALL;
goto bad_kernel;
}
if (0 != VbExStreamRead(stream, KBUF_SIZE, kbuf)) {
VBDEBUG(("Unable to read start of partition.\n"));
shpart->check_result = VBSD_LKP_CHECK_READ_START;
goto bad_kernel;
}
/* Verify the key block. */
key_block = (VbKeyBlockHeader*)kbuf;
struct vb2_keyblock *keyblock2 = (struct vb2_keyblock *)kbuf;
if (VB2_SUCCESS != vb2_verify_keyblock(keyblock2, KBUF_SIZE,
&kernel_subkey2, &wb)) {
VBDEBUG(("Verifying key block signature failed.\n"));
shpart->check_result = VBSD_LKP_CHECK_KEY_BLOCK_SIG;
key_block_valid = 0;
/* If not in developer mode, this kernel is bad. */
if (kBootDev != boot_mode)
goto bad_kernel;
/*
* In developer mode, we can explicitly disallow
* self-signed kernels
*/
if (require_official_os) {
VBDEBUG(("Self-signed kernels not enabled.\n"));
shpart->check_result =
VBSD_LKP_CHECK_SELF_SIGNED;
goto bad_kernel;
}
/*
* Allow the kernel if the SHA-512 hash of the key
* block is valid.
*/
if (VB2_SUCCESS !=
vb2_verify_keyblock_hash(keyblock2, KBUF_SIZE,
&wb)) {
VBDEBUG(("Verifying key block hash failed.\n"));
shpart->check_result =
VBSD_LKP_CHECK_KEY_BLOCK_HASH;
goto bad_kernel;
}
}
/* Check the key block flags against the current boot mode. */
if (!(key_block->key_block_flags &
(dev_switch ? KEY_BLOCK_FLAG_DEVELOPER_1 :
KEY_BLOCK_FLAG_DEVELOPER_0))) {
VBDEBUG(("Key block developer flag mismatch.\n"));
shpart->check_result = VBSD_LKP_CHECK_DEV_MISMATCH;
key_block_valid = 0;
}
if (!(key_block->key_block_flags &
(rec_switch ? KEY_BLOCK_FLAG_RECOVERY_1 :
KEY_BLOCK_FLAG_RECOVERY_0))) {
VBDEBUG(("Key block recovery flag mismatch.\n"));
shpart->check_result = VBSD_LKP_CHECK_REC_MISMATCH;
key_block_valid = 0;
}
/* Check for rollback of key version except in recovery mode. */
key_version = key_block->data_key.key_version;
if (kBootRecovery != boot_mode) {
if (key_version < (shared->kernel_version_tpm >> 16)) {
VBDEBUG(("Key version too old.\n"));
shpart->check_result =
VBSD_LKP_CHECK_KEY_ROLLBACK;
key_block_valid = 0;
}
if (key_version > 0xFFFF) {
/*
* Key version is stored in 16 bits in the TPM,
* so key versions greater than 0xFFFF can't be
* stored properly.
*/
VBDEBUG(("Key version > 0xFFFF.\n"));
shpart->check_result =
VBSD_LKP_CHECK_KEY_ROLLBACK;
key_block_valid = 0;
}
}
/* If not in developer mode, key block required to be valid. */
if (kBootDev != boot_mode && !key_block_valid) {
VBDEBUG(("Key block is invalid.\n"));
goto bad_kernel;
}
/* If in developer mode and using key hash, check it */
if ((kBootDev == boot_mode) &&
params->fwmp &&
(params->fwmp->flags & FWMP_DEV_USE_KEY_HASH)) {
VbPublicKey *key = &key_block->data_key;
uint8_t *buf = ((uint8_t *)key) + key->key_offset;
uint64_t buflen = key->key_size;
uint8_t digest[VB2_SHA256_DIGEST_SIZE];
VBDEBUG(("Checking developer key hash.\n"));
vb2_digest_buffer(buf, buflen, VB2_HASH_SHA256,
digest, sizeof(digest));
if (0 != vb2_safe_memcmp(digest,
params->fwmp->dev_key_hash,
VB2_SHA256_DIGEST_SIZE)) {
int i;
VBDEBUG(("Wrong developer key hash.\n"));
VBDEBUG(("Want: "));
for (i = 0; i < VB2_SHA256_DIGEST_SIZE; i++)
VBDEBUG(("%02x",
params->
fwmp->dev_key_hash[i]));
VBDEBUG(("\nGot: "));
for (i = 0; i < VB2_SHA256_DIGEST_SIZE; i++)
VBDEBUG(("%02x", digest[i]));
VBDEBUG(("\n"));
goto bad_kernel;
}
}
/* Get key for preamble/data verification from the key block. */
struct vb2_public_key data_key2;
if (VB2_SUCCESS !=
vb2_unpack_key(&data_key2,
(const uint8_t *)&keyblock2->data_key,
keyblock2->data_key.key_offset +
keyblock2->data_key.key_size)) {
VBDEBUG(("Unable to unpack kernel data key\n"));
shpart->check_result = VBSD_LKP_CHECK_DATA_KEY_PARSE;
goto bad_kernel;
}
/* Verify the preamble, which follows the key block */
preamble = (VbKernelPreambleHeader *)
(kbuf + key_block->key_block_size);
struct vb2_kernel_preamble *preamble2 =
(struct vb2_kernel_preamble *)
(kbuf + key_block->key_block_size);
if (VB2_SUCCESS != vb2_verify_kernel_preamble(
preamble2,
KBUF_SIZE - key_block->key_block_size,
&data_key2,
&wb)) {
VBDEBUG(("Preamble verification failed.\n"));
shpart->check_result = VBSD_LKP_CHECK_VERIFY_PREAMBLE;
goto bad_kernel;
}
/*
* If the key block is valid and we're not in recovery mode,
* check for rollback of the kernel version.
*/
combined_version = (uint32_t)(
(key_version << 16) |
(preamble->kernel_version & 0xFFFF));
shpart->combined_version = combined_version;
if (key_block_valid && kBootRecovery != boot_mode) {
if (combined_version < shared->kernel_version_tpm) {
VBDEBUG(("Kernel version too low.\n"));
shpart->check_result =
VBSD_LKP_CHECK_KERNEL_ROLLBACK;
/*
* If not in developer mode, kernel version
* must be valid.
*/
if (kBootDev != boot_mode)
goto bad_kernel;
}
}
VBDEBUG(("Kernel preamble is good.\n"));
shpart->check_result = VBSD_LKP_CHECK_PREAMBLE_VALID;
/* Check for lowest version from a valid header. */
if (key_block_valid && lowest_version > combined_version)
lowest_version = combined_version;
else {
VBDEBUG(("Key block valid: %d\n", key_block_valid));
VBDEBUG(("Combined version: %u\n",
(unsigned) combined_version));
}
/*
* If we already have a good kernel, no need to read another
* one; we only needed to look at the versions to check for
* rollback. So skip to the next kernel preamble.
*/
if (-1 != good_partition) {
VbExStreamClose(stream);
stream = NULL;
continue;
}
body_offset = key_block->key_block_size +
preamble->preamble_size;
/*
* Make sure the kernel starts at or before what we already
* read into kbuf.
*
* We could deal with a larger offset by reading and discarding
* the data in between the vblock and the kernel data.
*/
if (body_offset > KBUF_SIZE) {
shpart->check_result = VBSD_LKP_CHECK_BODY_OFFSET;
VBDEBUG(("Kernel body offset is %d > 64KB.\n",
(int)body_offset));
goto bad_kernel;
}
if (!params->kernel_buffer) {
/* Get kernel load address and size from the header. */
params->kernel_buffer =
(void *)((long)preamble->body_load_address);
params->kernel_buffer_size =
preamble->body_signature.data_size;
} else if (preamble->body_signature.data_size >
params->kernel_buffer_size) {
VBDEBUG(("Kernel body doesn't fit in memory.\n"));
shpart->check_result = VBSD_LKP_CHECK_BODY_EXCEEDS_MEM;
goto bad_kernel;
}
/*
* Body signature data size is 64 bit and toread is 32 bit so
* this could technically cause us to read less data. That's
* fine, because a 4 GB kernel is implausible, and if we did
* have one that big, we'd simply read too little data and fail
* to verify it.
*/
body_toread = preamble->body_signature.data_size;
body_readptr = params->kernel_buffer;
/*
* If we've already read part of the kernel, copy that to the
* beginning of the kernel buffer.
*/
if (body_offset < KBUF_SIZE) {
uint32_t body_copied = KBUF_SIZE - body_offset;
/* If the kernel is tiny, don't over-copy */
if (body_copied > body_toread)
body_copied = body_toread;
memcpy(body_readptr, kbuf + body_offset, body_copied);
body_toread -= body_copied;
body_readptr += body_copied;
}
/* Read the kernel data */
if (body_toread &&
0 != VbExStreamRead(stream, body_toread, body_readptr)) {
VBDEBUG(("Unable to read kernel data.\n"));
shpart->check_result = VBSD_LKP_CHECK_READ_DATA;
goto bad_kernel;
}
/* Close the stream; we're done with it */
VbExStreamClose(stream);
stream = NULL;
/* Verify kernel data */
struct vb2_signature *body_sig = (struct vb2_signature *)
&preamble->body_signature;
if (VB2_SUCCESS != vb2_verify_data(
(const uint8_t *)params->kernel_buffer,
params->kernel_buffer_size,
body_sig, &data_key2, &wb)) {
VBDEBUG(("Kernel data verification failed.\n"));
shpart->check_result = VBSD_LKP_CHECK_VERIFY_DATA;
goto bad_kernel;
}
/*
* If we're still here, the kernel is valid. Save the first
* good partition we find; that's the one we'll boot.
*/
VBDEBUG(("Partition is good.\n"));
shpart->check_result = VBSD_LKP_CHECK_KERNEL_GOOD;
if (key_block_valid)
shpart->flags |= VBSD_LKP_FLAG_KEY_BLOCK_VALID;
good_partition_key_block_valid = key_block_valid;
/*
* TODO: GPT partitions start at 1, but cgptlib starts them at
* 0. Adjust here, until cgptlib is fixed.
*/
good_partition = gpt.current_kernel + 1;
params->partition_number = gpt.current_kernel + 1;
GetCurrentKernelUniqueGuid(&gpt, &params->partition_guid);
/*
* TODO: GetCurrentKernelUniqueGuid() should take a destination
* size, or the dest should be a struct, so we know it's big
* enough.
*/
params->bootloader_address = preamble->bootloader_address;
params->bootloader_size = preamble->bootloader_size;
if (VbKernelHasFlags(preamble) == VBOOT_SUCCESS)
params->flags = preamble->flags;
/* Update GPT to note this is the kernel we're trying.
* But not when we assume that the boot process may
* not complete for valid reasons (eg. early shutdown).
*/
if (!(shared->flags & VBSD_NOFAIL_BOOT))
GptUpdateKernelEntry(&gpt, GPT_UPDATE_ENTRY_TRY);
/*
* If we're in recovery mode or we're about to boot a
* dev-signed kernel, there's no rollback protection, so we can
* stop at the first valid kernel.
*/
if (kBootRecovery == boot_mode || !key_block_valid) {
VBDEBUG(("In recovery mode or dev-signed kernel\n"));
break;
}
/*
* Otherwise, we do care about the key index in the TPM. If
* the good partition's key version is the same as the tpm,
* then the TPM doesn't need updating; we can stop now.
* Otherwise, we'll check all the other headers to see if they
* contain a newer key.
*/
if (combined_version == shared->kernel_version_tpm) {
VBDEBUG(("Same kernel version\n"));
break;
}
/* Continue, so that we skip the error handling code below */
continue;
bad_kernel:
/* Handle errors parsing this kernel */
if (NULL != stream)
VbExStreamClose(stream);
VBDEBUG(("Marking kernel as invalid.\n"));
GptUpdateKernelEntry(&gpt, GPT_UPDATE_ENTRY_BAD);
} /* while(GptNextKernelEntry) */
bad_gpt:
/* Free buffers */
if (workbuf)
free(workbuf);
if (kbuf)
free(kbuf);
/* Write and free GPT data */
WriteAndFreeGptData(params->disk_handle, &gpt);
/* Handle finding a good partition */
if (good_partition >= 0) {
VBDEBUG(("Good_partition >= 0\n"));
shcall->check_result = VBSD_LKC_CHECK_GOOD_PARTITION;
shared->kernel_version_lowest = lowest_version;
/*
* Sanity check - only store a new TPM version if we found one.
* If lowest_version is still at its initial value, we didn't
* find one; for example, we're in developer mode and just
* didn't look.
*/
if (lowest_version != LOWEST_TPM_VERSION &&
lowest_version > shared->kernel_version_tpm)
shared->kernel_version_tpm = lowest_version;
/* Success! */
retval = VBERROR_SUCCESS;
} else if (found_partitions > 0) {
shcall->check_result = VBSD_LKC_CHECK_INVALID_PARTITIONS;
recovery = VBNV_RECOVERY_RW_INVALID_OS;
retval = VBERROR_INVALID_KERNEL_FOUND;
} else {
shcall->check_result = VBSD_LKC_CHECK_NO_PARTITIONS;
recovery = VBNV_RECOVERY_RW_NO_OS;
retval = VBERROR_NO_KERNEL_FOUND;
}
LoadKernelExit:
/* Store recovery request, if any */
VbNvSet(vnc, VBNV_RECOVERY_REQUEST, VBERROR_SUCCESS != retval ?
recovery : VBNV_RECOVERY_NOT_REQUESTED);
/*
* If LoadKernel() was called with bad parameters, shcall may not be
* initialized.
*/
if (shcall)
shcall->return_code = (uint8_t)retval;
/* Save whether the good partition's key block was fully verified */
if (good_partition_key_block_valid)
shared->flags |= VBSD_KERNEL_KEY_VERIFIED;
/* Store how much shared data we used, if any */
params->shared_data_size = shared->data_used;
if (free_kernel_subkey)
free(kernel_subkey);
return retval;
}