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

vboot2: Use new hostlib functions in unit tests

Browse Source 
This removes the hacky conversion from old-style packed keys and
signatures, which existed only because at the time we didn't have the
ability in hostlib to create new-format key and signature structs
directly.

BUG=chromium:423882
BRANCH=none
TEST=VBOOT2=1 make runtests

Change-Id: Id7cb3dfce740f2546464a4caae2629af864d7b45
Signed-off-by: Randall Spangler <rspangler@chromium.org>
Reviewed-on: https://chromium-review.googlesource.com/231543
This commit is contained in:
Randall Spangler
2014-11-21 15:33:07 -08:00
committed by chrome-internal-fetch
parent 91852e7f58
commit fc73f08765
5 changed files with 95 additions and 233 deletions
Download Patch File Download Diff File Expand all files Collapse all files

101
tests/vb2_convert_structs.c
View File

@@ -7,114 +7,13 @@
#include "2sysincludes.h"
#include "2common.h"
#include "2rsa.h"
#include "host_common.h"
#include "host_key2.h"
#include "host_misc.h"
#include "host_signature2.h"
#include "vb2_convert_structs.h"
#include "vboot_struct.h" /* For old struct sizes */
#include "test_common.h"
struct vb2_packed_key2 *vb2_convert_packed_key2(
const struct vb2_packed_key *key,
const char *desc, uint32_t *out_size)
{
struct vb2_packed_key2 k2 = {
.c.magic = VB2_MAGIC_PACKED_KEY2,
.c.struct_version_major = VB2_PACKED_KEY2_VERSION_MAJOR,
.c.struct_version_minor = VB2_PACKED_KEY2_VERSION_MINOR,
};
uint8_t *kbuf;
/* Calculate sizes and offsets */
k2.c.fixed_size = sizeof(k2);
k2.c.desc_size = roundup32(strlen(desc) + 1);
k2.key_offset = k2.c.fixed_size + k2.c.desc_size;
k2.key_size = key->key_size;
k2.c.total_size = k2.key_offset + k2.key_size;
/* Copy/initialize fields */
k2.key_version = key->key_version;
k2.sig_alg = vb2_crypto_to_signature(key->algorithm);
k2.hash_alg = vb2_crypto_to_hash(key->algorithm);
/* TODO: fill in a non-zero GUID */
/* Allocate the new buffer */
*out_size = k2.c.total_size;
kbuf = malloc(*out_size);
memset(kbuf, 0, *out_size);
/* Copy data into the buffer */
memcpy(kbuf, &k2, sizeof(k2));
/* strcpy() is safe because we allocated above based on strlen() */
strcpy((char *)(kbuf + k2.c.fixed_size), desc);
kbuf[k2.c.fixed_size + k2.c.desc_size - 1] = 0;
memcpy(kbuf + k2.key_offset,
(const uint8_t *)key + key->key_offset,
key->key_size);
/* Return the newly allocated buffer */
return (struct vb2_packed_key2 *)kbuf;
}
struct vb2_signature2 *vb2_convert_signature2(
const struct vb2_signature *sig,
const char *desc,
const struct vb2_packed_key2 *key,
uint32_t *out_size)
{
struct vb2_signature2 s2 = {
.c.magic = VB2_MAGIC_SIGNATURE2,
.c.struct_version_major = VB2_SIGNATURE2_VERSION_MAJOR,
.c.struct_version_minor = VB2_SIGNATURE2_VERSION_MINOR,
};
uint8_t *buf;
/* Calculate description size */
s2.c.fixed_size = sizeof(s2);
s2.c.desc_size = roundup32(strlen(desc) + 1);
/* Copy/initialize fields */
s2.sig_offset = s2.c.fixed_size + s2.c.desc_size;
s2.sig_size = sig->sig_size;
s2.c.total_size = s2.sig_offset + s2.sig_size;
s2.data_size = sig->data_size;
/* Copy fields from key if present */
if (key) {
s2.sig_alg = key->sig_alg;
s2.hash_alg = key->hash_alg;
memcpy(&s2.guid, &key->guid, GUID_SIZE);
} else {
s2.sig_alg = VB2_SIG_INVALID;
s2.hash_alg = VB2_HASH_INVALID;
memset(&s2.guid, 0, GUID_SIZE);
}
/* Allocate the new buffer */
*out_size = s2.sig_offset + s2.sig_size;
buf = malloc(*out_size);
memset(buf, 0, *out_size);
/* Copy data into the buffer */
memcpy(buf, &s2, sizeof(s2));
/* strcpy() is safe because we allocated above based on strlen() */
strcpy((char *)(buf + s2.c.fixed_size), desc);
buf[s2.c.fixed_size + s2.c.desc_size - 1] = 0;
memcpy(buf + s2.sig_offset,
(const uint8_t *)sig + sig->sig_offset,
sig->sig_size);
/* Return the newly allocated buffer */
return (struct vb2_signature2 *)buf;
}
struct vb2_signature2 *vb2_create_hash_sig(const uint8_t *data,
uint32_t size,
enum vb2_hash_algorithm hash_alg)