vboot2: Get rid of extra '2' at end of new struct names

Now that lib20 and lib21 are distinct, they can have overlapping
struct names.  This will be cleaner in the long run, since vboot 2.0
(lib20) is just a temporary stepping stone to vboot 2.1 (lib21).  It
would be a shame to need to carry around the overhead of that extra
digit forever.

No functional changes, just a lot of renaming.

BUG=chromium:423882
BRANCH=none
TEST=make runtests && VBOOT2=1 make runtests (works with/withoug VBOOT2 flag)
     And compile firmware for veyron_pinky

Change-Id: I25f348fd31e32d08ca576836dfdd1278828765a1
Signed-off-by: Randall Spangler <rspangler@chromium.org>
Reviewed-on: https://chromium-review.googlesource.com/233183
Reviewed-by: Daisuke Nojiri <dnojiri@chromium.org>

9 files changed, 258 insertions, 259 deletions

diff --git a/tests/vb20_misc_tests.c b/tests/vb20_misc_tests.c
index aa602ac9..b291b4d3 100644
--- a/tests/vb20_misc_tests.c
+++ b/tests/vb20_misc_tests.c
@@ -333,13 +333,13 @@ static void verify_preamble_tests(void)
 	reset_common_data(FOR_PREAMBLE);
 	pre->firmware_version = 0x10000;
 	TEST_EQ(vb2_load_fw_preamble(&cc),
-		VB2_ERROR_FW_PREAMBLE2_VERSION_RANGE,
+		VB2_ERROR_FW_PREAMBLE_VERSION_RANGE,
 		"preamble version range");
 
 	reset_common_data(FOR_PREAMBLE);
 	pre->firmware_version = 1;
 	TEST_EQ(vb2_load_fw_preamble(&cc),
-		VB2_ERROR_FW_PREAMBLE2_VERSION_ROLLBACK,
+		VB2_ERROR_FW_PREAMBLE_VERSION_ROLLBACK,
 		"preamble version rollback");
 
 	reset_common_data(FOR_PREAMBLE);
diff --git a/tests/vb21_api_tests.c b/tests/vb21_api_tests.c
index 52ca0d9e..6c4e48df 100644
--- a/tests/vb21_api_tests.c
+++ b/tests/vb21_api_tests.c
@@ -54,8 +54,8 @@ enum reset_type {
 static void reset_common_data(enum reset_type t)
 {
 	const struct vb2_private_key *hash_key;
-	struct vb2_fw_preamble2 *pre;
-	struct vb2_signature2 *sig;
+	struct vb2_fw_preamble *pre;
+	struct vb2_signature *sig;
 	uint32_t sig_offset;
 
 	int i;
@@ -80,7 +80,7 @@ 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 vb2_fw_preamble2 *)
+	pre = (struct vb2_fw_preamble *)
 		(ctx.workbuf + sd->workbuf_preamble_offset);
 	pre->hash_count = 3;
 	pre->hash_offset = sig_offset = sizeof(*pre);
@@ -108,12 +108,12 @@ static void reset_common_data(enum reset_type t)
 
 /* Mocked functions */
 
-int vb2_load_fw_keyblock2(struct vb2_context *ctx)
+int vb2_load_fw_keyblock(struct vb2_context *ctx)
 {
 	return retval_vb2_load_fw_keyblock;
 }
 
-int vb2_load_fw_preamble2(struct vb2_context *ctx)
+int vb2_load_fw_preamble(struct vb2_context *ctx)
 {
 	return retval_vb2_load_fw_preamble;
 }
@@ -123,32 +123,32 @@ int vb2_load_fw_preamble2(struct vb2_context *ctx)
 static void phase3_tests(void)
 {
 	reset_common_data(FOR_MISC);
-	TEST_SUCC(vb2api_fw_phase3_2(&ctx), "phase3 good");
+	TEST_SUCC(vb2api_fw_phase3(&ctx), "phase3 good");
 
 	reset_common_data(FOR_MISC);
 	retval_vb2_load_fw_keyblock = VB2_ERROR_MOCK;
-	TEST_EQ(vb2api_fw_phase3_2(&ctx), VB2_ERROR_MOCK, "phase3 keyblock");
+	TEST_EQ(vb2api_fw_phase3(&ctx), VB2_ERROR_MOCK, "phase3 keyblock");
 	TEST_EQ(vb2_nv_get(&ctx, VB2_NV_RECOVERY_REQUEST),
 		VB2_RECOVERY_RO_INVALID_RW, "  recovery reason");
 
 	reset_common_data(FOR_MISC);
 	retval_vb2_load_fw_preamble = VB2_ERROR_MOCK;
-	TEST_EQ(vb2api_fw_phase3_2(&ctx), VB2_ERROR_MOCK, "phase3 keyblock");
+	TEST_EQ(vb2api_fw_phase3(&ctx), VB2_ERROR_MOCK, "phase3 keyblock");
 	TEST_EQ(vb2_nv_get(&ctx, VB2_NV_RECOVERY_REQUEST),
 		VB2_RECOVERY_RO_INVALID_RW, "  recovery reason");
 }
 
 static void init_hash_tests(void)
 {
-	struct vb2_fw_preamble2 *pre;
-	struct vb2_signature2 *sig;
+	struct vb2_fw_preamble *pre;
+	struct vb2_signature *sig;
 	int wb_used_before;
 	uint32_t size;
 
 	reset_common_data(FOR_MISC);
-	pre = (struct vb2_fw_preamble2 *)
+	pre = (struct vb2_fw_preamble *)
 		(ctx.workbuf + sd->workbuf_preamble_offset);
-	sig = (struct vb2_signature2 *)((uint8_t *)pre + pre->hash_offset);
+	sig = (struct vb2_signature *)((uint8_t *)pre + pre->hash_offset);
 
 	wb_used_before = ctx.workbuf_used;
 	TEST_SUCC(vb2api_init_hash2(&ctx, test_guid, &size),
@@ -233,48 +233,48 @@ static void extend_hash_tests(void)
 
 static void check_hash_tests(void)
 {
-	struct vb2_fw_preamble2 *pre;
-	struct vb2_signature2 *sig;
+	struct vb2_fw_preamble *pre;
+	struct vb2_signature *sig;
 	struct vb2_digest_context *dc;
 
 	reset_common_data(FOR_CHECK_HASH);
-	pre = (struct vb2_fw_preamble2 *)
+	pre = (struct vb2_fw_preamble *)
 		(ctx.workbuf + sd->workbuf_preamble_offset);
-	sig = (struct vb2_signature2 *)((uint8_t *)pre + pre->hash_offset);
+	sig = (struct vb2_signature *)((uint8_t *)pre + pre->hash_offset);
 	dc = (struct vb2_digest_context *)
 		(ctx.workbuf + sd->workbuf_hash_offset);
 
-	TEST_SUCC(vb2api_check_hash2(&ctx), "check hash good");
+	TEST_SUCC(vb2api_check_hash(&ctx), "check hash good");
 
 	reset_common_data(FOR_CHECK_HASH);
 	sd->hash_tag = 0;
-	TEST_EQ(vb2api_check_hash2(&ctx),
+	TEST_EQ(vb2api_check_hash(&ctx),
 		VB2_ERROR_API_CHECK_HASH_TAG, "check hash tag");
 
 	reset_common_data(FOR_CHECK_HASH);
 	sd->workbuf_hash_size = 0;
-	TEST_EQ(vb2api_check_hash2(&ctx),
+	TEST_EQ(vb2api_check_hash(&ctx),
 		VB2_ERROR_API_CHECK_HASH_WORKBUF, "check hash no workbuf");
 
 	reset_common_data(FOR_CHECK_HASH);
 	sd->hash_remaining_size = 1;
-	TEST_EQ(vb2api_check_hash2(&ctx),
+	TEST_EQ(vb2api_check_hash(&ctx),
 		VB2_ERROR_API_CHECK_HASH_SIZE, "check hash size");
 
 	reset_common_data(FOR_CHECK_HASH);
 	ctx.workbuf_used = ctx.workbuf_size;
-	TEST_EQ(vb2api_check_hash2(&ctx),
+	TEST_EQ(vb2api_check_hash(&ctx),
 		VB2_ERROR_API_CHECK_HASH_WORKBUF_DIGEST, "check hash workbuf");
 
 	reset_common_data(FOR_CHECK_HASH);
 	dc->hash_alg = VB2_HASH_INVALID;
 	*((uint8_t *)sig + sig->sig_offset) ^= 0x55;
-	TEST_EQ(vb2api_check_hash2(&ctx),
+	TEST_EQ(vb2api_check_hash(&ctx),
 		VB2_ERROR_SHA_FINALIZE_ALGORITHM, "check hash finalize");
 
 	reset_common_data(FOR_CHECK_HASH);
 	*((uint8_t *)sig + sig->sig_offset) ^= 0x55;
-	TEST_EQ(vb2api_check_hash2(&ctx),
+	TEST_EQ(vb2api_check_hash(&ctx),
 		VB2_ERROR_API_CHECK_HASH_SIG, "check hash sig");
 }
 
diff --git a/tests/vb21_common2_tests.c b/tests/vb21_common2_tests.c
index 510665e2..199a063a 100644
--- a/tests/vb21_common2_tests.c
+++ b/tests/vb21_common2_tests.c
@@ -22,48 +22,48 @@
 static const uint8_t test_data[] = "This is some test data to sign.";
 static const uint32_t test_size = sizeof(test_data);
 
-static void test_unpack_key2(const struct vb2_packed_key2 *key)
+static void test_unpack_key(const struct vb2_packed_key *key)
 {
 	struct vb2_public_key pubk;
-	struct vb2_packed_key2 *key2;
+	struct vb2_packed_key *key2;
 	uint32_t size = key->c.total_size;
 
 	/* Make a copy of the key for testing */
-	key2 = (struct vb2_packed_key2 *)malloc(size);
+	key2 = (struct vb2_packed_key *)malloc(size);
 
 	memcpy(key2, key, size);
-	TEST_SUCC(vb2_unpack_key2(&pubk, (uint8_t *)key2, size),
-		  "vb2_unpack_key2() ok");
+	TEST_SUCC(vb2_unpack_key(&pubk, (uint8_t *)key2, size),
+		  "vb2_unpack_key() ok");
 
 	memcpy(key2, key, size);
 	key2->key_offset += 4;
-	TEST_EQ(vb2_unpack_key2(&pubk, (uint8_t *)key2, size),
+	TEST_EQ(vb2_unpack_key(&pubk, (uint8_t *)key2, size),
 		VB2_ERROR_COMMON_MEMBER_SIZE,
-		"vb2_unpack_key2() buffer too small");
+		"vb2_unpack_key() buffer too small");
 
 	memcpy(key2, key, size);
 	key2->c.fixed_size += size;
-	TEST_EQ(vb2_unpack_key2(&pubk, (uint8_t *)key2, size),
+	TEST_EQ(vb2_unpack_key(&pubk, (uint8_t *)key2, size),
 		VB2_ERROR_COMMON_FIXED_SIZE,
-		"vb2_unpack_key2() buffer too small for desc");
+		"vb2_unpack_key() buffer too small for desc");
 
 	memcpy(key2, key, size);
 	key2->c.desc_size = 0;
-	TEST_SUCC(vb2_unpack_key2(&pubk, (uint8_t *)key2, size),
-		  "vb2_unpack_key2() no desc");
+	TEST_SUCC(vb2_unpack_key(&pubk, (uint8_t *)key2, size),
+		  "vb2_unpack_key() no desc");
 	TEST_EQ(strcmp(pubk.desc, ""), 0, "  empty desc string");
 
 	memcpy(key2, key, size);
 	key2->c.magic++;
-	TEST_EQ(vb2_unpack_key2(&pubk, (uint8_t *)key2, size),
+	TEST_EQ(vb2_unpack_key(&pubk, (uint8_t *)key2, size),
 		VB2_ERROR_UNPACK_KEY_MAGIC,
-		"vb2_unpack_key2() bad magic");
+		"vb2_unpack_key() bad magic");
 
 	memcpy(key2, key, size);
 	key2->c.struct_version_major++;
-	TEST_EQ(vb2_unpack_key2(&pubk, (uint8_t *)key2, size),
+	TEST_EQ(vb2_unpack_key(&pubk, (uint8_t *)key2, size),
 		VB2_ERROR_UNPACK_KEY_STRUCT_VERSION,
-		"vb2_unpack_key2() bad major version");
+		"vb2_unpack_key() bad major version");
 
 	/*
 	 * Minor version changes are ok.  Note that this test assumes that the
@@ -76,104 +76,104 @@ static void test_unpack_key2(const struct vb2_packed_key2 *key)
 	 */
 	memcpy(key2, key, size);
 	key2->c.struct_version_minor++;
-	TEST_SUCC(vb2_unpack_key2(&pubk, (uint8_t *)key2, size),
-		  "vb2_unpack_key2() minor version change ok");
+	TEST_SUCC(vb2_unpack_key(&pubk, (uint8_t *)key2, size),
+		  "vb2_unpack_key() minor version change ok");
 
 	memcpy(key2, key, size);
 	key2->sig_alg = VB2_SIG_INVALID;
-	TEST_EQ(vb2_unpack_key2(&pubk, (uint8_t *)key2, size),
+	TEST_EQ(vb2_unpack_key(&pubk, (uint8_t *)key2, size),
 		VB2_ERROR_UNPACK_KEY_SIG_ALGORITHM,
-		"vb2_unpack_key2() bad sig algorithm");
+		"vb2_unpack_key() bad sig algorithm");
 
 	memcpy(key2, key, size);
 	key2->hash_alg = VB2_HASH_INVALID;
-	TEST_EQ(vb2_unpack_key2(&pubk, (uint8_t *)key2, size),
+	TEST_EQ(vb2_unpack_key(&pubk, (uint8_t *)key2, size),
 		VB2_ERROR_UNPACK_KEY_HASH_ALGORITHM,
-		"vb2_unpack_key2() bad hash algorithm");
+		"vb2_unpack_key() bad hash algorithm");
 
 	memcpy(key2, key, size);
 	key2->key_size -= 4;
-	TEST_EQ(vb2_unpack_key2(&pubk, (uint8_t *)key2, size),
+	TEST_EQ(vb2_unpack_key(&pubk, (uint8_t *)key2, size),
 		VB2_ERROR_UNPACK_KEY_SIZE,
-		"vb2_unpack_key2() invalid size");
+		"vb2_unpack_key() invalid size");
 
 	memcpy(key2, key, size);
 	key2->key_offset--;
-	TEST_EQ(vb2_unpack_key2(&pubk, (uint8_t *)key2, size),
+	TEST_EQ(vb2_unpack_key(&pubk, (uint8_t *)key2, size),
 		VB2_ERROR_COMMON_MEMBER_UNALIGNED,
-		"vb2_unpack_key2() unaligned data");
+		"vb2_unpack_key() unaligned data");
 
 	memcpy(key2, key, size);
 	*(uint32_t *)((uint8_t *)key2 + key2->key_offset) /= 2;
-	TEST_EQ(vb2_unpack_key2(&pubk, (uint8_t *)key2, size),
+	TEST_EQ(vb2_unpack_key(&pubk, (uint8_t *)key2, size),
 		VB2_ERROR_UNPACK_KEY_ARRAY_SIZE,
-		"vb2_unpack_key2() invalid key array size");
+		"vb2_unpack_key() invalid key array size");
 
 	free(key2);
 }
 
-static void test_verify_signature2(const struct vb2_signature2 *sig)
+static void test_verify_signature(const struct vb2_signature *sig)
 {
-	struct vb2_signature2 *sig2;
+	struct vb2_signature *sig2;
 	uint8_t *buf2;
 	uint32_t size;
 
 	/* Make a copy of the signature */
 	size = sig->c.total_size;
 	buf2 = malloc(size);
-	sig2 = (struct vb2_signature2 *)buf2;
+	sig2 = (struct vb2_signature *)buf2;
 
 	memcpy(buf2, sig, size);
-	TEST_SUCC(vb2_verify_signature2(sig2, size), "verify_sig ok");
-	sig2->c.magic = VB2_MAGIC_PACKED_KEY2;
-	TEST_EQ(vb2_verify_signature2(sig2, size), VB2_ERROR_SIG_MAGIC,
+	TEST_SUCC(vb2_verify_signature(sig2, size), "verify_sig ok");
+	sig2->c.magic = VB2_MAGIC_PACKED_KEY;
+	TEST_EQ(vb2_verify_signature(sig2, size), VB2_ERROR_SIG_MAGIC,
 		"verify_sig magic");
 
 	memcpy(buf2, sig, size);
 	sig2->c.total_size += 4;
-	TEST_EQ(vb2_verify_signature2(sig2, size), VB2_ERROR_COMMON_TOTAL_SIZE,
+	TEST_EQ(vb2_verify_signature(sig2, size), VB2_ERROR_COMMON_TOTAL_SIZE,
 		"verify_sig common header");
 
 	memcpy(buf2, sig, size);
 	sig2->c.struct_version_minor++;
-	TEST_SUCC(vb2_verify_signature2(sig2, size), "verify_sig minor ver");
+	TEST_SUCC(vb2_verify_signature(sig2, size), "verify_sig minor ver");
 	sig2->c.struct_version_major++;
-	TEST_EQ(vb2_verify_signature2(sig2, size), VB2_ERROR_SIG_VERSION,
+	TEST_EQ(vb2_verify_signature(sig2, size), VB2_ERROR_SIG_VERSION,
 		"verify_sig major ver");
 
 	memcpy(buf2, sig, size);
 	sig2->c.fixed_size -= 4;
 	sig2->c.desc_size += 4;
-	TEST_EQ(vb2_verify_signature2(sig2, size), VB2_ERROR_SIG_HEADER_SIZE,
+	TEST_EQ(vb2_verify_signature(sig2, size), VB2_ERROR_SIG_HEADER_SIZE,
 		"verify_sig header size");
 
 	memcpy(buf2, sig, size);
 	sig2->sig_size += 4;
-	TEST_EQ(vb2_verify_signature2(sig2, size), VB2_ERROR_COMMON_MEMBER_SIZE,
+	TEST_EQ(vb2_verify_signature(sig2, size), VB2_ERROR_COMMON_MEMBER_SIZE,
 		"verify_sig sig size");
 
 	memcpy(buf2, sig, size);
 	sig2->sig_alg = VB2_SIG_INVALID;
-	TEST_EQ(vb2_verify_signature2(sig2, size), VB2_ERROR_SIG_ALGORITHM,
+	TEST_EQ(vb2_verify_signature(sig2, size), VB2_ERROR_SIG_ALGORITHM,
 		"verify_sig sig alg");
 
 	memcpy(buf2, sig, size);
 	sig2->sig_alg = (sig2->sig_alg == VB2_SIG_NONE ?
 			 VB2_SIG_RSA1024 : VB2_SIG_NONE);
-	TEST_EQ(vb2_verify_signature2(sig2, size), VB2_ERROR_SIG_SIZE,
+	TEST_EQ(vb2_verify_signature(sig2, size), VB2_ERROR_SIG_SIZE,
 		"verify_sig sig size");
 
 	free(buf2);
 }
 
-static void test_verify_data2(const struct vb2_public_key *pubk_orig,
-			      const struct vb2_signature2 *sig)
+static void test_verify_data(const struct vb2_public_key *pubk_orig,
+			      const struct vb2_signature *sig)
 {
 	uint8_t workbuf[VB2_VERIFY_DATA_WORKBUF_BYTES];
 	struct vb2_workbuf wb;
 
 	struct vb2_public_key pubk;
-	struct vb2_signature2 *sig2;
+	struct vb2_signature *sig2;
 	uint8_t *buf2;
 	uint32_t size;
 
@@ -184,53 +184,53 @@ static void test_verify_data2(const struct vb2_public_key *pubk_orig,
 	/* Allocate signature copy for tests */
 	size = sig->c.total_size;
 	buf2 = malloc(size);
-	sig2 = (struct vb2_signature2 *)buf2;
+	sig2 = (struct vb2_signature *)buf2;
 
 	memcpy(buf2, sig, size);
 	pubk.sig_alg = VB2_SIG_INVALID;
-	TEST_EQ(vb2_verify_data2(test_data, test_size, sig2, &pubk, &wb),
-		VB2_ERROR_VDATA_ALGORITHM, "vb2_verify_data2() bad sig alg");
+	TEST_EQ(vb2_verify_data(test_data, test_size, sig2, &pubk, &wb),
+		VB2_ERROR_VDATA_ALGORITHM, "vb2_verify_data() bad sig alg");
 	pubk = *pubk_orig;
 
 	memcpy(buf2, sig, size);
 	pubk.hash_alg = VB2_HASH_INVALID;
-	TEST_EQ(vb2_verify_data2(test_data, test_size, sig2, &pubk, &wb),
+	TEST_EQ(vb2_verify_data(test_data, test_size, sig2, &pubk, &wb),
 		VB2_ERROR_VDATA_DIGEST_SIZE,
-		"vb2_verify_data2() bad hash alg");
+		"vb2_verify_data() bad hash alg");
 	pubk = *pubk_orig;
 
 	vb2_workbuf_init(&wb, workbuf, 4);
 	memcpy(buf2, sig, size);
-	TEST_EQ(vb2_verify_data2(test_data, test_size, sig2, &pubk, &wb),
+	TEST_EQ(vb2_verify_data(test_data, test_size, sig2, &pubk, &wb),
 		VB2_ERROR_VDATA_WORKBUF_DIGEST,
-		"vb2_verify_data2() workbuf too small");
+		"vb2_verify_data() workbuf too small");
 	vb2_workbuf_init(&wb, workbuf, sizeof(workbuf));
 
 	memcpy(buf2, sig, size);
-	TEST_EQ(vb2_verify_data2(test_data, test_size, sig2, &pubk, &wb),
-		0, "vb2_verify_data2() ok");
+	TEST_EQ(vb2_verify_data(test_data, test_size, sig2, &pubk, &wb),
+		0, "vb2_verify_data() ok");
 
 	memcpy(buf2, sig, size);
 	sig2->sig_size -= 16;
-	TEST_EQ(vb2_verify_data2(test_data, test_size, sig2, &pubk, &wb),
-		VB2_ERROR_VDATA_SIG_SIZE, "vb2_verify_data2() wrong sig size");
+	TEST_EQ(vb2_verify_data(test_data, test_size, sig2, &pubk, &wb),
+		VB2_ERROR_VDATA_SIG_SIZE, "vb2_verify_data() wrong sig size");
 
 	memcpy(buf2, sig, size);
-	TEST_EQ(vb2_verify_data2(test_data, test_size - 1, sig2, &pubk, &wb),
-		VB2_ERROR_VDATA_SIZE, "vb2_verify_data2() wrong data size");
+	TEST_EQ(vb2_verify_data(test_data, test_size - 1, sig2, &pubk, &wb),
+		VB2_ERROR_VDATA_SIZE, "vb2_verify_data() wrong data size");
 
 	memcpy(buf2, sig, size);
 	sig2->hash_alg = (sig2->hash_alg == VB2_HASH_SHA1 ?
 			  VB2_HASH_SHA256 : VB2_HASH_SHA1);
-	TEST_EQ(vb2_verify_data2(test_data, test_size, sig2, &pubk, &wb),
+	TEST_EQ(vb2_verify_data(test_data, test_size, sig2, &pubk, &wb),
 		VB2_ERROR_VDATA_ALGORITHM_MISMATCH,
-		"vb2_verify_data2() alg mismatch");
+		"vb2_verify_data() alg mismatch");
 
 
 	memcpy(buf2, sig, size);
 	buf2[sig2->sig_offset] ^= 0x5A;
-	TEST_EQ(vb2_verify_data2(test_data, test_size, sig2, &pubk, &wb),
-		VB2_ERROR_RSA_PADDING, "vb2_verify_data2() wrong sig");
+	TEST_EQ(vb2_verify_data(test_data, test_size, sig2, &pubk, &wb),
+		VB2_ERROR_RSA_PADDING, "vb2_verify_data() wrong sig");
 
 	free(buf2);
 }
@@ -245,9 +245,9 @@ int test_algorithm(int key_algorithm, const char *keys_dir)
 	enum vb2_hash_algorithm hash_alg = vb2_crypto_to_hash(key_algorithm);
 
 	struct vb2_private_key *prik = NULL;
-	struct vb2_signature2 *sig2 = NULL;
+	struct vb2_signature *sig2 = NULL;
 	struct vb2_public_key *pubk = NULL;
-	struct vb2_packed_key2 *key2 = NULL;
+	struct vb2_packed_key *key2 = NULL;
 
 	printf("***Testing algorithm: %s\n", algo_strings[key_algorithm]);
 
@@ -269,9 +269,9 @@ int test_algorithm(int key_algorithm, const char *keys_dir)
 	TEST_SUCC(vb2_sign_data(&sig2, test_data, test_size, prik, ""),
 		  "Make test signature");
 
-	test_unpack_key2(key2);
-	test_verify_data2(pubk, sig2);
-	test_verify_signature2(sig2);
+	test_unpack_key(key2);
+	test_verify_data(pubk, sig2);
+	test_verify_signature(sig2);
 
 	free(key2);
 	free(sig2);
diff --git a/tests/vb21_common_tests.c b/tests/vb21_common_tests.c
index 39df1682..74440254 100644
--- a/tests/vb21_common_tests.c
+++ b/tests/vb21_common_tests.c
@@ -33,18 +33,18 @@ static void test_struct_packing(void)
 	TEST_EQ(EXPECTED_VB2_STRUCT_COMMON_SIZE,
 		sizeof(struct vb2_struct_common),
 		"sizeof(vb2_struct_common)");
-	TEST_EQ(EXPECTED_VB2_PACKED_KEY2_SIZE,
-		sizeof(struct vb2_packed_key2),
-		"sizeof(vb2_packed_key2)");
-	TEST_EQ(EXPECTED_VB2_SIGNATURE2_SIZE,
-		sizeof(struct vb2_signature2),
-		"sizeof(vb2_signature2)");
-	TEST_EQ(EXPECTED_VB2_KEYBLOCK2_SIZE,
-		sizeof(struct vb2_keyblock2),
-		"sizeof(vb2_keyblock2)");
-	TEST_EQ(EXPECTED_VB2_FW_PREAMBLE2_SIZE,
-		sizeof(struct vb2_fw_preamble2),
-		"sizeof(vb2_fw_preamble2)");
+	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)");
+	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)");
 }
 
 /**
@@ -217,7 +217,7 @@ static void test_sig_size(void)
  */
 static void test_verify_hash(void)
 {
-	struct vb2_signature2 *sig;
+	struct vb2_signature *sig;
 	const struct vb2_private_key *prik;
 	struct vb2_public_key pubk;
 	uint8_t workbuf[VB2_VERIFY_DATA_WORKBUF_BYTES];
@@ -231,17 +231,16 @@ static void test_verify_hash(void)
 		  "create hash key");
 
 	/* Create the signature */
-	TEST_SUCC(vb2_sign_data(&sig, test_data, sizeof(test_data),
-				prik, NULL),
+	TEST_SUCC(vb2_sign_data(&sig, test_data, sizeof(test_data), prik, NULL),
 		  "create hash sig");
 
-	TEST_SUCC(vb2_verify_data2(test_data, sizeof(test_data),
-				   sig, &pubk, &wb),
-		  "vb2_verify_data2() hash ok");
+	TEST_SUCC(vb2_verify_data(test_data, sizeof(test_data),
+				  sig, &pubk, &wb),
+		  "vb2_verify_data() hash ok");
 
 	*((uint8_t *)sig + sig->sig_offset) ^= 0xab;
-	TEST_EQ(vb2_verify_data2(test_data, sizeof(test_data), sig, &pubk, &wb),
-		VB2_ERROR_VDATA_VERIFY_DIGEST, "vb2_verify_data2() hash bad");
+	TEST_EQ(vb2_verify_data(test_data, sizeof(test_data), sig, &pubk, &wb),
+		VB2_ERROR_VDATA_VERIFY_DIGEST, "vb2_verify_data() hash bad");
 
 	free(sig);
 }
@@ -254,8 +253,8 @@ static void test_verify_keyblock(void)
 	const char desc[16] = "test keyblock";
 	const struct vb2_private_key *prik[2];
 	struct vb2_public_key pubk, pubk2, pubk3;
-	struct vb2_signature2 *sig;
-	struct vb2_keyblock2 *kbuf;
+	struct vb2_signature *sig;
+	struct vb2_keyblock *kbuf;
 	uint32_t buf_size;
 	uint8_t *buf, *buf2;
 
@@ -286,37 +285,37 @@ static void test_verify_keyblock(void)
 	memcpy(buf2, buf, buf_size);
 
 	vb2_workbuf_init(&wb, workbuf, sizeof(workbuf));
-	kbuf = (struct vb2_keyblock2 *)buf;
+	kbuf = (struct vb2_keyblock *)buf;
 
-	TEST_SUCC(vb2_verify_keyblock2(kbuf, buf_size, &pubk, &wb),
-		  "vb2_verify_keyblock2()");
+	TEST_SUCC(vb2_verify_keyblock(kbuf, buf_size, &pubk, &wb),
+		  "vb2_verify_keyblock()");
 
 	memcpy(buf, buf2, buf_size);
-	TEST_SUCC(vb2_verify_keyblock2(kbuf, buf_size, &pubk2, &wb),
-		  "vb2_verify_keyblock2() key 2");
+	TEST_SUCC(vb2_verify_keyblock(kbuf, buf_size, &pubk2, &wb),
+		  "vb2_verify_keyblock() key 2");
 
 	memcpy(buf, buf2, buf_size);
-	TEST_EQ(vb2_verify_keyblock2(kbuf, buf_size, &pubk3, &wb),
+	TEST_EQ(vb2_verify_keyblock(kbuf, buf_size, &pubk3, &wb),
 		VB2_ERROR_KEYBLOCK_SIG_GUID,
-		"vb2_verify_keyblock2() key not present");
+		"vb2_verify_keyblock() key not present");
 
 	memcpy(buf, buf2, buf_size);
-	kbuf->c.magic = VB2_MAGIC_PACKED_KEY2;
-	TEST_EQ(vb2_verify_keyblock2(kbuf, buf_size, &pubk, &wb),
+	kbuf->c.magic = VB2_MAGIC_PACKED_KEY;
+	TEST_EQ(vb2_verify_keyblock(kbuf, buf_size, &pubk, &wb),
 		VB2_ERROR_KEYBLOCK_MAGIC,
-		"vb2_verify_keyblock2() magic");
+		"vb2_verify_keyblock() magic");
 
 	memcpy(buf, buf2, buf_size);
 	kbuf->c.fixed_size++;
-	TEST_EQ(vb2_verify_keyblock2(kbuf, buf_size, &pubk, &wb),
+	TEST_EQ(vb2_verify_keyblock(kbuf, buf_size, &pubk, &wb),
 		VB2_ERROR_COMMON_FIXED_UNALIGNED,
-		"vb2_verify_keyblock2() header");
+		"vb2_verify_keyblock() header");
 
 	memcpy(buf, buf2, buf_size);
 	kbuf->c.struct_version_major++;
-	TEST_EQ(vb2_verify_keyblock2(kbuf, buf_size, &pubk, &wb),
+	TEST_EQ(vb2_verify_keyblock(kbuf, buf_size, &pubk, &wb),
 		VB2_ERROR_KEYBLOCK_HEADER_VERSION,
-		"vb2_verify_keyblock2() major version");
+		"vb2_verify_keyblock() major version");
 
 	memcpy(buf, buf2, buf_size);
 	kbuf->c.struct_version_minor++;
@@ -324,48 +323,48 @@ static void test_verify_keyblock(void)
 	vb2_sign_data(&sig, buf, kbuf->sig_offset, prik[0], NULL);
 	memcpy(buf + kbuf->sig_offset, sig, sig->c.total_size);
 	free(sig);
-	TEST_SUCC(vb2_verify_keyblock2(kbuf, buf_size, &pubk, &wb),
-		  "vb2_verify_keyblock2() minor version");
+	TEST_SUCC(vb2_verify_keyblock(kbuf, buf_size, &pubk, &wb),
+		  "vb2_verify_keyblock() minor version");
 
 	memcpy(buf, buf2, buf_size);
 	kbuf->c.fixed_size -= 4;
 	kbuf->c.desc_size += 4;
-	TEST_EQ(vb2_verify_keyblock2(kbuf, buf_size, &pubk, &wb),
+	TEST_EQ(vb2_verify_keyblock(kbuf, buf_size, &pubk, &wb),
 		VB2_ERROR_KEYBLOCK_SIZE,
-		"vb2_verify_keyblock2() header size");
+		"vb2_verify_keyblock() header size");
 
 	memcpy(buf, buf2, buf_size);
 	kbuf->key_offset = kbuf->c.total_size - 4;
-	TEST_EQ(vb2_verify_keyblock2(kbuf, buf_size, &pubk, &wb),
+	TEST_EQ(vb2_verify_keyblock(kbuf, buf_size, &pubk, &wb),
 		VB2_ERROR_COMMON_MEMBER_SIZE,
-		"vb2_verify_keyblock2() data key outside");
+		"vb2_verify_keyblock() data key outside");
 
 	memcpy(buf, buf2, buf_size);
-	sig = (struct vb2_signature2 *)(buf + kbuf->sig_offset);
+	sig = (struct vb2_signature *)(buf + kbuf->sig_offset);
 	sig->data_size--;
-	TEST_EQ(vb2_verify_keyblock2(kbuf, buf_size, &pubk, &wb),
+	TEST_EQ(vb2_verify_keyblock(kbuf, buf_size, &pubk, &wb),
 		VB2_ERROR_KEYBLOCK_SIGNED_SIZE,
-		"vb2_verify_keyblock2() signed wrong size");
+		"vb2_verify_keyblock() signed wrong size");
 
 	memcpy(buf, buf2, buf_size);
-	sig = (struct vb2_signature2 *)(buf + kbuf->sig_offset);
+	sig = (struct vb2_signature *)(buf + kbuf->sig_offset);
 	sig->c.total_size = kbuf->c.total_size - 4;
-	TEST_EQ(vb2_verify_keyblock2(kbuf, buf_size, &pubk, &wb),
+	TEST_EQ(vb2_verify_keyblock(kbuf, buf_size, &pubk, &wb),
 		VB2_ERROR_COMMON_TOTAL_SIZE,
-		"vb2_verify_keyblock2() key outside keyblock");
+		"vb2_verify_keyblock() key outside keyblock");
 
 	memcpy(buf, buf2, buf_size);
-	sig = (struct vb2_signature2 *)(buf + kbuf->sig_offset);
+	sig = (struct vb2_signature *)(buf + kbuf->sig_offset);
 	sig->c.struct_version_major++;
-	TEST_EQ(vb2_verify_keyblock2(kbuf, buf_size, &pubk, &wb),
+	TEST_EQ(vb2_verify_keyblock(kbuf, buf_size, &pubk, &wb),
 		VB2_ERROR_SIG_VERSION,
-		"vb2_verify_keyblock2() corrupt key");
+		"vb2_verify_keyblock() corrupt key");
 
 	memcpy(buf, buf2, buf_size);
 	kbuf->c.struct_version_minor++;
-	TEST_EQ(vb2_verify_keyblock2(kbuf, buf_size, &pubk, &wb),
+	TEST_EQ(vb2_verify_keyblock(kbuf, buf_size, &pubk, &wb),
 		VB2_ERROR_VDATA_VERIFY_DIGEST,
-		"vb2_verify_keyblock2() corrupt");
+		"vb2_verify_keyblock() corrupt");
 
 	free(buf);
 	free(buf2);
@@ -378,10 +377,10 @@ static void test_verify_fw_preamble(void)
 {
 	const char desc[16] = "test preamble";
 	const struct vb2_private_key *prikhash;
-	struct vb2_signature2 *hashes[3];
+	struct vb2_signature *hashes[3];
 	struct vb2_public_key pubk;
-	struct vb2_signature2 *sig;
-	struct vb2_fw_preamble2 *pre;
+	struct vb2_signature *sig;
+	struct vb2_fw_preamble *pre;
 	uint32_t buf_size;
 	uint8_t *buf, *buf2;
 
@@ -390,7 +389,7 @@ static void test_verify_fw_preamble(void)
 
 	/*
 	 * Preambles will usually be signed with a real key not a bare hash,
-	 * but the call to vb2_verify_data2() inside the preamble check is the
+	 * but the call to vb2_verify_data() inside the preamble check is the
 	 * same (and its functionality is verified separately), and using a
 	 * bare hash here saves us from needing to have a private key to do
 	 * this test.
@@ -413,7 +412,7 @@ static void test_verify_fw_preamble(void)
 
 	/* Test good preamble */
 	TEST_SUCC(vb2_fw_preamble_create(&pre, prikhash,
-					 (const struct vb2_signature2 **)hashes,
+					 (const struct vb2_signature **)hashes,
 					 3, 0x1234, 0x5678, desc),
 		  "Create preamble good");
 
@@ -425,28 +424,28 @@ static void test_verify_fw_preamble(void)
 	memcpy(buf2, buf, buf_size);
 
 	vb2_workbuf_init(&wb, workbuf, sizeof(workbuf));
-	pre = (struct vb2_fw_preamble2 *)buf;
+	pre = (struct vb2_fw_preamble *)buf;
 
-	TEST_SUCC(vb2_verify_fw_preamble2(pre, buf_size, &pubk, &wb),
-		  "vb2_verify_fw_preamble2()");
+	TEST_SUCC(vb2_verify_fw_preamble(pre, buf_size, &pubk, &wb),
+		  "vb2_verify_fw_preamble()");
 
 	memcpy(buf, buf2, buf_size);
-	pre->c.magic = VB2_MAGIC_PACKED_KEY2;
-	TEST_EQ(vb2_verify_fw_preamble2(pre, buf_size, &pubk, &wb),
+	pre->c.magic = VB2_MAGIC_PACKED_KEY;
+	TEST_EQ(vb2_verify_fw_preamble(pre, buf_size, &pubk, &wb),
 		VB2_ERROR_PREAMBLE_MAGIC,
-		"vb2_verify_fw_preamble2() magic");
+		"vb2_verify_fw_preamble() magic");
 
 	memcpy(buf, buf2, buf_size);
 	pre->c.fixed_size++;
-	TEST_EQ(vb2_verify_fw_preamble2(pre, buf_size, &pubk, &wb),
+	TEST_EQ(vb2_verify_fw_preamble(pre, buf_size, &pubk, &wb),
 		VB2_ERROR_COMMON_FIXED_UNALIGNED,
-		"vb2_verify_fw_preamble2() header");
+		"vb2_verify_fw_preamble() header");
 
 	memcpy(buf, buf2, buf_size);
 	pre->c.struct_version_major++;
-	TEST_EQ(vb2_verify_fw_preamble2(pre, buf_size, &pubk, &wb),
+	TEST_EQ(vb2_verify_fw_preamble(pre, buf_size, &pubk, &wb),
 		VB2_ERROR_PREAMBLE_HEADER_VERSION,
-		"vb2_verify_fw_preamble2() major version");
+		"vb2_verify_fw_preamble() major version");
 
 	memcpy(buf, buf2, buf_size);
 	pre->c.struct_version_minor++;
@@ -454,55 +453,55 @@ static void test_verify_fw_preamble(void)
 	vb2_sign_data(&sig, buf, pre->sig_offset, prikhash, NULL);
 	memcpy(buf + pre->sig_offset, sig, sig->c.total_size);
 	free(sig);
-	TEST_SUCC(vb2_verify_fw_preamble2(pre, buf_size, &pubk, &wb),
-		  "vb2_verify_fw_preamble2() minor version");
+	TEST_SUCC(vb2_verify_fw_preamble(pre, buf_size, &pubk, &wb),
+		  "vb2_verify_fw_preamble() minor version");
 
 	memcpy(buf, buf2, buf_size);
 	pre->c.fixed_size -= 4;
 	pre->c.desc_size += 4;
-	TEST_EQ(vb2_verify_fw_preamble2(pre, buf_size, &pubk, &wb),
+	TEST_EQ(vb2_verify_fw_preamble(pre, buf_size, &pubk, &wb),
 		VB2_ERROR_PREAMBLE_SIZE,
-		"vb2_verify_fw_preamble2() header size");
+		"vb2_verify_fw_preamble() header size");
 
 	memcpy(buf, buf2, buf_size);
-	sig = (struct vb2_signature2 *)(buf + pre->hash_offset);
+	sig = (struct vb2_signature *)(buf + pre->hash_offset);
 	sig->c.total_size += pre->c.total_size;
-	TEST_EQ(vb2_verify_fw_preamble2(pre, buf_size, &pubk, &wb),
+	TEST_EQ(vb2_verify_fw_preamble(pre, buf_size, &pubk, &wb),
 		VB2_ERROR_COMMON_TOTAL_SIZE,
-		"vb2_verify_fw_preamble2() hash size");
+		"vb2_verify_fw_preamble() hash size");
 
 	memcpy(buf, buf2, buf_size);
-	sig = (struct vb2_signature2 *)(buf + pre->hash_offset);
+	sig = (struct vb2_signature *)(buf + pre->hash_offset);
 	sig->sig_size /= 2;
-	TEST_EQ(vb2_verify_fw_preamble2(pre, buf_size, &pubk, &wb),
+	TEST_EQ(vb2_verify_fw_preamble(pre, buf_size, &pubk, &wb),
 		VB2_ERROR_SIG_SIZE,
-		"vb2_verify_fw_preamble2() hash integrity");
+		"vb2_verify_fw_preamble() hash integrity");
 
 	memcpy(buf, buf2, buf_size);
 	pre->hash_count++;
-	TEST_EQ(vb2_verify_fw_preamble2(pre, buf_size, &pubk, &wb),
+	TEST_EQ(vb2_verify_fw_preamble(pre, buf_size, &pubk, &wb),
 		VB2_ERROR_COMMON_MEMBER_OVERLAP,
-		"vb2_verify_fw_preamble2() hash count");
+		"vb2_verify_fw_preamble() hash count");
 
 	memcpy(buf, buf2, buf_size);
-	sig = (struct vb2_signature2 *)(buf + pre->sig_offset);
+	sig = (struct vb2_signature *)(buf + pre->sig_offset);
 	sig->c.total_size += 4;
-	TEST_EQ(vb2_verify_fw_preamble2(pre, buf_size, &pubk, &wb),
+	TEST_EQ(vb2_verify_fw_preamble(pre, buf_size, &pubk, &wb),
 		VB2_ERROR_COMMON_TOTAL_SIZE,
-		"vb2_verify_fw_preamble2() sig inside");
+		"vb2_verify_fw_preamble() sig inside");
 
 	memcpy(buf, buf2, buf_size);
-	sig = (struct vb2_signature2 *)(buf + pre->sig_offset);
+	sig = (struct vb2_signature *)(buf + pre->sig_offset);
 	buf[pre->sig_offset + sig->sig_offset]++;
-	TEST_EQ(vb2_verify_fw_preamble2(pre, buf_size, &pubk, &wb),
+	TEST_EQ(vb2_verify_fw_preamble(pre, buf_size, &pubk, &wb),
 		VB2_ERROR_VDATA_VERIFY_DIGEST,
-		"vb2_verify_fw_preamble2() sig corrupt");
+		"vb2_verify_fw_preamble() sig corrupt");
 
 	memcpy(buf, buf2, buf_size);
 	pre->flags++;
-	TEST_EQ(vb2_verify_fw_preamble2(pre, buf_size, &pubk, &wb),
+	TEST_EQ(vb2_verify_fw_preamble(pre, buf_size, &pubk, &wb),
 		VB2_ERROR_VDATA_VERIFY_DIGEST,
-		"vb2_verify_fw_preamble2() preamble corrupt");
+		"vb2_verify_fw_preamble() preamble corrupt");
 
 	free(buf);
 	free(buf2);
diff --git a/tests/vb21_host_fw_preamble_tests.c b/tests/vb21_host_fw_preamble_tests.c
index 1cd0a9a9..8bb83d05 100644
--- a/tests/vb21_host_fw_preamble_tests.c
+++ b/tests/vb21_host_fw_preamble_tests.c
@@ -29,9 +29,9 @@ static void preamble_tests(const char *keys_dir)
 {
 	struct vb2_private_key *prik4096;
 	struct vb2_public_key *pubk4096;
-	struct vb2_fw_preamble2 *fp;
+	struct vb2_fw_preamble *fp;
 	const struct vb2_private_key *prikhash;
-	struct vb2_signature2 *hashes[3];
+	struct vb2_signature *hashes[3];
 	char fname[1024];
 	const char test_desc[] = "Test fw preamble";
 	const uint32_t test_version = 2061;
@@ -74,15 +74,15 @@ static void preamble_tests(const char *keys_dir)
 
 	/* Test good preamble */
 	TEST_SUCC(vb2_fw_preamble_create(&fp, prik4096,
-					 (const struct vb2_signature2 **)hashes,
+					 (const struct vb2_signature **)hashes,
 					 3, test_version, test_flags,
 					 test_desc),
 		  "Create preamble good");
 	TEST_PTR_NEQ(fp, NULL, "  fp_ptr");
-	TEST_SUCC(vb2_verify_fw_preamble2(fp, fp->c.total_size, pubk4096, &wb),
+	TEST_SUCC(vb2_verify_fw_preamble(fp, fp->c.total_size, pubk4096, &wb),
 		  "Verify preamble good");
 	TEST_EQ(strcmp(vb2_common_desc(fp), test_desc), 0, "  desc");
-	TEST_EQ(fp->firmware_version, test_version, "  firmware_version");
+	TEST_EQ(fp->fw_version, test_version, "  fw_version");
 	TEST_EQ(fp->flags, test_flags, "  flags");
 	TEST_EQ(fp->hash_count, 3, "  hash_count");
 
@@ -98,7 +98,7 @@ static void preamble_tests(const char *keys_dir)
 	/* Test errors */
 	prik4096->hash_alg = VB2_HASH_INVALID;
 	TEST_EQ(vb2_fw_preamble_create(&fp, prik4096,
-				       (const struct vb2_signature2 **)hashes,
+				       (const struct vb2_signature **)hashes,
 				       3, test_version, test_flags,
 				       test_desc),
 		VB2_FW_PREAMBLE_CREATE_SIG_SIZE,
diff --git a/tests/vb21_host_key_tests.c b/tests/vb21_host_key_tests.c
index ed4c44b2..6a01d724 100644
--- a/tests/vb21_host_key_tests.c
+++ b/tests/vb21_host_key_tests.c
@@ -35,7 +35,7 @@ static void private_key_tests(const struct alg_combo *combo,
 {
 	struct vb2_private_key *key, *k2;
 	const struct vb2_private_key *ckey;
-	struct vb2_packed_private_key2 *pkey;
+	struct vb2_packed_private_key *pkey;
 	const char *testfile = "test.vbprik2";
 	const char *notapem = "not_a_pem";
 	const char *testdesc = "test desc";
@@ -91,7 +91,7 @@ static void private_key_tests(const struct alg_combo *combo,
 	vb2_private_key_free(k2);
 
 	TEST_SUCC(vb2_read_file(testfile, &buf, &bufsize), "Read key raw");
-	pkey = (struct vb2_packed_private_key2 *)buf;
+	pkey = (struct vb2_packed_private_key *)buf;
 
 	/* Make a backup of the good buffer so we can mangle it */
 	buf2 = malloc(bufsize);
@@ -102,7 +102,7 @@ static void private_key_tests(const struct alg_combo *combo,
 	vb2_private_key_free(k2);
 
 	memcpy(buf, buf2, bufsize);
-	pkey->c.magic = VB2_MAGIC_PACKED_KEY2;
+	pkey->c.magic = VB2_MAGIC_PACKED_KEY;
 	TEST_EQ(vb2_private_key_unpack(&k2, buf, bufsize),
 		VB2_ERROR_UNPACK_PRIVATE_KEY_MAGIC,
 		"Unpack private key bad magic");
@@ -169,7 +169,7 @@ static void public_key_tests(const struct alg_combo *combo,
 			     const char *keybfile)
 {
 	struct vb2_public_key *key, k2;
-	struct vb2_packed_key2 *pkey;
+	struct vb2_packed_key *pkey;
 	const char *testfile = "test.vbpubk2";
 	const char *testdesc = "test desc";
 	const struct vb2_guid test_guid = {.raw = {0xbb}};
@@ -225,7 +225,7 @@ static void public_key_tests(const struct alg_combo *combo,
 	TEST_EQ(memcmp(&pkey->guid, key->guid, sizeof(pkey->guid)), 0,
 		"  guid");
 	TEST_EQ(strcmp(vb2_common_desc(pkey), key->desc), 0, "  desc");
-	TEST_SUCC(vb2_unpack_key2(&k2, (uint8_t *)pkey, pkey->c.total_size),
+	TEST_SUCC(vb2_unpack_key(&k2, (uint8_t *)pkey, pkey->c.total_size),
 		  "Unpack public key");
 	TEST_EQ(key->arrsize, k2.arrsize, "  arrsize");
 	TEST_EQ(key->n0inv, k2.n0inv, "  n0inv");
@@ -237,7 +237,7 @@ static void public_key_tests(const struct alg_combo *combo,
 	TEST_SUCC(vb2_write_object(testfile, pkey), "Write packed key");
 	free(pkey);
 
-	TEST_SUCC(vb2_packed_key2_read(&pkey, testfile), "Read packed key");
+	TEST_SUCC(vb2_packed_key_read(&pkey, testfile), "Read packed key");
 	TEST_PTR_NEQ(pkey, NULL, "  key_ptr");
 	unlink(testfile);
 
@@ -245,12 +245,12 @@ static void public_key_tests(const struct alg_combo *combo,
 	TEST_SUCC(vb2_write_object(testfile, pkey), "Write bad packed key");
 	free(pkey);
 
-	TEST_EQ(vb2_packed_key2_read(&pkey, testfile),
+	TEST_EQ(vb2_packed_key_read(&pkey, testfile),
 		VB2_ERROR_READ_PACKED_KEY, "Read bad packed key");
 	TEST_PTR_EQ(pkey, NULL, "  key_ptr");
 	unlink(testfile);
 
-	TEST_EQ(vb2_packed_key2_read(&pkey, testfile),
+	TEST_EQ(vb2_packed_key_read(&pkey, testfile),
 		VB2_ERROR_READ_PACKED_KEY_DATA, "Read missing packed key");
 
 	key->sig_alg = VB2_SIG_INVALID;
@@ -271,7 +271,7 @@ static void public_key_tests(const struct alg_combo *combo,
 
 	TEST_SUCC(vb2_public_key_pack(&pkey, &k2), "Pack public hash key");
 	TEST_PTR_NEQ(pkey, NULL, "  key_ptr");
-	TEST_SUCC(vb2_unpack_key2(&k2, (uint8_t *)pkey, pkey->c.total_size),
+	TEST_SUCC(vb2_unpack_key(&k2, (uint8_t *)pkey, pkey->c.total_size),
 		  "Unpack public hash key");
 	free(pkey);
 }
diff --git a/tests/vb21_host_keyblock_tests.c b/tests/vb21_host_keyblock_tests.c
index 11a75d74..95dbe98e 100644
--- a/tests/vb21_host_keyblock_tests.c
+++ b/tests/vb21_host_keyblock_tests.c
@@ -22,8 +22,8 @@ static void keyblock_tests(const char *keys_dir)
 {
 	struct vb2_public_key *pubk2048, *pubk4096, *pubk8192, pubkhash;
 	struct vb2_private_key *prik4096, *prik8192;
-	struct vb2_packed_key2 *pak, *pakgood;
-	struct vb2_keyblock2 *kb;
+	struct vb2_packed_key *pak, *pakgood;
+	struct vb2_keyblock *kb;
 	const struct vb2_private_key *prikhash;
 	const struct vb2_private_key *prik[2];
 	char fname[1024];
@@ -80,12 +80,12 @@ static void keyblock_tests(const char *keys_dir)
 	TEST_SUCC(vb2_keyblock_create(&kb, pubk2048, prik, 1, 0x1234, NULL),
 		  "Keyblock single");
 	TEST_PTR_NEQ(kb, NULL, "  kb_ptr");
-	TEST_SUCC(vb2_verify_keyblock2(kb, kb->c.total_size, pubk4096, &wb),
+	TEST_SUCC(vb2_verify_keyblock(kb, kb->c.total_size, pubk4096, &wb),
 		  "  verify");
 	TEST_EQ(strcmp(vb2_common_desc(kb), pubk2048->desc), 0,	"  desc");
 	TEST_EQ(kb->flags, 0x1234, "  flags");
 
-	pak = (struct vb2_packed_key2 *)((uint8_t *)kb + kb->key_offset);
+	pak = (struct vb2_packed_key *)((uint8_t *)kb + kb->key_offset);
 	TEST_EQ(0, memcmp(pak, pakgood, pakgood->c.total_size), "  data key");
 	free(kb);
 
@@ -94,9 +94,9 @@ static void keyblock_tests(const char *keys_dir)
 	prik[1] = prikhash;
 	TEST_SUCC(vb2_keyblock_create(&kb, pubk4096, prik, 2, 0, test_desc),
 		  "Keyblock multiple");
-	TEST_SUCC(vb2_verify_keyblock2(kb, kb->c.total_size, pubk8192, &wb),
+	TEST_SUCC(vb2_verify_keyblock(kb, kb->c.total_size, pubk8192, &wb),
 		  "  verify 1");
-	TEST_SUCC(vb2_verify_keyblock2(kb, kb->c.total_size, &pubkhash, &wb),
+	TEST_SUCC(vb2_verify_keyblock(kb, kb->c.total_size, &pubkhash, &wb),
 		  "  verify 2");
 	TEST_EQ(strcmp(vb2_common_desc(kb), test_desc), 0,	"  desc");
 	TEST_EQ(kb->flags, 0, "  flags");
diff --git a/tests/vb21_host_sig_tests.c b/tests/vb21_host_sig_tests.c
index 5c1176ab..66e91553 100644
--- a/tests/vb21_host_sig_tests.c
+++ b/tests/vb21_host_sig_tests.c
@@ -43,7 +43,7 @@ static void sig_tests(const struct alg_combo *combo,
 	struct vb2_private_key *prik, prik2;
 	const struct vb2_private_key *prihash, *priks[2];
 	struct vb2_public_key *pubk, pubhash;
-	struct vb2_signature2 *sig, *sig2;
+	struct vb2_signature *sig, *sig2;
 	uint32_t size;
 
 	uint8_t workbuf[VB2_VERIFY_DATA_WORKBUF_BYTES];
@@ -86,7 +86,7 @@ static void sig_tests(const struct alg_combo *combo,
 	TEST_EQ(sig->data_size, test_size, "  data_size");
 	TEST_SUCC(vb2_sig_size_for_key(&size, prik, NULL), "Sig size");
 	TEST_EQ(size, sig->c.total_size, "  size");
-	TEST_SUCC(vb2_verify_data2(test_data, test_size, sig, pubk, &wb),
+	TEST_SUCC(vb2_verify_data(test_data, test_size, sig, pubk, &wb),
 		  "Verify good");
 	free(sig);
 
@@ -105,7 +105,7 @@ static void sig_tests(const struct alg_combo *combo,
 
 	TEST_SUCC(vb2_sign_data(&sig, test_data, test_size, prihash, NULL),
 		  "Sign with hash");
-	TEST_SUCC(vb2_verify_data2(test_data, test_size, sig, &pubhash, &wb),
+	TEST_SUCC(vb2_verify_data(test_data, test_size, sig, &pubhash, &wb),
 		  "Verify with hash");
 	free(sig);
 
@@ -124,8 +124,8 @@ static void sig_tests(const struct alg_combo *combo,
 	c->total_size = bufsize;
 
 	TEST_SUCC(vb2_sign_object(buf, c_sig_offs, prik, NULL), "Sign object");
-	sig = (struct vb2_signature2 *)(buf + c_sig_offs);
-	TEST_SUCC(vb2_verify_data2(buf, c_sig_offs, sig, pubk, &wb),
+	sig = (struct vb2_signature *)(buf + c_sig_offs);
+	TEST_SUCC(vb2_verify_data(buf, c_sig_offs, sig, pubk, &wb),
 		  "Verify object");
 
 	TEST_EQ(vb2_sign_object(buf, c_sig_offs + 4, prik, NULL),
@@ -142,11 +142,11 @@ static void sig_tests(const struct alg_combo *combo,
 
 	TEST_SUCC(vb2_sign_object_multiple(buf, c_sig_offs, priks, 2),
 		  "Sign multiple");
-	sig = (struct vb2_signature2 *)(buf + c_sig_offs);
-	TEST_SUCC(vb2_verify_data2(buf, c_sig_offs, sig, pubk, &wb),
+	sig = (struct vb2_signature *)(buf + c_sig_offs);
+	TEST_SUCC(vb2_verify_data(buf, c_sig_offs, sig, pubk, &wb),
 		  "Verify object with sig 1");
-	sig2 = (struct vb2_signature2 *)(buf + c_sig_offs + sig->c.total_size);
-	TEST_SUCC(vb2_verify_data2(buf, c_sig_offs, sig2, &pubhash, &wb),
+	sig2 = (struct vb2_signature *)(buf + c_sig_offs + sig->c.total_size);
+	TEST_SUCC(vb2_verify_data(buf, c_sig_offs, sig2, &pubhash, &wb),
 		  "Verify object with sig 2");
 
 	c->total_size -= 4;
diff --git a/tests/vb21_misc_tests.c b/tests/vb21_misc_tests.c
index 03b8e4fb..ff3f2766 100644
--- a/tests/vb21_misc_tests.c
+++ b/tests/vb21_misc_tests.c
@@ -28,21 +28,21 @@ static struct vb2_shared_data *sd;
 
 static struct {
 	struct vb2_gbb_header h;
-	struct vb2_packed_key2 rootkey;
+	struct vb2_packed_key rootkey;
 	char rootkey_data[32];
 } mock_gbb;
 
 static struct {
 	/* Keyblock */
 	struct {
-		struct vb2_keyblock2 kb;
-		struct vb2_packed_key2 data_key;
+		struct vb2_keyblock kb;
+		struct vb2_packed_key data_key;
 		char data_key_data[16];
 		uint8_t kbdata[128];
 	} k;
 	/* Preamble follows keyblock */
 	struct {
-		struct vb2_fw_preamble2 pre;
+		struct vb2_fw_preamble pre;
 		uint8_t predata[128];
 	} p;
 } mock_vblock;
@@ -60,9 +60,9 @@ enum reset_type {
 
 static void reset_common_data(enum reset_type t)
 {
-	struct vb2_keyblock2 *kb = &mock_vblock.k.kb;
-	struct vb2_packed_key2 *dk = &mock_vblock.k.data_key;
-	struct vb2_fw_preamble2 *pre = &mock_vblock.p.pre;
+	struct vb2_keyblock *kb = &mock_vblock.k.kb;
+	struct vb2_packed_key *dk = &mock_vblock.k.data_key;
+	struct vb2_fw_preamble *pre = &mock_vblock.p.pre;
 
 	memset(workbuf, 0xaa, sizeof(workbuf));
 
@@ -109,11 +109,11 @@ static void reset_common_data(enum reset_type t)
 	strcpy(mock_vblock.k.data_key_data, "data key data!!");
 
 	pre->c.total_size = sizeof(mock_vblock.p);
-	pre->firmware_version = 2;
+	pre->fw_version = 2;
 
 	/* If verifying preamble, verify keyblock first to set up data key */
 	if (t == FOR_PREAMBLE)
-		vb2_load_fw_keyblock2(&ctx);
+		vb2_load_fw_keyblock(&ctx);
 };
 
 /* Mocked functions */
@@ -150,14 +150,14 @@ int vb2ex_read_resource(struct vb2_context *ctx,
 	return VB2_SUCCESS;
 }
 
-int vb2_unpack_key2(struct vb2_public_key *key,
+int vb2_unpack_key(struct vb2_public_key *key,
 		    const uint8_t *buf,
 		    uint32_t size)
 {
 	return mock_unpack_key_retval;
 }
 
-int vb2_verify_keyblock2(struct vb2_keyblock2 *block,
+int vb2_verify_keyblock(struct vb2_keyblock *block,
 			 uint32_t size,
 			 const struct vb2_public_key *key,
 			 const struct vb2_workbuf *wb)
@@ -165,7 +165,7 @@ int vb2_verify_keyblock2(struct vb2_keyblock2 *block,
 	return mock_verify_keyblock_retval;
 }
 
-int vb2_verify_fw_preamble2(struct vb2_fw_preamble2 *preamble,
+int vb2_verify_fw_preamble(struct vb2_fw_preamble *preamble,
 			    uint32_t size,
 			    const struct vb2_public_key *key,
 			    const struct vb2_workbuf *wb)
@@ -177,15 +177,15 @@ int vb2_verify_fw_preamble2(struct vb2_fw_preamble2 *preamble,
 
 static void load_keyblock_tests(void)
 {
-	struct vb2_keyblock2 *kb = &mock_vblock.k.kb;
-	struct vb2_packed_key2 *dk = &mock_vblock.k.data_key;
-	struct vb2_packed_key2 *k;
+	struct vb2_keyblock *kb = &mock_vblock.k.kb;
+	struct vb2_packed_key *dk = &mock_vblock.k.data_key;
+	struct vb2_packed_key *k;
 	int wb_used_before;
 
 	/* Test successful call */
 	reset_common_data(FOR_KEYBLOCK);
 	wb_used_before = ctx.workbuf_used;
-	TEST_SUCC(vb2_load_fw_keyblock2(&ctx), "keyblock verify");
+	TEST_SUCC(vb2_load_fw_keyblock(&ctx), "keyblock verify");
 	TEST_EQ(sd->fw_version, 0x20000, "keyblock version");
 	TEST_EQ(sd->vblock_preamble_offset, sizeof(mock_vblock.k),
 		"preamble offset");
@@ -198,8 +198,8 @@ static void load_keyblock_tests(void)
 		"workbuf used");
 
 	/* Make sure data key was properly saved */
-	k = (struct vb2_packed_key2 *)(ctx.workbuf +
-				       sd->workbuf_data_key_offset);
+	k = (struct vb2_packed_key *)(ctx.workbuf +
+				      sd->workbuf_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),
@@ -215,76 +215,76 @@ static void load_keyblock_tests(void)
 	/* Test failures */
 	reset_common_data(FOR_KEYBLOCK);
 	ctx.workbuf_used = ctx.workbuf_size - sd->gbb_rootkey_size + 8;
-	TEST_EQ(vb2_load_fw_keyblock2(&ctx),
+	TEST_EQ(vb2_load_fw_keyblock(&ctx),
 		VB2_ERROR_FW_KEYBLOCK_WORKBUF_ROOT_KEY,
 		"keyblock not enough workbuf for root key");
 
 	reset_common_data(FOR_KEYBLOCK);
 	sd->gbb_rootkey_size = sizeof(mock_gbb);
-	TEST_EQ(vb2_load_fw_keyblock2(&ctx),
+	TEST_EQ(vb2_load_fw_keyblock(&ctx),
 		VB2_ERROR_EX_READ_RESOURCE_SIZE,
 		"keyblock read root key");
 
 	reset_common_data(FOR_KEYBLOCK);
 	mock_unpack_key_retval = VB2_ERROR_UNPACK_KEY_SIG_ALGORITHM;
-	TEST_EQ(vb2_load_fw_keyblock2(&ctx),
+	TEST_EQ(vb2_load_fw_keyblock(&ctx),
 		VB2_ERROR_UNPACK_KEY_SIG_ALGORITHM,
 		"keyblock unpack root key");
 
 	reset_common_data(FOR_KEYBLOCK);
 	ctx.workbuf_used = ctx.workbuf_size - sd->gbb_rootkey_size - 8;
-	TEST_EQ(vb2_load_fw_keyblock2(&ctx),
+	TEST_EQ(vb2_load_fw_keyblock(&ctx),
 		VB2_ERROR_READ_RESOURCE_OBJECT_BUF,
 		"keyblock not enough workbuf for header");
 
 	reset_common_data(FOR_KEYBLOCK);
 	mock_read_res_fail_on_call = 2;
-	TEST_EQ(vb2_load_fw_keyblock2(&ctx),
+	TEST_EQ(vb2_load_fw_keyblock(&ctx),
 		VB2_ERROR_EX_READ_RESOURCE_INDEX,
 		"keyblock read keyblock header");
 
 	reset_common_data(FOR_KEYBLOCK);
 	ctx.workbuf_used = ctx.workbuf_size - sd->gbb_rootkey_size
-		- sizeof(struct vb2_keyblock2);
-	TEST_EQ(vb2_load_fw_keyblock2(&ctx),
+		- sizeof(struct vb2_keyblock);
+	TEST_EQ(vb2_load_fw_keyblock(&ctx),
 		VB2_ERROR_READ_RESOURCE_OBJECT_BUF,
 		"keyblock not enough workbuf for entire keyblock");
 
 	reset_common_data(FOR_KEYBLOCK);
 	kb->c.total_size = sizeof(mock_vblock) + 1;
-	TEST_EQ(vb2_load_fw_keyblock2(&ctx),
+	TEST_EQ(vb2_load_fw_keyblock(&ctx),
 		VB2_ERROR_EX_READ_RESOURCE_SIZE,
 		"keyblock read keyblock");
 
 	reset_common_data(FOR_KEYBLOCK);
 	mock_verify_keyblock_retval = VB2_ERROR_KEYBLOCK_MAGIC;
-	TEST_EQ(vb2_load_fw_keyblock2(&ctx),
+	TEST_EQ(vb2_load_fw_keyblock(&ctx),
 		VB2_ERROR_KEYBLOCK_MAGIC,
 		"keyblock verify keyblock");
 
 	reset_common_data(FOR_KEYBLOCK);
 	dk->key_version = 0x10000;
-	TEST_EQ(vb2_load_fw_keyblock2(&ctx),
+	TEST_EQ(vb2_load_fw_keyblock(&ctx),
 		VB2_ERROR_FW_KEYBLOCK_VERSION_RANGE,
 		"keyblock version range");
 
 	reset_common_data(FOR_KEYBLOCK);
 	dk->key_version = 1;
-	TEST_EQ(vb2_load_fw_keyblock2(&ctx),
+	TEST_EQ(vb2_load_fw_keyblock(&ctx),
 		VB2_ERROR_FW_KEYBLOCK_VERSION_ROLLBACK,
 		"keyblock rollback");
 }
 
 static void load_preamble_tests(void)
 {
-	struct vb2_fw_preamble2 *pre = &mock_vblock.p.pre;
+	struct vb2_fw_preamble *pre = &mock_vblock.p.pre;
 	int data_key_offset_before;
 	uint32_t v;
 
 	/* Test successful call */
 	reset_common_data(FOR_PREAMBLE);
 	data_key_offset_before = sd->workbuf_data_key_offset;
-	TEST_SUCC(vb2_load_fw_preamble2(&ctx), "preamble good");
+	TEST_SUCC(vb2_load_fw_preamble(&ctx), "preamble good");
 	TEST_EQ(sd->fw_version, 0x20002, "combined version");
 	TEST_EQ(sd->workbuf_preamble_offset, data_key_offset_before,
 		"preamble offset");
@@ -298,80 +298,80 @@ static void load_preamble_tests(void)
 	/* Expected failures */
 	reset_common_data(FOR_PREAMBLE);
 	sd->workbuf_data_key_size = 0;
-	TEST_EQ(vb2_load_fw_preamble2(&ctx),
+	TEST_EQ(vb2_load_fw_preamble(&ctx),
 		VB2_ERROR_FW_PREAMBLE2_DATA_KEY,
 		"preamble no data key");
 
 	reset_common_data(FOR_PREAMBLE);
 	mock_unpack_key_retval = VB2_ERROR_UNPACK_KEY_HASH_ALGORITHM;
-	TEST_EQ(vb2_load_fw_preamble2(&ctx),
+	TEST_EQ(vb2_load_fw_preamble(&ctx),
 		VB2_ERROR_UNPACK_KEY_HASH_ALGORITHM,
 		"preamble unpack data key");
 
 	reset_common_data(FOR_PREAMBLE);
 	ctx.workbuf_used = ctx.workbuf_size
-		- sizeof(struct vb2_fw_preamble2) + 8;
-	TEST_EQ(vb2_load_fw_preamble2(&ctx),
+		- sizeof(struct vb2_fw_preamble) + 8;
+	TEST_EQ(vb2_load_fw_preamble(&ctx),
 		VB2_ERROR_READ_RESOURCE_OBJECT_BUF,
 		"preamble not enough workbuf for header");
 
 	reset_common_data(FOR_PREAMBLE);
 	sd->vblock_preamble_offset = sizeof(mock_vblock);
-	TEST_EQ(vb2_load_fw_preamble2(&ctx),
+	TEST_EQ(vb2_load_fw_preamble(&ctx),
 		VB2_ERROR_EX_READ_RESOURCE_SIZE,
 		"preamble read header");
 
 	reset_common_data(FOR_PREAMBLE);
 	ctx.workbuf_used = ctx.workbuf_size - sizeof(mock_vblock.p) + 8;
-	TEST_EQ(vb2_load_fw_preamble2(&ctx),
+	TEST_EQ(vb2_load_fw_preamble(&ctx),
 		VB2_ERROR_READ_RESOURCE_OBJECT_BUF,
 		"preamble not enough workbuf");
 
 	reset_common_data(FOR_PREAMBLE);
 	pre->c.total_size = sizeof(mock_vblock);
-	TEST_EQ(vb2_load_fw_preamble2(&ctx),
+	TEST_EQ(vb2_load_fw_preamble(&ctx),
 		VB2_ERROR_EX_READ_RESOURCE_SIZE,
 		"preamble read full");
 
 	reset_common_data(FOR_PREAMBLE);
 	mock_verify_preamble_retval = VB2_ERROR_PREAMBLE_SIG_INVALID;
-	TEST_EQ(vb2_load_fw_preamble2(&ctx),
+	TEST_EQ(vb2_load_fw_preamble(&ctx),
 		VB2_ERROR_PREAMBLE_SIG_INVALID,
 		"preamble verify");
 
 	reset_common_data(FOR_PREAMBLE);
-	pre->firmware_version = 0x10000;
-	TEST_EQ(vb2_load_fw_preamble2(&ctx),
-		VB2_ERROR_FW_PREAMBLE2_VERSION_RANGE,
+	pre->fw_version = 0x10000;
+	TEST_EQ(vb2_load_fw_preamble(&ctx),
+		VB2_ERROR_FW_PREAMBLE_VERSION_RANGE,
 		"preamble version range");
 
 	reset_common_data(FOR_PREAMBLE);
-	pre->firmware_version = 1;
-	TEST_EQ(vb2_load_fw_preamble2(&ctx),
-		VB2_ERROR_FW_PREAMBLE2_VERSION_ROLLBACK,
+	pre->fw_version = 1;
+	TEST_EQ(vb2_load_fw_preamble(&ctx),
+		VB2_ERROR_FW_PREAMBLE_VERSION_ROLLBACK,
 		"preamble version rollback");
 
 	reset_common_data(FOR_PREAMBLE);
-	pre->firmware_version = 3;
-	TEST_SUCC(vb2_load_fw_preamble2(&ctx),
+	pre->fw_version = 3;
+	TEST_SUCC(vb2_load_fw_preamble(&ctx),
 		  "preamble version roll forward");
 	vb2_secdata_get(&ctx, VB2_SECDATA_VERSIONS, &v);
 	TEST_EQ(v, 0x20003, "roll forward");
 
 	/* Newer version without result success doesn't roll forward */
 	reset_common_data(FOR_PREAMBLE);
-	pre->firmware_version = 3;
+	pre->fw_version = 3;
 	sd->last_fw_result = VB2_FW_RESULT_UNKNOWN;
-	TEST_SUCC(vb2_load_fw_preamble2(&ctx),
+	TEST_SUCC(vb2_load_fw_preamble(&ctx),
 		  "preamble version no roll forward 1");
 	vb2_secdata_get(&ctx, VB2_SECDATA_VERSIONS, &v);
 	TEST_EQ(v, 0x20002, "no roll forward");
 
 	/* Newer version with success but for other slot doesn't roll forward */
 	reset_common_data(FOR_PREAMBLE);
-	pre->firmware_version = 3;
+	pre->fw_version = 3;
 	sd->last_fw_slot = 1;
-	TEST_SUCC(vb2_load_fw_preamble2(&ctx),
+	TEST_SUCC(vb2_load_fw_preamble(&ctx),
 		  "preamble version no roll forward 2");
 	vb2_secdata_get(&ctx, VB2_SECDATA_VERSIONS, &v);
 	TEST_EQ(v, 0x20002, "no roll forward");