scottk/OpenCellular
1
0
Fork 0
mirror of https://github.com/Telecominfraproject/OpenCellular.git synced 2025-11-24 18:25:10 +00:00
Code Issues Packages Projects Releases Wiki Activity

Remove dead ECPreamble code

Browse Source 
BUG=none
BRANCH=none
TEST=make runtests

Change-Id: I99d8124a7d5a3a644f0d8d64ad36f51e78d851e5
Signed-off-by: Randall Spangler <rspangler@chromium.org>
Reviewed-on: https://gerrit.chromium.org/gerrit/42018
Reviewed-by: Bill Richardson <wfrichar@chromium.org>
This commit is contained in:
Randall Spangler
2013-01-25 10:14:10 -08:00
committed by ChromeBot
parent a2db67d204
commit 8fd1aaf66e
3 changed files with 125 additions and 229 deletions
Download Patch File Download Diff File Expand all files Collapse all files

46
firmware/include/vboot_struct.h
View File

@@ -94,52 +94,6 @@ typedef struct VbKeyBlockHeader {
/****************************************************************************/ /****************************************************************************/
#define EC_PREAMBLE_HEADER_VERSION_MAJOR 1
#define EC_PREAMBLE_HEADER_VERSION_MINOR 0
/* Flags for VbECPreambleHeader.flags */
/*
* Use the normal boot path from the read-only firmware, instead of verifying
* the body signature.
*/
#define VB_EC_PREAMBLE_USE_RO_NORMAL 0x00000001
/*
* Premable block for EC rewritable firmware, version 1.0.
*
* The firmware preamble header should be followed by:
* 1) The signature data for the firmware body, pointed to by
* body_signature.sig_offset.
* 2) The signature data for (header + body signature data), pointed
* to by preamble_signature.sig_offset.
*/
typedef struct VbECPreambleHeader {
/*
* Size of this preamble, including keys, signatures, and padding, in
* bytes
*/
uint64_t preamble_size;
/* Signature for this preamble (header + * body signature) */
VbSignature preamble_signature;
/* Version of this header format */
uint32_t header_version_major;
/* Version of this header format */
uint32_t header_version_minor;
/* Firmware version */
uint64_t firmware_version;
/* Digest for the firmware body */
VbSignature body_digest;
/* Flags; see VB_EC_PREAMBLE_* */
uint32_t flags;
/* Human-readable ASCII, null-padded */
char name[128];
} __attribute__((packed)) VbECPreambleHeader;
#define EXPECTED_VB_EC_PREAMBLE_HEADER1_0_SIZE 76
/****************************************************************************/
#define FIRMWARE_PREAMBLE_HEADER_VERSION_MAJOR 2 #define FIRMWARE_PREAMBLE_HEADER_VERSION_MAJOR 2
#define FIRMWARE_PREAMBLE_HEADER_VERSION_MINOR 1 #define FIRMWARE_PREAMBLE_HEADER_VERSION_MINOR 1

50
host/include/host_common.h
View File

@@ -1,4 +1,4 @@
/* Copyright (c) 2010 The Chromium OS Authors. All rights reserved. /* 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 * Use of this source code is governed by a BSD-style license that can be
* found in the LICENSE file. * found in the LICENSE file.
* *
@@ -8,8 +8,10 @@
#ifndef VBOOT_REFERENCE_HOST_COMMON_H_ #ifndef VBOOT_REFERENCE_HOST_COMMON_H_
#define VBOOT_REFERENCE_HOST_COMMON_H_ #define VBOOT_REFERENCE_HOST_COMMON_H_
/* Host is allowed direct use of stdlib funcs such as malloc() and free(), /*
* since it's using the stub implementation from firmware/lib/stub. */ * Host is allowed direct use of stdlib funcs such as malloc() and free(),
* since it's using the stub implementation from firmware/lib/stub.
*/
#define _STUB_IMPLEMENTATION_ #define _STUB_IMPLEMENTATION_
#include "cryptolib.h" #include "cryptolib.h"
@@ -21,42 +23,34 @@
#include "vboot_api.h" #include "vboot_api.h"
#include "vboot_struct.h" #include "vboot_struct.h"
/**
/* Creates an EC preamble, signed with [signing_key]. * Create a firmware preamble, signed with [signing_key].
*
* Caller owns the returned pointer, and must free it with Free(). * Caller owns the returned pointer, and must free it with Free().
* *
* Returns NULL if error. */ * Returns NULL if error.
VbECPreambleHeader* CreateECPreamble( */
VbFirmwarePreambleHeader *CreateFirmwarePreamble(
uint64_t firmware_version, uint64_t firmware_version,
const VbSignature* body_signature, const VbPublicKey *kernel_subkey,
const VbPrivateKey* signing_key, const VbSignature *body_signature,
uint32_t flags, const VbPrivateKey *signing_key,
const char* name);
/* Creates a firmware preamble, signed with [signing_key].
* Caller owns the returned pointer, and must free it with Free().
*
* Returns NULL if error. */
VbFirmwarePreambleHeader* CreateFirmwarePreamble(
uint64_t firmware_version,
const VbPublicKey* kernel_subkey,
const VbSignature* body_signature,
const VbPrivateKey* signing_key,
uint32_t flags); uint32_t flags);
/**
/* Creates a kernel preamble, signed with [signing_key]. * Create a kernel preamble, signed with [signing_key].
*
* Caller owns the returned pointer, and must free it with Free(). * Caller owns the returned pointer, and must free it with Free().
* *
* Returns NULL if error. */ * Returns NULL if error.
VbKernelPreambleHeader* CreateKernelPreamble( */
VbKernelPreambleHeader *CreateKernelPreamble(
uint64_t kernel_version, uint64_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, uint64_t bootloader_size,
const VbSignature* body_signature, const VbSignature *body_signature,
uint64_t desired_size, uint64_t desired_size,
const VbPrivateKey* signing_key); const VbPrivateKey *signing_key);
#endif /* VBOOT_REFERENCE_HOST_COMMON_H_ */ #endif /* VBOOT_REFERENCE_HOST_COMMON_H_ */

110
host/lib/host_common.c
View File

@@ -1,90 +1,43 @@
/* Copyright (c) 2011 The Chromium OS Authors. All rights reserved. /* 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 * Use of this source code is governed by a BSD-style license that can be
* 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.
*/ */
/* TODO: change all 'return 0', 'return 1' into meaningful return codes */
#include <string.h> #include <string.h>
#include "host_common.h" #include "host_common.h"
#include "cryptolib.h" #include "cryptolib.h"
#include "utility.h" #include "utility.h"
#include "vboot_common.h" #include "vboot_common.h"
VbECPreambleHeader* CreateECPreamble( VbFirmwarePreambleHeader *CreateFirmwarePreamble(
uint64_t firmware_version, uint64_t firmware_version,
const VbSignature* body_digest, const VbPublicKey *kernel_subkey,
const VbPrivateKey* signing_key, const VbSignature *body_signature,
uint32_t flags, const VbPrivateKey *signing_key,
const char* name) { uint32_t flags)
{
VbECPreambleHeader* h; VbFirmwarePreambleHeader *h;
uint64_t signed_size = (sizeof(VbECPreambleHeader) + body_digest->sig_size);
uint64_t block_size = signed_size + siglen_map[signing_key->algorithm];
uint8_t* body_digest_dest;
uint8_t* block_sig_dest;
VbSignature *sigtmp;
/* Allocate key block */
h = (VbECPreambleHeader*)malloc(block_size);
if (!h)
return NULL;
Memset(h, 0, block_size);
body_digest_dest = (uint8_t*)(h + 1);
block_sig_dest = body_digest_dest + body_digest->sig_size;
h->header_version_major = EC_PREAMBLE_HEADER_VERSION_MAJOR;
h->header_version_minor = EC_PREAMBLE_HEADER_VERSION_MINOR;
h->preamble_size = block_size;
h->firmware_version = firmware_version;
h->flags = flags;
if (name)
strncpy(h->name, name, sizeof(h->name));
/* Copy body hash */
SignatureInit(&h->body_digest, body_digest_dest,
body_digest->sig_size, 0);
SignatureCopy(&h->body_digest, body_digest);
/* Set up signature struct so we can calculate the signature */
SignatureInit(&h->preamble_signature, block_sig_dest,
siglen_map[signing_key->algorithm], signed_size);
/* Calculate signature */
sigtmp = CalculateSignature((uint8_t*)h, signed_size, signing_key);
SignatureCopy(&h->preamble_signature, sigtmp);
free(sigtmp);
/* Return the header */
return h;
}
VbFirmwarePreambleHeader* CreateFirmwarePreamble(
uint64_t firmware_version,
const VbPublicKey* kernel_subkey,
const VbSignature* body_signature,
const VbPrivateKey* signing_key,
uint32_t flags) {
VbFirmwarePreambleHeader* h;
uint64_t signed_size = (sizeof(VbFirmwarePreambleHeader) + uint64_t signed_size = (sizeof(VbFirmwarePreambleHeader) +
kernel_subkey->key_size + kernel_subkey->key_size +
body_signature->sig_size); body_signature->sig_size);
uint64_t block_size = signed_size + siglen_map[signing_key->algorithm]; uint64_t block_size = signed_size + siglen_map[signing_key->algorithm];
uint8_t* kernel_subkey_dest; uint8_t *kernel_subkey_dest;
uint8_t* body_sig_dest; uint8_t *body_sig_dest;
uint8_t* block_sig_dest; uint8_t *block_sig_dest;
VbSignature *sigtmp; VbSignature *sigtmp;
/* Allocate key block */ /* Allocate key block */
h = (VbFirmwarePreambleHeader*)malloc(block_size); h = (VbFirmwarePreambleHeader *)malloc(block_size);
if (!h) if (!h)
return NULL; return NULL;
Memset(h, 0, block_size); Memset(h, 0, block_size);
kernel_subkey_dest = (uint8_t*)(h + 1); kernel_subkey_dest = (uint8_t *)(h + 1);
body_sig_dest = kernel_subkey_dest + kernel_subkey->key_size; body_sig_dest = kernel_subkey_dest + kernel_subkey->key_size;
block_sig_dest = body_sig_dest + body_signature->sig_size; block_sig_dest = body_sig_dest + body_signature->sig_size;
@@ -109,7 +62,7 @@ VbFirmwarePreambleHeader* CreateFirmwarePreamble(
siglen_map[signing_key->algorithm], signed_size); siglen_map[signing_key->algorithm], signed_size);
/* Calculate signature */ /* Calculate signature */
sigtmp = CalculateSignature((uint8_t*)h, signed_size, signing_key); sigtmp = CalculateSignature((uint8_t *)h, signed_size, signing_key);
SignatureCopy(&h->preamble_signature, sigtmp); SignatureCopy(&h->preamble_signature, sigtmp);
free(sigtmp); free(sigtmp);
@@ -117,26 +70,21 @@ VbFirmwarePreambleHeader* CreateFirmwarePreamble(
return h; return h;
} }
VbKernelPreambleHeader *CreateKernelPreamble(
/* Creates a kernel preamble, signed with [signing_key].
* Caller owns the returned pointer, and must free it with free().
*
* Returns NULL if error. */
VbKernelPreambleHeader* CreateKernelPreamble(
uint64_t kernel_version, uint64_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, uint64_t bootloader_size,
const VbSignature* body_signature, const VbSignature *body_signature,
uint64_t desired_size, uint64_t desired_size,
const VbPrivateKey* signing_key) { const VbPrivateKey *signing_key)
{
VbKernelPreambleHeader* h; VbKernelPreambleHeader *h;
uint64_t signed_size = (sizeof(VbKernelPreambleHeader) + uint64_t signed_size = (sizeof(VbKernelPreambleHeader) +
body_signature->sig_size); body_signature->sig_size);
uint64_t block_size = signed_size + siglen_map[signing_key->algorithm]; uint64_t block_size = signed_size + siglen_map[signing_key->algorithm];
uint8_t* body_sig_dest; uint8_t *body_sig_dest;
uint8_t* block_sig_dest; uint8_t *block_sig_dest;
VbSignature *sigtmp; VbSignature *sigtmp;
/* If the block size is smaller than the desired size, pad it */ /* If the block size is smaller than the desired size, pad it */
@@ -144,12 +92,12 @@ VbKernelPreambleHeader* CreateKernelPreamble(
block_size = desired_size; block_size = desired_size;
/* Allocate key block */ /* Allocate key block */
h = (VbKernelPreambleHeader*)malloc(block_size); h = (VbKernelPreambleHeader *)malloc(block_size);
Memset(h, 0, block_size);
if (!h) if (!h)
return NULL; return NULL;
body_sig_dest = (uint8_t*)(h + 1);
Memset(h, 0, block_size);
body_sig_dest = (uint8_t *)(h + 1);
block_sig_dest = body_sig_dest + body_signature->sig_size; 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;
@@ -170,7 +118,7 @@ VbKernelPreambleHeader* CreateKernelPreamble(
siglen_map[signing_key->algorithm], signed_size); siglen_map[signing_key->algorithm], signed_size);
/* Calculate signature */ /* Calculate signature */
sigtmp = CalculateSignature((uint8_t*)h, signed_size, signing_key); sigtmp = CalculateSignature((uint8_t *)h, signed_size, signing_key);
SignatureCopy(&h->preamble_signature, sigtmp); SignatureCopy(&h->preamble_signature, sigtmp);
free(sigtmp); free(sigtmp);