From eb10ebf76d78a7ac7cb6b66c6f1bba747d4e10ca Mon Sep 17 00:00:00 2001 From: Joel Kitching Date: Thu, 25 Jul 2019 16:39:56 +0800 Subject: vboot: vb2_shared_data offsets should hang off parent vb2_shared_data struct has many offsets to other objects in the workbuf. They are all prefixed with `workbuf_`, e.g.: uint32_t workbuf_data_key_offset; uint32_t workbuf_data_key_size; In order to adhere to a hierarchical structure on the workbuf, remove the workbuf_ prefix from these symbols to reflect the relationship between vb2_shared_data and its children more accurately. Create a helper function vb2_member_of to safely look up a child of a particular object in the workbuf by offset. Pointer arithmetic to find vb2_shared_data children is replaced with calls to this function. BUG=b:124141368, chromium:994060 TEST=make clean && make runtests BRANCH=none Change-Id: Ia82417a35d2067ee5e4f42fea0396e6325127223 Signed-off-by: Joel Kitching Cq-Depend: chromium:1753400 Reviewed-on: https://chromium-review.googlesource.com/c/chromiumos/platform/vboot_reference/+/1718264 Commit-Queue: Joel Kitching Tested-by: Joel Kitching Reviewed-by: Julius Werner --- firmware/2lib/2api.c | 4 +-- firmware/2lib/2common.c | 6 ++++ firmware/2lib/include/2common.h | 9 ++++++ firmware/2lib/include/2struct.h | 19 ++++++----- firmware/lib20/api.c | 35 ++++++++++---------- firmware/lib20/api_kernel.c | 39 +++++++++++----------- firmware/lib20/kernel.c | 26 +++++++-------- firmware/lib20/misc.c | 20 ++++++------ firmware/lib21/api.c | 22 ++++++------- firmware/lib21/misc.c | 24 +++++++------- tests/vb20_api_kernel_tests.c | 72 ++++++++++++++++++++--------------------- tests/vb20_api_tests.c | 53 ++++++++++++++---------------- tests/vb20_kernel_tests.c | 26 +++++++-------- tests/vb20_misc_tests.c | 26 +++++++-------- tests/vb21_api_tests.c | 42 +++++++++++------------- tests/vb21_misc_tests.c | 33 +++++++++---------- tests/vb2_misc_tests.c | 3 +- 17 files changed, 230 insertions(+), 229 deletions(-) diff --git a/firmware/2lib/2api.c b/firmware/2lib/2api.c index f39ba290..e6ed5eb0 100644 --- a/firmware/2lib/2api.c +++ b/firmware/2lib/2api.c @@ -165,10 +165,10 @@ vb2_error_t vb2api_extend_hash(struct vb2_context *ctx, { struct vb2_shared_data *sd = vb2_get_sd(ctx); struct vb2_digest_context *dc = (struct vb2_digest_context *) - (ctx->workbuf + sd->workbuf_hash_offset); + vb2_member_of(sd, sd->hash_offset); /* Must have initialized hash digest work area */ - if (!sd->workbuf_hash_size) + if (!sd->hash_size) return VB2_ERROR_API_EXTEND_HASH_WORKBUF; /* Don't extend past the data we expect to hash */ diff --git a/firmware/2lib/2common.c b/firmware/2lib/2common.c index de1fc498..c0eb4479 100644 --- a/firmware/2lib/2common.c +++ b/firmware/2lib/2common.c @@ -104,6 +104,12 @@ ptrdiff_t vb2_offset_of(const void *base, const void *ptr) return (uintptr_t)ptr - (uintptr_t)base; } +void *vb2_member_of(void *parent, ptrdiff_t offset) +{ + /* TODO(kitching): vb2_assert(parent && offset) */ + return parent + offset; +} + vb2_error_t vb2_verify_member_inside(const void *parent, size_t parent_size, const void *member, size_t member_size, ptrdiff_t member_data_offset, diff --git a/firmware/2lib/include/2common.h b/firmware/2lib/include/2common.h index f0df9c0b..ccc0bfc4 100644 --- a/firmware/2lib/include/2common.h +++ b/firmware/2lib/include/2common.h @@ -165,6 +165,15 @@ vb2_error_t vb2_align(uint8_t **ptr, uint32_t *size, uint32_t align, */ ptrdiff_t vb2_offset_of(const void *base, const void *ptr); +/** + * Return member of given object. + * + * @param parent Pointer to parent object + * @param offset Offset from base + * @return Pointer to child object. + */ +void *vb2_member_of(void *parent, ptrdiff_t offset); + /** * Return expected signature size for a signature/hash algorithm pair * diff --git a/firmware/2lib/include/2struct.h b/firmware/2lib/include/2struct.h index 52783b6a..a045fef3 100644 --- a/firmware/2lib/include/2struct.h +++ b/firmware/2lib/include/2struct.h @@ -169,22 +169,22 @@ struct vb2_shared_data { * Offset and size of packed data key in work buffer. Size is 0 if * data key is not stored in the work buffer. */ - uint32_t workbuf_data_key_offset; - uint32_t workbuf_data_key_size; + uint32_t data_key_offset; + uint32_t data_key_size; /* * Offset and size of firmware preamble in work buffer. Size is 0 if * preamble is not stored in the work buffer. */ - uint32_t workbuf_preamble_offset; - uint32_t workbuf_preamble_size; + uint32_t preamble_offset; + uint32_t preamble_size; /* * Offset and size of hash context in work buffer. Size is 0 if * hash context is not stored in the work buffer. */ - uint32_t workbuf_hash_offset; - uint32_t workbuf_hash_size; + uint32_t hash_offset; + uint32_t hash_size; /* * Current tag we're hashing @@ -192,8 +192,7 @@ struct vb2_shared_data { * For new structs, this is the offset of the vb2_signature struct * in the work buffer. * - * TODO: rename to workbuf_hash_sig_offset when vboot1 structs are - * deprecated. + * TODO: rename to hash_sig_offset when vboot1 structs are deprecated. */ uint32_t hash_tag; @@ -222,8 +221,8 @@ struct vb2_shared_data { * subkey is not stored in the work buffer. Note that kernel key may * be inside the firmware preamble. */ - uint32_t workbuf_kernel_key_offset; - uint32_t workbuf_kernel_key_size; + uint32_t kernel_key_offset; + uint32_t kernel_key_size; } __attribute__((packed)); /****************************************************************************/ diff --git a/firmware/lib20/api.c b/firmware/lib20/api.c index 7c6b0d46..e28b168e 100644 --- a/firmware/lib20/api.c +++ b/firmware/lib20/api.c @@ -52,19 +52,19 @@ vb2_error_t vb2api_init_hash(struct vb2_context *ctx, uint32_t tag, return VB2_ERROR_API_INIT_HASH_TAG; /* Get preamble pointer */ - if (!sd->workbuf_preamble_size) + if (!sd->preamble_size) return VB2_ERROR_API_INIT_HASH_PREAMBLE; pre = (const struct vb2_fw_preamble *) - (ctx->workbuf + sd->workbuf_preamble_offset); + vb2_member_of(sd, sd->preamble_offset); /* For now, we only support the firmware body tag */ if (tag != VB2_HASH_TAG_FW_BODY) return VB2_ERROR_API_INIT_HASH_TAG; /* Allocate workbuf space for the hash */ - if (sd->workbuf_hash_size) { + if (sd->hash_size) { dc = (struct vb2_digest_context *) - (ctx->workbuf + sd->workbuf_hash_offset); + vb2_member_of(sd, sd->hash_offset); } else { uint32_t dig_size = sizeof(*dc); @@ -72,9 +72,9 @@ vb2_error_t vb2api_init_hash(struct vb2_context *ctx, uint32_t tag, if (!dc) return VB2_ERROR_API_INIT_HASH_WORKBUF; - sd->workbuf_hash_offset = vb2_offset_of(ctx->workbuf, dc); - sd->workbuf_hash_size = dig_size; - vb2_set_workbuf_used(ctx, sd->workbuf_hash_offset + dig_size); + sd->hash_offset = vb2_offset_of(sd, dc); + sd->hash_size = dig_size; + vb2_set_workbuf_used(ctx, sd->hash_offset + dig_size); } /* @@ -94,12 +94,12 @@ vb2_error_t vb2api_init_hash(struct vb2_context *ctx, uint32_t tag, * the firmware preamble. But until we can change the signing scripts, * we're stuck with a signature here instead of a hash. */ - if (!sd->workbuf_data_key_size) + if (!sd->data_key_size) return VB2_ERROR_API_INIT_HASH_DATA_KEY; rv = vb2_unpack_key_buffer(&key, - ctx->workbuf + sd->workbuf_data_key_offset, - sd->workbuf_data_key_size); + vb2_member_of(sd, sd->data_key_offset), + sd->data_key_size); if (rv) return rv; @@ -136,7 +136,7 @@ vb2_error_t vb2api_check_hash_get_digest(struct vb2_context *ctx, { struct vb2_shared_data *sd = vb2_get_sd(ctx); struct vb2_digest_context *dc = (struct vb2_digest_context *) - (ctx->workbuf + sd->workbuf_hash_offset); + vb2_member_of(sd, sd->hash_offset); struct vb2_workbuf wb; uint8_t *digest; @@ -149,13 +149,12 @@ vb2_error_t vb2api_check_hash_get_digest(struct vb2_context *ctx, vb2_workbuf_from_ctx(ctx, &wb); /* Get preamble pointer */ - if (!sd->workbuf_preamble_size) + if (!sd->preamble_size) return VB2_ERROR_API_CHECK_HASH_PREAMBLE; - pre = (struct vb2_fw_preamble *) - (ctx->workbuf + sd->workbuf_preamble_offset); + pre = vb2_member_of(sd, sd->preamble_offset); /* Must have initialized hash digest work area */ - if (!sd->workbuf_hash_size) + if (!sd->hash_size) return VB2_ERROR_API_CHECK_HASH_WORKBUF; /* Should have hashed the right amount of data */ @@ -185,12 +184,12 @@ vb2_error_t vb2api_check_hash_get_digest(struct vb2_context *ctx, */ /* Unpack the data key */ - if (!sd->workbuf_data_key_size) + if (!sd->data_key_size) return VB2_ERROR_API_CHECK_HASH_DATA_KEY; rv = vb2_unpack_key_buffer(&key, - ctx->workbuf + sd->workbuf_data_key_offset, - sd->workbuf_data_key_size); + vb2_member_of(sd, sd->data_key_offset), + sd->data_key_size); if (rv) return rv; diff --git a/firmware/lib20/api_kernel.c b/firmware/lib20/api_kernel.c index 8e5f5e61..7737f260 100644 --- a/firmware/lib20/api_kernel.c +++ b/firmware/lib20/api_kernel.c @@ -74,19 +74,18 @@ vb2_error_t vb2api_kernel_phase1(struct vb2_context *ctx) if (rv) return rv; - sd->workbuf_kernel_key_offset = - vb2_offset_of(ctx->workbuf, key_data); + sd->kernel_key_offset = vb2_offset_of(sd, key_data); } else { /* Kernel subkey from firmware preamble */ struct vb2_fw_preamble *pre; struct vb2_packed_key *pre_key, *packed_key; /* Make sure we have a firmware preamble loaded */ - if (!sd->workbuf_preamble_size) + if (!sd->preamble_size) return VB2_ERROR_API_KPHASE1_PREAMBLE; pre = (struct vb2_fw_preamble *) - (ctx->workbuf + sd->workbuf_preamble_offset); + vb2_member_of(sd, sd->preamble_offset); pre_key = &pre->kernel_subkey; /* @@ -94,8 +93,8 @@ vb2_error_t vb2api_kernel_phase1(struct vb2_context *ctx) * data key, firmware preamble, or hash data. So move the * kernel key from the preamble down after the shared data. */ - sd->workbuf_kernel_key_offset = vb2_wb_round_up(sizeof(*sd)); - key_data = ctx->workbuf + sd->workbuf_kernel_key_offset; + sd->kernel_key_offset = vb2_wb_round_up(sizeof(*sd)); + key_data = vb2_member_of(sd, sd->kernel_key_offset); packed_key = (struct vb2_packed_key *)key_data; memmove(packed_key, pre_key, sizeof(*packed_key)); packed_key->key_offset = sizeof(*packed_key); @@ -107,9 +106,9 @@ vb2_error_t vb2api_kernel_phase1(struct vb2_context *ctx) } /* Firmware stage structs are no longer present */ - sd->workbuf_data_key_size = 0; - sd->workbuf_preamble_size = 0; - sd->workbuf_hash_size = 0; + sd->data_key_size = 0; + sd->preamble_size = 0; + sd->hash_size = 0; /* * Kernel key will persist in the workbuf after we return. @@ -118,9 +117,9 @@ vb2_error_t vb2api_kernel_phase1(struct vb2_context *ctx) * - vb2_shared_data * - kernel key */ - sd->workbuf_kernel_key_size = key_size; - vb2_set_workbuf_used(ctx, sd->workbuf_kernel_key_offset + - sd->workbuf_kernel_key_size); + sd->kernel_key_size = key_size; + vb2_set_workbuf_used(ctx, sd->kernel_key_offset + + sd->kernel_key_size); return VB2_SUCCESS; } @@ -149,16 +148,16 @@ vb2_error_t vb2api_get_kernel_size(struct vb2_context *ctx, const struct vb2_kernel_preamble *pre; /* Get preamble pointer */ - if (!sd->workbuf_preamble_size) + if (!sd->preamble_size) return VB2_ERROR_API_GET_KERNEL_SIZE_PREAMBLE; pre = (const struct vb2_kernel_preamble *) - (ctx->workbuf + sd->workbuf_preamble_offset); + vb2_member_of(sd, sd->preamble_offset); if (offset_ptr) { /* The kernel implicitly follows the preamble */ *offset_ptr = sd->vblock_preamble_offset + - sd->workbuf_preamble_size; + sd->preamble_size; } if (size_ptr) { @@ -186,11 +185,11 @@ vb2_error_t vb2api_verify_kernel_data(struct vb2_context *ctx, const void *buf, vb2_workbuf_from_ctx(ctx, &wb); /* Get preamble pointer */ - if (!sd->workbuf_preamble_size) + if (!sd->preamble_size) return VB2_ERROR_API_VERIFY_KDATA_PREAMBLE; pre = (struct vb2_kernel_preamble *) - (ctx->workbuf + sd->workbuf_preamble_offset); + vb2_member_of(sd, sd->preamble_offset); /* Make sure we were passed the right amount of data */ if (size != pre->body_signature.data_size) @@ -210,12 +209,12 @@ vb2_error_t vb2api_verify_kernel_data(struct vb2_context *ctx, const void *buf, * the kernel preamble. But until we can change the signing scripts, * we're stuck with a signature here instead of a hash. */ - if (!sd->workbuf_data_key_size) + if (!sd->data_key_size) return VB2_ERROR_API_VERIFY_KDATA_KEY; rv = vb2_unpack_key_buffer(&key, - ctx->workbuf + sd->workbuf_data_key_offset, - sd->workbuf_data_key_size); + vb2_member_of(sd, sd->data_key_offset), + sd->data_key_size); if (rv) return rv; diff --git a/firmware/lib20/kernel.c b/firmware/lib20/kernel.c index 4d8f7721..10cf158f 100644 --- a/firmware/lib20/kernel.c +++ b/firmware/lib20/kernel.c @@ -121,8 +121,8 @@ vb2_error_t vb2_load_kernel_keyblock(struct vb2_context *ctx) sd->flags &= ~VB2_SD_FLAG_KERNEL_SIGNED; /* Unpack the kernel key */ - key_data = ctx->workbuf + sd->workbuf_kernel_key_offset; - key_size = sd->workbuf_kernel_key_size; + key_data = vb2_member_of(sd, sd->kernel_key_offset); + key_size = sd->kernel_key_size; rv = vb2_unpack_key_buffer(&kernel_key, key_data, key_size); if (rv) return rv; @@ -217,8 +217,8 @@ vb2_error_t vb2_load_kernel_keyblock(struct vb2_context *ctx) * (which we might still need to verify the next kernel, if the * assoiciated kernel preamble and data don't verify). */ - sd->workbuf_data_key_offset = ctx->workbuf_used; - key_data = ctx->workbuf + sd->workbuf_data_key_offset; + sd->data_key_offset = ctx->workbuf_used; + key_data = vb2_member_of(sd, sd->data_key_offset); packed_key = (struct vb2_packed_key *)key_data; memmove(packed_key, &kb->data_key, sizeof(*packed_key)); packed_key->key_offset = sizeof(*packed_key); @@ -227,7 +227,7 @@ vb2_error_t vb2_load_kernel_keyblock(struct vb2_context *ctx) packed_key->key_size); /* Save the packed key size */ - sd->workbuf_data_key_size = + sd->data_key_size = packed_key->key_offset + packed_key->key_size; /* @@ -238,8 +238,8 @@ vb2_error_t vb2_load_kernel_keyblock(struct vb2_context *ctx) * - kernel key * - packed kernel data key */ - vb2_set_workbuf_used(ctx, sd->workbuf_data_key_offset + - sd->workbuf_data_key_size); + vb2_set_workbuf_used(ctx, sd->data_key_offset + + sd->data_key_size); return VB2_SUCCESS; } @@ -357,8 +357,8 @@ vb2_error_t vb2_load_kernel_preamble(struct vb2_context *ctx) struct vb2_shared_data *sd = vb2_get_sd(ctx); struct vb2_workbuf wb; - uint8_t *key_data = ctx->workbuf + sd->workbuf_data_key_offset; - uint32_t key_size = sd->workbuf_data_key_size; + uint8_t *key_data = vb2_member_of(sd, sd->data_key_offset); + uint32_t key_size = sd->data_key_size; struct vb2_public_key data_key; /* Preamble goes in the next unused chunk of work buffer */ @@ -372,7 +372,7 @@ vb2_error_t vb2_load_kernel_preamble(struct vb2_context *ctx) vb2_workbuf_from_ctx(ctx, &wb); /* Unpack the kernel data key */ - if (!sd->workbuf_data_key_size) + if (!sd->data_key_size) return VB2_ERROR_KERNEL_PREAMBLE2_DATA_KEY; rv = vb2_unpack_key_buffer(&data_key, key_data, key_size); @@ -431,8 +431,8 @@ vb2_error_t vb2_load_kernel_preamble(struct vb2_context *ctx) return VB2_ERROR_KERNEL_PREAMBLE_VERSION_ROLLBACK; /* Keep track of where we put the preamble */ - sd->workbuf_preamble_offset = vb2_offset_of(ctx->workbuf, pre); - sd->workbuf_preamble_size = pre_size; + sd->preamble_offset = vb2_offset_of(sd, pre); + sd->preamble_size = pre_size; /* * Preamble will persist in work buffer after we return. @@ -447,7 +447,7 @@ vb2_error_t vb2_load_kernel_preamble(struct vb2_context *ctx) * TODO: we could move the preamble down over the kernel data key * since we don't need it anymore. */ - vb2_set_workbuf_used(ctx, sd->workbuf_preamble_offset + pre_size); + vb2_set_workbuf_used(ctx, sd->preamble_offset + pre_size); return VB2_SUCCESS; } diff --git a/firmware/lib20/misc.c b/firmware/lib20/misc.c index 70f3ab80..0d681799 100644 --- a/firmware/lib20/misc.c +++ b/firmware/lib20/misc.c @@ -172,8 +172,8 @@ vb2_error_t vb2_load_fw_keyblock(struct vb2_context *ctx) packed_key->key_size); /* Save the packed key offset and size */ - sd->workbuf_data_key_offset = vb2_offset_of(ctx->workbuf, key_data); - sd->workbuf_data_key_size = + sd->data_key_offset = vb2_offset_of(sd, key_data); + sd->data_key_size = packed_key->key_offset + packed_key->key_size; /* Preamble follows the keyblock in the vblock */ @@ -186,8 +186,8 @@ vb2_error_t vb2_load_fw_keyblock(struct vb2_context *ctx) * - vb2_shared_data * - packed firmware data key */ - vb2_set_workbuf_used(ctx, sd->workbuf_data_key_offset + - sd->workbuf_data_key_size); + vb2_set_workbuf_used(ctx, sd->data_key_offset + + sd->data_key_size); return VB2_SUCCESS; } @@ -198,8 +198,8 @@ vb2_error_t vb2_load_fw_preamble(struct vb2_context *ctx) struct vb2_gbb_header *gbb = vb2_get_gbb(ctx); struct vb2_workbuf wb; - uint8_t *key_data = ctx->workbuf + sd->workbuf_data_key_offset; - uint32_t key_size = sd->workbuf_data_key_size; + uint8_t *key_data = vb2_member_of(sd, sd->data_key_offset); + uint32_t key_size = sd->data_key_size; struct vb2_public_key data_key; /* Preamble goes in the next unused chunk of work buffer */ @@ -211,7 +211,7 @@ vb2_error_t vb2_load_fw_preamble(struct vb2_context *ctx) vb2_workbuf_from_ctx(ctx, &wb); /* Unpack the firmware data key */ - if (!sd->workbuf_data_key_size) + if (!sd->data_key_size) return VB2_ERROR_FW_PREAMBLE2_DATA_KEY; rv = vb2_unpack_key_buffer(&data_key, key_data, key_size); @@ -292,8 +292,8 @@ vb2_error_t vb2_load_fw_preamble(struct vb2_context *ctx) } /* Keep track of where we put the preamble */ - sd->workbuf_preamble_offset = vb2_offset_of(ctx->workbuf, pre); - sd->workbuf_preamble_size = pre_size; + sd->preamble_offset = vb2_offset_of(sd, pre); + sd->preamble_size = pre_size; /* * Preamble will persist in work buffer after we return. @@ -307,7 +307,7 @@ vb2_error_t vb2_load_fw_preamble(struct vb2_context *ctx) * TODO: we could move the preamble down over the firmware data key * since we don't need it anymore. */ - vb2_set_workbuf_used(ctx, sd->workbuf_preamble_offset + pre_size); + vb2_set_workbuf_used(ctx, sd->preamble_offset + pre_size); return VB2_SUCCESS; } diff --git a/firmware/lib21/api.c b/firmware/lib21/api.c index 59448695..d9a955e7 100644 --- a/firmware/lib21/api.c +++ b/firmware/lib21/api.c @@ -52,10 +52,10 @@ vb2_error_t vb21api_init_hash(struct vb2_context *ctx, vb2_workbuf_from_ctx(ctx, &wb); /* Get preamble pointer */ - if (!sd->workbuf_preamble_size) + if (!sd->preamble_size) return VB2_ERROR_API_INIT_HASH_PREAMBLE; pre = (const struct vb21_fw_preamble *) - (ctx->workbuf + sd->workbuf_preamble_offset); + vb2_member_of(sd, sd->preamble_offset); /* Find the matching signature */ hash_offset = pre->hash_offset; @@ -72,9 +72,9 @@ vb2_error_t vb21api_init_hash(struct vb2_context *ctx, return VB2_ERROR_API_INIT_HASH_ID; /* No match */ /* Allocate workbuf space for the hash */ - if (sd->workbuf_hash_size) { + if (sd->hash_size) { dc = (struct vb2_digest_context *) - (ctx->workbuf + sd->workbuf_hash_offset); + vb2_member_of(sd, sd->hash_offset); } else { uint32_t dig_size = sizeof(*dc); @@ -82,12 +82,12 @@ vb2_error_t vb21api_init_hash(struct vb2_context *ctx, if (!dc) return VB2_ERROR_API_INIT_HASH_WORKBUF; - sd->workbuf_hash_offset = vb2_offset_of(ctx->workbuf, dc); - sd->workbuf_hash_size = dig_size; - vb2_set_workbuf_used(ctx, sd->workbuf_hash_offset + dig_size); + sd->hash_offset = vb2_offset_of(sd, dc); + sd->hash_size = dig_size; + vb2_set_workbuf_used(ctx, sd->hash_offset + dig_size); } - sd->hash_tag = vb2_offset_of(ctx->workbuf, sig); + sd->hash_tag = vb2_offset_of(sd, sig); sd->hash_remaining_size = sig->data_size; if (size) @@ -117,7 +117,7 @@ vb2_error_t vb21api_check_hash(struct vb2_context *ctx) { struct vb2_shared_data *sd = vb2_get_sd(ctx); struct vb2_digest_context *dc = (struct vb2_digest_context *) - (ctx->workbuf + sd->workbuf_hash_offset); + vb2_member_of(sd, sd->hash_offset); struct vb2_workbuf wb; uint8_t *digest; @@ -132,10 +132,10 @@ vb2_error_t vb21api_check_hash(struct vb2_context *ctx) /* Get signature pointer */ if (!sd->hash_tag) return VB2_ERROR_API_CHECK_HASH_TAG; - sig = (const struct vb21_signature *)(ctx->workbuf + sd->hash_tag); + sig = vb2_member_of(sd, sd->hash_tag); /* Must have initialized hash digest work area */ - if (!sd->workbuf_hash_size) + if (!sd->hash_size) return VB2_ERROR_API_CHECK_HASH_WORKBUF; /* Should have hashed the right amount of data */ diff --git a/firmware/lib21/misc.c b/firmware/lib21/misc.c index de7d4477..96071685 100644 --- a/firmware/lib21/misc.c +++ b/firmware/lib21/misc.c @@ -145,12 +145,12 @@ vb2_error_t vb21_load_fw_keyblock(struct vb2_context *ctx) packed_key = (struct vb21_packed_key *)key_data; /* Save the packed key offset and size */ - sd->workbuf_data_key_offset = vb2_offset_of(ctx->workbuf, key_data); - sd->workbuf_data_key_size = packed_key->c.total_size; + sd->data_key_offset = vb2_offset_of(sd, key_data); + sd->data_key_size = packed_key->c.total_size; /* Data key will persist in the workbuf after we return */ - vb2_set_workbuf_used(ctx, sd->workbuf_data_key_offset + - sd->workbuf_data_key_size); + vb2_set_workbuf_used(ctx, sd->data_key_offset + + sd->data_key_size); return VB2_SUCCESS; } @@ -161,8 +161,8 @@ vb2_error_t vb21_load_fw_preamble(struct vb2_context *ctx) struct vb2_gbb_header *gbb = vb2_get_gbb(ctx); struct vb2_workbuf wb; - uint8_t *key_data = ctx->workbuf + sd->workbuf_data_key_offset; - uint32_t key_size = sd->workbuf_data_key_size; + uint8_t *key_data = vb2_member_of(sd, sd->data_key_offset); + uint32_t key_size = sd->data_key_size; struct vb2_public_key data_key; /* Preamble goes in the next unused chunk of work buffer */ @@ -173,7 +173,7 @@ vb2_error_t vb21_load_fw_preamble(struct vb2_context *ctx) vb2_workbuf_from_ctx(ctx, &wb); /* Unpack the firmware data key */ - if (!sd->workbuf_data_key_size) + if (!sd->data_key_size) return VB2_ERROR_FW_PREAMBLE2_DATA_KEY; rv = vb21_unpack_key(&data_key, key_data, key_size); @@ -201,7 +201,7 @@ vb2_error_t vb21_load_fw_preamble(struct vb2_context *ctx) pre = (struct vb21_fw_preamble *)key_data; /* Data key is now gone */ - sd->workbuf_data_key_offset = sd->workbuf_data_key_size = 0; + sd->data_key_offset = sd->data_key_size = 0; /* * Firmware version is the lower 16 bits of the composite firmware @@ -238,12 +238,12 @@ vb2_error_t vb21_load_fw_preamble(struct vb2_context *ctx) } /* Keep track of where we put the preamble */ - sd->workbuf_preamble_offset = vb2_offset_of(ctx->workbuf, pre); - sd->workbuf_preamble_size = pre->c.total_size; + sd->preamble_offset = vb2_offset_of(sd, pre); + sd->preamble_size = pre->c.total_size; /* Preamble will persist in work buffer after we return */ - vb2_set_workbuf_used(ctx, sd->workbuf_preamble_offset + - sd->workbuf_preamble_size); + vb2_set_workbuf_used(ctx, sd->preamble_offset + + sd->preamble_size); return VB2_SUCCESS; } diff --git a/tests/vb20_api_kernel_tests.c b/tests/vb20_api_kernel_tests.c index 3a300ab6..cdb87e88 100644 --- a/tests/vb20_api_kernel_tests.c +++ b/tests/vb20_api_kernel_tests.c @@ -92,18 +92,18 @@ static void reset_common_data(enum reset_type t) uint8_t *kdata; /* Create mock firmware preamble in the context */ - sd->workbuf_preamble_offset = ctx.workbuf_used; + sd->preamble_offset = ctx.workbuf_used; fwpre = (struct vb2_fw_preamble *) - (ctx.workbuf + sd->workbuf_preamble_offset); + vb2_member_of(sd, sd->preamble_offset); k = &fwpre->kernel_subkey; kdata = (uint8_t *)fwpre + sizeof(*fwpre); memcpy(kdata, fw_kernel_key_data, sizeof(fw_kernel_key_data)); k->algorithm = 7; k->key_offset = vb2_offset_of(k, kdata); k->key_size = sizeof(fw_kernel_key_data); - sd->workbuf_preamble_size = sizeof(*fwpre) + k->key_size; - vb2_set_workbuf_used(&ctx, sd->workbuf_preamble_offset + - sd->workbuf_preamble_size); + sd->preamble_size = sizeof(*fwpre) + k->key_size; + vb2_set_workbuf_used(&ctx, sd->preamble_offset + + sd->preamble_size); } else if (t == FOR_PHASE2) { struct vb2_signature *sig; @@ -111,18 +111,18 @@ static void reset_common_data(enum reset_type t) uint8_t *sdata; /* Create mock kernel data key */ - sd->workbuf_data_key_offset = ctx.workbuf_used; + sd->data_key_offset = ctx.workbuf_used; kdkey = (struct vb2_packed_key *) - (ctx.workbuf + sd->workbuf_data_key_offset); + vb2_member_of(sd, sd->data_key_offset); kdkey->algorithm = VB2_ALG_RSA2048_SHA256; - sd->workbuf_data_key_size = sizeof(*kdkey); - vb2_set_workbuf_used(&ctx, sd->workbuf_data_key_offset + - sd->workbuf_data_key_size); + sd->data_key_size = sizeof(*kdkey); + vb2_set_workbuf_used(&ctx, sd->data_key_offset + + sd->data_key_size); /* Create mock kernel preamble in the context */ - sd->workbuf_preamble_offset = ctx.workbuf_used; + sd->preamble_offset = ctx.workbuf_used; kpre = (struct vb2_kernel_preamble *) - (ctx.workbuf + sd->workbuf_preamble_offset); + vb2_member_of(sd, sd->preamble_offset); sdata = (uint8_t *)kpre + sizeof(*kpre); sig = &kpre->body_signature; @@ -135,11 +135,11 @@ static void reset_common_data(enum reset_type t) sizeof(kernel_data)); vb2_digest_finalize(&dc, sdata, sig->sig_size); - sd->workbuf_preamble_size = sizeof(*kpre) + sig->sig_size; + sd->preamble_size = sizeof(*kpre) + sig->sig_size; sd->vblock_preamble_offset = - 0x10000 - sd->workbuf_preamble_size; - vb2_set_workbuf_used(&ctx, sd->workbuf_preamble_offset + - sd->workbuf_preamble_size); + 0x10000 - sd->preamble_size; + vb2_set_workbuf_used(&ctx, sd->preamble_offset + + sd->preamble_size); } else { /* Set flags and versions for roll-forward */ @@ -224,19 +224,18 @@ static void phase1_tests(void) /* Test successful call */ reset_common_data(FOR_PHASE1); - old_preamble_offset = sd->workbuf_preamble_offset; + old_preamble_offset = sd->preamble_offset; TEST_SUCC(vb2api_kernel_phase1(&ctx), "phase1 good"); - TEST_EQ(sd->workbuf_preamble_size, 0, " no more fw preamble"); + TEST_EQ(sd->preamble_size, 0, " no more fw preamble"); /* Make sure normal key was loaded */ - TEST_EQ(sd->workbuf_kernel_key_offset, old_preamble_offset, + TEST_EQ(sd->kernel_key_offset, old_preamble_offset, " workbuf key offset"); - k = (struct vb2_packed_key *) - (ctx.workbuf + sd->workbuf_kernel_key_offset); - TEST_EQ(sd->workbuf_kernel_key_size, k->key_offset + k->key_size, + k = vb2_member_of(sd, sd->kernel_key_offset); + TEST_EQ(sd->kernel_key_size, k->key_offset + k->key_size, " workbuf key size"); TEST_EQ(ctx.workbuf_used, - vb2_wb_round_up(sd->workbuf_kernel_key_offset + - sd->workbuf_kernel_key_size), + vb2_wb_round_up(sd->kernel_key_offset + + sd->kernel_key_size), " workbuf used"); TEST_EQ(k->algorithm, 7, " key algorithm"); TEST_EQ(k->key_size, sizeof(fw_kernel_key_data), " key_size"); @@ -248,20 +247,19 @@ static void phase1_tests(void) reset_common_data(FOR_PHASE1); ctx.flags |= VB2_CONTEXT_RECOVERY_MODE; /* No preamble loaded in recovery mode */ - ctx.workbuf_used = old_preamble_offset = sd->workbuf_preamble_offset; - sd->workbuf_preamble_offset = sd->workbuf_preamble_size = 0; + ctx.workbuf_used = old_preamble_offset = sd->preamble_offset; + sd->preamble_offset = sd->preamble_size = 0; TEST_SUCC(vb2api_kernel_phase1(&ctx), "phase1 rec good"); - TEST_EQ(sd->workbuf_preamble_size, 0, "no more fw preamble"); + TEST_EQ(sd->preamble_size, 0, "no more fw preamble"); /* Make sure recovery key was loaded */ - TEST_EQ(sd->workbuf_kernel_key_offset, old_preamble_offset, + TEST_EQ(sd->kernel_key_offset, old_preamble_offset, " workbuf key offset"); - k = (struct vb2_packed_key *) - (ctx.workbuf + sd->workbuf_kernel_key_offset); - TEST_EQ(sd->workbuf_kernel_key_size, k->key_offset + k->key_size, + k = vb2_member_of(sd, sd->kernel_key_offset); + TEST_EQ(sd->kernel_key_size, k->key_offset + k->key_size, " workbuf key size"); TEST_EQ(ctx.workbuf_used, - vb2_wb_round_up(sd->workbuf_kernel_key_offset + - sd->workbuf_kernel_key_size), + vb2_wb_round_up(sd->kernel_key_offset + + sd->kernel_key_size), " workbuf used"); TEST_EQ(k->algorithm, 11, " key algorithm"); TEST_EQ(k->key_size, sizeof(mock_gbb.recovery_key_data), " key_size"); @@ -311,7 +309,7 @@ static void phase1_tests(void) /* Failures while parsing subkey from firmware preamble */ reset_common_data(FOR_PHASE1); - sd->workbuf_preamble_size = 0; + sd->preamble_size = 0; TEST_EQ(vb2api_kernel_phase1(&ctx), VB2_ERROR_API_KPHASE1_PREAMBLE, "phase1 fw preamble"); } @@ -347,7 +345,7 @@ static void get_kernel_size_tests(void) TEST_SUCC(vb2api_get_kernel_size(&ctx, NULL, NULL), "get size null"); reset_common_data(FOR_PHASE2); - sd->workbuf_preamble_size = 0; + sd->preamble_size = 0; TEST_EQ(vb2api_get_kernel_size(&ctx, &offs, &size), VB2_ERROR_API_GET_KERNEL_SIZE_PREAMBLE, "get size no preamble"); @@ -361,7 +359,7 @@ static void verify_kernel_data_tests(void) "verify data good"); reset_common_data(FOR_PHASE2); - sd->workbuf_preamble_size = 0; + sd->preamble_size = 0; TEST_EQ(vb2api_verify_kernel_data(&ctx, kernel_data, sizeof(kernel_data)), VB2_ERROR_API_VERIFY_KDATA_PREAMBLE, "verify no preamble"); @@ -379,7 +377,7 @@ static void verify_kernel_data_tests(void) VB2_ERROR_API_VERIFY_KDATA_WORKBUF, "verify workbuf"); reset_common_data(FOR_PHASE2); - sd->workbuf_data_key_size = 0; + sd->data_key_size = 0; TEST_EQ(vb2api_verify_kernel_data(&ctx, kernel_data, sizeof(kernel_data)), VB2_ERROR_API_VERIFY_KDATA_KEY, "verify no key"); diff --git a/tests/vb20_api_tests.c b/tests/vb20_api_tests.c index ae6a216c..c3b48b78 100644 --- a/tests/vb20_api_tests.c +++ b/tests/vb20_api_tests.c @@ -74,12 +74,11 @@ static void reset_common_data(enum reset_type t) retval_vb2_digest_finalize = VB2_SUCCESS; retval_vb2_verify_digest = VB2_SUCCESS; - sd->workbuf_preamble_offset = ctx.workbuf_used; - sd->workbuf_preamble_size = sizeof(*pre); - vb2_set_workbuf_used(&ctx, sd->workbuf_preamble_offset - + sd->workbuf_preamble_size); - pre = (struct vb2_fw_preamble *) - (ctx.workbuf + sd->workbuf_preamble_offset); + sd->preamble_offset = ctx.workbuf_used; + sd->preamble_size = sizeof(*pre); + vb2_set_workbuf_used(&ctx, sd->preamble_offset + + sd->preamble_size); + pre = vb2_member_of(sd, sd->preamble_offset); pre->body_signature.data_size = mock_body_size; pre->body_signature.sig_size = mock_sig_size; if (hwcrypto_state == HWCRYPTO_FORBIDDEN) @@ -87,12 +86,11 @@ static void reset_common_data(enum reset_type t) else pre->flags = 0; - sd->workbuf_data_key_offset = ctx.workbuf_used; - sd->workbuf_data_key_size = sizeof(*k) + 8; - vb2_set_workbuf_used(&ctx, sd->workbuf_data_key_offset + - sd->workbuf_data_key_size); - k = (struct vb2_packed_key *) - (ctx.workbuf + sd->workbuf_data_key_offset); + sd->data_key_offset = ctx.workbuf_used; + sd->data_key_size = sizeof(*k) + 8; + vb2_set_workbuf_used(&ctx, sd->data_key_offset + + sd->data_key_size); + k = vb2_member_of(sd, sd->data_key_offset); k->algorithm = mock_algorithm; if (t == FOR_EXTEND_HASH || t == FOR_CHECK_HASH) @@ -255,13 +253,13 @@ static void init_hash_tests(void) wb_used_before = ctx.workbuf_used; TEST_SUCC(vb2api_init_hash(&ctx, VB2_HASH_TAG_FW_BODY, &size), "init hash good"); - TEST_EQ(sd->workbuf_hash_offset, wb_used_before, + TEST_EQ(sd->hash_offset, wb_used_before, "hash context offset"); - TEST_EQ(sd->workbuf_hash_size, sizeof(struct vb2_digest_context), + TEST_EQ(sd->hash_size, sizeof(struct vb2_digest_context), "hash context size"); TEST_EQ(ctx.workbuf_used, - vb2_wb_round_up(sd->workbuf_hash_offset + - sd->workbuf_hash_size), + vb2_wb_round_up(sd->hash_offset + + sd->hash_size), "hash uses workbuf"); TEST_EQ(sd->hash_tag, VB2_HASH_TAG_FW_BODY, "hash tag"); TEST_EQ(sd->hash_remaining_size, mock_body_size, "hash remaining"); @@ -276,7 +274,7 @@ static void init_hash_tests(void) VB2_ERROR_API_INIT_HASH_TAG, "init hash invalid tag"); reset_common_data(FOR_MISC); - sd->workbuf_preamble_size = 0; + sd->preamble_size = 0; TEST_EQ(vb2api_init_hash(&ctx, VB2_HASH_TAG_FW_BODY, &size), VB2_ERROR_API_INIT_HASH_PREAMBLE, "init hash preamble"); @@ -291,17 +289,17 @@ static void init_hash_tests(void) VB2_ERROR_API_INIT_HASH_WORKBUF, "init hash workbuf"); reset_common_data(FOR_MISC); - sd->workbuf_data_key_size = 0; + sd->data_key_size = 0; TEST_EQ(vb2api_init_hash(&ctx, VB2_HASH_TAG_FW_BODY, &size), VB2_ERROR_API_INIT_HASH_DATA_KEY, "init hash data key"); reset_common_data(FOR_MISC); - sd->workbuf_data_key_size--; + sd->data_key_size--; TEST_EQ(vb2api_init_hash(&ctx, VB2_HASH_TAG_FW_BODY, &size), VB2_ERROR_UNPACK_KEY_SIZE, "init hash data key size"); reset_common_data(FOR_MISC); - k = (struct vb2_packed_key *)(ctx.workbuf + sd->workbuf_data_key_offset); + k = vb2_member_of(sd, sd->data_key_offset); k->algorithm--; TEST_EQ(vb2api_init_hash(&ctx, VB2_HASH_TAG_FW_BODY, &size), VB2_ERROR_SHA_INIT_ALGORITHM, "init hash algorithm"); @@ -321,7 +319,7 @@ static void extend_hash_tests(void) TEST_EQ(sd->hash_remaining_size, 0, "hash extend remaining 2"); reset_common_data(FOR_EXTEND_HASH); - sd->workbuf_hash_size = 0; + sd->hash_size = 0; TEST_EQ(vb2api_extend_hash(&ctx, mock_body, mock_body_size), VB2_ERROR_API_EXTEND_HASH_WORKBUF, "hash extend no workbuf"); @@ -336,7 +334,7 @@ static void extend_hash_tests(void) if (hwcrypto_state != HWCRYPTO_ENABLED) { reset_common_data(FOR_EXTEND_HASH); dc = (struct vb2_digest_context *) - (ctx.workbuf + sd->workbuf_hash_offset); + vb2_member_of(sd, sd->hash_offset); dc->hash_alg = mock_hash_alg + 1; TEST_EQ(vb2api_extend_hash(&ctx, mock_body, mock_body_size), VB2_ERROR_SHA_EXTEND_ALGORITHM, "hash extend fail"); @@ -366,12 +364,12 @@ static void check_hash_tests(void) "check digest wrong size"); reset_common_data(FOR_CHECK_HASH); - sd->workbuf_preamble_size = 0; + sd->preamble_size = 0; TEST_EQ(vb2api_check_hash(&ctx), VB2_ERROR_API_CHECK_HASH_PREAMBLE, "check hash preamble"); reset_common_data(FOR_CHECK_HASH); - sd->workbuf_hash_size = 0; + sd->hash_size = 0; TEST_EQ(vb2api_check_hash(&ctx), VB2_ERROR_API_CHECK_HASH_WORKBUF, "check hash no workbuf"); @@ -395,18 +393,17 @@ static void check_hash_tests(void) VB2_ERROR_API_CHECK_HASH_TAG, "check hash tag"); reset_common_data(FOR_CHECK_HASH); - sd->workbuf_data_key_size = 0; + sd->data_key_size = 0; TEST_EQ(vb2api_check_hash(&ctx), VB2_ERROR_API_CHECK_HASH_DATA_KEY, "check hash data key"); reset_common_data(FOR_CHECK_HASH); - sd->workbuf_data_key_size--; + sd->data_key_size--; TEST_EQ(vb2api_check_hash(&ctx), VB2_ERROR_UNPACK_KEY_SIZE, "check hash data key size"); reset_common_data(FOR_CHECK_HASH); - pre = (struct vb2_fw_preamble *) - (ctx.workbuf + sd->workbuf_preamble_offset); + pre = vb2_member_of(sd, sd->preamble_offset); pre->body_signature.sig_size++; TEST_EQ(vb2api_check_hash(&ctx), VB2_ERROR_VDATA_SIG_SIZE, "check hash sig size"); diff --git a/tests/vb20_kernel_tests.c b/tests/vb20_kernel_tests.c index 5490ccce..52899cca 100644 --- a/tests/vb20_kernel_tests.c +++ b/tests/vb20_kernel_tests.c @@ -248,26 +248,26 @@ static void load_kernel_keyblock_tests(void) TEST_EQ(sd->kernel_version, 0x20000, "keyblock version"); TEST_EQ(sd->vblock_preamble_offset, sizeof(mock_vblock.k), "preamble offset"); - TEST_EQ(sd->workbuf_data_key_offset, wb_used_before, + TEST_EQ(sd->data_key_offset, wb_used_before, "keyblock data key offset"); TEST_EQ(ctx.workbuf_used, - vb2_wb_round_up(sd->workbuf_data_key_offset + - sd->workbuf_data_key_size), + vb2_wb_round_up(sd->data_key_offset + + sd->data_key_size), "workbuf used"); /* Make sure data key was properly saved */ - k = (struct vb2_packed_key *)(ctx.workbuf + sd->workbuf_data_key_offset); + k = vb2_member_of(sd, sd->data_key_offset); TEST_EQ(k->algorithm, 7, "data key algorithm"); TEST_EQ(k->key_version, 2, "data key version"); TEST_EQ(k->key_size, sizeof(mock_vblock.k.data_key_data), "data key size"); - TEST_EQ(memcmp(ctx.workbuf + sd->workbuf_data_key_offset + - k->key_offset, mock_vblock.k.data_key_data, + TEST_EQ(memcmp(vb2_member_of(k, k->key_offset), + mock_vblock.k.data_key_data, sizeof(mock_vblock.k.data_key_data)), 0, "data key data"); TEST_EQ(ctx.workbuf_used, - vb2_wb_round_up(sd->workbuf_data_key_offset + - sd->workbuf_data_key_size), + vb2_wb_round_up(sd->data_key_offset + + sd->data_key_size), "workbuf used after"); /* Test failures */ @@ -403,17 +403,17 @@ static void load_kernel_preamble_tests(void) wb_used_before = ctx.workbuf_used; TEST_SUCC(vb2_load_kernel_preamble(&ctx), "preamble good"); TEST_EQ(sd->kernel_version, 0x20002, "combined version"); - TEST_EQ(sd->workbuf_preamble_offset, wb_used_before, + TEST_EQ(sd->preamble_offset, wb_used_before, "preamble offset"); - TEST_EQ(sd->workbuf_preamble_size, pre->preamble_size, "preamble size"); + TEST_EQ(sd->preamble_size, pre->preamble_size, "preamble size"); TEST_EQ(ctx.workbuf_used, - vb2_wb_round_up(sd->workbuf_preamble_offset + - sd->workbuf_preamble_size), + vb2_wb_round_up(sd->preamble_offset + + sd->preamble_size), "workbuf used"); /* Expected failures */ reset_common_data(FOR_PREAMBLE); - sd->workbuf_data_key_size = 0; + sd->data_key_size = 0; TEST_EQ(vb2_load_kernel_preamble(&ctx), VB2_ERROR_KERNEL_PREAMBLE2_DATA_KEY, "preamble no data key"); diff --git a/tests/vb20_misc_tests.c b/tests/vb20_misc_tests.c index 46e3f036..1d23a6d6 100644 --- a/tests/vb20_misc_tests.c +++ b/tests/vb20_misc_tests.c @@ -188,26 +188,26 @@ static void verify_keyblock_tests(void) TEST_EQ(sd->fw_version, 0x20000, "keyblock version"); TEST_EQ(sd->vblock_preamble_offset, sizeof(mock_vblock.k), "preamble offset"); - TEST_EQ(sd->workbuf_data_key_offset, wb_used_before, + TEST_EQ(sd->data_key_offset, wb_used_before, "keyblock data key offset"); TEST_EQ(ctx.workbuf_used, - vb2_wb_round_up(sd->workbuf_data_key_offset + - sd->workbuf_data_key_size), + vb2_wb_round_up(sd->data_key_offset + + sd->data_key_size), "workbuf used"); /* Make sure data key was properly saved */ - k = (struct vb2_packed_key *)(ctx.workbuf + sd->workbuf_data_key_offset); + k = vb2_member_of(sd, sd->data_key_offset); TEST_EQ(k->algorithm, 7, "data key algorithm"); TEST_EQ(k->key_version, 2, "data key version"); TEST_EQ(k->key_size, sizeof(mock_vblock.k.data_key_data), "data key size"); - TEST_EQ(memcmp(ctx.workbuf + sd->workbuf_data_key_offset + - k->key_offset, mock_vblock.k.data_key_data, + TEST_EQ(memcmp(vb2_member_of(k, k->key_offset), + mock_vblock.k.data_key_data, sizeof(mock_vblock.k.data_key_data)), 0, "data key data"); TEST_EQ(ctx.workbuf_used, - vb2_wb_round_up(sd->workbuf_data_key_offset + - sd->workbuf_data_key_size), + vb2_wb_round_up(sd->data_key_offset + + sd->data_key_size), "workbuf used after"); /* Test failures */ @@ -292,17 +292,17 @@ static void verify_preamble_tests(void) wb_used_before = ctx.workbuf_used; TEST_SUCC(vb2_load_fw_preamble(&ctx), "preamble good"); TEST_EQ(sd->fw_version, 0x20002, "combined version"); - TEST_EQ(sd->workbuf_preamble_offset, wb_used_before, + TEST_EQ(sd->preamble_offset, wb_used_before, "preamble offset"); - TEST_EQ(sd->workbuf_preamble_size, pre->preamble_size, "preamble size"); + TEST_EQ(sd->preamble_size, pre->preamble_size, "preamble size"); TEST_EQ(ctx.workbuf_used, - vb2_wb_round_up(sd->workbuf_preamble_offset + - sd->workbuf_preamble_size), + vb2_wb_round_up(sd->preamble_offset + + sd->preamble_size), "workbuf used"); /* Expected failures */ reset_common_data(FOR_PREAMBLE); - sd->workbuf_data_key_size = 0; + sd->data_key_size = 0; TEST_EQ(vb2_load_fw_preamble(&ctx), VB2_ERROR_FW_PREAMBLE2_DATA_KEY, "preamble no data key"); diff --git a/tests/vb21_api_tests.c b/tests/vb21_api_tests.c index 53177957..8ea9bf3a 100644 --- a/tests/vb21_api_tests.c +++ b/tests/vb21_api_tests.c @@ -91,9 +91,8 @@ static void reset_common_data(enum reset_type t) vb2_private_key_hash(&hash_key, mock_hash_alg); - sd->workbuf_preamble_offset = ctx.workbuf_used; - pre = (struct vb21_fw_preamble *) - (ctx.workbuf + sd->workbuf_preamble_offset); + sd->preamble_offset = ctx.workbuf_used; + pre = vb2_member_of(sd, sd->preamble_offset); pre->hash_count = 3; pre->hash_offset = sig_offset = sizeof(*pre); if (hwcrypto_state == HWCRYPTO_FORBIDDEN) @@ -111,9 +110,9 @@ static void reset_common_data(enum reset_type t) free(sig); } - sd->workbuf_preamble_size = sig_offset; - ctx.workbuf_used = vb2_wb_round_up(sd->workbuf_preamble_offset + - sd->workbuf_preamble_size); + sd->preamble_size = sig_offset; + ctx.workbuf_used = vb2_wb_round_up(sd->preamble_offset + + sd->preamble_size); if (t == FOR_EXTEND_HASH || t == FOR_CHECK_HASH) vb21api_init_hash(&ctx, test_id, NULL); @@ -202,23 +201,22 @@ static void init_hash_tests(void) uint32_t size; reset_common_data(FOR_MISC); - pre = (struct vb21_fw_preamble *) - (ctx.workbuf + sd->workbuf_preamble_offset); + pre = vb2_member_of(sd, sd->preamble_offset); sig = (struct vb21_signature *)((uint8_t *)pre + pre->hash_offset); wb_used_before = ctx.workbuf_used; TEST_SUCC(vb21api_init_hash(&ctx, test_id, &size), "init hash good"); - TEST_EQ(sd->workbuf_hash_offset, wb_used_before, + TEST_EQ(sd->hash_offset, wb_used_before, "hash context offset"); - TEST_EQ(sd->workbuf_hash_size, sizeof(struct vb2_digest_context), + TEST_EQ(sd->hash_size, sizeof(struct vb2_digest_context), "hash context size"); TEST_EQ(ctx.workbuf_used, - vb2_wb_round_up(sd->workbuf_hash_offset + - sd->workbuf_hash_size), + vb2_wb_round_up(sd->hash_offset + + sd->hash_size), "hash uses workbuf"); TEST_EQ(sd->hash_tag, - sd->workbuf_preamble_offset + pre->hash_offset, + sd->preamble_offset + pre->hash_offset, "hash signature offset"); TEST_EQ(sd->hash_remaining_size, mock_body_size, "hash remaining"); @@ -227,7 +225,7 @@ static void init_hash_tests(void) "init hash again"); TEST_EQ(ctx.workbuf_used, wb_used_before, "init hash reuses context"); TEST_EQ(sd->hash_tag, - sd->workbuf_preamble_offset + pre->hash_offset + + sd->preamble_offset + pre->hash_offset + 2 * mock_sig_size, "hash signature offset 2"); @@ -236,7 +234,7 @@ static void init_hash_tests(void) VB2_ERROR_API_INIT_HASH_ID, "init hash invalid id"); reset_common_data(FOR_MISC); - sd->workbuf_preamble_size = 0; + sd->preamble_size = 0; TEST_EQ(vb21api_init_hash(&ctx, test_id, &size), VB2_ERROR_API_INIT_HASH_PREAMBLE, "init hash preamble"); @@ -273,7 +271,7 @@ static void extend_hash_tests(void) TEST_EQ(sd->hash_remaining_size, 0, "hash extend remaining 2"); reset_common_data(FOR_EXTEND_HASH); - sd->workbuf_hash_size = 0; + sd->hash_size = 0; TEST_EQ(vb2api_extend_hash(&ctx, mock_body, mock_body_size), VB2_ERROR_API_EXTEND_HASH_WORKBUF, "hash extend no workbuf"); @@ -293,7 +291,7 @@ static void extend_hash_tests(void) } else { reset_common_data(FOR_EXTEND_HASH); dc = (struct vb2_digest_context *) - (ctx.workbuf + sd->workbuf_hash_offset); + vb2_member_of(sd, sd->hash_offset); dc->hash_alg = VB2_HASH_INVALID; TEST_EQ(vb2api_extend_hash(&ctx, mock_body, mock_body_size), VB2_ERROR_SHA_EXTEND_ALGORITHM, "hash extend fail"); @@ -307,11 +305,9 @@ static void check_hash_tests(void) struct vb2_digest_context *dc; reset_common_data(FOR_CHECK_HASH); - pre = (struct vb21_fw_preamble *) - (ctx.workbuf + sd->workbuf_preamble_offset); - sig = (struct vb21_signature *)((uint8_t *)pre + pre->hash_offset); - dc = (struct vb2_digest_context *) - (ctx.workbuf + sd->workbuf_hash_offset); + pre = vb2_member_of(sd, sd->preamble_offset); + sig = vb2_member_of(pre, pre->hash_offset); + dc = vb2_member_of(sd, sd->hash_offset); TEST_SUCC(vb21api_check_hash(&ctx), "check hash good"); @@ -321,7 +317,7 @@ static void check_hash_tests(void) VB2_ERROR_API_CHECK_HASH_TAG, "check hash tag"); reset_common_data(FOR_CHECK_HASH); - sd->workbuf_hash_size = 0; + sd->hash_size = 0; TEST_EQ(vb21api_check_hash(&ctx), VB2_ERROR_API_CHECK_HASH_WORKBUF, "check hash no workbuf"); diff --git a/tests/vb21_misc_tests.c b/tests/vb21_misc_tests.c index 37c0ea3a..383e3d02 100644 --- a/tests/vb21_misc_tests.c +++ b/tests/vb21_misc_tests.c @@ -193,27 +193,26 @@ static void load_keyblock_tests(void) TEST_EQ(sd->fw_version, 0x20000, "keyblock version"); TEST_EQ(sd->vblock_preamble_offset, sizeof(mock_vblock.k), "preamble offset"); - TEST_EQ(sd->workbuf_data_key_offset, wb_used_before, + TEST_EQ(sd->data_key_offset, wb_used_before, "keyblock data key offset"); TEST_EQ(ctx.workbuf_used, - vb2_wb_round_up(sd->workbuf_data_key_offset + - sd->workbuf_data_key_size), + vb2_wb_round_up(sd->data_key_offset + + sd->data_key_size), "workbuf used"); /* Make sure data key was properly saved */ - k = (struct vb21_packed_key *)(ctx.workbuf + - sd->workbuf_data_key_offset); + k = vb2_member_of(sd, sd->data_key_offset); TEST_EQ(k->sig_alg, VB2_SIG_RSA4096, "data key algorithm"); TEST_EQ(k->key_version, 2, "data key version"); TEST_EQ(k->key_size, sizeof(mock_vblock.k.data_key_data), "data key size"); - TEST_EQ(memcmp(ctx.workbuf + sd->workbuf_data_key_offset + - k->key_offset, mock_vblock.k.data_key_data, + TEST_EQ(memcmp(vb2_member_of(k, k->key_offset), + mock_vblock.k.data_key_data, sizeof(mock_vblock.k.data_key_data)), 0, "data key data"); TEST_EQ(ctx.workbuf_used, - vb2_wb_round_up(sd->workbuf_data_key_offset + - sd->workbuf_data_key_size), + vb2_wb_round_up(sd->data_key_offset + + sd->data_key_size), "workbuf used after"); /* Test failures */ @@ -295,22 +294,22 @@ static void load_preamble_tests(void) /* Test successful call */ reset_common_data(FOR_PREAMBLE); - data_key_offset_before = sd->workbuf_data_key_offset; + data_key_offset_before = sd->data_key_offset; TEST_SUCC(vb21_load_fw_preamble(&ctx), "preamble good"); TEST_EQ(sd->fw_version, 0x20002, "combined version"); - TEST_EQ(sd->workbuf_preamble_offset, data_key_offset_before, + TEST_EQ(sd->preamble_offset, data_key_offset_before, "preamble offset"); - TEST_EQ(sd->workbuf_preamble_size, pre->c.total_size, "preamble size"); + TEST_EQ(sd->preamble_size, pre->c.total_size, "preamble size"); TEST_EQ(ctx.workbuf_used, - vb2_wb_round_up(sd->workbuf_preamble_offset + - sd->workbuf_preamble_size), + vb2_wb_round_up(sd->preamble_offset + + sd->preamble_size), "workbuf used"); - TEST_EQ(sd->workbuf_data_key_offset, 0, "data key offset gone"); - TEST_EQ(sd->workbuf_data_key_size, 0, "data key size gone"); + TEST_EQ(sd->data_key_offset, 0, "data key offset gone"); + TEST_EQ(sd->data_key_size, 0, "data key size gone"); /* Expected failures */ reset_common_data(FOR_PREAMBLE); - sd->workbuf_data_key_size = 0; + sd->data_key_size = 0; TEST_EQ(vb21_load_fw_preamble(&ctx), VB2_ERROR_FW_PREAMBLE2_DATA_KEY, "preamble no data key"); diff --git a/tests/vb2_misc_tests.c b/tests/vb2_misc_tests.c index a9f82531..c2763e4e 100644 --- a/tests/vb2_misc_tests.c +++ b/tests/vb2_misc_tests.c @@ -228,8 +228,7 @@ static void gbb_tests(void) TEST_SUCC(vb2_fw_parse_gbb(&ctx), "parse gbb"); /* Manually calculate the location of GBB since we have mocked out the original definition of vb2_get_gbb. */ - struct vb2_gbb_header *current_gbb = - (struct vb2_gbb_header *)((void *)sd + sd->gbb_offset); + struct vb2_gbb_header *current_gbb = vb2_member_of(sd, sd->gbb_offset); TEST_SUCC(memcmp(&gbbsrc, current_gbb, sizeof(gbbsrc)), "copy gbb contents"); TEST_EQ(used_before, ctx.workbuf_used - sizeof(gbbsrc), -- cgit v1.2.1