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>
diff --git a/firmware/2lib/include/2api.h b/firmware/2lib/include/2api.h
index c0727c7..1ce6a09 100644
--- a/firmware/2lib/include/2api.h
+++ b/firmware/2lib/include/2api.h
@@ -297,11 +297,6 @@
 int vb2api_fw_phase3(struct vb2_context *ctx);
 
 /**
- * Same, but for new-style structs.
- */
-int vb2api_fw_phase3_2(struct vb2_context *ctx);
-
-/**
  * Initialize hashing data for the specified tag.
  *
  * @param ctx		Vboot context
@@ -341,11 +336,6 @@
  */
 int vb2api_check_hash(struct vb2_context *ctx);
 
-/**
- * Same, but for new-style structs.
- */
-int vb2api_check_hash2(struct vb2_context *ctx);
-
 /*****************************************************************************/
 /* APIs provided by the caller to verified boot */
 
diff --git a/firmware/2lib/include/2common.h b/firmware/2lib/include/2common.h
index 06d0ee0..9b4a1eb 100644
--- a/firmware/2lib/include/2common.h
+++ b/firmware/2lib/include/2common.h
@@ -165,31 +165,19 @@
  */
 const struct vb2_guid *vb2_hash_guid(enum vb2_hash_algorithm hash_alg);
 
-/*
- * Size of work buffer sufficient for vb2_verify_digest() or
- * vb2_verify_digest2() worst case.
- */
+/* Size of work buffer sufficient for vb2_verify_digest() worst case. */
 #define VB2_VERIFY_DIGEST_WORKBUF_BYTES VB2_VERIFY_RSA_DIGEST_WORKBUF_BYTES
 
-/*
- * Size of work buffer sufficient for vb2_verify_data() or vb2_verify_data2()
- * worst case.
- */
+/* Size of work buffer sufficient for vb2_verify_data() worst case. */
 #define VB2_VERIFY_DATA_WORKBUF_BYTES					\
 	(VB2_SHA512_DIGEST_SIZE +					\
 	 VB2_MAX(VB2_VERIFY_DIGEST_WORKBUF_BYTES,			\
 		 sizeof(struct vb2_digest_context)))
 
-/*
- * Size of work buffer sufficient for vb2_verify_keyblock() or
- * vb2_verify_keyblock2() worst case.
- */
+/* Size of work buffer sufficient for vb2_verify_keyblock() worst case. */
 #define VB2_KEY_BLOCK_VERIFY_WORKBUF_BYTES VB2_VERIFY_DATA_WORKBUF_BYTES
 
-/*
- * Size of work buffer sufficient for vb2_verify_fw_preamble() or
- * vb2_verify_fw_preamble2() worst case.
- */
+/* Size of work buffer sufficient for vb2_verify_fw_preamble() worst case. */
 #define VB2_VERIFY_FIRMWARE_PREAMBLE_WORKBUF_BYTES VB2_VERIFY_DATA_WORKBUF_BYTES
 
 #endif  /* VBOOT_REFERENCE_VBOOT_2COMMON_H_ */
diff --git a/firmware/2lib/include/2misc.h b/firmware/2lib/include/2misc.h
index e3d9bec..928ada3 100644
--- a/firmware/2lib/include/2misc.h
+++ b/firmware/2lib/include/2misc.h
@@ -26,7 +26,7 @@
 /**
  * Validate gbb signature (the magic number)
  *
- * @param sig	pointer to the signature bytes to validate
+ * @param sig		Pointer to the signature bytes to validate
  * @return VB2_SUCCESS if valid or VB2_ERROR_GBB_MAGIC otherwise.
  */
 int vb2_validate_gbb_signature(uint8_t *sig);
@@ -132,11 +132,6 @@
 int vb2_load_fw_keyblock(struct vb2_context *ctx);
 
 /**
- * (same, for new-style structs)
- */
-int vb2_load_fw_keyblock2(struct vb2_context *ctx);
-
-/**
  * Verify the firmware preamble using the data subkey from the keyblock.
  *
  * After this call, the preamble is stored in the work buffer.
@@ -146,9 +141,4 @@
  */
 int vb2_load_fw_preamble(struct vb2_context *ctx);
 
-/**
- * (same, for new-style structs)
- */
-int vb2_load_fw_preamble2(struct vb2_context *ctx);
-
 #endif  /* VBOOT_REFERENCE_VBOOT_2MISC_H_ */
diff --git a/firmware/2lib/include/2return_codes.h b/firmware/2lib/include/2return_codes.h
index f41d784..2cffc56 100644
--- a/firmware/2lib/include/2return_codes.h
+++ b/firmware/2lib/include/2return_codes.h
@@ -226,7 +226,7 @@
 	/* Key algorithm doesn't match signature algorithm */
 	VB2_ERROR_VDATA_ALGORITHM_MISMATCH,
 
-	/* Bad magic number in vb2_unpack_key2() */
+	/* Bad magic number in vb2_unpack_key() */
 	VB2_ERROR_UNPACK_KEY_MAGIC,
 
         /**********************************************************************
@@ -362,10 +362,10 @@
 	VB2_ERROR_FW_PREAMBLE2_WORKBUF,
 
 	/* Firmware version out of range in vb2_load_fw_preamble() */
-	VB2_ERROR_FW_PREAMBLE2_VERSION_RANGE,
+	VB2_ERROR_FW_PREAMBLE_VERSION_RANGE,
 
 	/* Firmware version rollback in vb2_load_fw_preamble() */
-	VB2_ERROR_FW_PREAMBLE2_VERSION_ROLLBACK,
+	VB2_ERROR_FW_PREAMBLE_VERSION_ROLLBACK,
 
 	/* Not enough space in work buffer for resource object */
 	VB2_ERROR_READ_RESOURCE_OBJECT_BUF,
diff --git a/firmware/2lib/include/2struct.h b/firmware/2lib/include/2struct.h
index c8ff237..c0cd907 100644
--- a/firmware/2lib/include/2struct.h
+++ b/firmware/2lib/include/2struct.h
@@ -160,7 +160,7 @@
 	/*
 	 * Current tag we're hashing
 	 *
-	 * For new structs, this is the offset of the vb2_signature2 struct
+	 * 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
diff --git a/firmware/lib20/misc.c b/firmware/lib20/misc.c
index 7fa3787..89e46ec 100644
--- a/firmware/lib20/misc.c
+++ b/firmware/lib20/misc.c
@@ -194,12 +194,12 @@
 	 * version.
 	 */
 	if (pre->firmware_version > 0xffff)
-		return VB2_ERROR_FW_PREAMBLE2_VERSION_RANGE;
+		return VB2_ERROR_FW_PREAMBLE_VERSION_RANGE;
 
 	/* Combine with the key version from vb2_load_fw_keyblock() */
 	sd->fw_version |= pre->firmware_version;
 	if (sd->fw_version < sec_version)
-		return VB2_ERROR_FW_PREAMBLE2_VERSION_ROLLBACK;
+		return VB2_ERROR_FW_PREAMBLE_VERSION_ROLLBACK;
 
 	/*
 	 * If this is a newer version than in secure storage, and we
diff --git a/firmware/lib21/api.c b/firmware/lib21/api.c
index 99bc443..beed98b 100644
--- a/firmware/lib21/api.c
+++ b/firmware/lib21/api.c
@@ -16,19 +16,19 @@
 #include "2rsa.h"
 #include "vb2_common.h"
 
-int vb2api_fw_phase3_2(struct vb2_context *ctx)
+int vb2api_fw_phase3(struct vb2_context *ctx)
 {
 	int rv;
 
 	/* Verify firmware keyblock */
-	rv = vb2_load_fw_keyblock2(ctx);
+	rv = vb2_load_fw_keyblock(ctx);
 	if (rv) {
 		vb2_fail(ctx, VB2_RECOVERY_RO_INVALID_RW, rv);
 		return rv;
 	}
 
 	/* Verify firmware preamble */
-	rv = vb2_load_fw_preamble2(ctx);
+	rv = vb2_load_fw_preamble(ctx);
 	if (rv) {
 		vb2_fail(ctx, VB2_RECOVERY_RO_INVALID_RW, rv);
 		return rv;
@@ -42,8 +42,8 @@
 		      uint32_t *size)
 {
 	struct vb2_shared_data *sd = vb2_get_sd(ctx);
-	const struct vb2_fw_preamble2 *pre;
-	const struct vb2_signature2 *sig = NULL;
+	const struct vb2_fw_preamble *pre;
+	const struct vb2_signature *sig = NULL;
 	struct vb2_digest_context *dc;
 	struct vb2_workbuf wb;
 	uint32_t hash_offset;
@@ -54,13 +54,13 @@
 	/* Get preamble pointer */
 	if (!sd->workbuf_preamble_size)
 		return VB2_ERROR_API_INIT_HASH_PREAMBLE;
-	pre = (const struct vb2_fw_preamble2 *)
+	pre = (const struct vb2_fw_preamble *)
 		(ctx->workbuf + sd->workbuf_preamble_offset);
 
 	/* Find the matching signature */
 	hash_offset = pre->hash_offset;
 	for (i = 0; i < pre->hash_count; i++) {
-		sig = (const struct vb2_signature2 *)
+		sig = (const struct vb2_signature *)
 			((uint8_t *)pre + hash_offset);
 
 		if (!memcmp(guid, &sig->guid, sizeof(*guid)))
@@ -96,7 +96,7 @@
 	return vb2_digest_init(dc, sig->hash_alg);
 }
 
-int vb2api_check_hash2(struct vb2_context *ctx)
+int vb2api_check_hash(struct vb2_context *ctx)
 {
 	struct vb2_shared_data *sd = vb2_get_sd(ctx);
 	struct vb2_digest_context *dc = (struct vb2_digest_context *)
@@ -106,7 +106,7 @@
 	uint8_t *digest;
 	uint32_t digest_size = vb2_digest_size(dc->hash_alg);
 
-	const struct vb2_signature2 *sig;
+	const struct vb2_signature *sig;
 
 	int rv;
 
@@ -115,7 +115,7 @@
 	/* Get signature pointer */
 	if (!sd->hash_tag)
 		return VB2_ERROR_API_CHECK_HASH_TAG;
-	sig = (const struct vb2_signature2 *)(ctx->workbuf + sd->hash_tag);
+	sig = (const struct vb2_signature *)(ctx->workbuf + sd->hash_tag);
 
 	/* Must have initialized hash digest work area */
 	if (!sd->workbuf_hash_size)
diff --git a/firmware/lib21/common.c b/firmware/lib21/common.c
index cf1ec41..5adbf7a 100644
--- a/firmware/lib21/common.c
+++ b/firmware/lib21/common.c
@@ -173,15 +173,14 @@
 	}
 }
 
-int vb2_verify_signature2(const struct vb2_signature2 *sig,
-			  uint32_t size)
+int vb2_verify_signature(const struct vb2_signature *sig, uint32_t size)
 {
 	uint32_t min_offset = 0;
 	uint32_t expect_sig_size;
 	int rv;
 
 	/* Check magic number */
-	if (sig->c.magic != VB2_MAGIC_SIGNATURE2)
+	if (sig->c.magic != VB2_MAGIC_SIGNATURE)
 		return VB2_ERROR_SIG_MAGIC;
 
 	/* Make sure common header is good */
@@ -194,7 +193,7 @@
 	 * that's compatible across readers matching the major version, and we
 	 * haven't added any new fields.
 	 */
-	if (sig->c.struct_version_major != VB2_SIGNATURE2_VERSION_MAJOR)
+	if (sig->c.struct_version_major != VB2_SIGNATURE_VERSION_MAJOR)
 		return VB2_ERROR_SIG_VERSION;
 
 	/* Make sure header is big enough for signature */
@@ -220,15 +219,15 @@
 /**
  * Return the signature data for a signature
  */
-static uint8_t *vb2_signature2_data(struct vb2_signature2 *sig)
+static uint8_t *vb2_signature_data(struct vb2_signature *sig)
 {
 	return (uint8_t *)sig + sig->sig_offset;
 }
 
-int vb2_verify_digest2(const struct vb2_public_key *key,
-		       struct vb2_signature2 *sig,
-		       const uint8_t *digest,
-		       const struct vb2_workbuf *wb)
+int vb2_verify_digest(const struct vb2_public_key *key,
+		      struct vb2_signature *sig,
+		      const uint8_t *digest,
+		      const struct vb2_workbuf *wb)
 {
 	uint32_t key_sig_size = vb2_sig_size(key->sig_alg, key->hash_alg);
 
@@ -245,7 +244,7 @@
 
 	if (key->sig_alg == VB2_SIG_NONE) {
 		/* Bare hash */
-		if (vb2_safe_memcmp(vb2_signature2_data(sig),
+		if (vb2_safe_memcmp(vb2_signature_data(sig),
 				    digest, key_sig_size))
 			return VB2_ERROR_VDATA_VERIFY_DIGEST;
 
@@ -253,16 +252,16 @@
 	} else {
 		/* RSA-signed digest */
 		return vb2_rsa_verify_digest(key,
-					     vb2_signature2_data(sig),
+					     vb2_signature_data(sig),
 					     digest, wb);
 	}
 }
 
-int vb2_verify_data2(const void *data,
-		     uint32_t size,
-		     struct vb2_signature2 *sig,
-		     const struct vb2_public_key *key,
-		     const struct vb2_workbuf *wb)
+int vb2_verify_data(const void *data,
+		    uint32_t size,
+		    struct vb2_signature *sig,
+		    const struct vb2_public_key *key,
+		    const struct vb2_workbuf *wb)
 {
 	struct vb2_workbuf wblocal = *wb;
 	struct vb2_digest_context *dc;
@@ -303,19 +302,19 @@
 
 	vb2_workbuf_free(&wblocal, sizeof(*dc));
 
-	return vb2_verify_digest2(key, sig, digest, &wblocal);
+	return vb2_verify_digest(key, sig, digest, &wblocal);
 }
 
-int vb2_verify_keyblock2(struct vb2_keyblock2 *block,
-			 uint32_t size,
-			 const struct vb2_public_key *key,
-			 const struct vb2_workbuf *wb)
+int vb2_verify_keyblock(struct vb2_keyblock *block,
+			uint32_t size,
+			const struct vb2_public_key *key,
+			const struct vb2_workbuf *wb)
 {
 	uint32_t min_offset = 0, sig_offset;
 	int rv, i;
 
 	/* Check magic number */
-	if (block->c.magic != VB2_MAGIC_KEYBLOCK2)
+	if (block->c.magic != VB2_MAGIC_KEYBLOCK)
 		return VB2_ERROR_KEYBLOCK_MAGIC;
 
 	/* Make sure common header is good */
@@ -328,7 +327,7 @@
 	 * that's compatible across readers matching the major version, and we
 	 * haven't added any new fields.
 	 */
-	if (block->c.struct_version_major != VB2_KEYBLOCK2_VERSION_MAJOR)
+	if (block->c.struct_version_major != VB2_KEYBLOCK_VERSION_MAJOR)
 		return VB2_ERROR_KEYBLOCK_HEADER_VERSION;
 
 	/* Make sure header is big enough */
@@ -343,7 +342,7 @@
 	/* Loop over signatures */
 	sig_offset = block->sig_offset;
 	for (i = 0; i < block->sig_count; i++, sig_offset = min_offset) {
-		struct vb2_signature2 *sig;
+		struct vb2_signature *sig;
 
 		/* Make sure signature is inside keyblock */
 		rv = vb2_verify_common_subobject(block, &min_offset,
@@ -351,11 +350,11 @@
 		if (rv)
 			return rv;
 
-		sig = (struct vb2_signature2 *)((uint8_t *)block + sig_offset);
+		sig = (struct vb2_signature *)((uint8_t *)block + sig_offset);
 
 		/* Verify the signature integrity */
-		rv = vb2_verify_signature2(sig,
-					   block->c.total_size - sig_offset);
+		rv = vb2_verify_signature(sig,
+					  block->c.total_size - sig_offset);
 		if (rv)
 			return rv;
 
@@ -367,24 +366,24 @@
 		if (sig->data_size != block->sig_offset)
 			return VB2_ERROR_KEYBLOCK_SIGNED_SIZE;
 
-		return vb2_verify_data2(block, block->sig_offset, sig, key, wb);
+		return vb2_verify_data(block, block->sig_offset, sig, key, wb);
 	}
 
 	/* If we're still here, no signature matched the key GUID */
 	return VB2_ERROR_KEYBLOCK_SIG_GUID;
 }
 
-int vb2_verify_fw_preamble2(struct vb2_fw_preamble2 *preamble,
-			    uint32_t size,
-			    const struct vb2_public_key *key,
-			    const struct vb2_workbuf *wb)
+int vb2_verify_fw_preamble(struct vb2_fw_preamble *preamble,
+			   uint32_t size,
+			   const struct vb2_public_key *key,
+			   const struct vb2_workbuf *wb)
 {
-	struct vb2_signature2 *sig;
+	struct vb2_signature *sig;
 	uint32_t min_offset = 0, hash_offset;
 	int rv, i;
 
 	/* Check magic number */
-	if (preamble->c.magic != VB2_MAGIC_FW_PREAMBLE2)
+	if (preamble->c.magic != VB2_MAGIC_FW_PREAMBLE)
 		return VB2_ERROR_PREAMBLE_MAGIC;
 
 	/* Make sure common header is good */
@@ -397,7 +396,7 @@
 	 * that's compatible across readers matching the major version, and we
 	 * haven't added any new fields.
 	 */
-	if (preamble->c.struct_version_major != VB2_FW_PREAMBLE2_VERSION_MAJOR)
+	if (preamble->c.struct_version_major != VB2_FW_PREAMBLE_VERSION_MAJOR)
 		return VB2_ERROR_PREAMBLE_HEADER_VERSION;
 
 	/* Make sure header is big enough */
@@ -413,11 +412,11 @@
 		if (rv)
 			return rv;
 
-		sig = (struct vb2_signature2 *)
+		sig = (struct vb2_signature *)
 			((uint8_t *)preamble + hash_offset);
 
 		/* Verify the signature integrity */
-		rv = vb2_verify_signature2(
+		rv = vb2_verify_signature(
 				sig, preamble->c.total_size - hash_offset);
 		if (rv)
 			return rv;
@@ -434,10 +433,10 @@
 		return rv;
 
 	/* Verify preamble signature */
-	sig = (struct vb2_signature2 *)((uint8_t *)preamble +
-					preamble->sig_offset);
+	sig = (struct vb2_signature *)((uint8_t *)preamble +
+				       preamble->sig_offset);
 
-	rv = vb2_verify_data2(preamble, preamble->sig_offset, sig, key, wb);
+	rv = vb2_verify_data(preamble, preamble->sig_offset, sig, key, wb);
 	if (rv)
 		return rv;
 
diff --git a/firmware/lib21/include/vb2_common.h b/firmware/lib21/include/vb2_common.h
index db29604..19b4310 100644
--- a/firmware/lib21/include/vb2_common.h
+++ b/firmware/lib21/include/vb2_common.h
@@ -8,10 +8,8 @@
 #ifndef VBOOT_REFERENCE_VB2_COMMON_H_
 #define VBOOT_REFERENCE_VB2_COMMON_H_
 
-#include "2api.h"
 #include "2common.h"
 #include "2return_codes.h"
-#include "2sha.h"
 #include "2struct.h"
 #include "vb2_struct.h"
 
@@ -87,23 +85,23 @@
  * @param size		Size of buffer in bytes
  * @return VB2_SUCCESS, or non-zero error code if error.
  */
-int vb2_unpack_key2(struct vb2_public_key *key,
-		    const uint8_t *buf,
-		    uint32_t size);
+int vb2_unpack_key(struct vb2_public_key *key,
+		   const uint8_t *buf,
+		   uint32_t size);
 
 /**
  * Unpack the RSA data fields for a public key
  *
- * This is called by vb2_unpack_key2() to extract the arrays from a packed key.
+ * This is called by vb2_unpack_key() to extract the arrays from a packed key.
  * These elements of *key will point inside the key_data buffer.
  *
  * @param key		Destination key for RSA data fields
  * @param key_data	Packed key data (from inside a packed key buffer)
  * @param key_size	Size of packed key data in bytes
  */
-int vb2_unpack_key2_data(struct vb2_public_key *key,
-			 const uint8_t *key_data,
-			 uint32_t key_size);
+int vb2_unpack_key_data(struct vb2_public_key *key,
+			const uint8_t *key_data,
+			uint32_t key_size);
 
 /**
  * Verify the integrity of a signature struct
@@ -111,8 +109,8 @@
  * @param size		Size of buffer containing signature struct
  * @return VB2_SUCCESS, or non-zero if error.
  */
-int vb2_verify_signature2(const struct vb2_signature2 *sig,
-			  uint32_t size);
+int vb2_verify_signature(const struct vb2_signature *sig,
+			 uint32_t size);
 
 /**
  * Verify a signature against an expected hash digest.
@@ -123,10 +121,10 @@
  * @param wb		Work buffer
  * @return VB2_SUCCESS, or non-zero if error.
  */
-int vb2_verify_digest2(const struct vb2_public_key *key,
-		       struct vb2_signature2 *sig,
-		       const uint8_t *digest,
-		       const struct vb2_workbuf *wb);
+int vb2_verify_digest(const struct vb2_public_key *key,
+		      struct vb2_signature *sig,
+		      const uint8_t *digest,
+		      const struct vb2_workbuf *wb);
 
 /**
  * Verify data matches signature.
@@ -139,11 +137,11 @@
  * @param wb		Work buffer
  * @return VB2_SUCCESS, or non-zero error code if error.
  */
-int vb2_verify_data2(const void *data,
-		     uint32_t size,
-		     struct vb2_signature2 *sig,
-		     const struct vb2_public_key *key,
-		     const struct vb2_workbuf *wb);
+int vb2_verify_data(const void *data,
+		    uint32_t size,
+		    struct vb2_signature *sig,
+		    const struct vb2_public_key *key,
+		    const struct vb2_workbuf *wb);
 
 /**
  * Check the sanity of a key block using a public key.
@@ -157,10 +155,10 @@
  * @param wb		Work buffer
  * @return VB2_SUCCESS, or non-zero error code if error.
  */
-int vb2_verify_keyblock2(struct vb2_keyblock2 *block,
-			 uint32_t size,
-			 const struct vb2_public_key *key,
-			 const struct vb2_workbuf *wb);
+int vb2_verify_keyblock(struct vb2_keyblock *block,
+			uint32_t size,
+			const struct vb2_public_key *key,
+			const struct vb2_workbuf *wb);
 
 /**
  * Check the sanity of a firmware preamble using a public key.
@@ -173,9 +171,9 @@
  * @param wb		Work buffer
  * @return VB2_SUCCESS, or non-zero error code if error.
  */
-int vb2_verify_fw_preamble2(struct vb2_fw_preamble2 *preamble,
-			    uint32_t size,
-			    const struct vb2_public_key *key,
-			    const struct vb2_workbuf *wb);
+int vb2_verify_fw_preamble(struct vb2_fw_preamble *preamble,
+			   uint32_t size,
+			   const struct vb2_public_key *key,
+			   const struct vb2_workbuf *wb);
 
 #endif  /* VBOOT_REFERENCE_VB2_COMMON_H_ */
diff --git a/firmware/lib21/include/vb2_struct.h b/firmware/lib21/include/vb2_struct.h
index 4bf4da7..d9921d9 100644
--- a/firmware/lib21/include/vb2_struct.h
+++ b/firmware/lib21/include/vb2_struct.h
@@ -23,23 +23,23 @@
  * structs as invalid.
  */
 enum vb2_struct_common_magic {
-	/* "Vb2B" = vb2_keyblock2.c.magic */
-	VB2_MAGIC_KEYBLOCK2		= 0x42326256,
+	/* "Vb2B" = vb2_keyblock.c.magic */
+	VB2_MAGIC_KEYBLOCK		= 0x42326256,
 
 	/* "Vb2F" = vb2_fw_preamble.c.magic */
-	VB2_MAGIC_FW_PREAMBLE2		= 0x46326256,
+	VB2_MAGIC_FW_PREAMBLE		= 0x46326256,
 
-	/* "Vb2I" = vb2_packed_private_key2.c.magic */
-	VB2_MAGIC_PACKED_PRIVATE_KEY2	= 0x49326256,
+	/* "Vb2I" = vb2_packed_private_key.c.magic */
+	VB2_MAGIC_PACKED_PRIVATE_KEY	= 0x49326256,
 
 	/* "Vb2K" = vb2_kernel_preamble.c.magic */
-	VB2_MAGIC_KERNEL_PREAMBLE2	= 0x4b326256,
+	VB2_MAGIC_KERNEL_PREAMBLE	= 0x4b326256,
 
-	/* "Vb2P" = vb2_packed_key2.c.magic */
-	VB2_MAGIC_PACKED_KEY2		= 0x50326256,
+	/* "Vb2P" = vb2_packed_key.c.magic */
+	VB2_MAGIC_PACKED_KEY		= 0x50326256,
 
 	/* "Vb2S" = vb2_signature.c.magic */
-	VB2_MAGIC_SIGNATURE2		= 0x53326256,
+	VB2_MAGIC_SIGNATURE		= 0x53326256,
 };
 
 
@@ -102,19 +102,19 @@
 
 #define EXPECTED_VB2_STRUCT_COMMON_SIZE 20
 
-/* Current version of vb2_packed_key2 struct */
-#define VB2_PACKED_KEY2_VERSION_MAJOR 3
-#define VB2_PACKED_KEY2_VERSION_MINOR 0
+/* Current version of vb2_packed_key struct */
+#define VB2_PACKED_KEY_VERSION_MAJOR 3
+#define VB2_PACKED_KEY_VERSION_MINOR 0
 
 /*
- * Packed public key data, version 2
+ * Packed public key data
  *
  * The key data must be arranged like this:
- *     1) vb2_packed_key2 header struct h
+ *     1) vb2_packed_key header struct h
  *     2) Key description (pointed to by h.c.fixed_size)
  *     3) Key data key (pointed to by h.key_offset)
  */
-struct vb2_packed_key2 {
+struct vb2_packed_key {
 	/* Common header fields */
 	struct vb2_struct_common c;
 
@@ -141,22 +141,22 @@
 	struct vb2_guid guid;
 } __attribute__((packed));
 
-#define EXPECTED_VB2_PACKED_KEY2_SIZE					\
+#define EXPECTED_VB2_PACKED_KEY_SIZE					\
 	(EXPECTED_VB2_STRUCT_COMMON_SIZE + EXPECTED_GUID_SIZE + 16)
 
-/* Current version of vb2_packed_private_key2 struct */
-#define VB2_PACKED_PRIVATE_KEY2_VERSION_MAJOR 3
-#define VB2_PACKED_PRIVATE_KEY2_VERSION_MINOR 0
+/* Current version of vb2_packed_private_key struct */
+#define VB2_PACKED_PRIVATE_KEY_VERSION_MAJOR 3
+#define VB2_PACKED_PRIVATE_KEY_VERSION_MINOR 0
 
 /*
- * Packed private key data, version 2
+ * Packed private key data
  *
  * The key data must be arranged like this:
- *     1) vb2_packed_private_key2 header struct h
+ *     1) vb2_packed_private_key header struct h
  *     2) Key description (pointed to by h.c.fixed_size)
  *     3) Key data key (pointed to by h.key_offset)
  */
-struct vb2_packed_private_key2 {
+struct vb2_packed_private_key {
 	/* Common header fields */
 	struct vb2_struct_common c;
 
@@ -180,22 +180,22 @@
 	struct vb2_guid guid;
 } __attribute__((packed));
 
-#define EXPECTED_VB2_PACKED_PRIVATE_KEY2_SIZE				\
+#define EXPECTED_VB2_PACKED_PRIVATE_KEY_SIZE				\
 	(EXPECTED_VB2_STRUCT_COMMON_SIZE + EXPECTED_GUID_SIZE + 12)
 
-/* Current version of vb2_signature2 struct */
-#define VB2_SIGNATURE2_VERSION_MAJOR 3
-#define VB2_SIGNATURE2_VERSION_MINOR 0
+/* Current version of vb2_signature struct */
+#define VB2_SIGNATURE_VERSION_MAJOR 3
+#define VB2_SIGNATURE_VERSION_MINOR 0
 
 /*
- * Signature data, version 2
+ * Signature data
  *
  * The signature data must be arranged like this:
- *     1) vb2_signature2 header struct h
+ *     1) vb2_signature header struct h
  *     2) Signature description (pointed to by h.c.fixed_size)
  *     3) Signature data (pointed to by h.sig_offset)
  */
-struct vb2_signature2 {
+struct vb2_signature {
 	/* Common header fields */
 	struct vb2_struct_common c;
 
@@ -228,20 +228,20 @@
 	struct vb2_guid guid;
 } __attribute__((packed));
 
-#define EXPECTED_VB2_SIGNATURE2_SIZE					\
+#define EXPECTED_VB2_SIGNATURE_SIZE					\
 	(EXPECTED_VB2_STRUCT_COMMON_SIZE + EXPECTED_GUID_SIZE + 16)
 
 
-/* Current version of vb2_keyblock2 struct */
-#define VB2_KEYBLOCK2_VERSION_MAJOR 3
-#define VB2_KEYBLOCK2_VERSION_MINOR 0
+/* Current version of vb2_keyblock struct */
+#define VB2_KEYBLOCK_VERSION_MAJOR 3
+#define VB2_KEYBLOCK_VERSION_MINOR 0
 
 /*
  * Key block.  This contains a signed, versioned key for use in the next stage
  * of verified boot.
  *
  * The key block data must be arranged like this:
- *     1) vb2_keyblock2 header struct h
+ *     1) vb2_keyblock header struct h
  *     2) Keyblock description (pointed to by h.c.fixed_size)
  *     3) Data key (pointed to by h.data_key_offset)
  *     4) Signatures (first signature pointed to by h.sig_offset)
@@ -249,7 +249,7 @@
  * The signatures from 4) must cover all the data from 1), 2), 3).  That is,
  * signatures must sign all data up to sig_offset.
  */
-struct vb2_keyblock2 {
+struct vb2_keyblock {
 	/* Common header fields */
 	struct vb2_struct_common c;
 
@@ -257,7 +257,7 @@
 	uint32_t flags;
 
 	/*
-	 * Offset of key (struct vb2_packed_key2) to use in next stage of
+	 * Offset of key (struct vb2_packed_key) to use in next stage of
 	 * verification, from start of the keyblock.
 	 */
 	uint32_t key_offset;
@@ -266,7 +266,7 @@
 	uint32_t sig_count;
 
 	/*
-	 * Offset of the first signature (struct vb2_signature2) from the start
+	 * Offset of the first signature (struct vb2_signature) from the start
 	 * of the keyblock.
 	 *
 	 * Signatures sign the contents of this struct and the data pointed to
@@ -284,25 +284,25 @@
 	uint32_t sig_offset;
 } __attribute__((packed));
 
-#define EXPECTED_VB2_KEYBLOCK2_SIZE (EXPECTED_VB2_STRUCT_COMMON_SIZE + 16)
+#define EXPECTED_VB2_KEYBLOCK_SIZE (EXPECTED_VB2_STRUCT_COMMON_SIZE + 16)
 
 
-/* Current version of vb2_fw_preamble2 struct */
-#define VB2_FW_PREAMBLE2_VERSION_MAJOR 3
-#define VB2_FW_PREAMBLE2_VERSION_MINOR 0
+/* Current version of vb2_fw_preamble struct */
+#define VB2_FW_PREAMBLE_VERSION_MAJOR 3
+#define VB2_FW_PREAMBLE_VERSION_MINOR 0
 
 /*
  * Firmware preamble
  *
  * The preamble data must be arranged like this:
- *     1) vb2_fw_preamble2 header struct h
+ *     1) vb2_fw_preamble header struct h
  *     2) Preamble description (pointed to by h.c.fixed_size)
  *     3) Hashes (pointed to by h.hash_offset)
  *     4) Signature (pointed to by h.sig_offset)
  *
  * The signature 4) must cover all the data from 1), 2), 3).
  */
-struct vb2_fw_preamble2 {
+struct vb2_fw_preamble {
 	/* Common header fields */
 	struct vb2_struct_common c;
 
@@ -310,13 +310,13 @@
 	uint32_t flags;
 
 	/* Firmware version */
-	uint32_t firmware_version;
+	uint32_t fw_version;
 
-	/* Offset of signature (struct vb2_signature2) for this preamble */
+	/* Offset of signature (struct vb2_signature) for this preamble */
 	uint32_t sig_offset;
 
 	/*
-	 * The preamble contains a list of hashes (struct vb2_signature2) for
+	 * The preamble contains a list of hashes (struct vb2_signature) for
 	 * the various firmware components.  These have sig_alg=VB2_SIG_NONE,
 	 * and the GUID for each hash identifies the component being hashed.
 	 * The calling firmware is responsible for knowing where to find those
@@ -331,6 +331,6 @@
 	uint32_t hash_offset;
 } __attribute__((packed));
 
-#define EXPECTED_VB2_FW_PREAMBLE2_SIZE (EXPECTED_VB2_STRUCT_COMMON_SIZE + 20)
+#define EXPECTED_VB2_FW_PREAMBLE_SIZE (EXPECTED_VB2_STRUCT_COMMON_SIZE + 20)
 
 #endif  /* VBOOT_REFERENCE_VB2_STRUCT_H_ */
diff --git a/firmware/lib21/misc.c b/firmware/lib21/misc.c
index 16648a7..384d44e 100644
--- a/firmware/lib21/misc.c
+++ b/firmware/lib21/misc.c
@@ -62,16 +62,16 @@
 	return VB2_SUCCESS;
 }
 
-int vb2_load_fw_keyblock2(struct vb2_context *ctx)
+int vb2_load_fw_keyblock(struct vb2_context *ctx)
 {
 	struct vb2_shared_data *sd = vb2_get_sd(ctx);
 	struct vb2_workbuf wb;
 
 	uint8_t *key_data;
 	uint32_t key_size;
-	struct vb2_packed_key2 *packed_key;
+	struct vb2_packed_key *packed_key;
 	struct vb2_public_key root_key;
-	struct vb2_keyblock2 *kb;
+	struct vb2_keyblock *kb;
 
 	uint32_t sec_version;
 	int rv;
@@ -90,7 +90,7 @@
 		return rv;
 
 	/* Unpack the root key */
-	rv = vb2_unpack_key2(&root_key, key_data, key_size);
+	rv = vb2_unpack_key(&root_key, key_data, key_size);
 	if (rv)
 		return rv;
 
@@ -104,7 +104,7 @@
 		return rv;
 
 	/* Verify the keyblock */
-	rv = vb2_verify_keyblock2(kb, kb->c.total_size, &root_key, &wb);
+	rv = vb2_verify_keyblock(kb, kb->c.total_size, &root_key, &wb);
 	if (rv)
 		return rv;
 
@@ -116,7 +116,7 @@
 	if (rv)
 		return rv;
 
-	packed_key = (struct vb2_packed_key2 *)((uint8_t *)kb + kb->key_offset);
+	packed_key = (struct vb2_packed_key *)((uint8_t *)kb + kb->key_offset);
 
 	/* Key version is the upper 16 bits of the composite firmware version */
 	if (packed_key->key_version > 0xffff)
@@ -137,7 +137,7 @@
 	 * paranoid.
 	 */
 	memmove(key_data, packed_key, packed_key->c.total_size);
-	packed_key = (struct vb2_packed_key2 *)key_data;
+	packed_key = (struct vb2_packed_key *)key_data;
 
 	/* Save the packed key offset and size */
 	sd->workbuf_data_key_offset = vb2_offset_of(ctx->workbuf, key_data);
@@ -150,7 +150,7 @@
 	return VB2_SUCCESS;
 }
 
-int vb2_load_fw_preamble2(struct vb2_context *ctx)
+int vb2_load_fw_preamble(struct vb2_context *ctx)
 {
 	struct vb2_shared_data *sd = vb2_get_sd(ctx);
 	struct vb2_workbuf wb;
@@ -160,7 +160,7 @@
 	struct vb2_public_key data_key;
 
 	/* Preamble goes in the next unused chunk of work buffer */
-	struct vb2_fw_preamble2 *pre;
+	struct vb2_fw_preamble *pre;
 
 	uint32_t sec_version;
 	int rv;
@@ -171,7 +171,7 @@
 	if (!sd->workbuf_data_key_size)
 		return VB2_ERROR_FW_PREAMBLE2_DATA_KEY;
 
-	rv = vb2_unpack_key2(&data_key, key_data, key_size);
+	rv = vb2_unpack_key(&data_key, key_data, key_size);
 	if (rv)
 		return rv;
 
@@ -185,13 +185,13 @@
 	/* Work buffer now contains the data subkey data and the preamble */
 
 	/* Verify the preamble */
-	rv = vb2_verify_fw_preamble2(pre, pre->c.total_size, &data_key, &wb);
+	rv = vb2_verify_fw_preamble(pre, pre->c.total_size, &data_key, &wb);
 	if (rv)
 		return rv;
 
 	/* Move the preamble down now that the data key is no longer used */
 	memmove(key_data, pre, pre->c.total_size);
-	pre = (struct vb2_fw_preamble2 *)key_data;
+	pre = (struct vb2_fw_preamble *)key_data;
 
 	/* Data key is now gone */
 	sd->workbuf_data_key_offset = sd->workbuf_data_key_size = 0;
@@ -205,13 +205,13 @@
 	 * Firmware version is the lower 16 bits of the composite firmware
 	 * version.
 	 */
-	if (pre->firmware_version > 0xffff)
-		return VB2_ERROR_FW_PREAMBLE2_VERSION_RANGE;
+	if (pre->fw_version > 0xffff)
+		return VB2_ERROR_FW_PREAMBLE_VERSION_RANGE;
 
 	/* Combine with the key version from vb2_load_fw_keyblock() */
-	sd->fw_version |= pre->firmware_version;
+	sd->fw_version |= pre->fw_version;
 	if (sd->fw_version < sec_version)
-		return VB2_ERROR_FW_PREAMBLE2_VERSION_ROLLBACK;
+		return VB2_ERROR_FW_PREAMBLE_VERSION_ROLLBACK;
 
 	/*
 	 * If this is a newer version than in secure storage, and we
diff --git a/firmware/lib21/packed_key.c b/firmware/lib21/packed_key.c
index 3974b5f..f7f2de9 100644
--- a/firmware/lib21/packed_key.c
+++ b/firmware/lib21/packed_key.c
@@ -10,7 +10,7 @@
 #include "2rsa.h"
 #include "vb2_common.h"
 
-int vb2_unpack_key2_data(struct vb2_public_key *key,
+int vb2_unpack_key_data(struct vb2_public_key *key,
 			 const uint8_t *key_data,
 			 uint32_t key_size)
 {
@@ -42,18 +42,18 @@
 	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)
 {
-	const struct vb2_packed_key2 *pkey =
-		(const struct vb2_packed_key2 *)buf;
+	const struct vb2_packed_key *pkey =
+		(const struct vb2_packed_key *)buf;
 	uint32_t sig_size;
 	uint32_t min_offset = 0;
 	int rv;
 
 	/* Check magic number */
-	if (pkey->c.magic != VB2_MAGIC_PACKED_KEY2)
+	if (pkey->c.magic != VB2_MAGIC_PACKED_KEY)
 		return VB2_ERROR_UNPACK_KEY_MAGIC;
 
 	rv = vb2_verify_common_header(buf, size);
@@ -71,7 +71,7 @@
 	 * that's compatible across readers matching the major version, and we
 	 * haven't added any new fields.
 	 */
-	if (pkey->c.struct_version_major != VB2_PACKED_KEY2_VERSION_MAJOR)
+	if (pkey->c.struct_version_major != VB2_PACKED_KEY_VERSION_MAJOR)
 		return VB2_ERROR_UNPACK_KEY_STRUCT_VERSION;
 
 	/* Copy key algorithms */
@@ -84,7 +84,7 @@
 		sig_size = vb2_rsa_sig_size(key->sig_alg);
 		if (!sig_size)
 			return VB2_ERROR_UNPACK_KEY_SIG_ALGORITHM;
-		rv = vb2_unpack_key2_data(
+		rv = vb2_unpack_key_data(
 				key,
 				(const uint8_t *)pkey + pkey->key_offset,
 				pkey->key_size);
diff --git a/host/lib21/host_fw_preamble.c b/host/lib21/host_fw_preamble.c
index 557c157..6b5686b 100644
--- a/host/lib21/host_fw_preamble.c
+++ b/host/lib21/host_fw_preamble.c
@@ -16,22 +16,22 @@
 #include "host_signature2.h"
 #include "vb2_common.h"
 
-int vb2_fw_preamble_create(struct vb2_fw_preamble2 **fp_ptr,
+int vb2_fw_preamble_create(struct vb2_fw_preamble **fp_ptr,
 			   const struct vb2_private_key *signing_key,
-			   const struct vb2_signature2 **hash_list,
+			   const struct vb2_signature **hash_list,
 			   uint32_t hash_count,
 			   uint32_t fw_version,
 			   uint32_t flags,
 			   const char *desc)
 {
-	struct vb2_fw_preamble2 fp = {
-		.c.magic = VB2_MAGIC_FW_PREAMBLE2,
-		.c.struct_version_major = VB2_FW_PREAMBLE2_VERSION_MAJOR,
-		.c.struct_version_minor = VB2_FW_PREAMBLE2_VERSION_MAJOR,
+	struct vb2_fw_preamble fp = {
+		.c.magic = VB2_MAGIC_FW_PREAMBLE,
+		.c.struct_version_major = VB2_FW_PREAMBLE_VERSION_MAJOR,
+		.c.struct_version_minor = VB2_FW_PREAMBLE_VERSION_MAJOR,
 		.c.fixed_size = sizeof(fp),
 		.c.desc_size = vb2_desc_size(desc),
 		.flags = flags,
-		.firmware_version = fw_version,
+		.fw_version = fw_version,
 		.hash_count = hash_count,
 	};
 
@@ -77,6 +77,6 @@
 		return VB2_FW_PREAMBLE_CREATE_SIGN;
 	}
 
-	*fp_ptr = (struct vb2_fw_preamble2 *)buf;
+	*fp_ptr = (struct vb2_fw_preamble *)buf;
 	return VB2_SUCCESS;
 }
diff --git a/host/lib21/host_key.c b/host/lib21/host_key.c
index 5fc4188..1f45683 100644
--- a/host/lib21/host_key.c
+++ b/host/lib21/host_key.c
@@ -38,8 +38,8 @@
 			   const uint8_t *buf,
 			   uint32_t size)
 {
-	const struct vb2_packed_private_key2 *pkey =
-		(const struct vb2_packed_private_key2 *)buf;
+	const struct vb2_packed_private_key *pkey =
+		(const struct vb2_packed_private_key *)buf;
 	struct vb2_private_key *key;
 	const unsigned char *start;
 	uint32_t min_offset = 0;
@@ -51,7 +51,7 @@
 	 *
 	 * TODO: If it doesn't match, pass through to the old packed key format.
 	 */
-	if (pkey->c.magic != VB2_MAGIC_PACKED_PRIVATE_KEY2)
+	if (pkey->c.magic != VB2_MAGIC_PACKED_PRIVATE_KEY)
 		return VB2_ERROR_UNPACK_PRIVATE_KEY_MAGIC;
 
 	if (vb2_verify_common_header(buf, size))
@@ -68,7 +68,7 @@
 	 * haven't added any new fields.
 	 */
 	if (pkey->c.struct_version_major !=
-	    VB2_PACKED_PRIVATE_KEY2_VERSION_MAJOR)
+	    VB2_PACKED_PRIVATE_KEY_VERSION_MAJOR)
 		return VB2_ERROR_UNPACK_PRIVATE_KEY_STRUCT_VERSION;
 
 	/* Allocate the new key */
@@ -179,10 +179,10 @@
 int vb2_private_key_write(const struct vb2_private_key *key,
 			  const char *filename)
 {
-	struct vb2_packed_private_key2 pkey = {
-		.c.magic = VB2_MAGIC_PACKED_PRIVATE_KEY2,
-		.c.struct_version_major = VB2_PACKED_PRIVATE_KEY2_VERSION_MAJOR,
-		.c.struct_version_minor = VB2_PACKED_PRIVATE_KEY2_VERSION_MINOR,
+	struct vb2_packed_private_key pkey = {
+		.c.magic = VB2_MAGIC_PACKED_PRIVATE_KEY,
+		.c.struct_version_major = VB2_PACKED_PRIVATE_KEY_VERSION_MAJOR,
+		.c.struct_version_minor = VB2_PACKED_PRIVATE_KEY_VERSION_MINOR,
 		.c.fixed_size = sizeof(pkey),
 		.sig_alg = key->sig_alg,
 		.hash_alg = key->hash_alg,
@@ -369,7 +369,7 @@
 	memcpy(key_buf, key_data, key_size);
 	free(key_data);
 
-	if (vb2_unpack_key2_data(key, key_buf, key_size)) {
+	if (vb2_unpack_key_data(key, key_buf, key_size)) {
 		vb2_public_key_free(key);
 		return VB2_ERROR_READ_KEYB_UNPACK;
 	}
@@ -395,8 +395,8 @@
 	return VB2_SUCCESS;
 }
 
-int vb2_packed_key2_read(struct vb2_packed_key2 **key_ptr,
-			 const char *filename)
+int vb2_packed_key_read(struct vb2_packed_key **key_ptr,
+			const char *filename)
 {
 	struct vb2_public_key key;
 	uint8_t *buf;
@@ -408,21 +408,21 @@
 		return VB2_ERROR_READ_PACKED_KEY_DATA;
 
 	/* Sanity check: make sure key unpacks properly */
-	if (vb2_unpack_key2(&key, buf, size))
+	if (vb2_unpack_key(&key, buf, size))
 		return VB2_ERROR_READ_PACKED_KEY;
 
-	*key_ptr = (struct vb2_packed_key2 *)buf;
+	*key_ptr = (struct vb2_packed_key *)buf;
 
 	return VB2_SUCCESS;
 }
 
-int vb2_public_key_pack(struct vb2_packed_key2 **key_ptr,
+int vb2_public_key_pack(struct vb2_packed_key **key_ptr,
 			const struct vb2_public_key *pubk)
 {
-	struct vb2_packed_key2 key = {
-		.c.magic = VB2_MAGIC_PACKED_KEY2,
-		.c.struct_version_major = VB2_PACKED_KEY2_VERSION_MAJOR,
-		.c.struct_version_minor = VB2_PACKED_KEY2_VERSION_MINOR,
+	struct vb2_packed_key key = {
+		.c.magic = VB2_MAGIC_PACKED_KEY,
+		.c.struct_version_major = VB2_PACKED_KEY_VERSION_MAJOR,
+		.c.struct_version_minor = VB2_PACKED_KEY_VERSION_MINOR,
 	};
 	uint8_t *buf;
 	uint32_t *buf32;
@@ -470,7 +470,7 @@
 		       pubk->arrsize * sizeof(uint32_t));
 	}
 
-	*key_ptr = (struct vb2_packed_key2 *)buf;
+	*key_ptr = (struct vb2_packed_key *)buf;
 
 	return VB2_SUCCESS;
 }
diff --git a/host/lib21/host_keyblock.c b/host/lib21/host_keyblock.c
index f242cdd..42b91c7 100644
--- a/host/lib21/host_keyblock.c
+++ b/host/lib21/host_keyblock.c
@@ -15,23 +15,23 @@
 #include "host_misc.h"
 #include "host_signature2.h"
 
-int vb2_keyblock_create(struct vb2_keyblock2 **kb_ptr,
+int vb2_keyblock_create(struct vb2_keyblock **kb_ptr,
 			const struct vb2_public_key *data_key,
 			const struct vb2_private_key **signing_keys,
 			uint32_t signing_key_count,
 			uint32_t flags,
 			const char *desc)
 {
-	struct vb2_keyblock2 kb = {
-		.c.magic = VB2_MAGIC_KEYBLOCK2,
-		.c.struct_version_major = VB2_KEYBLOCK2_VERSION_MAJOR,
-		.c.struct_version_minor = VB2_KEYBLOCK2_VERSION_MAJOR,
+	struct vb2_keyblock kb = {
+		.c.magic = VB2_MAGIC_KEYBLOCK,
+		.c.struct_version_major = VB2_KEYBLOCK_VERSION_MAJOR,
+		.c.struct_version_minor = VB2_KEYBLOCK_VERSION_MAJOR,
 		.c.fixed_size = sizeof(kb),
 		.flags = flags,
 		.sig_count = signing_key_count,
 	};
 
-	struct vb2_packed_key2 *key = NULL;
+	struct vb2_packed_key *key = NULL;
 	uint32_t sig_size;
 	uint8_t *buf;
 
@@ -72,6 +72,6 @@
 		return VB2_KEYBLOCK_CREATE_SIGN;
 	}
 
-	*kb_ptr = (struct vb2_keyblock2 *)buf;
+	*kb_ptr = (struct vb2_keyblock *)buf;
 	return VB2_SUCCESS;
 }
diff --git a/host/lib21/host_signature.c b/host/lib21/host_signature.c
index 9ffb3a8..553aa38 100644
--- a/host/lib21/host_signature.c
+++ b/host/lib21/host_signature.c
@@ -79,16 +79,16 @@
 	}
 }
 
-int vb2_sign_data(struct vb2_signature2 **sig_ptr,
+int vb2_sign_data(struct vb2_signature **sig_ptr,
 		  const uint8_t *data,
 		  uint32_t size,
 		  const struct vb2_private_key *key,
 		  const char *desc)
 {
-	struct vb2_signature2 s = {
-		.c.magic = VB2_MAGIC_SIGNATURE2,
-		.c.struct_version_major = VB2_SIGNATURE2_VERSION_MAJOR,
-		.c.struct_version_minor = VB2_SIGNATURE2_VERSION_MINOR,
+	struct vb2_signature s = {
+		.c.magic = VB2_MAGIC_SIGNATURE,
+		.c.struct_version_major = VB2_SIGNATURE_VERSION_MAJOR,
+		.c.struct_version_minor = VB2_SIGNATURE_VERSION_MINOR,
 		.c.fixed_size = sizeof(s),
 		.sig_alg = key->sig_alg,
 		.hash_alg = key->hash_alg,
@@ -179,7 +179,7 @@
 	}
 
 	free(sig_digest);
-	*sig_ptr = (struct vb2_signature2 *)buf;
+	*sig_ptr = (struct vb2_signature *)buf;
 	return VB2_SUCCESS;
 }
 
@@ -192,7 +192,7 @@
 	if (!size)
 		return VB2_ERROR_SIG_SIZE_FOR_KEY;
 
-	size += sizeof(struct vb2_signature2);
+	size += sizeof(struct vb2_signature);
 	size += vb2_desc_size(desc ? desc : key->desc);
 
 	*size_ptr = size;
@@ -225,7 +225,7 @@
 		    const char *desc)
 {
 	struct vb2_struct_common *c = (struct vb2_struct_common *)buf;
-	struct vb2_signature2 *sig = NULL;
+	struct vb2_signature *sig = NULL;
 	int rv;
 
 	rv = vb2_sign_data(&sig, buf, sig_offset, key, desc);
@@ -253,7 +253,7 @@
 	int rv, i;
 
 	for (i = 0; i < key_count; i++)	{
-		struct vb2_signature2 *sig = NULL;
+		struct vb2_signature *sig = NULL;
 
 		rv = vb2_sign_data(&sig, buf, sig_offset, key_list[i], NULL);
 		if (rv)
diff --git a/host/lib21/include/host_fw_preamble2.h b/host/lib21/include/host_fw_preamble2.h
index 5264449..9723441 100644
--- a/host/lib21/include/host_fw_preamble2.h
+++ b/host/lib21/include/host_fw_preamble2.h
@@ -25,9 +25,9 @@
  * @param desc		Description for preamble, or NULL if none
  * @return VB2_SUCCESS, or non-zero error code if failure.
  */
-int vb2_fw_preamble_create(struct vb2_fw_preamble2 **fp_ptr,
+int vb2_fw_preamble_create(struct vb2_fw_preamble **fp_ptr,
 			   const struct vb2_private_key *signing_key,
-			   const struct vb2_signature2 **hash_list,
+			   const struct vb2_signature **hash_list,
 			   uint32_t hash_count,
 			   uint32_t fw_version,
 			   uint32_t flags,
diff --git a/host/lib21/include/host_key2.h b/host/lib21/include/host_key2.h
index 96dab3e..7c48dca 100644
--- a/host/lib21/include/host_key2.h
+++ b/host/lib21/include/host_key2.h
@@ -29,7 +29,7 @@
 void vb2_private_key_free(struct vb2_private_key *key);
 
 /**
- * Unpack a private key from vb2_packed_private_key2 format.
+ * Unpack a private key from vb2_packed_private_key format.
  *
  * @param key_ptr	Destination for newly allocated key; this must be
  *			freed with vb2_private_key_free().
@@ -42,7 +42,7 @@
 			   uint32_t size);
 
 /**
- * Read a private key from vb2_packed_private_key2 format.
+ * Read a private key from vb2_packed_private_key format.
  *
  * @param key_ptr	Destination for newly allocated key; this must be
  *			freed with vb2_private_key_free().
@@ -76,7 +76,7 @@
 int vb2_private_key_set_desc(struct vb2_private_key *key, const char *desc);
 
 /**
- * Write a private key to vb2_packed_private_key2 format.
+ * Write a private key to vb2_packed_private_key format.
  *
  * @param key		Key to write
  * @param filename	File to write key data to.
@@ -101,7 +101,7 @@
  *
  * Note that this should ONLY be called for public keys allocated via one
  * of those functions; public keys created or filled in other ways (such as
- * vb2_unpack_key2()) do not allocate memory for sub-fields in the same way.
+ * vb2_unpack_key()) do not allocate memory for sub-fields in the same way.
  *
  * @param key		Key to free
  */
@@ -133,17 +133,17 @@
 int vb2_public_key_set_desc(struct vb2_public_key *key, const char *desc);
 
 /**
- * Read a public key in vb2_packed_key2 format.
+ * Read a public key in vb2_packed_key format.
  *
  * @param key_ptr	On success, points to the newly allocated key buffer.
  *			Caller is responsible for calling free() on this.
  * @return VB2_SUCCESS, or non-zero if error.
  */
-int vb2_packed_key2_read(struct vb2_packed_key2 **key_ptr,
+int vb2_packed_key_read(struct vb2_packed_key **key_ptr,
 			 const char *filename);
 
 /**
- * Pack a public key into vb2_packed_key2 format.
+ * Pack a public key into vb2_packed_key format.
  *
  * @param pubk		Public key to pack
  * @param key_ptr	On success, points to a newly allocated packed key
@@ -151,7 +151,7 @@
  *			this.
  * @return VB2_SUCCESS, or non-zero if error.
  */
-int vb2_public_key_pack(struct vb2_packed_key2 **key_ptr,
+int vb2_public_key_pack(struct vb2_packed_key **key_ptr,
 			const struct vb2_public_key *pubk);
 
 /**
diff --git a/host/lib21/include/host_keyblock2.h b/host/lib21/include/host_keyblock2.h
index 5b05ab1..23d3484 100644
--- a/host/lib21/include/host_keyblock2.h
+++ b/host/lib21/include/host_keyblock2.h
@@ -26,7 +26,7 @@
  *			taken from the data key.
  * @return VB2_SUCCESS, or non-zero error code if failure.
  */
-int vb2_keyblock_create(struct vb2_keyblock2 **kb_ptr,
+int vb2_keyblock_create(struct vb2_keyblock **kb_ptr,
 			const struct vb2_public_key *data_key,
 			const struct vb2_private_key **signing_keys,
 			uint32_t signing_key_count,
diff --git a/host/lib21/include/host_signature2.h b/host/lib21/include/host_signature2.h
index 2e5718b..aecd6df 100644
--- a/host/lib21/include/host_signature2.h
+++ b/host/lib21/include/host_signature2.h
@@ -24,7 +24,7 @@
  *			key description will be used.
  * @return VB2_SUCCESS, or non-zero error code on failure.
  */
-int vb2_sign_data(struct vb2_signature2 **sig_ptr,
+int vb2_sign_data(struct vb2_signature **sig_ptr,
 		  const uint8_t *data,
 		  uint32_t size,
 		  const struct vb2_private_key *key,
diff --git a/tests/vb20_misc_tests.c b/tests/vb20_misc_tests.c
index aa602ac..b291b4d 100644
--- a/tests/vb20_misc_tests.c
+++ b/tests/vb20_misc_tests.c
@@ -333,13 +333,13 @@
 	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 52ca0d9..6c4e48d 100644
--- a/tests/vb21_api_tests.c
+++ b/tests/vb21_api_tests.c
@@ -54,8 +54,8 @@
 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 @@
 	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 @@
 
 /* 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 @@
 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 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 510665e..199a063 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 @@
 	 */
 	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 @@
 	/* 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 @@
 	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 @@
 	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 39df168..7444025 100644
--- a/tests/vb21_common_tests.c
+++ b/tests/vb21_common_tests.c
@@ -33,18 +33,18 @@
 	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_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 @@
 		  "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 @@
 	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 @@
 	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 @@
 	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 @@
 {
 	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 @@
 
 	/*
 	 * 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 @@
 
 	/* 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 @@
 	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 @@
 	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 1cd0a9a..8bb83d0 100644
--- a/tests/vb21_host_fw_preamble_tests.c
+++ b/tests/vb21_host_fw_preamble_tests.c
@@ -29,9 +29,9 @@
 {
 	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 @@
 
 	/* 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 @@
 	/* 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 ed4c44b..6a01d72 100644
--- a/tests/vb21_host_key_tests.c
+++ b/tests/vb21_host_key_tests.c
@@ -35,7 +35,7 @@
 {
 	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 @@
 	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 @@
 	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 @@
 			     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 @@
 	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 @@
 	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 @@
 	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 @@
 
 	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 11a75d7..95dbe98 100644
--- a/tests/vb21_host_keyblock_tests.c
+++ b/tests/vb21_host_keyblock_tests.c
@@ -22,8 +22,8 @@
 {
 	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 @@
 	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 @@
 	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 5c1176a..66e9155 100644
--- a/tests/vb21_host_sig_tests.c
+++ b/tests/vb21_host_sig_tests.c
@@ -43,7 +43,7 @@
 	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 @@
 	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 @@
 
 	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 @@
 	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 @@
 
 	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 03b8e4f..ff3f276 100644
--- a/tests/vb21_misc_tests.c
+++ b/tests/vb21_misc_tests.c
@@ -28,21 +28,21 @@
 
 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 @@
 
 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 @@
 	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 @@
 	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 @@
 	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 @@
 
 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 @@
 		"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 @@
 	/* 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 @@
 	/* 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");