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

vboot: Add vb2_unpack_key_buffer

Browse Source 
Previously, vb2_unpack_key() actually unpacked a key buffer.  Callers
that had a vb2_packed_key had to typecast it back to a uint8_t buffer to
unpack it.  Rename vb2_unpack_key() to vb2_unpack_key_buffer(), and make
vb2_unpack_key() unpack a vb2_packed_key.

BUG=chromium:611535
BRANCH=none
TEST=make runtests; emerge-kevin coreboot depthcharge;
     emerge-samus and boot it

Change-Id: I9ee38a819c59cc58a72ead78cf5ddf3d0f301ae7
Signed-off-by: Randall Spangler <rspangler@chromium.org>
Reviewed-on: https://chromium-review.googlesource.com/400906
Reviewed-by: Daisuke Nojiri <dnojiri@chromium.org>
This commit is contained in:
Randall Spangler
2016-10-18 15:09:21 -07:00
parent 559a110f33
commit 6e3931d1f6
24 changed files with 101 additions and 98 deletions
Download Patch File Download Diff File Expand all files Collapse all files

15
firmware/2lib/include/2return_codes.h
View File

@@ -161,16 +161,16 @@ enum vb2_return_code {
/* Member data outside parent in vb2_verify_member_inside() */
VB2_ERROR_INSIDE_DATA_OUTSIDE,
/* Unsupported signature algorithm in vb2_unpack_key() */
/* Unsupported signature algorithm in vb2_unpack_key_buffer() */
VB2_ERROR_UNPACK_KEY_SIG_ALGORITHM, /* 0x150008 */
/* Bad key size in vb2_unpack_key() */
/* Bad key size in vb2_unpack_key_buffer() */
VB2_ERROR_UNPACK_KEY_SIZE,
/* Bad key alignment in vb2_unpack_key() */
/* Bad key alignment in vb2_unpack_key_buffer() */
VB2_ERROR_UNPACK_KEY_ALIGN,
/* Bad key array size in vb2_unpack_key() */
/* Bad key array size in vb2_unpack_key_buffer() */
VB2_ERROR_UNPACK_KEY_ARRAY_SIZE,
/* Bad algorithm in vb2_verify_data() */
@@ -194,7 +194,7 @@ enum vb2_return_code {
*/
VB2_ERROR_VDATA_DIGEST_SIZE,
/* Unsupported hash algorithm in vb2_unpack_key() */
/* Unsupported hash algorithm in vb2_unpack_key_buffer() */
VB2_ERROR_UNPACK_KEY_HASH_ALGORITHM,
/* Member data overlaps member header */
@@ -256,9 +256,12 @@ enum vb2_return_code {
/* Key algorithm doesn't match signature algorithm */
VB2_ERROR_VDATA_ALGORITHM_MISMATCH,
/* Bad magic number in vb2_unpack_key() */
/* Bad magic number in vb2_unpack_key_buffer() */
VB2_ERROR_UNPACK_KEY_MAGIC,
/* Null public key buffer passed to vb2_unpack_key_buffer() */
VB2_ERROR_UNPACK_KEY_BUFFER,
/**********************************************************************
* Keyblock verification errors (all in vb2_verify_keyblock())
*/

13
firmware/lib/vboot_api_kernel.c
View File

@@ -1417,10 +1417,9 @@ VbError_t VbVerifyMemoryBootImage(VbCommonParams *cparams,
} else {
/* 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)) {
if (VB2_SUCCESS !=
vb2_unpack_key(&kernel_subkey2,
(struct vb2_packed_key *)kernel_subkey)) {
VBDEBUG(("Unable to unpack kernel subkey\n"));
goto fail;
}
@@ -1450,11 +1449,7 @@ VbError_t VbVerifyMemoryBootImage(VbCommonParams *cparams,
/* 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)) {
if (VB2_SUCCESS != vb2_unpack_key(&data_key2, &keyblock2->data_key)) {
VBDEBUG(("Unable to unpack kernel data key\n"));
goto fail;
}

12
firmware/lib/vboot_kernel.c
View File

@@ -159,10 +159,9 @@ VbError_t LoadKernel(LoadKernelParams *params, VbCommonParams *cparams)
/* 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)) {
if (VB2_SUCCESS !=
vb2_unpack_key(&kernel_subkey2,
(struct vb2_packed_key *)kernel_subkey)) {
VBDEBUG(("Unable to unpack kernel subkey\n"));
goto bad_gpt;
}
@@ -334,10 +333,7 @@ VbError_t LoadKernel(LoadKernelParams *params, VbCommonParams *cparams)
/* 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)) {
vb2_unpack_key(&data_key2, &keyblock2->data_key)) {
VBDEBUG(("Unable to unpack kernel data key\n"));
shpart->check_result = VBSD_LKP_CHECK_DATA_KEY_PARSE;
goto bad_kernel;

4
firmware/lib20/api.c
View File

@@ -96,7 +96,7 @@ int vb2api_init_hash(struct vb2_context *ctx, uint32_t tag, uint32_t *size)
if (!sd->workbuf_data_key_size)
return VB2_ERROR_API_INIT_HASH_DATA_KEY;
rv = vb2_unpack_key(&key,
rv = vb2_unpack_key_buffer(&key,
ctx->workbuf + sd->workbuf_data_key_offset,
sd->workbuf_data_key_size);
if (rv)
@@ -186,7 +186,7 @@ int vb2api_check_hash_get_digest(struct vb2_context *ctx, void *digest_out,
if (!sd->workbuf_data_key_size)
return VB2_ERROR_API_CHECK_HASH_DATA_KEY;
rv = vb2_unpack_key(&key,
rv = vb2_unpack_key_buffer(&key,
ctx->workbuf + sd->workbuf_data_key_offset,
sd->workbuf_data_key_size);
if (rv)

2
firmware/lib20/api_kernel.c
View File

@@ -213,7 +213,7 @@ int vb2api_verify_kernel_data(struct vb2_context *ctx,
if (!sd->workbuf_data_key_size)
return VB2_ERROR_API_VERIFY_KDATA_KEY;
rv = vb2_unpack_key(&key,
rv = vb2_unpack_key_buffer(&key,
ctx->workbuf + sd->workbuf_data_key_offset,
sd->workbuf_data_key_size);
if (rv)

20
firmware/lib20/include/vb2_common.h
View File

@@ -78,7 +78,7 @@ int vb2_verify_packed_key_inside(const void *parent,
const struct vb2_packed_key *key);
/**
* Unpack a vboot1-format key for use in verification
* Unpack a vboot1-format key buffer for use in verification
*
* The elements of the unpacked key will point into the source buffer, so don't
* free the source buffer until you're done with the key.
@@ -88,9 +88,23 @@ int vb2_verify_packed_key_inside(const void *parent,
* @param size Size of buffer in bytes
* @return VB2_SUCCESS, or non-zero error code if error.
*/
int vb2_unpack_key_buffer(struct vb2_public_key *key,
const uint8_t *buf,
uint32_t size);
/**
* Unpack a vboot1-format key for use in verification
*
* The elements of the unpacked key will point into the source packed key, so
* don't free the source until you're done with the public key.
*
* @param key Destintion for unpacked key
* @param packed_key Source packed key
* @param size Size of buffer in bytes
* @return VB2_SUCCESS, or non-zero error code if error.
*/
int vb2_unpack_key(struct vb2_public_key *key,
const uint8_t *buf,
uint32_t size);
const struct vb2_packed_key *packed_key);
/**
* Verify a signature against an expected hash digest.

4
firmware/lib20/kernel.c
View File

@@ -122,7 +122,7 @@ int vb2_load_kernel_keyblock(struct vb2_context *ctx)
/* Unpack the kernel key */
key_data = ctx->workbuf + sd->workbuf_kernel_key_offset;
key_size = sd->workbuf_kernel_key_size;
rv = vb2_unpack_key(&kernel_key, key_data, key_size);
rv = vb2_unpack_key_buffer(&kernel_key, key_data, key_size);
if (rv)
return rv;
@@ -374,7 +374,7 @@ int vb2_load_kernel_preamble(struct vb2_context *ctx)
if (!sd->workbuf_data_key_size)
return VB2_ERROR_KERNEL_PREAMBLE2_DATA_KEY;
rv = vb2_unpack_key(&data_key, key_data, key_size);
rv = vb2_unpack_key_buffer(&data_key, key_data, key_size);
if (rv)
return rv;

4
firmware/lib20/misc.c
View File

@@ -94,7 +94,7 @@ int vb2_load_fw_keyblock(struct vb2_context *ctx)
return rv;
/* Unpack the root key */
rv = vb2_unpack_key(&root_key, key_data, key_size);
rv = vb2_unpack_key_buffer(&root_key, key_data, key_size);
if (rv)
return rv;
@@ -212,7 +212,7 @@ int vb2_load_fw_preamble(struct vb2_context *ctx)
if (!sd->workbuf_data_key_size)
return VB2_ERROR_FW_PREAMBLE2_DATA_KEY;
rv = vb2_unpack_key(&data_key, key_data, key_size);
rv = vb2_unpack_key_buffer(&data_key, key_data, key_size);
if (rv)
return rv;

18
firmware/lib20/packed_key.c
View File

@@ -23,9 +23,9 @@ int vb2_verify_packed_key_inside(const void *parent,
key->key_offset, key->key_size);
}
int vb2_unpack_key(struct vb2_public_key *key,
const uint8_t *buf,
uint32_t size)
int vb2_unpack_key_buffer(struct vb2_public_key *key,
const uint8_t *buf,
uint32_t size)
{
const struct vb2_packed_key *packed_key =
(const struct vb2_packed_key *)buf;
@@ -75,3 +75,15 @@ int vb2_unpack_key(struct vb2_public_key *key,
return VB2_SUCCESS;
}
int vb2_unpack_key(struct vb2_public_key *key,
const struct vb2_packed_key *packed_key)
{
if (!packed_key)
return VB2_ERROR_UNPACK_KEY_BUFFER;
return vb2_unpack_key_buffer(key,
(const uint8_t *)packed_key,
packed_key->key_offset +
packed_key->key_size);
}

17
futility/cmd_show.c
View File

@@ -177,8 +177,9 @@ int ft_show_fw_preamble(const char *name, uint8_t *buf, uint32_t len,
if (state) {
if (!sign_key &&
state->rootkey.is_valid &&
VB2_SUCCESS == vb2_unpack_key(&root_key, state->rootkey.buf,
state->rootkey.len)) {
VB2_SUCCESS == vb2_unpack_key_buffer(&root_key,
state->rootkey.buf,
state->rootkey.len)) {
/* BIOS should have a rootkey in the GBB */
sign_key = &root_key;
}
@@ -201,10 +202,7 @@ int ft_show_fw_preamble(const char *name, uint8_t *buf, uint32_t len,
retval = 1;
struct vb2_public_key data_key;
if (VB2_SUCCESS !=
vb2_unpack_key(&data_key, (const uint8_t *)&keyblock->data_key,
keyblock->data_key.key_offset +
keyblock->data_key.key_size)) {
if (VB2_SUCCESS != vb2_unpack_key(&data_key, &keyblock->data_key)) {
fprintf(stderr, "Error parsing data key in %s\n", name);
return 1;
}
@@ -308,10 +306,7 @@ int ft_show_kernel_preamble(const char *name, uint8_t *buf, uint32_t len,
retval = 1;
struct vb2_public_key data_key;
if (VB2_SUCCESS !=
vb2_unpack_key(&data_key, (const uint8_t *)&keyblock->data_key,
keyblock->data_key.key_offset +
keyblock->data_key.key_size)) {
if (VB2_SUCCESS != vb2_unpack_key(&data_key, &keyblock->data_key)) {
fprintf(stderr, "Error parsing data key in %s\n", name);
return 1;
}
@@ -510,7 +505,7 @@ static int do_show(int argc, char *argv[])
}
if (VB2_SUCCESS !=
vb2_unpack_key(&pubk2, pubkbuf, len)) {
vb2_unpack_key_buffer(&pubk2, pubkbuf, len)) {
fprintf(stderr, "Error unpacking %s\n", optarg);
errorcnt++;
break;

6
futility/cmd_vbutil_firmware.c
View File

@@ -211,7 +211,7 @@ static int do_verify(const char *infile, const char *signpubkey,
fprintf(stderr, "Error reading signpubkey.\n");
goto verify_cleanup;
}
if (VB2_SUCCESS != vb2_unpack_key(&sign_key, pubkbuf, pubklen)) {
if (VB2_SUCCESS != vb2_unpack_key_buffer(&sign_key, pubkbuf, pubklen)) {
fprintf(stderr, "Error unpacking signpubkey.\n");
goto verify_cleanup;
}
@@ -254,9 +254,7 @@ static int do_verify(const char *infile, const char *signpubkey,
struct vb2_public_key data_key;
if (VB2_SUCCESS !=
vb2_unpack_key(&data_key, (const uint8_t *)&keyblock->data_key,
keyblock->data_key.key_offset +
keyblock->data_key.key_size)) {
vb2_unpack_key(&data_key, &keyblock->data_key)) {
fprintf(stderr, "Error parsing data key.\n");
goto verify_cleanup;
}

4
futility/cmd_vbutil_keyblock.c
View File

@@ -189,9 +189,7 @@ static int Unpack(const char *infile, const char *datapubkey,
return 1;
}
struct vb2_public_key key;
if (VB2_SUCCESS !=
vb2_unpack_key(&key, (uint8_t *)sign_key,
sign_key->key_offset + sign_key->key_size)) {
if (VB2_SUCCESS != vb2_unpack_key(&key, sign_key)) {
fprintf(stderr,
"vbutil_keyblock: Error reading signpubkey.\n");
return 1;

14
futility/vb1_helper.c
View File

@@ -501,11 +501,7 @@ int VerifyKernelBlob(uint8_t *kernel_blob,
if (signpub_key) {
struct vb2_public_key pubkey;
if (VB2_SUCCESS !=
vb2_unpack_key(&pubkey,
(uint8_t *)signpub_key,
signpub_key->key_offset +
signpub_key->key_size)) {
if (VB2_SUCCESS != vb2_unpack_key(&pubkey, signpub_key)) {
fprintf(stderr, "Error unpacking signing key.\n");
goto done;
}
@@ -568,9 +564,7 @@ int VerifyKernelBlob(uint8_t *kernel_blob,
}
struct vb2_public_key pubkey;
if (VB2_SUCCESS !=
vb2_unpack_key(&pubkey, (uint8_t *)data_key,
data_key->key_offset + data_key->key_size)) {
if (VB2_SUCCESS != vb2_unpack_key(&pubkey, data_key)) {
fprintf(stderr, "Error parsing data key.\n");
goto done;
}
@@ -743,9 +737,7 @@ enum futil_file_type ft_recognize_vblock1(uint8_t *buf, uint32_t len)
/* Try unpacking the data key from the keyblock */
struct vb2_public_key data_key;
if (VB2_SUCCESS !=
vb2_unpack_key(&data_key, (const uint8_t *)&keyblock->data_key,
keyblock->data_key.key_offset +
keyblock->data_key.key_size)) {
vb2_unpack_key(&data_key, &keyblock->data_key)) {
/* It looks like a bad keyblock, but still a keyblock */
free(buf2);
return FILE_TYPE_KEYBLOCK;

4
host/lib/host_key.c
View File

@@ -25,7 +25,9 @@
int packed_key_looks_ok(const struct vb2_packed_key *key, uint32_t size)
{
struct vb2_public_key pubkey;
if (VB2_SUCCESS != vb2_unpack_key(&pubkey, (const uint8_t *)key, size))
if (VB2_SUCCESS != vb2_unpack_key_buffer(&pubkey,
(const uint8_t *)key,
size))
return 0;
if (key->key_version > VB2_MAX_KEY_VERSION) {

2
tests/vb20_api_kernel_tests.c
View File

@@ -194,7 +194,7 @@ int vb2_load_kernel_preamble(struct vb2_context *ctx)
return mock_load_kernel_preamble_retval;
}
int vb2_unpack_key(struct vb2_public_key *key,
int vb2_unpack_key_buffer(struct vb2_public_key *key,
const uint8_t *buf,
uint32_t size)
{

2
tests/vb20_api_tests.c
View File

@@ -117,7 +117,7 @@ int vb2_load_fw_preamble(struct vb2_context *ctx)
return retval_vb2_load_fw_preamble;
}
int vb2_unpack_key(struct vb2_public_key *key,
int vb2_unpack_key_buffer(struct vb2_public_key *key,
const uint8_t *buf,
uint32_t size)
{

35
tests/vb20_common2_tests.c
View File

@@ -35,44 +35,49 @@ static void test_unpack_key(const struct vb2_packed_key *key1)
struct vb2_packed_key *key = (struct vb2_packed_key *)buf;
memcpy(key, key1, size);
TEST_SUCC(vb2_unpack_key(&pubk, buf, size), "vb2_unpack_key() ok");
TEST_SUCC(vb2_unpack_key_buffer(&pubk, buf, size),
"vb2_unpack_key_buffer() ok");
TEST_EQ(pubk.sig_alg, vb2_crypto_to_signature(key->algorithm),
"vb2_unpack_key() sig_alg");
"vb2_unpack_key_buffer() sig_alg");
TEST_EQ(pubk.hash_alg, vb2_crypto_to_hash(key->algorithm),
"vb2_unpack_key() hash_alg");
"vb2_unpack_key_buffer() hash_alg");
memcpy(key, key1, size);
key->algorithm = VB2_ALG_COUNT;
TEST_EQ(vb2_unpack_key(&pubk, buf, size),
TEST_EQ(vb2_unpack_key_buffer(&pubk, buf, size),
VB2_ERROR_UNPACK_KEY_SIG_ALGORITHM,
"vb2_unpack_key() invalid algorithm");
"vb2_unpack_key_buffer() invalid algorithm");
memcpy(key, key1, size);
key->key_size--;
TEST_EQ(vb2_unpack_key(&pubk, buf, size),
TEST_EQ(vb2_unpack_key_buffer(&pubk, buf, size),
VB2_ERROR_UNPACK_KEY_SIZE,
"vb2_unpack_key() invalid size");
"vb2_unpack_key_buffer() invalid size");
memcpy(key, key1, size);
key->key_offset++;
TEST_EQ(vb2_unpack_key(&pubk, buf, size + 1),
TEST_EQ(vb2_unpack_key_buffer(&pubk, buf, size + 1),
VB2_ERROR_UNPACK_KEY_ALIGN,
"vb2_unpack_key() unaligned data");
"vb2_unpack_key_buffer() unaligned data");
memcpy(key, key1, size);
*(uint32_t *)(buf + key->key_offset) /= 2;
TEST_EQ(vb2_unpack_key(&pubk, buf, size),
TEST_EQ(vb2_unpack_key_buffer(&pubk, buf, size),
VB2_ERROR_UNPACK_KEY_ARRAY_SIZE,
"vb2_unpack_key() invalid key array size");
"vb2_unpack_key_buffer() invalid key array size");
memcpy(key, key1, size);
TEST_EQ(vb2_unpack_key(&pubk, buf, size - 1),
TEST_EQ(vb2_unpack_key_buffer(&pubk, buf, size - 1),
VB2_ERROR_INSIDE_DATA_OUTSIDE,
"vb2_unpack_key() buffer too small");
"vb2_unpack_key_buffer() buffer too small");
free(key);
TEST_EQ(vb2_unpack_key(&pubk, NULL),
VB2_ERROR_UNPACK_KEY_BUFFER,
"vb2_unpack_key_() buffer NULL");
}
static void test_verify_data(const struct vb2_packed_key *key1,
@@ -82,7 +87,6 @@ static void test_verify_data(const struct vb2_packed_key *key1,
__attribute__ ((aligned (VB2_WORKBUF_ALIGN)));
struct vb2_workbuf wb;
uint32_t pubkey_size = key1->key_offset + key1->key_size;
struct vb2_public_key pubk, pubk_orig;
uint32_t sig_total_size = sig->sig_offset + sig->sig_size;
struct vb2_signature *sig2;
@@ -92,8 +96,7 @@ static void test_verify_data(const struct vb2_packed_key *key1,
/* Allocate signature copy for tests */
sig2 = (struct vb2_signature *)malloc(sig_total_size);
TEST_EQ(vb2_unpack_key(&pubk, (uint8_t *)key1, pubkey_size),
0, "vb2_verify_data() unpack key");
TEST_SUCC(vb2_unpack_key(&pubk, key1), "vb2_verify_data() unpack key");
pubk_orig = pubk;
memcpy(sig2, sig, sig_total_size);

8
tests/vb20_common3_tests.c
View File

@@ -216,8 +216,7 @@ static void test_verify_fw_preamble(struct vb2_packed_key *public_key,
/* Create a dummy signature */
struct vb2_signature *body_sig = vb2_alloc_signature(56, 78);
TEST_SUCC(vb2_unpack_key(&rsa, (uint8_t *)public_key,
public_key->key_offset + public_key->key_size),
TEST_SUCC(vb2_unpack_key(&rsa, public_key),
"vb2_verify_fw_preamble() prereq key");
hdr = vb2_create_fw_preamble(0x1234, kernel_subkey, body_sig,
@@ -359,8 +358,7 @@ static void test_verify_kernel_preamble(
/* Create a dummy signature */
struct vb2_signature *body_sig = vb2_alloc_signature(56, 0x214000);
TEST_SUCC(vb2_unpack_key(&rsa, (uint8_t *)public_key,
public_key->key_offset + public_key->key_size),
TEST_SUCC(vb2_unpack_key(&rsa, public_key),
"vb2_verify_kernel_preamble() prereq key");
struct vb2_kernel_preamble *hdr =
@@ -563,7 +561,7 @@ int test_permutation(int signing_key_algorithm, int data_key_algorithm,
/* Unpack public key */
struct vb2_public_key signing_public_key2;
if (VB2_SUCCESS !=
vb2_unpack_key(&signing_public_key2,
vb2_unpack_key_buffer(&signing_public_key2,
(uint8_t *)signing_public_key,
signing_public_key->key_offset +
signing_public_key->key_size)) {

2
tests/vb20_kernel_tests.c
View File

@@ -167,7 +167,7 @@ int vb2ex_read_resource(struct vb2_context *ctx,
return VB2_SUCCESS;
}
int vb2_unpack_key(struct vb2_public_key *key,
int vb2_unpack_key_buffer(struct vb2_public_key *key,
const uint8_t *buf,
uint32_t size)
{

2
tests/vb20_misc_tests.c
View File

@@ -146,7 +146,7 @@ int vb2ex_read_resource(struct vb2_context *ctx,
return VB2_SUCCESS;
}
int vb2_unpack_key(struct vb2_public_key *key,
int vb2_unpack_key_buffer(struct vb2_public_key *key,
const uint8_t *buf,
uint32_t size)
{

4
tests/vb20_rsa_padding_tests.c
View File

@@ -114,9 +114,7 @@ int main(int argc, char *argv[])
fprintf(stderr, "Couldn't read RSA public key for the test.\n");
return 1;
}
if (VB2_SUCCESS != vb2_unpack_key(&k2, (const uint8_t *)pk,
pk->key_offset + pk->key_size)) {
if (VB2_SUCCESS != vb2_unpack_key(&k2, pk)) {
fprintf(stderr, "Couldn't unpack RSA public key.\n");
free(pk);
return 1;

2
tests/vboot_api_kernel5_tests.c
View File

@@ -96,7 +96,7 @@ static void copy_kbh(void)
}
/* Mocks */
int vb2_unpack_key(struct vb2_public_key *key,
int vb2_unpack_key_buffer(struct vb2_public_key *key,
const uint8_t *buf,
uint32_t size)
{

2
tests/vboot_kernel_tests.c
View File

@@ -243,7 +243,7 @@ void GetCurrentKernelUniqueGuid(GptData *gpt, void *dest)
memcpy(dest, fake_guid, sizeof(fake_guid));
}
int vb2_unpack_key(struct vb2_public_key *key,
int vb2_unpack_key_buffer(struct vb2_public_key *key,
const uint8_t *buf,
uint32_t size)
{

3
utility/verify_data.c
View File

@@ -97,8 +97,7 @@ int main(int argc, char* argv[])
}
struct vb2_public_key k2;
if (VB2_SUCCESS != vb2_unpack_key(&k2, (const uint8_t *)pk,
pk->key_offset + pk->key_size)) {
if (VB2_SUCCESS != vb2_unpack_key(&k2, pk)) {
fprintf(stderr, "Can't unpack RSA public key.\n");
goto error;
}