vboot: relocate vb2_signature and vb2_keybock structs

Move from vboot20 to vboot2.

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

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

5 files changed, 46 insertions, 88 deletions

diff --git a/tests/vb20_common_tests.c b/tests/vb20_common_tests.c
index 7d9ffe82..17ffe670 100644
--- a/tests/vb20_common_tests.c
+++ b/tests/vb20_common_tests.c
@@ -8,7 +8,6 @@
 #include "2sysincludes.h"
 #include "test_common.h"
 #include "vb2_common.h"
-#include "vboot_struct.h"  /* For old struct sizes */
 
 /*
  * Test struct packing for vboot_struct.h structs which are passed between
@@ -17,68 +16,14 @@
 static void test_struct_packing(void)
 {
 	/* Test vboot2 versions of vboot1 structs */
-	TEST_EQ(EXPECTED_VB2_SIGNATURE_SIZE,
-		sizeof(struct vb2_signature),
-		"sizeof(vb2_signature)");
-	TEST_EQ(EXPECTED_VB2_KEYBLOCK_SIZE,
-		sizeof(struct vb2_keyblock),
-		"sizeof(vb2_keyblock)");
 	TEST_EQ(EXPECTED_VB2_FW_PREAMBLE_SIZE,
 		sizeof(struct vb2_fw_preamble),
 		"sizeof(vb2_fw_preamble)");
-
-	/* And make sure they're the same as their vboot1 equivalents */
-	TEST_EQ(EXPECTED_VB2_SIGNATURE_SIZE,
-		EXPECTED_VBSIGNATURE_SIZE,
-		"vboot1->2 signature sizes same");
-	TEST_EQ(EXPECTED_VB2_KEYBLOCK_SIZE,
-		EXPECTED_VBKEYBLOCKHEADER_SIZE,
-		"vboot1->2 keyblock sizes same");
-}
-
-/**
- * Helper functions not dependent on specific key sizes
- */
-static void test_helper_functions(void)
-{
-	{
-		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");
-	}
-
-	{
-		struct vb2_signature s = {.sig_offset = 123};
-		TEST_EQ((int)vb2_offset_of(&s, vb2_signature_data(&s)), 123,
-			"vb2_signature_data() spaced");
-	}
-
-	{
-		struct vb2_signature s = {.sig_offset = sizeof(s),
-					  .sig_size = 128};
-		TEST_SUCC(vb2_verify_signature_inside(&s, sizeof(s)+128, &s),
-			"SignatureInside ok 1");
-		TEST_SUCC(vb2_verify_signature_inside(&s - 1,
-						      2*sizeof(s)+128, &s),
-			  "SignatureInside ok 2");
-		TEST_EQ(vb2_verify_signature_inside(&s, 128, &s),
-			VB2_ERROR_INSIDE_DATA_OUTSIDE,
-			"SignatureInside sig too big");
-	}
-
-	{
-		struct vb2_signature s = {.sig_offset = 100,
-					  .sig_size = 4};
-		TEST_EQ(vb2_verify_signature_inside(&s, 99, &s),
-			VB2_ERROR_INSIDE_DATA_OUTSIDE,
-			"SignatureInside offset too big");
-	}
 }
 
 int main(int argc, char* argv[])
 {
 	test_struct_packing();
-	test_helper_functions();
 
 	return gTestSuccess ? 0 : 255;
 }
diff --git a/tests/vb20_kernel_tests.c b/tests/vb20_kernel_tests.c
index 90f7e5ff..3a80552e 100644
--- a/tests/vb20_kernel_tests.c
+++ b/tests/vb20_kernel_tests.c
@@ -109,13 +109,13 @@ static void reset_common_data(enum reset_type t)
 	mock_gbb.recovery_key.key_size = sizeof(mock_gbb.recovery_key_data);
 
 	kb->keyblock_size = sizeof(mock_vblock.k);
-	memcpy(kb->magic, KEYBLOCK_MAGIC, KEYBLOCK_MAGIC_SIZE);
+	memcpy(kb->magic, VB2_KEYBLOCK_MAGIC, VB2_KEYBLOCK_MAGIC_SIZE);
 
 	kb->keyblock_flags = VB2_KEYBLOCK_FLAG_DEVELOPER_1 |
 		VB2_KEYBLOCK_FLAG_DEVELOPER_0 |
 		VB2_KEYBLOCK_FLAG_RECOVERY_1 | VB2_KEYBLOCK_FLAG_RECOVERY_0;
-	kb->header_version_major = KEYBLOCK_HEADER_VERSION_MAJOR;
-	kb->header_version_minor = KEYBLOCK_HEADER_VERSION_MINOR;
+	kb->header_version_major = VB2_KEYBLOCK_VERSION_MAJOR;
+	kb->header_version_minor = VB2_KEYBLOCK_VERSION_MINOR;
 	kb->data_key.algorithm = 7;
 	kb->data_key.key_version = 2;
 	kb->data_key.key_offset =
diff --git a/tests/vb2_common_tests.c b/tests/vb2_common_tests.c
index 2661cce9..61ce1338 100644
--- a/tests/vb2_common_tests.c
+++ b/tests/vb2_common_tests.c
@@ -86,6 +86,12 @@ static void test_struct_packing(void)
 	TEST_EQ(EXPECTED_VB2_GBB_HEADER_SIZE,
 		sizeof(struct vb2_gbb_header),
 		"sizeof(vb2_gbb_header)");
+	TEST_EQ(EXPECTED_VB2_SIGNATURE_SIZE,
+		sizeof(struct vb2_signature),
+		"sizeof(vb2_signature)");
+	TEST_EQ(EXPECTED_VB2_KEYBLOCK_SIZE,
+		sizeof(struct vb2_keyblock),
+		"sizeof(vb2_keyblock)");
 }
 
 /**
@@ -204,6 +210,17 @@ static void test_helper_functions(void)
 		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");
+	}
+
+	{
+		struct vb2_signature s = {.sig_offset = 123};
+		TEST_EQ((int)vb2_offset_of(&s, vb2_signature_data(&s)), 123,
+			"vb2_signature_data() spaced");
+	}
 
 	{
 		uint8_t *p = (uint8_t *)test_helper_functions;
@@ -272,6 +289,27 @@ static void test_helper_functions(void)
 			VB2_ERROR_INSIDE_DATA_OUTSIDE,
 			"vb2_packed_key_inside() 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),
+			"vb2_verify_signature_inside() ok 1");
+		TEST_SUCC(vb2_verify_signature_inside(&s - 1,
+						      2*sizeof(s)+128, &s),
+			  "vb2_verify_signature_inside() ok 2");
+		TEST_EQ(vb2_verify_signature_inside(&s, 128, &s),
+			VB2_ERROR_INSIDE_DATA_OUTSIDE,
+			"vb2_verify_signature_inside() sig too big");
+	}
+
+	{
+		struct vb2_signature s = {.sig_offset = 100,
+					  .sig_size = 4};
+		TEST_EQ(vb2_verify_signature_inside(&s, 99, &s),
+			VB2_ERROR_INSIDE_DATA_OUTSIDE,
+			"vb2_verify_signature_inside() offset too big");
+	}
 }
 
 /* Helper for test_assert_die() below */
diff --git a/tests/vboot_common_tests.c b/tests/vboot_common_tests.c
index 6a09d92f..1869556b 100644
--- a/tests/vboot_common_tests.c
+++ b/tests/vboot_common_tests.c
@@ -21,10 +21,6 @@
  */
 static void StructPackingTest(void)
 {
-	TEST_EQ(EXPECTED_VBSIGNATURE_SIZE, sizeof(VbSignature),
-		"sizeof(VbSignature)");
-	TEST_EQ(EXPECTED_VBKEYBLOCKHEADER_SIZE, sizeof(VbKeyBlockHeader),
-		"sizeof(VbKeyBlockHeader)");
 	TEST_EQ(EXPECTED_VBKERNELPREAMBLEHEADER2_2_SIZE,
 		sizeof(VbKernelPreambleHeader),
 		"sizeof(VbKernelPreambleHeader)");
@@ -38,26 +34,6 @@ static void StructPackingTest(void)
 		"sizeof(VbSharedDataHeader) V2");
 }
 
-/* Helper functions not dependent on specific key sizes */
-static void VerifyHelperFunctions(void)
-{
-	{
-		VbSignature s = {sizeof(s), 128, 2000};
-		TEST_EQ(VerifySignatureInside(&s, sizeof(s)+128, &s), 0,
-			"SignatureInside ok 1");
-		TEST_EQ(VerifySignatureInside(&s - 1, 2*sizeof(s)+128, &s), 0,
-			"SignatureInside ok 2");
-		TEST_NEQ(VerifySignatureInside(&s, 128, &s), 0,
-			 "SignatureInside sig too big");
-	}
-
-	{
-		VbSignature s = {100, 4, 0};
-		TEST_NEQ(VerifySignatureInside(&s, 99, &s), 0,
-			 "SignatureInside offset too big");
-	}
-}
-
 /* Public key utility functions */
 static void PublicKeyTest(void)
 {
@@ -152,7 +128,6 @@ static void VbSharedDataTest(void)
 int main(int argc, char* argv[])
 {
 	StructPackingTest();
-	VerifyHelperFunctions();
 	PublicKeyTest();
 	VbSharedDataTest();
 
diff --git a/tests/vboot_kernel_tests.c b/tests/vboot_kernel_tests.c
index 33705f2c..531a1187 100644
--- a/tests/vboot_kernel_tests.c
+++ b/tests/vboot_kernel_tests.c
@@ -61,7 +61,7 @@ static VbExDiskHandle_t handle;
 static uint8_t shared_data[VB_SHARED_DATA_MIN_SIZE];
 static VbSharedDataHeader *shared = (VbSharedDataHeader *)shared_data;
 static LoadKernelParams lkp;
-static VbKeyBlockHeader kbh;
+static struct vb2_keyblock kbh;
 static VbKernelPreambleHeader kph;
 static struct RollbackSpaceFwmp fwmp;
 static uint8_t mock_disk[MOCK_SECTOR_SIZE * MOCK_SECTOR_COUNT];
@@ -683,27 +683,27 @@ static void LoadKernelTest(void)
 	/* Check keyblock flag mismatches */
 	ResetMocks();
 	kbh.keyblock_flags =
-		KEYBLOCK_FLAG_RECOVERY_0 | KEYBLOCK_FLAG_DEVELOPER_1;
+		VB2_KEYBLOCK_FLAG_RECOVERY_0 | VB2_KEYBLOCK_FLAG_DEVELOPER_1;
 	TestLoadKernel(VBERROR_INVALID_KERNEL_FOUND,
 		       "Keyblock dev flag mismatch");
 
 	ResetMocks();
 	kbh.keyblock_flags =
-		KEYBLOCK_FLAG_RECOVERY_1 | KEYBLOCK_FLAG_DEVELOPER_0;
+		VB2_KEYBLOCK_FLAG_RECOVERY_1 | VB2_KEYBLOCK_FLAG_DEVELOPER_0;
 	TestLoadKernel(VBERROR_INVALID_KERNEL_FOUND,
 		       "Keyblock rec flag mismatch");
 
 	ResetMocks();
 	ctx.flags |= VB2_CONTEXT_RECOVERY_MODE;
 	kbh.keyblock_flags =
-		KEYBLOCK_FLAG_RECOVERY_1 | KEYBLOCK_FLAG_DEVELOPER_1;
+		VB2_KEYBLOCK_FLAG_RECOVERY_1 | VB2_KEYBLOCK_FLAG_DEVELOPER_1;
 	TestLoadKernel(VBERROR_INVALID_KERNEL_FOUND,
 		       "Keyblock recdev flag mismatch");
 
 	ResetMocks();
 	ctx.flags |= VB2_CONTEXT_RECOVERY_MODE | VB2_CONTEXT_DEVELOPER_MODE;
 	kbh.keyblock_flags =
-		KEYBLOCK_FLAG_RECOVERY_1 | KEYBLOCK_FLAG_DEVELOPER_0;
+		VB2_KEYBLOCK_FLAG_RECOVERY_1 | VB2_KEYBLOCK_FLAG_DEVELOPER_0;
 	TestLoadKernel(VBERROR_INVALID_KERNEL_FOUND,
 		       "Keyblock rec!dev flag mismatch");