mirror of
https://github.com/brain-hackers/u-boot-brain
synced 2024-08-19 08:28:51 +09:00
![Simon Glass](/assets/img/avatar_default.png)
At present panic() is in the vsprintf.h header file. That does not seem like an obvious choice for hang(), even though it relates to panic(). So let's put hang() in its own header. Signed-off-by: Simon Glass <sjg@chromium.org> [trini: Migrate a few more files] Signed-off-by: Tom Rini <trini@konsulko.com>
1242 lines
28 KiB
C
1242 lines
28 KiB
C
// SPDX-License-Identifier: GPL-2.0+
|
|
/*
|
|
* (C) Copyright 2013
|
|
* Reinhard Pfau, Guntermann & Drunck GmbH, reinhard.pfau@gdsys.cc
|
|
*/
|
|
|
|
/* TODO: some more #ifdef's to avoid unneeded code for stage 1 / stage 2 */
|
|
|
|
#ifdef CCDM_ID_DEBUG
|
|
#define DEBUG
|
|
#endif
|
|
|
|
#include <common.h>
|
|
#include <command.h>
|
|
#include <dm.h>
|
|
#include <env.h>
|
|
#include <hang.h>
|
|
#include <malloc.h>
|
|
#include <fs.h>
|
|
#include <i2c.h>
|
|
#include <mmc.h>
|
|
#include <tpm-v1.h>
|
|
#include <u-boot/crc.h>
|
|
#include <u-boot/sha1.h>
|
|
#include <asm/byteorder.h>
|
|
#include <asm/unaligned.h>
|
|
#include <pca9698.h>
|
|
|
|
#undef CCDM_FIRST_STAGE
|
|
#undef CCDM_SECOND_STAGE
|
|
#undef CCDM_AUTO_FIRST_STAGE
|
|
|
|
#ifdef CONFIG_DEVELOP
|
|
#define CCDM_DEVELOP
|
|
#endif
|
|
|
|
#ifdef CONFIG_TRAILBLAZER
|
|
#define CCDM_FIRST_STAGE
|
|
#undef CCDM_SECOND_STAGE
|
|
#else
|
|
#undef CCDM_FIRST_STAGE
|
|
#define CCDM_SECOND_STAGE
|
|
#endif
|
|
|
|
#if defined(CCDM_DEVELOP) && defined(CCDM_SECOND_STAGE) && \
|
|
!defined(CCCM_FIRST_STAGE)
|
|
#define CCDM_AUTO_FIRST_STAGE
|
|
#endif
|
|
|
|
/* CCDM specific contants */
|
|
enum {
|
|
/* NV indices */
|
|
NV_COMMON_DATA_INDEX = 0x40000001,
|
|
/* magics for key blob chains */
|
|
MAGIC_KEY_PROGRAM = 0x68726500,
|
|
MAGIC_HMAC = 0x68616300,
|
|
MAGIC_END_OF_CHAIN = 0x00000000,
|
|
/* sizes */
|
|
NV_COMMON_DATA_MIN_SIZE = 3 * sizeof(uint64_t) + 2 * sizeof(uint16_t),
|
|
};
|
|
|
|
/* other constants */
|
|
enum {
|
|
ESDHC_BOOT_IMAGE_SIG_OFS = 0x40,
|
|
ESDHC_BOOT_IMAGE_SIZE_OFS = 0x48,
|
|
ESDHC_BOOT_IMAGE_ADDR_OFS = 0x50,
|
|
ESDHC_BOOT_IMAGE_TARGET_OFS = 0x58,
|
|
ESDHC_BOOT_IMAGE_ENTRY_OFS = 0x60,
|
|
};
|
|
|
|
enum {
|
|
I2C_SOC_0 = 0,
|
|
I2C_SOC_1 = 1,
|
|
};
|
|
|
|
struct key_program {
|
|
uint32_t magic;
|
|
uint32_t code_crc;
|
|
uint32_t code_size;
|
|
uint8_t code[];
|
|
};
|
|
|
|
struct h_reg {
|
|
bool valid;
|
|
uint8_t digest[20];
|
|
};
|
|
|
|
|
|
enum access_mode {
|
|
HREG_NONE = 0,
|
|
HREG_RD = 1,
|
|
HREG_WR = 2,
|
|
HREG_RDWR = 3,
|
|
};
|
|
|
|
/* register constants */
|
|
enum {
|
|
FIX_HREG_DEVICE_ID_HASH = 0,
|
|
FIX_HREG_SELF_HASH = 1,
|
|
FIX_HREG_STAGE2_HASH = 2,
|
|
FIX_HREG_VENDOR = 3,
|
|
COUNT_FIX_HREGS
|
|
};
|
|
|
|
|
|
/* hre opcodes */
|
|
enum {
|
|
/* opcodes w/o data */
|
|
HRE_NOP = 0x00,
|
|
HRE_SYNC = HRE_NOP,
|
|
HRE_CHECK0 = 0x01,
|
|
/* opcodes w/o data, w/ sync dst */
|
|
/* opcodes w/ data */
|
|
HRE_LOAD = 0x81,
|
|
/* opcodes w/data, w/sync dst */
|
|
HRE_XOR = 0xC1,
|
|
HRE_AND = 0xC2,
|
|
HRE_OR = 0xC3,
|
|
HRE_EXTEND = 0xC4,
|
|
HRE_LOADKEY = 0xC5,
|
|
};
|
|
|
|
/* hre errors */
|
|
enum {
|
|
HRE_E_OK = 0,
|
|
HRE_E_TPM_FAILURE,
|
|
HRE_E_INVALID_HREG,
|
|
};
|
|
|
|
static uint64_t device_id;
|
|
static uint64_t device_cl;
|
|
static uint64_t device_type;
|
|
|
|
static uint32_t platform_key_handle;
|
|
|
|
static void(*bl2_entry)(void);
|
|
|
|
static struct h_reg pcr_hregs[24];
|
|
static struct h_reg fix_hregs[COUNT_FIX_HREGS];
|
|
static struct h_reg var_hregs[8];
|
|
static uint32_t hre_tpm_err;
|
|
static int hre_err = HRE_E_OK;
|
|
|
|
#define IS_PCR_HREG(spec) ((spec) & 0x20)
|
|
#define IS_FIX_HREG(spec) (((spec) & 0x38) == 0x08)
|
|
#define IS_VAR_HREG(spec) (((spec) & 0x38) == 0x10)
|
|
#define HREG_IDX(spec) ((spec) & (IS_PCR_HREG(spec) ? 0x1f : 0x7))
|
|
|
|
static int get_tpm(struct udevice **devp)
|
|
{
|
|
int rc;
|
|
|
|
rc = uclass_first_device_err(UCLASS_TPM, devp);
|
|
if (rc) {
|
|
printf("Could not find TPM (ret=%d)\n", rc);
|
|
return CMD_RET_FAILURE;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
static const uint8_t vendor[] = "Guntermann & Drunck";
|
|
|
|
/**
|
|
* @brief read a bunch of data from MMC into memory.
|
|
*
|
|
* @param mmc pointer to the mmc structure to use.
|
|
* @param src offset where the data starts on MMC/SD device (in bytes).
|
|
* @param dst pointer to the location where the read data should be stored.
|
|
* @param size number of bytes to read from the MMC/SD device.
|
|
* @return number of bytes read or -1 on error.
|
|
*/
|
|
static int ccdm_mmc_read(struct mmc *mmc, u64 src, u8 *dst, int size)
|
|
{
|
|
int result = 0;
|
|
u32 blk_len, ofs;
|
|
ulong block_no, n, cnt;
|
|
u8 *tmp_buf = NULL;
|
|
|
|
if (size <= 0)
|
|
goto end;
|
|
|
|
blk_len = mmc->read_bl_len;
|
|
tmp_buf = malloc(blk_len);
|
|
if (!tmp_buf)
|
|
goto failure;
|
|
block_no = src / blk_len;
|
|
ofs = src % blk_len;
|
|
|
|
if (ofs) {
|
|
n = mmc->block_dev.block_read(&mmc->block_dev, block_no++, 1,
|
|
tmp_buf);
|
|
if (!n)
|
|
goto failure;
|
|
result = min(size, (int)(blk_len - ofs));
|
|
memcpy(dst, tmp_buf + ofs, result);
|
|
dst += result;
|
|
size -= result;
|
|
}
|
|
cnt = size / blk_len;
|
|
if (cnt) {
|
|
n = mmc->block_dev.block_read(&mmc->block_dev, block_no, cnt,
|
|
dst);
|
|
if (n != cnt)
|
|
goto failure;
|
|
size -= cnt * blk_len;
|
|
result += cnt * blk_len;
|
|
dst += cnt * blk_len;
|
|
block_no += cnt;
|
|
}
|
|
if (size) {
|
|
n = mmc->block_dev.block_read(&mmc->block_dev, block_no++, 1,
|
|
tmp_buf);
|
|
if (!n)
|
|
goto failure;
|
|
memcpy(dst, tmp_buf, size);
|
|
result += size;
|
|
}
|
|
goto end;
|
|
failure:
|
|
result = -1;
|
|
end:
|
|
if (tmp_buf)
|
|
free(tmp_buf);
|
|
return result;
|
|
}
|
|
|
|
/**
|
|
* @brief returns a location where the 2nd stage bootloader can be(/ is) placed.
|
|
*
|
|
* @return pointer to the location for/of the 2nd stage bootloader
|
|
*/
|
|
static u8 *get_2nd_stage_bl_location(ulong target_addr)
|
|
{
|
|
ulong addr;
|
|
#ifdef CCDM_SECOND_STAGE
|
|
addr = env_get_ulong("loadaddr", 16, CONFIG_LOADADDR);
|
|
#else
|
|
addr = target_addr;
|
|
#endif
|
|
return (u8 *)(addr);
|
|
}
|
|
|
|
|
|
#ifdef CCDM_SECOND_STAGE
|
|
/**
|
|
* @brief returns a location where the image can be(/ is) placed.
|
|
*
|
|
* @return pointer to the location for/of the image
|
|
*/
|
|
static u8 *get_image_location(void)
|
|
{
|
|
ulong addr;
|
|
/* TODO use other area? */
|
|
addr = env_get_ulong("loadaddr", 16, CONFIG_LOADADDR);
|
|
return (u8 *)(addr);
|
|
}
|
|
#endif
|
|
|
|
/**
|
|
* @brief get the size of a given (TPM) NV area
|
|
* @param index NV index of the area to get size for
|
|
* @param size pointer to the size
|
|
* @return 0 on success, != 0 on error
|
|
*/
|
|
static int get_tpm_nv_size(struct udevice *tpm, uint32_t index, uint32_t *size)
|
|
{
|
|
uint32_t err;
|
|
uint8_t info[72];
|
|
uint8_t *ptr;
|
|
uint16_t v16;
|
|
|
|
err = tpm_get_capability(tpm, TPM_CAP_NV_INDEX, index,
|
|
info, sizeof(info));
|
|
if (err) {
|
|
printf("tpm_get_capability(CAP_NV_INDEX, %08x) failed: %u\n",
|
|
index, err);
|
|
return 1;
|
|
}
|
|
|
|
/* skip tag and nvIndex */
|
|
ptr = info + 6;
|
|
/* skip 2 pcr info fields */
|
|
v16 = get_unaligned_be16(ptr);
|
|
ptr += 2 + v16 + 1 + 20;
|
|
v16 = get_unaligned_be16(ptr);
|
|
ptr += 2 + v16 + 1 + 20;
|
|
/* skip permission and flags */
|
|
ptr += 6 + 3;
|
|
|
|
*size = get_unaligned_be32(ptr);
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* @brief search for a key by usage auth and pub key hash.
|
|
* @param auth usage auth of the key to search for
|
|
* @param pubkey_digest (SHA1) hash of the pub key structure of the key
|
|
* @param[out] handle the handle of the key iff found
|
|
* @return 0 if key was found in TPM; != 0 if not.
|
|
*/
|
|
static int find_key(struct udevice *tpm, const uint8_t auth[20],
|
|
const uint8_t pubkey_digest[20], uint32_t *handle)
|
|
{
|
|
uint16_t key_count;
|
|
uint32_t key_handles[10];
|
|
uint8_t buf[288];
|
|
uint8_t *ptr;
|
|
uint32_t err;
|
|
uint8_t digest[20];
|
|
size_t buf_len;
|
|
unsigned int i;
|
|
|
|
/* fetch list of already loaded keys in the TPM */
|
|
err = tpm_get_capability(tpm, TPM_CAP_HANDLE, TPM_RT_KEY, buf,
|
|
sizeof(buf));
|
|
if (err)
|
|
return -1;
|
|
key_count = get_unaligned_be16(buf);
|
|
ptr = buf + 2;
|
|
for (i = 0; i < key_count; ++i, ptr += 4)
|
|
key_handles[i] = get_unaligned_be32(ptr);
|
|
|
|
/* now search a(/ the) key which we can access with the given auth */
|
|
for (i = 0; i < key_count; ++i) {
|
|
buf_len = sizeof(buf);
|
|
err = tpm_get_pub_key_oiap(tpm, key_handles[i], auth, buf,
|
|
&buf_len);
|
|
if (err && err != TPM_AUTHFAIL)
|
|
return -1;
|
|
if (err)
|
|
continue;
|
|
sha1_csum(buf, buf_len, digest);
|
|
if (!memcmp(digest, pubkey_digest, 20)) {
|
|
*handle = key_handles[i];
|
|
return 0;
|
|
}
|
|
}
|
|
return 1;
|
|
}
|
|
|
|
/**
|
|
* @brief read CCDM common data from TPM NV
|
|
* @return 0 if CCDM common data was found and read, !=0 if something failed.
|
|
*/
|
|
static int read_common_data(struct udevice *tpm)
|
|
{
|
|
uint32_t size;
|
|
uint32_t err;
|
|
uint8_t buf[256];
|
|
sha1_context ctx;
|
|
|
|
if (get_tpm_nv_size(tpm, NV_COMMON_DATA_INDEX, &size) ||
|
|
size < NV_COMMON_DATA_MIN_SIZE)
|
|
return 1;
|
|
err = tpm_nv_read_value(tpm, NV_COMMON_DATA_INDEX,
|
|
buf, min(sizeof(buf), size));
|
|
if (err) {
|
|
printf("tpm_nv_read_value() failed: %u\n", err);
|
|
return 1;
|
|
}
|
|
|
|
device_id = get_unaligned_be64(buf);
|
|
device_cl = get_unaligned_be64(buf + 8);
|
|
device_type = get_unaligned_be64(buf + 16);
|
|
|
|
sha1_starts(&ctx);
|
|
sha1_update(&ctx, buf, 24);
|
|
sha1_finish(&ctx, fix_hregs[FIX_HREG_DEVICE_ID_HASH].digest);
|
|
fix_hregs[FIX_HREG_DEVICE_ID_HASH].valid = true;
|
|
|
|
platform_key_handle = get_unaligned_be32(buf + 24);
|
|
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* @brief compute hash of bootloader itself.
|
|
* @param[out] dst hash register where the hash should be stored
|
|
* @return 0 on success, != 0 on failure.
|
|
*
|
|
* @note MUST be called at a time where the boot loader is accessible at the
|
|
* configured location (; so take care when code is reallocated).
|
|
*/
|
|
static int compute_self_hash(struct h_reg *dst)
|
|
{
|
|
sha1_csum((const uint8_t *)CONFIG_SYS_MONITOR_BASE,
|
|
CONFIG_SYS_MONITOR_LEN, dst->digest);
|
|
dst->valid = true;
|
|
return 0;
|
|
}
|
|
|
|
int ccdm_compute_self_hash(void)
|
|
{
|
|
if (!fix_hregs[FIX_HREG_SELF_HASH].valid)
|
|
compute_self_hash(&fix_hregs[FIX_HREG_SELF_HASH]);
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* @brief compute the hash of the 2nd stage boot loader (on SD card)
|
|
* @param[out] dst hash register to store the computed hash
|
|
* @return 0 on success, != 0 on failure
|
|
*
|
|
* Determines the size and location of the 2nd stage boot loader on SD card,
|
|
* loads the 2nd stage boot loader and computes the (SHA1) hash value.
|
|
* Within the 1st stage boot loader, the 2nd stage boot loader is loaded at
|
|
* the desired memory location and the variable @a bl2_entry is set.
|
|
*
|
|
* @note This sets the variable @a bl2_entry to the entry point when the
|
|
* 2nd stage boot loader is loaded at its configured memory location.
|
|
*/
|
|
static int compute_second_stage_hash(struct h_reg *dst)
|
|
{
|
|
int result = 0;
|
|
u32 code_len, code_offset, target_addr, exec_entry;
|
|
struct mmc *mmc;
|
|
u8 *load_addr = NULL;
|
|
u8 buf[128];
|
|
|
|
mmc = find_mmc_device(0);
|
|
if (!mmc)
|
|
goto failure;
|
|
mmc_init(mmc);
|
|
|
|
if (ccdm_mmc_read(mmc, 0, buf, sizeof(buf)) < 0)
|
|
goto failure;
|
|
|
|
code_offset = *(u32 *)(buf + ESDHC_BOOT_IMAGE_ADDR_OFS);
|
|
code_len = *(u32 *)(buf + ESDHC_BOOT_IMAGE_SIZE_OFS);
|
|
target_addr = *(u32 *)(buf + ESDHC_BOOT_IMAGE_TARGET_OFS);
|
|
exec_entry = *(u32 *)(buf + ESDHC_BOOT_IMAGE_ENTRY_OFS);
|
|
|
|
load_addr = get_2nd_stage_bl_location(target_addr);
|
|
if (load_addr == (u8 *)target_addr)
|
|
bl2_entry = (void(*)(void))exec_entry;
|
|
|
|
if (ccdm_mmc_read(mmc, code_offset, load_addr, code_len) < 0)
|
|
goto failure;
|
|
|
|
sha1_csum(load_addr, code_len, dst->digest);
|
|
dst->valid = true;
|
|
|
|
goto end;
|
|
failure:
|
|
result = 1;
|
|
bl2_entry = NULL;
|
|
end:
|
|
return result;
|
|
}
|
|
|
|
/**
|
|
* @brief get pointer to hash register by specification
|
|
* @param spec specification of a hash register
|
|
* @return pointer to hash register or NULL if @a spec does not qualify a
|
|
* valid hash register; NULL else.
|
|
*/
|
|
static struct h_reg *get_hreg(uint8_t spec)
|
|
{
|
|
uint8_t idx;
|
|
|
|
idx = HREG_IDX(spec);
|
|
if (IS_FIX_HREG(spec)) {
|
|
if (idx < ARRAY_SIZE(fix_hregs))
|
|
return fix_hregs + idx;
|
|
hre_err = HRE_E_INVALID_HREG;
|
|
} else if (IS_PCR_HREG(spec)) {
|
|
if (idx < ARRAY_SIZE(pcr_hregs))
|
|
return pcr_hregs + idx;
|
|
hre_err = HRE_E_INVALID_HREG;
|
|
} else if (IS_VAR_HREG(spec)) {
|
|
if (idx < ARRAY_SIZE(var_hregs))
|
|
return var_hregs + idx;
|
|
hre_err = HRE_E_INVALID_HREG;
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
/**
|
|
* @brief get pointer of a hash register by specification and usage.
|
|
* @param spec specification of a hash register
|
|
* @param mode access mode (read or write or read/write)
|
|
* @return pointer to hash register if found and valid; NULL else.
|
|
*
|
|
* This func uses @a get_reg() to determine the hash register for a given spec.
|
|
* If a register is found it is validated according to the desired access mode.
|
|
* The value of automatic registers (PCR register and fixed registers) is
|
|
* loaded or computed on read access.
|
|
*/
|
|
static struct h_reg *access_hreg(struct udevice *tpm, uint8_t spec,
|
|
enum access_mode mode)
|
|
{
|
|
struct h_reg *result;
|
|
|
|
result = get_hreg(spec);
|
|
if (!result)
|
|
return NULL;
|
|
|
|
if (mode & HREG_WR) {
|
|
if (IS_FIX_HREG(spec)) {
|
|
hre_err = HRE_E_INVALID_HREG;
|
|
return NULL;
|
|
}
|
|
}
|
|
if (mode & HREG_RD) {
|
|
if (!result->valid) {
|
|
if (IS_PCR_HREG(spec)) {
|
|
hre_tpm_err = tpm_pcr_read(tpm, HREG_IDX(spec),
|
|
result->digest, 20);
|
|
result->valid = (hre_tpm_err == TPM_SUCCESS);
|
|
} else if (IS_FIX_HREG(spec)) {
|
|
switch (HREG_IDX(spec)) {
|
|
case FIX_HREG_DEVICE_ID_HASH:
|
|
read_common_data(tpm);
|
|
break;
|
|
case FIX_HREG_SELF_HASH:
|
|
ccdm_compute_self_hash();
|
|
break;
|
|
case FIX_HREG_STAGE2_HASH:
|
|
compute_second_stage_hash(result);
|
|
break;
|
|
case FIX_HREG_VENDOR:
|
|
memcpy(result->digest, vendor, 20);
|
|
result->valid = true;
|
|
break;
|
|
}
|
|
} else {
|
|
result->valid = true;
|
|
}
|
|
}
|
|
if (!result->valid) {
|
|
hre_err = HRE_E_INVALID_HREG;
|
|
return NULL;
|
|
}
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
static void *compute_and(void *_dst, const void *_src, size_t n)
|
|
{
|
|
uint8_t *dst = _dst;
|
|
const uint8_t *src = _src;
|
|
size_t i;
|
|
|
|
for (i = n; i-- > 0; )
|
|
*dst++ &= *src++;
|
|
|
|
return _dst;
|
|
}
|
|
|
|
static void *compute_or(void *_dst, const void *_src, size_t n)
|
|
{
|
|
uint8_t *dst = _dst;
|
|
const uint8_t *src = _src;
|
|
size_t i;
|
|
|
|
for (i = n; i-- > 0; )
|
|
*dst++ |= *src++;
|
|
|
|
return _dst;
|
|
}
|
|
|
|
static void *compute_xor(void *_dst, const void *_src, size_t n)
|
|
{
|
|
uint8_t *dst = _dst;
|
|
const uint8_t *src = _src;
|
|
size_t i;
|
|
|
|
for (i = n; i-- > 0; )
|
|
*dst++ ^= *src++;
|
|
|
|
return _dst;
|
|
}
|
|
|
|
static void *compute_extend(void *_dst, const void *_src, size_t n)
|
|
{
|
|
uint8_t digest[20];
|
|
sha1_context ctx;
|
|
|
|
sha1_starts(&ctx);
|
|
sha1_update(&ctx, _dst, n);
|
|
sha1_update(&ctx, _src, n);
|
|
sha1_finish(&ctx, digest);
|
|
memcpy(_dst, digest, min(n, sizeof(digest)));
|
|
|
|
return _dst;
|
|
}
|
|
|
|
static int hre_op_loadkey(struct udevice *tpm, struct h_reg *src_reg,
|
|
struct h_reg *dst_reg, const void *key,
|
|
size_t key_size)
|
|
{
|
|
uint32_t parent_handle;
|
|
uint32_t key_handle;
|
|
|
|
if (!src_reg || !dst_reg || !src_reg->valid || !dst_reg->valid)
|
|
return -1;
|
|
if (find_key(tpm, src_reg->digest, dst_reg->digest, &parent_handle))
|
|
return -1;
|
|
hre_tpm_err = tpm_load_key2_oiap(tpm, parent_handle, key, key_size,
|
|
src_reg->digest, &key_handle);
|
|
if (hre_tpm_err) {
|
|
hre_err = HRE_E_TPM_FAILURE;
|
|
return -1;
|
|
}
|
|
/* TODO remember key handle somehow? */
|
|
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* @brief executes the next opcode on the hash register engine.
|
|
* @param[in,out] ip pointer to the opcode (instruction pointer)
|
|
* @param[in,out] code_size (remaining) size of the code
|
|
* @return new instruction pointer on success, NULL on error.
|
|
*/
|
|
static const uint8_t *hre_execute_op(struct udevice *tpm, const uint8_t **ip,
|
|
size_t *code_size)
|
|
{
|
|
bool dst_modified = false;
|
|
uint32_t ins;
|
|
uint8_t opcode;
|
|
uint8_t src_spec;
|
|
uint8_t dst_spec;
|
|
uint16_t data_size;
|
|
struct h_reg *src_reg, *dst_reg;
|
|
uint8_t buf[20];
|
|
const uint8_t *src_buf, *data;
|
|
uint8_t *ptr;
|
|
int i;
|
|
void * (*bin_func)(void *, const void *, size_t);
|
|
|
|
if (*code_size < 4)
|
|
return NULL;
|
|
|
|
ins = get_unaligned_be32(*ip);
|
|
opcode = **ip;
|
|
data = *ip + 4;
|
|
src_spec = (ins >> 18) & 0x3f;
|
|
dst_spec = (ins >> 12) & 0x3f;
|
|
data_size = (ins & 0x7ff);
|
|
|
|
debug("HRE: ins=%08x (op=%02x, s=%02x, d=%02x, L=%d)\n", ins,
|
|
opcode, src_spec, dst_spec, data_size);
|
|
|
|
if ((opcode & 0x80) && (data_size + 4) > *code_size)
|
|
return NULL;
|
|
|
|
src_reg = access_hreg(tpm, src_spec, HREG_RD);
|
|
if (hre_err || hre_tpm_err)
|
|
return NULL;
|
|
dst_reg = access_hreg(tpm, dst_spec,
|
|
(opcode & 0x40) ? HREG_RDWR : HREG_WR);
|
|
if (hre_err || hre_tpm_err)
|
|
return NULL;
|
|
|
|
switch (opcode) {
|
|
case HRE_NOP:
|
|
goto end;
|
|
case HRE_CHECK0:
|
|
if (src_reg) {
|
|
for (i = 0; i < 20; ++i) {
|
|
if (src_reg->digest[i])
|
|
return NULL;
|
|
}
|
|
}
|
|
break;
|
|
case HRE_LOAD:
|
|
bin_func = memcpy;
|
|
goto do_bin_func;
|
|
case HRE_XOR:
|
|
bin_func = compute_xor;
|
|
goto do_bin_func;
|
|
case HRE_AND:
|
|
bin_func = compute_and;
|
|
goto do_bin_func;
|
|
case HRE_OR:
|
|
bin_func = compute_or;
|
|
goto do_bin_func;
|
|
case HRE_EXTEND:
|
|
bin_func = compute_extend;
|
|
do_bin_func:
|
|
if (!dst_reg)
|
|
return NULL;
|
|
if (src_reg) {
|
|
src_buf = src_reg->digest;
|
|
} else {
|
|
if (!data_size) {
|
|
memset(buf, 0, 20);
|
|
src_buf = buf;
|
|
} else if (data_size == 1) {
|
|
memset(buf, *data, 20);
|
|
src_buf = buf;
|
|
} else if (data_size >= 20) {
|
|
src_buf = data;
|
|
} else {
|
|
src_buf = buf;
|
|
for (ptr = (uint8_t *)src_buf, i = 20; i > 0;
|
|
i -= data_size, ptr += data_size)
|
|
memcpy(ptr, data,
|
|
min_t(size_t, i, data_size));
|
|
}
|
|
}
|
|
bin_func(dst_reg->digest, src_buf, 20);
|
|
dst_reg->valid = true;
|
|
dst_modified = true;
|
|
break;
|
|
case HRE_LOADKEY:
|
|
if (hre_op_loadkey(tpm, src_reg, dst_reg, data, data_size))
|
|
return NULL;
|
|
break;
|
|
default:
|
|
return NULL;
|
|
}
|
|
|
|
if (dst_reg && dst_modified && IS_PCR_HREG(dst_spec)) {
|
|
hre_tpm_err = tpm_extend(tpm, HREG_IDX(dst_spec),
|
|
dst_reg->digest, dst_reg->digest);
|
|
if (hre_tpm_err) {
|
|
hre_err = HRE_E_TPM_FAILURE;
|
|
return NULL;
|
|
}
|
|
}
|
|
end:
|
|
*ip += 4;
|
|
*code_size -= 4;
|
|
if (opcode & 0x80) {
|
|
*ip += data_size;
|
|
*code_size -= data_size;
|
|
}
|
|
|
|
return *ip;
|
|
}
|
|
|
|
/**
|
|
* @brief runs a program on the hash register engine.
|
|
* @param code pointer to the (HRE) code.
|
|
* @param code_size size of the code (in bytes).
|
|
* @return 0 on success, != 0 on failure.
|
|
*/
|
|
static int hre_run_program(struct udevice *tpm, const uint8_t *code,
|
|
size_t code_size)
|
|
{
|
|
size_t code_left;
|
|
const uint8_t *ip = code;
|
|
|
|
code_left = code_size;
|
|
hre_tpm_err = 0;
|
|
hre_err = HRE_E_OK;
|
|
while (code_left > 0)
|
|
if (!hre_execute_op(tpm, &ip, &code_left))
|
|
return -1;
|
|
|
|
return hre_err;
|
|
}
|
|
|
|
static int check_hmac(struct key_program *hmac,
|
|
const uint8_t *data, size_t data_size)
|
|
{
|
|
uint8_t key[20], computed_hmac[20];
|
|
uint32_t type;
|
|
|
|
type = get_unaligned_be32(hmac->code);
|
|
if (type != 0)
|
|
return 1;
|
|
memset(key, 0, sizeof(key));
|
|
compute_extend(key, pcr_hregs[1].digest, 20);
|
|
compute_extend(key, pcr_hregs[2].digest, 20);
|
|
compute_extend(key, pcr_hregs[3].digest, 20);
|
|
compute_extend(key, pcr_hregs[4].digest, 20);
|
|
|
|
sha1_hmac(key, sizeof(key), data, data_size, computed_hmac);
|
|
|
|
return memcmp(computed_hmac, hmac->code + 4, 20);
|
|
}
|
|
|
|
static int verify_program(struct key_program *prg)
|
|
{
|
|
uint32_t crc;
|
|
crc = crc32(0, prg->code, prg->code_size);
|
|
|
|
if (crc != prg->code_crc) {
|
|
printf("HRC crc mismatch: %08x != %08x\n",
|
|
crc, prg->code_crc);
|
|
return 1;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
#if defined(CCDM_FIRST_STAGE) || (defined CCDM_AUTO_FIRST_STAGE)
|
|
static struct key_program *load_sd_key_program(void)
|
|
{
|
|
u32 code_len, code_offset;
|
|
struct mmc *mmc;
|
|
u8 buf[128];
|
|
struct key_program *result = NULL, *hmac = NULL;
|
|
struct key_program header;
|
|
|
|
mmc = find_mmc_device(0);
|
|
if (!mmc)
|
|
return NULL;
|
|
mmc_init(mmc);
|
|
|
|
if (ccdm_mmc_read(mmc, 0, buf, sizeof(buf)) <= 0)
|
|
goto failure;
|
|
|
|
code_offset = *(u32 *)(buf + ESDHC_BOOT_IMAGE_ADDR_OFS);
|
|
code_len = *(u32 *)(buf + ESDHC_BOOT_IMAGE_SIZE_OFS);
|
|
|
|
code_offset += code_len;
|
|
/* TODO: the following needs to be the size of the 2nd stage env */
|
|
code_offset += CONFIG_ENV_SIZE;
|
|
|
|
if (ccdm_mmc_read(mmc, code_offset, buf, 4*3) < 0)
|
|
goto failure;
|
|
|
|
header.magic = get_unaligned_be32(buf);
|
|
header.code_crc = get_unaligned_be32(buf + 4);
|
|
header.code_size = get_unaligned_be32(buf + 8);
|
|
|
|
if (header.magic != MAGIC_KEY_PROGRAM)
|
|
goto failure;
|
|
|
|
result = malloc(sizeof(struct key_program) + header.code_size);
|
|
if (!result)
|
|
goto failure;
|
|
*result = header;
|
|
|
|
printf("load key program chunk from SD card (%u bytes) ",
|
|
header.code_size);
|
|
code_offset += 12;
|
|
if (ccdm_mmc_read(mmc, code_offset, result->code, header.code_size)
|
|
< 0)
|
|
goto failure;
|
|
code_offset += header.code_size;
|
|
puts("\n");
|
|
|
|
if (verify_program(result))
|
|
goto failure;
|
|
|
|
if (ccdm_mmc_read(mmc, code_offset, buf, 4*3) < 0)
|
|
goto failure;
|
|
|
|
header.magic = get_unaligned_be32(buf);
|
|
header.code_crc = get_unaligned_be32(buf + 4);
|
|
header.code_size = get_unaligned_be32(buf + 8);
|
|
|
|
if (header.magic == MAGIC_HMAC) {
|
|
puts("check integrity\n");
|
|
hmac = malloc(sizeof(struct key_program) + header.code_size);
|
|
if (!hmac)
|
|
goto failure;
|
|
*hmac = header;
|
|
code_offset += 12;
|
|
if (ccdm_mmc_read(mmc, code_offset, hmac->code,
|
|
hmac->code_size) < 0)
|
|
goto failure;
|
|
if (verify_program(hmac))
|
|
goto failure;
|
|
if (check_hmac(hmac, result->code, result->code_size)) {
|
|
puts("key program integrity could not be verified\n");
|
|
goto failure;
|
|
}
|
|
puts("key program verified\n");
|
|
}
|
|
|
|
goto end;
|
|
failure:
|
|
if (result)
|
|
free(result);
|
|
result = NULL;
|
|
end:
|
|
if (hmac)
|
|
free(hmac);
|
|
|
|
return result;
|
|
}
|
|
#endif
|
|
|
|
#ifdef CCDM_SECOND_STAGE
|
|
/**
|
|
* @brief load a key program from file system.
|
|
* @param ifname interface of the file system
|
|
* @param dev_part_str device part of the file system
|
|
* @param fs_type tyep of the file system
|
|
* @param path path of the file to load.
|
|
* @return the loaded structure or NULL on failure.
|
|
*/
|
|
static struct key_program *load_key_chunk(const char *ifname,
|
|
const char *dev_part_str, int fs_type,
|
|
const char *path)
|
|
{
|
|
struct key_program *result = NULL;
|
|
struct key_program header;
|
|
uint32_t crc;
|
|
uint8_t buf[12];
|
|
loff_t i;
|
|
|
|
if (fs_set_blk_dev(ifname, dev_part_str, fs_type))
|
|
goto failure;
|
|
if (fs_read(path, (ulong)buf, 0, 12, &i) < 0)
|
|
goto failure;
|
|
if (i < 12)
|
|
goto failure;
|
|
header.magic = get_unaligned_be32(buf);
|
|
header.code_crc = get_unaligned_be32(buf + 4);
|
|
header.code_size = get_unaligned_be32(buf + 8);
|
|
|
|
if (header.magic != MAGIC_HMAC && header.magic != MAGIC_KEY_PROGRAM)
|
|
goto failure;
|
|
|
|
result = malloc(sizeof(struct key_program) + header.code_size);
|
|
if (!result)
|
|
goto failure;
|
|
if (fs_set_blk_dev(ifname, dev_part_str, fs_type))
|
|
goto failure;
|
|
if (fs_read(path, (ulong)result, 0,
|
|
sizeof(struct key_program) + header.code_size, &i) < 0)
|
|
goto failure;
|
|
if (i <= 0)
|
|
goto failure;
|
|
*result = header;
|
|
|
|
crc = crc32(0, result->code, result->code_size);
|
|
|
|
if (crc != result->code_crc) {
|
|
printf("%s: HRC crc mismatch: %08x != %08x\n",
|
|
path, crc, result->code_crc);
|
|
goto failure;
|
|
}
|
|
goto end;
|
|
failure:
|
|
if (result) {
|
|
free(result);
|
|
result = NULL;
|
|
}
|
|
end:
|
|
return result;
|
|
}
|
|
#endif
|
|
|
|
#if defined(CCDM_FIRST_STAGE) || (defined CCDM_AUTO_FIRST_STAGE)
|
|
static const uint8_t prg_stage1_prepare[] = {
|
|
0x00, 0x20, 0x00, 0x00, /* opcode: SYNC f0 */
|
|
0x00, 0x24, 0x00, 0x00, /* opcode: SYNC f1 */
|
|
0x01, 0x80, 0x00, 0x00, /* opcode: CHECK0 PCR0 */
|
|
0x81, 0x22, 0x00, 0x00, /* opcode: LOAD PCR0, f0 */
|
|
0x01, 0x84, 0x00, 0x00, /* opcode: CHECK0 PCR1 */
|
|
0x81, 0x26, 0x10, 0x00, /* opcode: LOAD PCR1, f1 */
|
|
0x01, 0x88, 0x00, 0x00, /* opcode: CHECK0 PCR2 */
|
|
0x81, 0x2a, 0x20, 0x00, /* opcode: LOAD PCR2, f2 */
|
|
0x01, 0x8c, 0x00, 0x00, /* opcode: CHECK0 PCR3 */
|
|
0x81, 0x2e, 0x30, 0x00, /* opcode: LOAD PCR3, f3 */
|
|
};
|
|
|
|
static int first_stage_actions(struct udevice *tpm)
|
|
{
|
|
int result = 0;
|
|
struct key_program *sd_prg = NULL;
|
|
|
|
puts("CCDM S1: start actions\n");
|
|
#ifndef CCDM_SECOND_STAGE
|
|
if (tpm_continue_self_test(tpm))
|
|
goto failure;
|
|
#else
|
|
tpm_continue_self_test(tpm);
|
|
#endif
|
|
mdelay(37);
|
|
|
|
if (hre_run_program(tpm, prg_stage1_prepare,
|
|
sizeof(prg_stage1_prepare)))
|
|
goto failure;
|
|
|
|
sd_prg = load_sd_key_program();
|
|
if (sd_prg) {
|
|
if (hre_run_program(tpm, sd_prg->code, sd_prg->code_size))
|
|
goto failure;
|
|
puts("SD code run successfully\n");
|
|
} else {
|
|
puts("no key program found on SD\n");
|
|
goto failure;
|
|
}
|
|
goto end;
|
|
failure:
|
|
result = 1;
|
|
end:
|
|
if (sd_prg)
|
|
free(sd_prg);
|
|
printf("CCDM S1: actions done (%d)\n", result);
|
|
return result;
|
|
}
|
|
#endif
|
|
|
|
#ifdef CCDM_FIRST_STAGE
|
|
static int first_stage_init(void)
|
|
{
|
|
struct udevice *tpm;
|
|
int ret;
|
|
|
|
puts("CCDM S1\n");
|
|
ret = get_tpm(&tpm);
|
|
if (ret || tpm_init(tpm) || tpm_startup(tpm, TPM_ST_CLEAR))
|
|
return 1;
|
|
ret = first_stage_actions(tpm);
|
|
#ifndef CCDM_SECOND_STAGE
|
|
if (!ret) {
|
|
if (bl2_entry)
|
|
(*bl2_entry)();
|
|
ret = 1;
|
|
}
|
|
#endif
|
|
return ret;
|
|
}
|
|
#endif
|
|
|
|
#ifdef CCDM_SECOND_STAGE
|
|
static const uint8_t prg_stage2_prepare[] = {
|
|
0x00, 0x80, 0x00, 0x00, /* opcode: SYNC PCR0 */
|
|
0x00, 0x84, 0x00, 0x00, /* opcode: SYNC PCR1 */
|
|
0x00, 0x88, 0x00, 0x00, /* opcode: SYNC PCR2 */
|
|
0x00, 0x8c, 0x00, 0x00, /* opcode: SYNC PCR3 */
|
|
0x00, 0x90, 0x00, 0x00, /* opcode: SYNC PCR4 */
|
|
};
|
|
|
|
static const uint8_t prg_stage2_success[] = {
|
|
0x81, 0x02, 0x40, 0x14, /* opcode: LOAD PCR4, #<20B data> */
|
|
0x48, 0xfd, 0x95, 0x17, 0xe7, 0x54, 0x6b, 0x68, /* data */
|
|
0x92, 0x31, 0x18, 0x05, 0xf8, 0x58, 0x58, 0x3c, /* data */
|
|
0xe4, 0xd2, 0x81, 0xe0, /* data */
|
|
};
|
|
|
|
static const uint8_t prg_stage_fail[] = {
|
|
0x81, 0x01, 0x00, 0x14, /* opcode: LOAD v0, #<20B data> */
|
|
0xc0, 0x32, 0xad, 0xc1, 0xff, 0x62, 0x9c, 0x9b, /* data */
|
|
0x66, 0xf2, 0x27, 0x49, 0xad, 0x66, 0x7e, 0x6b, /* data */
|
|
0xea, 0xdf, 0x14, 0x4b, /* data */
|
|
0x81, 0x42, 0x30, 0x00, /* opcode: LOAD PCR3, v0 */
|
|
0x81, 0x42, 0x40, 0x00, /* opcode: LOAD PCR4, v0 */
|
|
};
|
|
|
|
static int second_stage_init(void)
|
|
{
|
|
static const char mac_suffix[] = ".mac";
|
|
bool did_first_stage_run = true;
|
|
int result = 0;
|
|
char *cptr, *mmcdev = NULL;
|
|
struct key_program *hmac_blob = NULL;
|
|
const char *image_path = "/ccdm.itb";
|
|
char *mac_path = NULL;
|
|
ulong image_addr;
|
|
loff_t image_size;
|
|
struct udevice *tpm;
|
|
uint32_t err;
|
|
int ret;
|
|
|
|
printf("CCDM S2\n");
|
|
ret = get_tpm(&tpm);
|
|
if (ret || tpm_init(tpm))
|
|
return 1;
|
|
err = tpm_startup(tpm, TPM_ST_CLEAR);
|
|
if (err != TPM_INVALID_POSTINIT)
|
|
did_first_stage_run = false;
|
|
|
|
#ifdef CCDM_AUTO_FIRST_STAGE
|
|
if (!did_first_stage_run && first_stage_actions(tpm))
|
|
goto failure;
|
|
#else
|
|
if (!did_first_stage_run)
|
|
goto failure;
|
|
#endif
|
|
|
|
if (hre_run_program(tpm, prg_stage2_prepare,
|
|
sizeof(prg_stage2_prepare)))
|
|
goto failure;
|
|
|
|
/* run "prepboot" from env to get "mmcdev" set */
|
|
cptr = env_get("prepboot");
|
|
if (cptr && !run_command(cptr, 0))
|
|
mmcdev = env_get("mmcdev");
|
|
if (!mmcdev)
|
|
goto failure;
|
|
|
|
cptr = env_get("ramdiskimage");
|
|
if (cptr)
|
|
image_path = cptr;
|
|
|
|
mac_path = malloc(strlen(image_path) + strlen(mac_suffix) + 1);
|
|
if (mac_path == NULL)
|
|
goto failure;
|
|
strcpy(mac_path, image_path);
|
|
strcat(mac_path, mac_suffix);
|
|
|
|
/* read image from mmcdev (ccdm.itb) */
|
|
image_addr = (ulong)get_image_location();
|
|
if (fs_set_blk_dev("mmc", mmcdev, FS_TYPE_EXT))
|
|
goto failure;
|
|
if (fs_read(image_path, image_addr, 0, 0, &image_size) < 0)
|
|
goto failure;
|
|
if (image_size <= 0)
|
|
goto failure;
|
|
printf("CCDM image found on %s, %lld bytes\n", mmcdev, image_size);
|
|
|
|
hmac_blob = load_key_chunk("mmc", mmcdev, FS_TYPE_EXT, mac_path);
|
|
if (!hmac_blob) {
|
|
puts("failed to load mac file\n");
|
|
goto failure;
|
|
}
|
|
if (verify_program(hmac_blob)) {
|
|
puts("corrupted mac file\n");
|
|
goto failure;
|
|
}
|
|
if (check_hmac(hmac_blob, (u8 *)image_addr, image_size)) {
|
|
puts("image integrity could not be verified\n");
|
|
goto failure;
|
|
}
|
|
puts("CCDM image OK\n");
|
|
|
|
hre_run_program(tpm, prg_stage2_success, sizeof(prg_stage2_success));
|
|
|
|
goto end;
|
|
failure:
|
|
result = 1;
|
|
hre_run_program(tpm, prg_stage_fail, sizeof(prg_stage_fail));
|
|
end:
|
|
if (hmac_blob)
|
|
free(hmac_blob);
|
|
if (mac_path)
|
|
free(mac_path);
|
|
|
|
return result;
|
|
}
|
|
#endif
|
|
|
|
int show_self_hash(void)
|
|
{
|
|
struct h_reg *hash_ptr;
|
|
#ifdef CCDM_SECOND_STAGE
|
|
struct h_reg hash;
|
|
|
|
hash_ptr = &hash;
|
|
if (compute_self_hash(hash_ptr))
|
|
return 1;
|
|
#else
|
|
hash_ptr = &fix_hregs[FIX_HREG_SELF_HASH];
|
|
#endif
|
|
puts("self hash: ");
|
|
if (hash_ptr && hash_ptr->valid)
|
|
print_buffer(0, hash_ptr->digest, 1, 20, 20);
|
|
else
|
|
puts("INVALID\n");
|
|
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* @brief let the system hang.
|
|
*
|
|
* Called on error.
|
|
* Will stop the boot process; display a message and signal the error condition
|
|
* by blinking the "status" and the "finder" LED of the controller board.
|
|
*
|
|
* @note the develop version runs the blink cycle 2 times and then returns.
|
|
* The release version never returns.
|
|
*/
|
|
static void ccdm_hang(void)
|
|
{
|
|
static const u64 f0 = 0x0ba3bb8ba2e880; /* blink code "finder" LED */
|
|
static const u64 s0 = 0x00f0f0f0f0f0f0; /* blink code "status" LED */
|
|
u64 f, s;
|
|
int i;
|
|
#ifdef CCDM_DEVELOP
|
|
int j;
|
|
#endif
|
|
|
|
I2C_SET_BUS(I2C_SOC_0);
|
|
pca9698_direction_output(0x22, 0, 0); /* Finder */
|
|
pca9698_direction_output(0x22, 4, 0); /* Status */
|
|
|
|
puts("### ERROR ### Please RESET the board ###\n");
|
|
bootstage_error(BOOTSTAGE_ID_NEED_RESET);
|
|
#ifdef CCDM_DEVELOP
|
|
puts("*** ERROR ******** THIS WOULD HANG ******** ERROR ***\n");
|
|
puts("** but we continue since this is a DEVELOP version **\n");
|
|
puts("*** ERROR ******** THIS WOULD HANG ******** ERROR ***\n");
|
|
for (j = 2; j-- > 0;) {
|
|
putc('#');
|
|
#else
|
|
for (;;) {
|
|
#endif
|
|
f = f0;
|
|
s = s0;
|
|
for (i = 54; i-- > 0;) {
|
|
pca9698_set_value(0x22, 0, !(f & 1));
|
|
pca9698_set_value(0x22, 4, (s & 1));
|
|
f >>= 1;
|
|
s >>= 1;
|
|
mdelay(120);
|
|
}
|
|
}
|
|
puts("\ncontinue...\n");
|
|
}
|
|
|
|
int startup_ccdm_id_module(void)
|
|
{
|
|
int result = 0;
|
|
unsigned int orig_i2c_bus;
|
|
|
|
orig_i2c_bus = i2c_get_bus_num();
|
|
i2c_set_bus_num(I2C_SOC_1);
|
|
|
|
/* goto end; */
|
|
|
|
#ifdef CCDM_DEVELOP
|
|
show_self_hash();
|
|
#endif
|
|
#ifdef CCDM_FIRST_STAGE
|
|
result = first_stage_init();
|
|
if (result) {
|
|
puts("1st stage init failed\n");
|
|
goto failure;
|
|
}
|
|
#endif
|
|
#ifdef CCDM_SECOND_STAGE
|
|
result = second_stage_init();
|
|
if (result) {
|
|
puts("2nd stage init failed\n");
|
|
goto failure;
|
|
}
|
|
#endif
|
|
|
|
goto end;
|
|
failure:
|
|
result = 1;
|
|
end:
|
|
i2c_set_bus_num(orig_i2c_bus);
|
|
if (result)
|
|
ccdm_hang();
|
|
|
|
return result;
|
|
}
|