vboot: move vb2_packed_key and several functions from lib20 to 2lib

* Move vb2_packed_key from vb2_struct.h to 2struct.h
* Move vb2_verify_member_inside from lib20/common.c to 2common.c
* Move vb2_packed_key_data and vb2_verify_packed_key_inside from
  lib20/packed_key.c to 2packed_key.c
* Relocate tests accordingly

BUG=b:124141368, chromium:968464
TEST=make clean && make runtests
BRANCH=none

Change-Id: I6a9338ffdb640aad071941c3768427e15cd2aa93
Signed-off-by: Joel Kitching <kitching@google.com>
Reviewed-on: https://chromium-review.googlesource.com/c/chromiumos/platform/vboot_reference/+/1642773
Tested-by: Joel Kitching <kitching@chromium.org>
Reviewed-by: Julius Werner <jwerner@chromium.org>
Commit-Queue: Joel Kitching <kitching@chromium.org>

15 files changed, 255 insertions, 210 deletions

diff --git a/Makefile b/Makefile
index bcb0daf6..0c6e2307 100644
--- a/Makefile
+++ b/Makefile
@@ -366,6 +366,7 @@ FWLIB2X_SRCS = \
 	firmware/2lib/2crc8.c \
 	firmware/2lib/2misc.c \
 	firmware/2lib/2nvstorage.c \
+	firmware/2lib/2packed_key.c \
 	firmware/2lib/2rsa.c \
 	firmware/2lib/2secdata.c \
 	firmware/2lib/2secdatak.c \
diff --git a/firmware/2lib/2common.c b/firmware/2lib/2common.c
index 4db9e77a..472d5acc 100644
--- a/firmware/2lib/2common.c
+++ b/firmware/2lib/2common.c
@@ -103,3 +103,42 @@ ptrdiff_t vb2_offset_of(const void *base, const void *ptr)
 {
 	return (uintptr_t)ptr - (uintptr_t)base;
 }
+
+int vb2_verify_member_inside(const void *parent, size_t parent_size,
+			     const void *member, size_t member_size,
+			     ptrdiff_t member_data_offset,
+			     size_t member_data_size)
+{
+	const uintptr_t parent_end = (uintptr_t)parent + parent_size;
+	const ptrdiff_t member_offs = vb2_offset_of(parent, member);
+	const ptrdiff_t member_end_offs = member_offs + member_size;
+	const ptrdiff_t data_offs = member_offs + member_data_offset;
+	const ptrdiff_t data_end_offs = data_offs + member_data_size;
+
+	/* Make sure parent doesn't wrap */
+	if (parent_end < (uintptr_t)parent)
+		return VB2_ERROR_INSIDE_PARENT_WRAPS;
+
+	/*
+	 * Make sure the member is fully contained in the parent and doesn't
+	 * wrap.  Use >, not >=, since member_size = 0 is possible.
+	 */
+	if (member_end_offs < member_offs)
+		return VB2_ERROR_INSIDE_MEMBER_WRAPS;
+	if (member_offs < 0 || member_offs > parent_size ||
+	    member_end_offs > parent_size)
+		return VB2_ERROR_INSIDE_MEMBER_OUTSIDE;
+
+	/* Make sure the member data is after the member */
+	if (member_data_size > 0 && data_offs < member_end_offs)
+		return VB2_ERROR_INSIDE_DATA_OVERLAP;
+
+	/* Make sure parent fully contains member data, if any */
+	if (data_end_offs < data_offs)
+		return VB2_ERROR_INSIDE_DATA_WRAPS;
+	if (data_offs < 0 || data_offs > parent_size ||
+	    data_end_offs > parent_size)
+		return VB2_ERROR_INSIDE_DATA_OUTSIDE;
+
+	return VB2_SUCCESS;
+}
diff --git a/firmware/2lib/2packed_key.c b/firmware/2lib/2packed_key.c
new file mode 100644
index 00000000..00262866
--- /dev/null
+++ b/firmware/2lib/2packed_key.c
@@ -0,0 +1,22 @@
+/* Copyright 2019 The Chromium OS Authors. All rights reserved.
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ *
+ * Packed key related functions.
+ */
+
+#include "2common.h"
+
+const uint8_t *vb2_packed_key_data(const struct vb2_packed_key *key)
+{
+	return (const uint8_t *)key + key->key_offset;
+}
+
+int vb2_verify_packed_key_inside(const void *parent,
+				 uint32_t parent_size,
+				 const struct vb2_packed_key *key)
+{
+	return vb2_verify_member_inside(parent, parent_size,
+					key, sizeof(*key),
+					key->key_offset, key->key_size);
+}
diff --git a/firmware/2lib/include/2common.h b/firmware/2lib/include/2common.h
index 4b80e12c..be8a4ec5 100644
--- a/firmware/2lib/include/2common.h
+++ b/firmware/2lib/include/2common.h
@@ -200,4 +200,51 @@ const struct vb2_id *vb2_hash_id(enum vb2_hash_algorithm hash_alg);
  */
 #define VB2_VERIFY_KERNEL_PREAMBLE_WORKBUF_BYTES VB2_VERIFY_DATA_WORKBUF_BYTES
 
+/**
+ * Verify the data pointed to by a subfield is inside the parent data.
+ *
+ * The subfield has a header pointed to by member, and a separate data
+ * field at an offset relative to the header.  That is:
+ *
+ *   struct parent {
+ *     (possibly other parent fields)
+ *     struct member {
+ *        (member header fields)
+ *     };
+ *     (possibly other parent fields)
+ *   };
+ *   (possibly some other parent data)
+ *   (member data)
+ *   (possibly some other parent data)
+ *
+ * @param parent		Parent data
+ * @param parent_size		Parent size in bytes
+ * @param member		Subfield header
+ * @param member_size		Size of subfield header in bytes
+ * @param member_data_offset	Offset of member data from start of member
+ * @param member_data_size	Size of member data in bytes
+ * @return VB2_SUCCESS, or non-zero if error.
+ */
+int vb2_verify_member_inside(const void *parent, size_t parent_size,
+			     const void *member, size_t member_size,
+			     ptrdiff_t member_data_offset,
+			     size_t member_data_size);
+
+/*
+ * Helper function to get data pointed to by a public key.
+ */
+const uint8_t *vb2_packed_key_data(const struct vb2_packed_key *key);
+
+/**
+ * Verify a packed key is fully contained in its parent data
+ *
+ * @param parent	Parent data
+ * @param parent_size	Parent size in bytes
+ * @param key		Packed key pointer
+ * @return VB2_SUCCESS, or non-zero if error.
+ */
+int vb2_verify_packed_key_inside(const void *parent,
+				 uint32_t parent_size,
+				 const struct vb2_packed_key *key);
+
 #endif  /* VBOOT_REFERENCE_VBOOT_2COMMON_H_ */
diff --git a/firmware/2lib/include/2struct.h b/firmware/2lib/include/2struct.h
index 0b94c20a..2ca30142 100644
--- a/firmware/2lib/include/2struct.h
+++ b/firmware/2lib/include/2struct.h
@@ -2,8 +2,15 @@
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  *
- * Data structure definitions for verified boot, for on-disk / in-eeprom
- * data.
+ * Vboot data structures.
+ *
+ * Note: Many of the structs have pairs of 32-bit fields and reserved fields.
+ * This is to be backwards-compatible with older verified boot data which used
+ * 64-bit fields (when we thought that hey, UEFI is 64-bit so all our fields
+ * should be too).
+ *
+ * Offsets should be padded to 32-bit boundaries, since some architectures
+ * have trouble with accessing unaligned integers.
  */
 
 #ifndef VBOOT_REFERENCE_VBOOT_2STRUCT_H_
@@ -301,4 +308,27 @@ struct vb2_ryu_root_key_hash {
 
 #define EXPECTED_VB2_RYU_ROOT_KEY_HASH_SIZE 48
 
+/* Packed public key data */
+struct vb2_packed_key {
+	/* Offset of key data from start of this struct */
+	uint32_t key_offset;
+	uint32_t reserved0;
+
+	/* Size of key data in bytes (NOT strength of key in bits) */
+	uint32_t key_size;
+	uint32_t reserved1;
+
+	/* Signature algorithm used by the key (enum vb2_crypto_algorithm) */
+	uint32_t algorithm;
+	uint32_t reserved2;
+
+	/* Key version */
+	uint32_t key_version;
+	uint32_t reserved3;
+
+	/* TODO: when redoing this struct, add a text description of the key */
+} __attribute__((packed));
+
+#define EXPECTED_VB2_PACKED_KEY_SIZE 32
+
 #endif  /* VBOOT_REFERENCE_VBOOT_2STRUCT_H_ */
diff --git a/firmware/lib20/common.c b/firmware/lib20/common.c
index 91221147..64644d4a 100644
--- a/firmware/lib20/common.c
+++ b/firmware/lib20/common.c
@@ -16,45 +16,6 @@ uint8_t *vb2_signature_data(struct vb2_signature *sig)
 	return (uint8_t *)sig + sig->sig_offset;
 }
 
-int vb2_verify_member_inside(const void *parent, size_t parent_size,
-			     const void *member, size_t member_size,
-			     ptrdiff_t member_data_offset,
-			     size_t member_data_size)
-{
-	const uintptr_t parent_end = (uintptr_t)parent + parent_size;
-	const ptrdiff_t member_offs = vb2_offset_of(parent, member);
-	const ptrdiff_t member_end_offs = member_offs + member_size;
-	const ptrdiff_t data_offs = member_offs + member_data_offset;
-	const ptrdiff_t data_end_offs = data_offs + member_data_size;
-
-	/* Make sure parent doesn't wrap */
-	if (parent_end < (uintptr_t)parent)
-		return VB2_ERROR_INSIDE_PARENT_WRAPS;
-
-	/*
-	 * Make sure the member is fully contained in the parent and doesn't
-	 * wrap.  Use >, not >=, since member_size = 0 is possible.
-	 */
-	if (member_end_offs < member_offs)
-		return VB2_ERROR_INSIDE_MEMBER_WRAPS;
-	if (member_offs < 0 || member_offs > parent_size ||
-	    member_end_offs > parent_size)
-		return VB2_ERROR_INSIDE_MEMBER_OUTSIDE;
-
-	/* Make sure the member data is after the member */
-	if (member_data_size > 0 && data_offs < member_end_offs)
-		return VB2_ERROR_INSIDE_DATA_OVERLAP;
-
-	/* Make sure parent fully contains member data, if any */
-	if (data_end_offs < data_offs)
-		return VB2_ERROR_INSIDE_DATA_WRAPS;
-	if (data_offs < 0 || data_offs > parent_size ||
-	    data_end_offs > parent_size)
-		return VB2_ERROR_INSIDE_DATA_OUTSIDE;
-
-	return VB2_SUCCESS;
-}
-
 int vb2_verify_signature_inside(const void *parent,
 				uint32_t parent_size,
 				const struct vb2_signature *sig)
diff --git a/firmware/lib20/include/vb2_common.h b/firmware/lib20/include/vb2_common.h
index 96deb51a..4cb0e5a5 100644
--- a/firmware/lib20/include/vb2_common.h
+++ b/firmware/lib20/include/vb2_common.h
@@ -19,40 +19,9 @@
  * Helper functions to get data pointed to by a public key or signature.
  */
 
-const uint8_t *vb2_packed_key_data(const struct vb2_packed_key *key);
 uint8_t *vb2_signature_data(struct vb2_signature *sig);
 
 /**
- * Verify the data pointed to by a subfield is inside the parent data.
- *
- * The subfield has a header pointed to by member, and a separate data
- * field at an offset relative to the header.  That is:
- *
- *   struct parent {
- *     (possibly other parent fields)
- *     struct member {
- *        (member header fields)
- *     };
- *     (possibly other parent fields)
- *   };
- *   (possibly some other parent data)
- *   (member data)
- *   (possibly some other parent data)
- *
- * @param parent		Parent data
- * @param parent_size		Parent size in bytes
- * @param member		Subfield header
- * @param member_size		Size of subfield header in bytes
- * @param member_data_offset	Offset of member data from start of member
- * @param member_data_size	Size of member data in bytes
- * @return VB2_SUCCESS, or non-zero if error.
- */
-int vb2_verify_member_inside(const void *parent, size_t parent_size,
-			     const void *member, size_t member_size,
-			     ptrdiff_t member_data_offset,
-			     size_t member_data_size);
-
-/**
  * Verify a signature is fully contained in its parent data
  *
  * @param parent	Parent data
@@ -64,19 +33,6 @@ int vb2_verify_signature_inside(const void *parent,
 				uint32_t parent_size,
 				const struct vb2_signature *sig);
 
-
-/**
- * Verify a packed key is fully contained in its parent data
- *
- * @param parent	Parent data
- * @param parent_size	Parent size in bytes
- * @param key		Packed key pointer
- * @return VB2_SUCCESS, or non-zero if error.
- */
-int vb2_verify_packed_key_inside(const void *parent,
-				 uint32_t parent_size,
-				 const struct vb2_packed_key *key);
-
 /**
  * Unpack a vboot1-format key buffer for use in verification
  *
diff --git a/firmware/lib20/include/vb2_struct.h b/firmware/lib20/include/vb2_struct.h
index b409376a..59304db8 100644
--- a/firmware/lib20/include/vb2_struct.h
+++ b/firmware/lib20/include/vb2_struct.h
@@ -26,29 +26,6 @@
 #define VB2_MAX_KEY_VERSION 0xffff
 #define VB2_MAX_PREAMBLE_VERSION 0xffff
 
-/* Packed public key data */
-struct vb2_packed_key {
-	/* Offset of key data from start of this struct */
-	uint32_t key_offset;
-	uint32_t reserved0;
-
-	/* Size of key data in bytes (NOT strength of key in bits) */
-	uint32_t key_size;
-	uint32_t reserved1;
-
-	/* Signature algorithm used by the key (enum vb2_crypto_algorithm) */
-	uint32_t algorithm;
-	uint32_t reserved2;
-
-	/* Key version */
-	uint32_t key_version;
-	uint32_t reserved3;
-
-	/* TODO: when redoing this struct, add a text description of the key */
-} __attribute__((packed));
-
-#define EXPECTED_VB2_PACKED_KEY_SIZE 32
-
 
 /* Signature data (a secure hash, possibly signed) */
 struct vb2_signature {
diff --git a/firmware/lib20/kernel.c b/firmware/lib20/kernel.c
index f169e7eb..c192b892 100644
--- a/firmware/lib20/kernel.c
+++ b/firmware/lib20/kernel.c
@@ -5,6 +5,7 @@
  * Kernel verified boot functions
  */
 
+#include "2common.h"
 #include "2sysincludes.h"
 #include "2misc.h"
 #include "2nvstorage.h"
diff --git a/firmware/lib20/packed_key.c b/firmware/lib20/packed_key.c
index 3cbaff24..2e1c9cbc 100644
--- a/firmware/lib20/packed_key.c
+++ b/firmware/lib20/packed_key.c
@@ -5,24 +5,11 @@
  * Key unpacking functions
  */
 
+#include "2common.h"
 #include "2sysincludes.h"
 #include "2rsa.h"
 #include "vb2_common.h"
 
-const uint8_t *vb2_packed_key_data(const struct vb2_packed_key *key)
-{
-	return (const uint8_t *)key + key->key_offset;
-}
-
-int vb2_verify_packed_key_inside(const void *parent,
-				 uint32_t parent_size,
-				 const struct vb2_packed_key *key)
-{
-	return vb2_verify_member_inside(parent, parent_size,
-					key, sizeof(*key),
-					key->key_offset, key->key_size);
-}
-
 test_mockable
 int vb2_unpack_key_buffer(struct vb2_public_key *key,
 			  const uint8_t *buf,
diff --git a/futility/cmd_sign.c b/futility/cmd_sign.c
index c458eef6..4d0c262f 100644
--- a/futility/cmd_sign.c
+++ b/futility/cmd_sign.c
@@ -17,6 +17,7 @@
 #include <sys/types.h>
 #include <unistd.h>
 
+#include "2common.h"
 #include "file_type.h"
 #include "file_type_bios.h"
 #include "fmap.h"
diff --git a/futility/updater.c b/futility/updater.c
index a239a31c..0a7a3d5c 100644
--- a/futility/updater.c
+++ b/futility/updater.c
@@ -14,6 +14,7 @@
 #include <unistd.h>
 
 #include "2rsa.h"
+#include "2common.h"
 #include "crossystem.h"
 #include "fmap.h"
 #include "futility.h"
diff --git a/host/lib/extract_vmlinuz.c b/host/lib/extract_vmlinuz.c
index efce2ef5..58fd7d7f 100644
--- a/host/lib/extract_vmlinuz.c
+++ b/host/lib/extract_vmlinuz.c
@@ -8,6 +8,8 @@
 #include <stdlib.h>
 #include <string.h>
 
+#include "2common.h"
+#include "2struct.h"
 #include "vb2_struct.h"
 #include "vboot_host.h"
 #include "vboot_struct.h"
diff --git a/tests/vb20_common_tests.c b/tests/vb20_common_tests.c
index 9cc6dd7f..d4555f44 100644
--- a/tests/vb20_common_tests.c
+++ b/tests/vb20_common_tests.c
@@ -17,9 +17,6 @@
 static void test_struct_packing(void)
 {
 	/* Test vboot2 versions of vboot1 structs */
-	TEST_EQ(EXPECTED_VB2_PACKED_KEY_SIZE,
-		sizeof(struct vb2_packed_key),
-		"sizeof(vb2_packed_key)");
 	TEST_EQ(EXPECTED_VB2_SIGNATURE_SIZE,
 		sizeof(struct vb2_signature),
 		"sizeof(vb2_signature)");
@@ -29,14 +26,8 @@ static void test_struct_packing(void)
 	TEST_EQ(EXPECTED_VB2_FW_PREAMBLE_SIZE,
 		sizeof(struct vb2_fw_preamble),
 		"sizeof(vb2_fw_preamble)");
-	TEST_EQ(EXPECTED_VB2_GBB_HEADER_SIZE,
-		sizeof(struct vb2_gbb_header),
-		"sizeof(vb2_gbb_header)");
 
 	/* And make sure they're the same as their vboot1 equivalents */
-	TEST_EQ(EXPECTED_VB2_PACKED_KEY_SIZE,
-		EXPECTED_VBPUBLICKEY_SIZE,
-		"vboot1->2 packed key sizes same");
 	TEST_EQ(EXPECTED_VB2_SIGNATURE_SIZE,
 		EXPECTED_VBSIGNATURE_SIZE,
 		"vboot1->2 signature sizes same");
@@ -51,25 +42,6 @@ static void test_struct_packing(void)
 static void test_helper_functions(void)
 {
 	{
-		uint8_t *p = (uint8_t *)test_helper_functions;
-		TEST_EQ((int)vb2_offset_of(p, p), 0, "vb2_offset_of() equal");
-		TEST_EQ((int)vb2_offset_of(p, p+10), 10,
-			"vb2_offset_of() positive");
-	}
-
-	{
-		struct vb2_packed_key k = {.key_offset = sizeof(k)};
-		TEST_EQ((int)vb2_offset_of(&k, vb2_packed_key_data(&k)),
-			sizeof(k), "vb2_packed_key_data() adjacent");
-	}
-
-	{
-		struct vb2_packed_key k = {.key_offset = 123};
-		TEST_EQ((int)vb2_offset_of(&k, vb2_packed_key_data(&k)), 123,
-			"vb2_packed_key_data() spaced");
-	}
-
-	{
 		struct vb2_signature s = {.sig_offset = sizeof(s)};
 		TEST_EQ((int)vb2_offset_of(&s, vb2_signature_data(&s)),
 			sizeof(s), "vb2_signature_data() adjacent");
@@ -82,65 +54,6 @@ static void test_helper_functions(void)
 	}
 
 	{
-		uint8_t *p = (uint8_t *)test_helper_functions;
-		TEST_SUCC(vb2_verify_member_inside(p, 20, p, 6, 11, 3),
-			  "MemberInside ok 1");
-		TEST_SUCC(vb2_verify_member_inside(p, 20, p+4, 4, 8, 4),
-			  "MemberInside ok 2");
-		TEST_EQ(vb2_verify_member_inside(p, 20, p-4, 4, 8, 4),
-			VB2_ERROR_INSIDE_MEMBER_OUTSIDE,
-			"MemberInside member before parent");
-		TEST_EQ(vb2_verify_member_inside(p, 20, p+20, 4, 8, 4),
-			VB2_ERROR_INSIDE_MEMBER_OUTSIDE,
-			"MemberInside member after parent");
-		TEST_EQ(vb2_verify_member_inside(p, 20, p, 21, 0, 0),
-			VB2_ERROR_INSIDE_MEMBER_OUTSIDE,
-			"MemberInside member too big");
-		TEST_EQ(vb2_verify_member_inside(p, 20, p, 4, 21, 0),
-			VB2_ERROR_INSIDE_DATA_OUTSIDE,
-			"MemberInside data after parent");
-		TEST_EQ(vb2_verify_member_inside(p, 20, p, 4, SIZE_MAX, 0),
-			VB2_ERROR_INSIDE_DATA_OUTSIDE,
-			"MemberInside data before parent");
-		TEST_EQ(vb2_verify_member_inside(p, 20, p, 4, 4, 17),
-			VB2_ERROR_INSIDE_DATA_OUTSIDE,
-			"MemberInside data too big");
-		TEST_EQ(vb2_verify_member_inside(p, 20, p, 8, 4, 8),
-			VB2_ERROR_INSIDE_DATA_OVERLAP,
-			"MemberInside data overlaps member");
-		TEST_EQ(vb2_verify_member_inside(p, -8, p, 12, 0, 0),
-			VB2_ERROR_INSIDE_PARENT_WRAPS,
-			"MemberInside wraparound 1");
-		TEST_EQ(vb2_verify_member_inside(p, 20, p, -8, 0, 0),
-			VB2_ERROR_INSIDE_MEMBER_WRAPS,
-			"MemberInside wraparound 2");
-		TEST_EQ(vb2_verify_member_inside(p, 20, p, 4, 4, -12),
-			VB2_ERROR_INSIDE_DATA_WRAPS,
-			"MemberInside wraparound 3");
-	}
-
-	{
-		struct vb2_packed_key k = {.key_offset = sizeof(k),
-					   .key_size = 128};
-		TEST_SUCC(vb2_verify_packed_key_inside(&k, sizeof(k)+128, &k),
-			  "PublicKeyInside ok 1");
-		TEST_SUCC(vb2_verify_packed_key_inside(&k - 1,
-						       2*sizeof(k)+128, &k),
-			  "PublicKeyInside ok 2");
-		TEST_EQ(vb2_verify_packed_key_inside(&k, 128, &k),
-			VB2_ERROR_INSIDE_DATA_OUTSIDE,
-			"PublicKeyInside key too big");
-	}
-
-	{
-		struct vb2_packed_key k = {.key_offset = 100,
-					   .key_size = 4};
-		TEST_EQ(vb2_verify_packed_key_inside(&k, 99, &k),
-			VB2_ERROR_INSIDE_DATA_OUTSIDE,
-			"PublicKeyInside offset too big");
-	}
-
-	{
 		struct vb2_signature s = {.sig_offset = sizeof(s),
 					  .sig_size = 128};
 		TEST_SUCC(vb2_verify_signature_inside(&s, sizeof(s)+128, &s),
diff --git a/tests/vb2_common_tests.c b/tests/vb2_common_tests.c
index c7e99769..a9b25b61 100644
--- a/tests/vb2_common_tests.c
+++ b/tests/vb2_common_tests.c
@@ -5,9 +5,30 @@
  * Tests for firmware 2common.c
  */
 
-#include "2sysincludes.h"
 #include "2common.h"
+#include "2sysincludes.h"
 #include "test_common.h"
+#include "vboot_struct.h"  /* For old struct sizes */
+
+/*
+ * Test struct packing for vboot_struct.h structs which are passed between
+ * firmware and OS, or passed between different phases of firmware.
+ */
+static void test_struct_packing(void)
+{
+	/* Test vboot2 versions of vboot1 structs */
+	TEST_EQ(EXPECTED_VB2_PACKED_KEY_SIZE,
+		sizeof(struct vb2_packed_key),
+		"sizeof(vb2_packed_key)");
+	TEST_EQ(EXPECTED_VB2_GBB_HEADER_SIZE,
+		sizeof(struct vb2_gbb_header),
+		"sizeof(vb2_gbb_header)");
+
+	/* And make sure they're the same as their vboot1 equivalents */
+	TEST_EQ(EXPECTED_VB2_PACKED_KEY_SIZE,
+		EXPECTED_VBPUBLICKEY_SIZE,
+		"vboot1->2 packed key sizes same");
+}
 
 /**
  * Test memory compare functions
@@ -109,11 +130,97 @@ static void test_workbuf(void)
 	TEST_EQ(wb.size, 32, "  size");
 }
 
+/**
+ * Helper functions not dependent on specific key sizes
+ */
+static void test_helper_functions(void)
+{
+	{
+		struct vb2_packed_key k = {.key_offset = sizeof(k)};
+		TEST_EQ((int)vb2_offset_of(&k, vb2_packed_key_data(&k)),
+			sizeof(k), "vb2_packed_key_data() adjacent");
+	}
+
+	{
+		struct vb2_packed_key k = {.key_offset = 123};
+		TEST_EQ((int)vb2_offset_of(&k, vb2_packed_key_data(&k)), 123,
+			"vb2_packed_key_data() spaced");
+	}
+
+	{
+		uint8_t *p = (uint8_t *)test_helper_functions;
+		TEST_EQ((int)vb2_offset_of(p, p), 0, "vb2_offset_of() equal");
+		TEST_EQ((int)vb2_offset_of(p, p+10), 10,
+			"vb2_offset_of() positive");
+	}
+
+	{
+		uint8_t *p = (uint8_t *)test_helper_functions;
+		TEST_SUCC(vb2_verify_member_inside(p, 20, p, 6, 11, 3),
+			  "MemberInside ok 1");
+		TEST_SUCC(vb2_verify_member_inside(p, 20, p+4, 4, 8, 4),
+			  "MemberInside ok 2");
+		TEST_EQ(vb2_verify_member_inside(p, 20, p-4, 4, 8, 4),
+			VB2_ERROR_INSIDE_MEMBER_OUTSIDE,
+			"MemberInside member before parent");
+		TEST_EQ(vb2_verify_member_inside(p, 20, p+20, 4, 8, 4),
+			VB2_ERROR_INSIDE_MEMBER_OUTSIDE,
+			"MemberInside member after parent");
+		TEST_EQ(vb2_verify_member_inside(p, 20, p, 21, 0, 0),
+			VB2_ERROR_INSIDE_MEMBER_OUTSIDE,
+			"MemberInside member too big");
+		TEST_EQ(vb2_verify_member_inside(p, 20, p, 4, 21, 0),
+			VB2_ERROR_INSIDE_DATA_OUTSIDE,
+			"MemberInside data after parent");
+		TEST_EQ(vb2_verify_member_inside(p, 20, p, 4, SIZE_MAX, 0),
+			VB2_ERROR_INSIDE_DATA_OUTSIDE,
+			"MemberInside data before parent");
+		TEST_EQ(vb2_verify_member_inside(p, 20, p, 4, 4, 17),
+			VB2_ERROR_INSIDE_DATA_OUTSIDE,
+			"MemberInside data too big");
+		TEST_EQ(vb2_verify_member_inside(p, 20, p, 8, 4, 8),
+			VB2_ERROR_INSIDE_DATA_OVERLAP,
+			"MemberInside data overlaps member");
+		TEST_EQ(vb2_verify_member_inside(p, -8, p, 12, 0, 0),
+			VB2_ERROR_INSIDE_PARENT_WRAPS,
+			"MemberInside wraparound 1");
+		TEST_EQ(vb2_verify_member_inside(p, 20, p, -8, 0, 0),
+			VB2_ERROR_INSIDE_MEMBER_WRAPS,
+			"MemberInside wraparound 2");
+		TEST_EQ(vb2_verify_member_inside(p, 20, p, 4, 4, -12),
+			VB2_ERROR_INSIDE_DATA_WRAPS,
+			"MemberInside wraparound 3");
+	}
+
+	{
+		struct vb2_packed_key k = {.key_offset = sizeof(k),
+					   .key_size = 128};
+		TEST_SUCC(vb2_verify_packed_key_inside(&k, sizeof(k)+128, &k),
+			  "PublicKeyInside ok 1");
+		TEST_SUCC(vb2_verify_packed_key_inside(&k - 1,
+						       2*sizeof(k)+128, &k),
+			  "PublicKeyInside ok 2");
+		TEST_EQ(vb2_verify_packed_key_inside(&k, 128, &k),
+			VB2_ERROR_INSIDE_DATA_OUTSIDE,
+			"PublicKeyInside key too big");
+	}
+
+	{
+		struct vb2_packed_key k = {.key_offset = 100,
+					   .key_size = 4};
+		TEST_EQ(vb2_verify_packed_key_inside(&k, 99, &k),
+			VB2_ERROR_INSIDE_DATA_OUTSIDE,
+			"PublicKeyInside offset too big");
+	}
+}
+
 int main(int argc, char* argv[])
 {
+	test_struct_packing();
 	test_memcmp();
 	test_align();
 	test_workbuf();
+	test_helper_functions();
 
 	return gTestSuccess ? 0 : 255;
 }