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 <kitching@google.com>
Cq-Depend: chromium:1753400
Reviewed-on: https://chromium-review.googlesource.com/c/chromiumos/platform/vboot_reference/+/1718264
Commit-Queue: Joel Kitching <kitching@chromium.org>
Tested-by: Joel Kitching <kitching@chromium.org>
Reviewed-by: Julius Werner <jwerner@chromium.org>
diff --git a/firmware/2lib/2api.c b/firmware/2lib/2api.c
index f39ba29..e6ed5eb 100644
--- a/firmware/2lib/2api.c
+++ b/firmware/2lib/2api.c
@@ -165,10 +165,10 @@
{
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 de1fc49..c0eb447 100644
--- a/firmware/2lib/2common.c
+++ b/firmware/2lib/2common.c
@@ -104,6 +104,12 @@
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 f0df9c0..ccc0bfc 100644
--- a/firmware/2lib/include/2common.h
+++ b/firmware/2lib/include/2common.h
@@ -166,6 +166,15 @@
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
*
* @param sig_alg Signature algorithm
diff --git a/firmware/2lib/include/2struct.h b/firmware/2lib/include/2struct.h
index 52783b6..a045fef 100644
--- a/firmware/2lib/include/2struct.h
+++ b/firmware/2lib/include/2struct.h
@@ -169,22 +169,22 @@
* 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 @@
* 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 @@
* 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 7c6b0d4..e28b168 100644
--- a/firmware/lib20/api.c
+++ b/firmware/lib20/api.c
@@ -52,19 +52,19 @@
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 @@
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 @@
* 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 @@
{
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_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 @@
*/
/* 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 8e5f5e6..7737f26 100644
--- a/firmware/lib20/api_kernel.c
+++ b/firmware/lib20/api_kernel.c
@@ -74,19 +74,18 @@
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 @@
* 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 @@
}
/* 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_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 @@
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_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 @@
* 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 4d8f772..10cf158 100644
--- a/firmware/lib20/kernel.c
+++ b/firmware/lib20/kernel.c
@@ -121,8 +121,8 @@
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 @@
* (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 @@
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 @@
* - 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 @@
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_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 @@
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 @@
* 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 70f3ab8..0d68179 100644
--- a/firmware/lib20/misc.c
+++ b/firmware/lib20/misc.c
@@ -172,8 +172,8 @@
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_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 @@
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_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 @@
}
/* 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 @@
* 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 5944869..d9a955e 100644
--- a/firmware/lib21/api.c
+++ b/firmware/lib21/api.c
@@ -52,10 +52,10 @@
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 @@
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 @@
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 @@
{
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 @@
/* 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 de7d447..9607168 100644
--- a/firmware/lib21/misc.c
+++ b/firmware/lib21/misc.c
@@ -145,12 +145,12 @@
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 @@
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_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 @@
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 @@
}
/* 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 3a300ab..cdb87e8 100644
--- a/tests/vb20_api_kernel_tests.c
+++ b/tests/vb20_api_kernel_tests.c
@@ -92,18 +92,18 @@
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 @@
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 @@
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 @@
/* 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 @@
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 @@
/* 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 @@
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 @@
"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 @@
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 ae6a216..c3b48b7 100644
--- a/tests/vb20_api_tests.c
+++ b/tests/vb20_api_tests.c
@@ -74,12 +74,11 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
"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 @@
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 5490ccc..52899cc 100644
--- a/tests/vb20_kernel_tests.c
+++ b/tests/vb20_kernel_tests.c
@@ -248,26 +248,26 @@
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 @@
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 46e3f03..1d23a6d 100644
--- a/tests/vb20_misc_tests.c
+++ b/tests/vb20_misc_tests.c
@@ -188,26 +188,26 @@
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 @@
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 5317795..8ea9bf3 100644
--- a/tests/vb21_api_tests.c
+++ b/tests/vb21_api_tests.c
@@ -91,9 +91,8 @@
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 @@
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 @@
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 @@
"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 @@
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 @@
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 @@
} 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 @@
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 @@
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 37c0ea3..383e3d0 100644
--- a/tests/vb21_misc_tests.c
+++ b/tests/vb21_misc_tests.c
@@ -193,27 +193,26 @@
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 @@
/* 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 a9f8253..c2763e4 100644
--- a/tests/vb2_misc_tests.c
+++ b/tests/vb2_misc_tests.c
@@ -228,8 +228,7 @@
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),
