scottk/OpenCellular
1
0
Fork 0
mirror of https://github.com/Telecominfraproject/OpenCellular.git synced 2025-11-27 03:33:50 +00:00
Code Issues Packages Projects Releases Wiki Activity

vboot: replace CreateKernelPreamble() with vboot2 equivalent

Browse Source 
Continued refactoring of host library to kernel style / vboot2 structs.

BUG=chromium:611535
BRANCH=none
TEST=make runtests

Change-Id: Ifed376812ed7690eea1ec0dfab958e836f7724a0
Signed-off-by: Randall Spangler <rspangler@chromium.org>
Reviewed-on: https://chromium-review.googlesource.com/363951
Reviewed-by: Daisuke Nojiri <dnojiri@chromium.org>
This commit is contained in:
Randall Spangler
2016-06-30 11:24:24 -07:00
committed by chrome-bot
parent 0efc4f3ee1
commit a62ffa8d61
8 changed files with 129 additions and 150 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
Makefile
View File

@@ -460,7 +460,6 @@ UTILLIB_SRCS = \
host/lib/file_keys.c \ host/lib/file_keys.c \
host/lib/fmap.c \ host/lib/fmap.c \
host/lib/host_common.c \ host/lib/host_common.c \
host/lib/host_common2.c \
host/lib/host_key.c \ host/lib/host_key.c \
host/lib/host_key2.c \ host/lib/host_key2.c \
host/lib/host_keyblock.c \ host/lib/host_keyblock.c \

43
futility/vb1_helper.c
View File

@@ -411,43 +411,40 @@ uint8_t *SignKernelBlob(uint8_t *kernel_blob, uint64_t kernel_size,
struct vb2_private_key *signpriv_key, struct vb2_private_key *signpriv_key,
uint32_t flags, uint64_t *vblock_size_ptr) uint32_t flags, uint64_t *vblock_size_ptr)
{ {
VbSignature *body_sig; /* Make sure the preamble fills up the rest of the required padding */
VbKernelPreambleHeader *preamble; uint32_t min_size = padding > keyblock->keyblock_size
uint64_t min_size = padding > keyblock->keyblock_size
? padding - keyblock->keyblock_size : 0; ? padding - keyblock->keyblock_size : 0;
void *outbuf;
uint64_t outsize;
/* Sign the kernel data */ /* Sign the kernel data */
body_sig = (VbSignature *)vb2_calculate_signature(kernel_blob, struct vb2_signature *body_sig = vb2_calculate_signature(kernel_blob,
kernel_size, kernel_size,
signpriv_key); signpriv_key);
if (!body_sig) { if (!body_sig) {
fprintf(stderr, "Error calculating body signature\n"); fprintf(stderr, "Error calculating body signature\n");
return NULL; return NULL;
} }
/* Create preamble */ /* Create preamble */
preamble = CreateKernelPreamble(version, struct vb2_kernel_preamble *preamble =
kernel_body_load_address, vb2_create_kernel_preamble(version,
g_ondisk_bootloader_addr, kernel_body_load_address,
g_bootloader_size, g_ondisk_bootloader_addr,
body_sig, g_bootloader_size,
g_ondisk_vmlinuz_header_addr, body_sig,
g_vmlinuz_header_size, g_ondisk_vmlinuz_header_addr,
flags, g_vmlinuz_header_size,
min_size, flags,
signpriv_key); min_size,
signpriv_key);
if (!preamble) { if (!preamble) {
fprintf(stderr, "Error creating preamble.\n"); fprintf(stderr, "Error creating preamble.\n");
return 0; return 0;
} }
outsize = keyblock->keyblock_size + preamble->preamble_size; uint32_t outsize = keyblock->keyblock_size + preamble->preamble_size;
outbuf = malloc(outsize); void *outbuf = calloc(outsize, 1);
Memset(outbuf, 0, outsize); memcpy(outbuf, keyblock, keyblock->keyblock_size);
Memcpy(outbuf, keyblock, keyblock->keyblock_size); memcpy(outbuf + keyblock->keyblock_size,
Memcpy(outbuf + keyblock->keyblock_size,
preamble, preamble->preamble_size); preamble, preamble->preamble_size);
if (vblock_size_ptr) if (vblock_size_ptr)

102
host/lib/host_common.c
View File

@@ -3,8 +3,6 @@
* found in the LICENSE file. * found in the LICENSE file.
* *
* Host functions for verified boot. * Host functions for verified boot.
*
* TODO: change all 'return 0', 'return 1' into meaningful return codes.
*/ */
#include <string.h> #include <string.h>
@@ -16,39 +14,99 @@
#include "host_key2.h" #include "host_key2.h"
#include "cryptolib.h" #include "cryptolib.h"
#include "utility.h" #include "utility.h"
#include "vb2_common.h"
#include "vboot_common.h" #include "vboot_common.h"
VbKernelPreambleHeader *CreateKernelPreamble( struct vb2_fw_preamble *vb2_create_fw_preamble(
uint64_t kernel_version, uint32_t firmware_version,
const struct vb2_packed_key *kernel_subkey,
const struct vb2_signature *body_signature,
const struct vb2_private_key *signing_key,
uint32_t flags)
{
uint32_t signed_size = (sizeof(struct vb2_fw_preamble) +
kernel_subkey->key_size +
body_signature->sig_size);
uint32_t block_size = signed_size +
vb2_rsa_sig_size(signing_key->sig_alg);
/* Allocate key block */
struct vb2_fw_preamble *h =
(struct vb2_fw_preamble *)calloc(block_size, 1);
if (!h)
return NULL;
uint8_t *kernel_subkey_dest = (uint8_t *)(h + 1);
uint8_t *body_sig_dest = kernel_subkey_dest + kernel_subkey->key_size;
uint8_t *block_sig_dest = body_sig_dest + body_signature->sig_size;
h->header_version_major = FIRMWARE_PREAMBLE_HEADER_VERSION_MAJOR;
h->header_version_minor = FIRMWARE_PREAMBLE_HEADER_VERSION_MINOR;
h->preamble_size = block_size;
h->firmware_version = firmware_version;
h->flags = flags;
/* Copy data key */
vb2_init_packed_key(&h->kernel_subkey, kernel_subkey_dest,
kernel_subkey->key_size);
if (VB2_SUCCESS !=
vb2_copy_packed_key(&h->kernel_subkey, kernel_subkey)) {
free(h);
return NULL;
}
/* Copy body signature */
vb2_init_signature(&h->body_signature,
body_sig_dest, body_signature->sig_size, 0);
if (VB2_SUCCESS !=
vb2_copy_signature(&h->body_signature, body_signature)) {
free(h);
return NULL;
}
/* Set up signature struct so we can calculate the signature */
vb2_init_signature(&h->preamble_signature, block_sig_dest,
vb2_rsa_sig_size(signing_key->sig_alg), signed_size);
/* Calculate signature */
struct vb2_signature *sig =
vb2_calculate_signature((uint8_t *)h, signed_size, signing_key);
vb2_copy_signature(&h->preamble_signature, sig);
free(sig);
/* Return the header */
return h;
}
struct vb2_kernel_preamble *vb2_create_kernel_preamble(
uint32_t kernel_version,
uint64_t body_load_address, uint64_t body_load_address,
uint64_t bootloader_address, uint64_t bootloader_address,
uint64_t bootloader_size, uint32_t bootloader_size,
const VbSignature *body_signature, const struct vb2_signature *body_signature,
uint64_t vmlinuz_header_address, uint64_t vmlinuz_header_address,
uint64_t vmlinuz_header_size, uint32_t vmlinuz_header_size,
uint32_t flags, uint32_t flags,
uint64_t desired_size, uint32_t desired_size,
const struct vb2_private_key *signing_key) const struct vb2_private_key *signing_key)
{ {
VbKernelPreambleHeader *h; uint64_t signed_size = (sizeof(struct vb2_kernel_preamble) +
uint64_t signed_size = (sizeof(VbKernelPreambleHeader) +
body_signature->sig_size); body_signature->sig_size);
uint32_t sig_size = vb2_rsa_sig_size(signing_key->sig_alg); uint32_t sig_size = vb2_rsa_sig_size(signing_key->sig_alg);
uint64_t block_size = signed_size + sig_size; uint32_t block_size = signed_size + sig_size;
uint8_t *body_sig_dest;
uint8_t *block_sig_dest;
/* If the block size is smaller than the desired size, pad it */ /* If the block size is smaller than the desired size, pad it */
if (block_size < desired_size) if (block_size < desired_size)
block_size = desired_size; block_size = desired_size;
/* Allocate key block */ /* Allocate key block */
h = (VbKernelPreambleHeader *)calloc(block_size, 1); struct vb2_kernel_preamble *h =
(struct vb2_kernel_preamble *)calloc(block_size, 1);
if (!h) if (!h)
return NULL; return NULL;
body_sig_dest = (uint8_t *)(h + 1); uint8_t *body_sig_dest = (uint8_t *)(h + 1);
block_sig_dest = body_sig_dest + body_signature->sig_size; uint8_t *block_sig_dest = body_sig_dest + body_signature->sig_size;
h->header_version_major = KERNEL_PREAMBLE_HEADER_VERSION_MAJOR; h->header_version_major = KERNEL_PREAMBLE_HEADER_VERSION_MAJOR;
h->header_version_minor = KERNEL_PREAMBLE_HEADER_VERSION_MINOR; h->header_version_minor = KERNEL_PREAMBLE_HEADER_VERSION_MINOR;
@@ -62,18 +120,18 @@ VbKernelPreambleHeader *CreateKernelPreamble(
h->flags = flags; h->flags = flags;
/* Copy body signature */ /* Copy body signature */
SignatureInit(&h->body_signature, body_sig_dest, vb2_init_signature(&h->body_signature, body_sig_dest,
body_signature->sig_size, 0); body_signature->sig_size, 0);
SignatureCopy(&h->body_signature, body_signature); vb2_copy_signature(&h->body_signature, body_signature);
/* Set up signature struct so we can calculate the signature */ /* Set up signature struct so we can calculate the signature */
SignatureInit(&h->preamble_signature, block_sig_dest, vb2_init_signature(&h->preamble_signature, block_sig_dest,
sig_size, signed_size); sig_size, signed_size);
/* Calculate signature */ /* Calculate signature */
struct vb2_signature *sigtmp = struct vb2_signature *sigtmp =
vb2_calculate_signature((uint8_t *)h, signed_size, signing_key); vb2_calculate_signature((uint8_t *)h, signed_size, signing_key);
SignatureCopy(&h->preamble_signature, (VbSignature *)sigtmp); vb2_copy_signature(&h->preamble_signature, sigtmp);
free(sigtmp); free(sigtmp);
/* Return the header */ /* Return the header */

81
host/lib/host_common2.c
View File

@@ -1,81 +0,0 @@
/* 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.
*
* Host functions for verified boot.
*
* TODO: change all 'return 0', 'return 1' into meaningful return codes.
*/
#include <string.h>
#include "2sysincludes.h"
#include "2common.h"
#include "2rsa.h"
#include "host_common.h"
#include "host_key2.h"
#include "cryptolib.h"
#include "utility.h"
#include "vb2_common.h"
#include "vboot_common.h"
struct vb2_fw_preamble *vb2_create_fw_preamble(
uint32_t firmware_version,
const struct vb2_packed_key *kernel_subkey,
const struct vb2_signature *body_signature,
const struct vb2_private_key *signing_key,
uint32_t flags)
{
uint32_t signed_size = (sizeof(struct vb2_fw_preamble) +
kernel_subkey->key_size +
body_signature->sig_size);
uint32_t block_size = signed_size +
vb2_rsa_sig_size(signing_key->sig_alg);
/* Allocate preamble */
struct vb2_fw_preamble *h =
(struct vb2_fw_preamble *)calloc(block_size, 1);
if (!h)
return NULL;
uint8_t *kernel_subkey_dest = (uint8_t *)(h + 1);
uint8_t *body_sig_dest = kernel_subkey_dest + kernel_subkey->key_size;
uint8_t *block_sig_dest = body_sig_dest + body_signature->sig_size;
h->header_version_major = FIRMWARE_PREAMBLE_HEADER_VERSION_MAJOR;
h->header_version_minor = FIRMWARE_PREAMBLE_HEADER_VERSION_MINOR;
h->preamble_size = block_size;
h->firmware_version = firmware_version;
h->flags = flags;
/* Copy data key */
vb2_init_packed_key(&h->kernel_subkey, kernel_subkey_dest,
kernel_subkey->key_size);
if (VB2_SUCCESS !=
vb2_copy_packed_key(&h->kernel_subkey, kernel_subkey)) {
free(h);
return NULL;
}
/* Copy body signature */
vb2_init_signature(&h->body_signature,
body_sig_dest, body_signature->sig_size, 0);
if (VB2_SUCCESS !=
vb2_copy_signature(&h->body_signature, body_signature)) {
free(h);
return NULL;
}
/* Set up signature struct so we can calculate the signature */
vb2_init_signature(&h->preamble_signature, block_sig_dest,
vb2_rsa_sig_size(signing_key->sig_alg), signed_size);
/* Calculate signature */
struct vb2_signature *sig =
vb2_calculate_signature((uint8_t *)h, signed_size, signing_key);
vb2_copy_signature(&h->preamble_signature, sig);
free(sig);
/* Return the header */
return h;
}

28
host/lib/include/host_common.h
View File

@@ -41,23 +41,33 @@ struct vb2_fw_preamble *vb2_create_fw_preamble(
const struct vb2_private_key *signing_key, const struct vb2_private_key *signing_key,
uint32_t flags); uint32_t flags);
/** /**
* Create a kernel preamble, signed with [signing_key]. * Create a kernel preamble.
* *
* Caller owns the returned pointer, and must free it with Free(). * @param kernel_version Firmware version
* @param body_load_address Load address for kernel body
* @param bootloader_address Load address for bootloader
* @param bootloader_size Size of bootloader in bytes
* @param body_signature Signature of kernel body
* @param vmlinuz_header_address Load address for 16-bit vmlinuz header
* @param vmlinuz_header_size Size of 16-bit vmlinuz header in bytes
* @param flags Kernel preamble flags
* @param desired_size Minimum size of preamble in bytes
* @param signing_key Private key to sign header with
* *
* Returns NULL if error. * @return The preamble, or NULL if error. Caller must free() it.
*/ */
VbKernelPreambleHeader *CreateKernelPreamble( struct vb2_kernel_preamble *vb2_create_kernel_preamble(
uint64_t kernel_version, uint32_t kernel_version,
uint64_t body_load_address, uint64_t body_load_address,
uint64_t bootloader_address, uint64_t bootloader_address,
uint64_t bootloader_size, uint32_t bootloader_size,
const VbSignature *body_signature, const struct vb2_signature *body_signature,
uint64_t vmlinuz_header_address, uint64_t vmlinuz_header_address,
uint64_t vmlinuz_header_size, uint32_t vmlinuz_header_size,
uint32_t flags, uint32_t flags,
uint64_t desired_size, uint32_t desired_size,
const struct vb2_private_key *signing_key); const struct vb2_private_key *signing_key);
#endif /* VBOOT_REFERENCE_HOST_COMMON_H_ */ #endif /* VBOOT_REFERENCE_HOST_COMMON_H_ */

3
host/linktest/main.c
View File

@@ -24,9 +24,6 @@ int main(void)
SignatureAlloc(0, 0); SignatureAlloc(0, 0);
SignatureCopy(0, 0); SignatureCopy(0, 0);
/* host_common.h */
CreateKernelPreamble(0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
/* file_keys.h */ /* file_keys.h */
BufferFromFile(0, 0); BufferFromFile(0, 0);
RSAPublicKeyFromFile(0); RSAPublicKeyFromFile(0);

14
tests/vb20_common3_tests.c
View File

@@ -343,8 +343,6 @@ static void test_verify_kernel_preamble(
const struct vb2_packed_key *public_key, const struct vb2_packed_key *public_key,
const struct vb2_private_key *private_key) const struct vb2_private_key *private_key)
{ {
struct vb2_kernel_preamble *hdr;
struct vb2_kernel_preamble *h;
struct vb2_public_key rsa; struct vb2_public_key rsa;
// TODO: how many workbuf bytes? // TODO: how many workbuf bytes?
uint8_t workbuf[VB2_VERIFY_FIRMWARE_PREAMBLE_WORKBUF_BYTES] uint8_t workbuf[VB2_VERIFY_FIRMWARE_PREAMBLE_WORKBUF_BYTES]
@@ -361,17 +359,17 @@ static void test_verify_kernel_preamble(
public_key->key_offset + public_key->key_size), public_key->key_offset + public_key->key_size),
"vb2_verify_kernel_preamble() prereq key"); "vb2_verify_kernel_preamble() prereq key");
hdr = (struct vb2_kernel_preamble *) struct vb2_kernel_preamble *hdr =
CreateKernelPreamble(0x1234, 0x100000, 0x300000, 0x4000, vb2_create_kernel_preamble(0x1234, 0x100000, 0x300000, 0x4000,
(VbSignature *)body_sig, body_sig, 0x304000, 0x10000, 0, 0,
0x304000, 0x10000, 0, 0, private_key);
private_key);
TEST_PTR_NEQ(hdr, NULL, TEST_PTR_NEQ(hdr, NULL,
"vb2_verify_kernel_preamble() prereq test preamble"); "vb2_verify_kernel_preamble() prereq test preamble");
if (!hdr) if (!hdr)
return; return;
hsize = (uint32_t) hdr->preamble_size; hsize = (uint32_t) hdr->preamble_size;
h = (struct vb2_kernel_preamble *)malloc(hsize + 16384); struct vb2_kernel_preamble *h =
(struct vb2_kernel_preamble *)malloc(hsize + 16384);
Memcpy(h, hdr, hsize); Memcpy(h, hdr, hsize);
TEST_SUCC(vb2_verify_kernel_preamble(h, hsize, &rsa, &wb), TEST_SUCC(vb2_verify_kernel_preamble(h, hsize, &rsa, &wb),

7
tests/vboot_common2_tests.c
View File

@@ -133,11 +133,12 @@ static void VerifyKernelPreambleTest(const VbPublicKey *public_key,
unsigned hsize; unsigned hsize;
/* Create a dummy signature */ /* Create a dummy signature */
VbSignature *body_sig = SignatureAlloc(56, 78); struct vb2_signature *body_sig = vb2_alloc_signature(56, 78);
rsa = PublicKeyToRSA(public_key); rsa = PublicKeyToRSA(public_key);
hdr = CreateKernelPreamble(0x1234, 0x100000, 0x300000, 0x4000, body_sig, hdr = (VbKernelPreambleHeader *)
0, 0, 0, 0, private_key); vb2_create_kernel_preamble(0x1234, 0x100000, 0x300000, 0x4000,
body_sig, 0, 0, 0, 0, private_key);
TEST_NEQ(hdr && rsa, 0, "VerifyKernelPreamble() prerequisites"); TEST_NEQ(hdr && rsa, 0, "VerifyKernelPreamble() prerequisites");
if (!hdr) if (!hdr)
return; return;