Repository: chipsalliance/caliptra-sw
Pull request #532 (2023-07-22 00:19:41)

[feat] Make LMS verification dependent on a fuse.
This change adds the following:
	1. LMS verification based on lms_verify fuse.
	2. LMS vendor public key revocation check.
	3. Logging of the LMS vendor and owner public key indices and vendor public key revocation fuse to fuse log.
	4. Tests.

Note: Updating vendor key count to 32 will come as a separate PR.


Patch:
diff --git a/common/src/fuse.rs b/common/src/fuse.rs
index 3841343e..3a7b79b1 100644
--- a/common/src/fuse.rs
+++ b/common/src/fuse.rs
@@ -18,27 +18,33 @@ use zerocopy::{AsBytes, FromBytes};
 
 pub enum FuseLogEntryId {
     Invalid = 0,
-    VendorPubKeyIndex = 1,      // 4 bytes  (From Manifest)
-    VendorPubKeyRevocation = 2, // 4 bytes  (From Fuse)
-    ManifestFmcSvn = 3,         // 4 bytes
-    ManifestFmcMinSvn = 4,      // 4 bytes
-    FuseFmcSvn = 5,             // 4 bytes
-    ManifestRtSvn = 6,          // 4 bytes
-    ManifestRtMinSvn = 7,       // 4 bytes
-    FuseRtSvn = 8,              // 4 bytes
+    VendorEccPubKeyIndex = 1,       // 4 bytes  (From Manifest)
+    VendorEccPubKeyRevocation = 2,  // 4 bytes  (From Fuse)
+    ManifestFmcSvn = 3,             // 4 bytes
+    ManifestFmcMinSvn = 4,          // 4 bytes
+    FuseFmcSvn = 5,                 // 4 bytes
+    ManifestRtSvn = 6,              // 4 bytes
+    ManifestRtMinSvn = 7,           // 4 bytes
+    FuseRtSvn = 8,                  // 4 bytes
+    VendorLmsPubKeyIndex = 9,       // 4 bytes  (From Manifest)
+    VendorLmsPubKeyRevocation = 10, // 4 bytes  (From Fuse)
+    OwnerLmsPubKeyIndex = 11,       // 4 bytes  (From Manifest)
 }
 
 impl From<u32> for FuseLogEntryId {
     fn from(id: u32) -> FuseLogEntryId {
         match id {
-            1 => FuseLogEntryId::VendorPubKeyIndex,
-            2 => FuseLogEntryId::VendorPubKeyRevocation,
+            1 => FuseLogEntryId::VendorEccPubKeyIndex,
+            2 => FuseLogEntryId::VendorEccPubKeyRevocation,
             3 => FuseLogEntryId::ManifestFmcSvn,
             4 => FuseLogEntryId::ManifestFmcMinSvn,
             5 => FuseLogEntryId::FuseFmcSvn,
             6 => FuseLogEntryId::ManifestRtSvn,
             7 => FuseLogEntryId::ManifestRtMinSvn,
             8 => FuseLogEntryId::FuseRtSvn,
+            9 => FuseLogEntryId::VendorLmsPubKeyIndex,
+            10 => FuseLogEntryId::VendorLmsPubKeyRevocation,
+            11 => FuseLogEntryId::OwnerLmsPubKeyIndex,
             _ => FuseLogEntryId::Invalid,
         }
     }
diff --git a/drivers/src/fuse_bank.rs b/drivers/src/fuse_bank.rs
index 042e8771..e3a9983d 100644
--- a/drivers/src/fuse_bank.rs
+++ b/drivers/src/fuse_bank.rs
@@ -54,6 +54,7 @@ impl From<IdevidCertAttr> for usize {
     }
 }
 
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub enum LmsVerifyConfig {
     EcdsaOnly = 0,
     EcdsaAndLms = 1,
@@ -167,21 +168,34 @@ impl FuseBank<'_> {
         Array4x12::read_from_reg(soc_ifc_regs.fuse_key_manifest_pk_hash())
     }
 
-    /// Get the vendor public key revocation mask.
+    /// Get the ecc vendor public key revocation mask.
     ///
     /// # Arguments
     /// * None
     ///
     /// # Returns
-    ///     vendor public key revocation mask
+    ///     ecc vendor public key revocation mask
     ///
-    pub fn vendor_pub_key_revocation(&self) -> VendorPubKeyRevocation {
+    pub fn vendor_ecc_pub_key_revocation(&self) -> VendorPubKeyRevocation {
         let soc_ifc_regs = self.soc_ifc.regs();
         VendorPubKeyRevocation::from_bits_truncate(
             soc_ifc_regs.fuse_key_manifest_pk_hash_mask().read().mask(),
         )
     }
 
+    /// Get the lms vendor public key revocation mask.
+    ///
+    /// # Arguments
+    /// * None
+    ///
+    /// # Returns
+    ///     lms vendor public key revocation mask
+    ///
+    pub fn vendor_lms_pub_key_revocation(&self) -> VendorPubKeyRevocation {
+        let soc_ifc_regs = self.soc_ifc.regs();
+        VendorPubKeyRevocation::from_bits_truncate(soc_ifc_regs.fuse_lms_revocation().read())
+    }
+
     /// Get the owner public key hash.
     ///
     /// # Arguments
diff --git a/drivers/src/lib.rs b/drivers/src/lib.rs
index dc7be748..1e50871a 100644
--- a/drivers/src/lib.rs
+++ b/drivers/src/lib.rs
@@ -57,7 +57,9 @@ pub use ecc384::{
 };
 pub use error_reporter::{report_fw_error_fatal, report_fw_error_non_fatal};
 pub use exit_ctrl::ExitCtrl;
-pub use fuse_bank::{FuseBank, IdevidCertAttr, VendorPubKeyRevocation, X509KeyIdAlgo};
+pub use fuse_bank::{
+    FuseBank, IdevidCertAttr, LmsVerifyConfig, VendorPubKeyRevocation, X509KeyIdAlgo,
+};
 pub use hmac384::{Hmac384, Hmac384Data, Hmac384Key, Hmac384Op, Hmac384Tag};
 pub use hmac384_kdf::hmac384_kdf;
 pub use key_vault::{KeyId, KeyUsage, KeyVault};
diff --git a/error/src/lib.rs b/error/src/lib.rs
index f2bf688e..dffab6aa 100644
--- a/error/src/lib.rs
+++ b/error/src/lib.rs
@@ -167,7 +167,7 @@ impl CaliptraError {
         CaliptraError::new_const(0x000b0017);
     pub const IMAGE_VERIFIER_ERR_FMC_RUNTIME_INCORRECT_ORDER: CaliptraError =
         CaliptraError::new_const(0x000b0018);
-    pub const IMAGE_VERIFIER_ERR_OWNER_PUB_KEY_DIGEST_INVALID_ARG: CaliptraError =
+    pub const IMAGE_VERIFIER_ERR_OWNER_ECC_PUB_KEY_INVALID_ARG: CaliptraError =
         CaliptraError::new_const(0x000b0019);
     pub const IMAGE_VERIFIER_ERR_OWNER_ECC_SIGNATURE_INVALID_ARG: CaliptraError =
         CaliptraError::new_const(0x000b001a);
@@ -215,7 +215,7 @@ impl CaliptraError {
         CaliptraError::new_const(0x000b0030);
     pub const IMAGE_VERIFIER_ERR_VENDOR_LMS_VERIFY_FAILURE: CaliptraError =
         CaliptraError::new_const(0x000b0031);
-    pub const IMAGE_VERIFIER_ERR_VENDOR_LMS_PUBKEY_INDEX_OUT_OF_BOUNDS: CaliptraError =
+    pub const IMAGE_VERIFIER_ERR_VENDOR_LMS_PUB_KEY_INDEX_OUT_OF_BOUNDS: CaliptraError =
         CaliptraError::new_const(0x000b0032);
     pub const IMAGE_VERIFIER_ERR_VENDOR_LMS_SIGNATURE_INVALID: CaliptraError =
         CaliptraError::new_const(0x000b0033);
@@ -225,11 +225,13 @@ impl CaliptraError {
         CaliptraError::new_const(0x000b0035);
     pub const IMAGE_VERIFIER_ERR_OWNER_LMS_VERIFY_FAILURE: CaliptraError =
         CaliptraError::new_const(0x000b0036);
-    pub const IMAGE_VERIFIER_ERR_OWNER_LMS_PUBKEY_INDEX_OUT_OF_BOUNDS: CaliptraError =
+    pub const IMAGE_VERIFIER_ERR_OWNER_LMS_PUB_KEY_INDEX_OUT_OF_BOUNDS: CaliptraError =
         CaliptraError::new_const(0x000b0037);
     pub const IMAGE_VERIFIER_ERR_OWNER_LMS_SIGNATURE_INVALID: CaliptraError =
         CaliptraError::new_const(0x000b0038);
     pub const RUNTIME_HANDOFF_FHT_NOT_LOADED: CaliptraError = CaliptraError::new_const(0x000b0039);
+    pub const IMAGE_VERIFIER_ERR_VENDOR_LMS_PUB_KEY_REVOKED: CaliptraError =
+        CaliptraError::new_const(0x000b0003a);
 
     /// Driver Error: LMS
     pub const DRIVER_LMS_INVALID_LMS_ALGO_TYPE: CaliptraError =
diff --git a/hw-model/src/lib.rs b/hw-model/src/lib.rs
index 9727ecfb..ec08d8d2 100644
--- a/hw-model/src/lib.rs
+++ b/hw-model/src/lib.rs
@@ -443,6 +443,12 @@ pub trait HwModel {
         self.soc_ifc()
             .fuse_life_cycle()
             .write(|w| w.life_cycle(fuses.life_cycle.into()));
+        self.soc_ifc()
+            .fuse_lms_verify()
+            .write(|w| w.lms_verify(fuses.lms_verify));
+        self.soc_ifc()
+            .fuse_lms_revocation()
+            .write(|_| fuses.fuse_lms_revocation);
 
         self.soc_ifc().cptra_fuse_wr_done().write(|w| w.done(true));
         assert!(self.soc_ifc().cptra_fuse_wr_done().read().done());
diff --git a/hw-model/types/src/lib.rs b/hw-model/types/src/lib.rs
index 790ed0c5..0b3fd56c 100644
--- a/hw-model/types/src/lib.rs
+++ b/hw-model/types/src/lib.rs
@@ -167,6 +167,8 @@ pub struct Fuses {
     pub idevid_cert_attr: [u32; 24],
     pub idevid_manuf_hsm_id: [u32; 4],
     pub life_cycle: DeviceLifecycle,
+    pub lms_verify: bool,
+    pub fuse_lms_revocation: u32,
 }
 impl Default for Fuses {
     fn default() -> Self {
@@ -182,6 +184,8 @@ impl Default for Fuses {
             idevid_cert_attr: Default::default(),
             idevid_manuf_hsm_id: Default::default(),
             life_cycle: Default::default(),
+            lms_verify: Default::default(),
+            fuse_lms_revocation: Default::default(),
         }
     }
 }
diff --git a/image/types/src/lib.rs b/image/types/src/lib.rs
index 3628f2d2..875d22a5 100644
--- a/image/types/src/lib.rs
+++ b/image/types/src/lib.rs
@@ -8,7 +8,7 @@ File Name:
 
 Abstract:
 
-    File contains data strucutres for the firmware image bundle.
+    File contains data structures for the firmware image bundle.
 
 --*/
 
diff --git a/image/verify/src/lib.rs b/image/verify/src/lib.rs
index de404768..ce8876ec 100644
--- a/image/verify/src/lib.rs
+++ b/image/verify/src/lib.rs
@@ -54,11 +54,20 @@ pub struct ImageVerificationExeInfo {
 /// Information To Be Logged For The Verified Image
 #[derive(Default, Debug)]
 pub struct ImageVerificationLogInfo {
-    // Vendor Public Key Index To Log
+    // ECC Vendor Public Key Index To Log
     pub vendor_ecc_pub_key_idx: u32,
 
-    /// Vendor Public Key Revocation Fuse    
-    pub fuse_vendor_pub_key_revocation: VendorPubKeyRevocation,
+    /// Vendor ECC Public Key Revocation Fuse    
+    pub fuse_vendor_ecc_pub_key_revocation: VendorPubKeyRevocation,
+
+    // LMS Vendor Public Key Index
+    pub vendor_lms_pub_key_idx: Option<u32>,
+
+    // LMS Owner Public Key Index To Log
+    pub owner_lms_pub_key_idx: Option<u32>,
+
+    /// Vendor LMS Public Key Revocation Fuse
+    pub fuse_vendor_lms_pub_key_revocation: Option<VendorPubKeyRevocation>,
 
     /// First Mutable code's logging information
     pub fmc_log_info: ImageSvnLogInfo,
@@ -73,6 +82,12 @@ pub struct ImageVerificationInfo {
     /// Vendor ECC public key index
     pub vendor_ecc_pub_key_idx: u32,
 
+    /// Vendor LMS public key index
+    pub vendor_lms_pub_key_idx: Option<u32>,
+
+    /// Owner LMS public key index
+    pub owner_lms_pub_key_idx: Option<u32>,
+
     /// Digest of vendor public keys that verified the image
     pub vendor_pub_keys_digest: ImageDigest,
 
@@ -113,8 +128,11 @@ pub trait ImageVerificationEnv {
     /// Get Vendor Public Key Digest
     fn vendor_pub_key_digest(&self) -> ImageDigest;
 
-    /// Get Vendor Public Key Revocation list
-    fn vendor_pub_key_revocation(&self) -> VendorPubKeyRevocation;
+    /// Get Vendor ECC Public Key Revocation list
+    fn vendor_ecc_pub_key_revocation(&self) -> VendorPubKeyRevocation;
+
+    /// Get Vendor LMS Public Key Revocation list
+    fn vendor_lms_pub_key_revocation(&self) -> VendorPubKeyRevocation;
 
     /// Get Owner Public Key Digest from fuses
     fn owner_pub_key_digest_fuses(&self) -> ImageDigest;
@@ -142,4 +160,7 @@ pub trait ImageVerificationEnv {
 
     // ICCM Range
     fn iccm_range(&self) -> Range<u32>;
+
+    // LMS Verification enabled
+    fn lms_verify_enabled(&self) -> bool;
 }
diff --git a/image/verify/src/verifier.rs b/image/verify/src/verifier.rs
index 7467f8f6..e4906b98 100644
--- a/image/verify/src/verifier.rs
+++ b/image/verify/src/verifier.rs
@@ -24,12 +24,13 @@ const ZERO_DIGEST: ImageDigest = [0u32; SHA384_DIGEST_WORD_SIZE];
 /// Header Info
 struct HeaderInfo<'a> {
     vendor_ecc_pub_key_idx: u32,
-    vendor_lms_pub_key_idx: u32,
-    owner_lms_pub_key_idx: u32,
-    vendor_pub_key_revocation: VendorPubKeyRevocation,
-    vendor_info: (&'a ImageEccPubKey, &'a ImageEccSignature),
-    vendor_lms_info: (&'a ImageLmsPublicKey, &'a ImageLmsSignature),
-    owner_info: Option<(&'a ImageEccPubKey, &'a ImageEccSignature)>,
+    vendor_lms_pub_key_idx: Option<u32>,
+    owner_lms_pub_key_idx: Option<u32>,
+    vendor_ecc_pub_key_revocation: VendorPubKeyRevocation,
+    vendor_ecc_info: (&'a ImageEccPubKey, &'a ImageEccSignature),
+    vendor_lms_info: Option<(&'a ImageLmsPublicKey, &'a ImageLmsSignature)>,
+    vendor_lms_pub_key_revocation: Option<VendorPubKeyRevocation>,
+    owner_ecc_info: Option<(&'a ImageEccPubKey, &'a ImageEccSignature)>,
     owner_lms_info: Option<(&'a ImageLmsPublicKey, &'a ImageLmsSignature)>,
     owner_pub_keys_digest: ImageDigest,
 }
@@ -72,7 +73,7 @@ impl<Env: ImageVerificationEnv> ImageVerifier<Env> {
     ///
     /// # Returns
     ///
-    /// * `ImageVerificationInfo` - Image verifiaction information success
+    /// * `ImageVerificationInfo` - Image verification information success
     pub fn verify(
         &mut self,
         manifest: &ImageManifest,
@@ -111,15 +112,20 @@ impl<Env: ImageVerificationEnv> ImageVerifier<Env> {
 
         let info = ImageVerificationInfo {
             vendor_ecc_pub_key_idx: header_info.vendor_ecc_pub_key_idx,
+            vendor_lms_pub_key_idx: header_info.vendor_lms_pub_key_idx,
+            owner_lms_pub_key_idx: header_info.owner_lms_pub_key_idx,
             vendor_pub_keys_digest: self.make_vendor_key_digest(header_info)?,
             owner_pub_keys_digest: header_info.owner_pub_keys_digest,
             fmc: fmc_info,
             runtime: runtime_info,
             log_info: ImageVerificationLogInfo {
                 vendor_ecc_pub_key_idx: header_info.vendor_ecc_pub_key_idx,
-                fuse_vendor_pub_key_revocation: header_info.vendor_pub_key_revocation,
+                fuse_vendor_ecc_pub_key_revocation: header_info.vendor_ecc_pub_key_revocation,
                 fmc_log_info,
                 rt_log_info,
+                fuse_vendor_lms_pub_key_revocation: header_info.vendor_lms_pub_key_revocation,
+                vendor_lms_pub_key_idx: header_info.vendor_lms_pub_key_idx,
+                owner_lms_pub_key_idx: header_info.owner_lms_pub_key_idx,
             },
         };
 
@@ -138,66 +144,80 @@ impl<Env: ImageVerificationEnv> ImageVerifier<Env> {
         // Verify Owner Public Key Digest
         let owner_pk_digest = self.verify_owner_pk_digest(reason)?;
 
-        // Verify Vendor Key Index
-        let (vendor_ecc_pub_key_idx, vendor_pub_key_revocation) =
+        // Verify ECC Vendor Key Index
+        let (vendor_ecc_pub_key_idx, vendor_ecc_pub_key_revocation) =
             self.verify_vendor_ecc_pk_idx(preamble, reason)?;
 
-        if vendor_ecc_pub_key_idx >= VENDOR_ECC_KEY_COUNT {
-            Err(CaliptraError::IMAGE_VERIFIER_ERR_VENDOR_ECC_PUB_KEY_INDEX_OUT_OF_BOUNDS)?;
-        }
-
-        // Vendor Information
-        let vendor_info = (
+        // ECC Vendor Information
+        let vendor_ecc_info = (
             &preamble.vendor_pub_keys.ecc_pub_keys[vendor_ecc_pub_key_idx as usize],
             &preamble.vendor_sigs.ecc_sig,
         );
 
-        let vendor_lms_pub_key_idx = preamble.vendor_lms_pub_key_idx;
-        if vendor_lms_pub_key_idx >= VENDOR_LMS_KEY_COUNT {
-            return Err(CaliptraError::IMAGE_VERIFIER_ERR_VENDOR_LMS_PUBKEY_INDEX_OUT_OF_BOUNDS);
-        }
+        // Verify LMS Vendor Key Index
+        let mut vendor_lms_pub_key_idx: Option<u32> = None;
+        let mut vendor_lms_info: Option<(&ImageLmsPublicKey, &'a ImageLmsSignature)> = None;
+        let mut vendor_lms_pub_key_revocation: Option<VendorPubKeyRevocation> = None;
 
-        let vendor_lms_info = (
-            &preamble.vendor_pub_keys.lms_pub_keys[vendor_lms_pub_key_idx as usize],
-            &preamble.vendor_sigs.lms_sig,
-        );
+        if self.env.lms_verify_enabled() {
+            (vendor_lms_pub_key_idx, vendor_lms_pub_key_revocation) =
+                self.verify_vendor_lms_pk_idx(preamble, reason)?;
+
+            if let Some(idx) = vendor_lms_pub_key_idx {
+                vendor_lms_info = Some((
+                    &preamble.vendor_pub_keys.lms_pub_keys[idx as usize],
+                    &preamble.vendor_sigs.lms_sig,
+                ));
+            }
+        }
 
         // Owner Information
-        let (owner_lms_pub_key_idx, owner_pub_keys_digest, owner_info, owner_lms_info) =
+        let (owner_lms_pub_key_idx, owner_pub_keys_digest, owner_ecc_info, owner_lms_info) =
             if let Some(digest) = owner_pk_digest {
-                if preamble.owner_lms_pub_key_idx >= OWNER_LMS_KEY_COUNT {
-                    return Err(
-                        CaliptraError::IMAGE_VERIFIER_ERR_OWNER_LMS_PUBKEY_INDEX_OUT_OF_BOUNDS,
-                    );
-                }
-
                 (
-                    preamble.owner_lms_pub_key_idx,
+                    if self.env.lms_verify_enabled() {
+                        if preamble.owner_lms_pub_key_idx >= OWNER_LMS_KEY_COUNT {
+                            return Err(CaliptraError::IMAGE_VERIFIER_ERR_OWNER_LMS_PUB_KEY_INDEX_OUT_OF_BOUNDS);
+                        } else {
+                            Some(preamble.owner_lms_pub_key_idx)
+                        }
+                    } else {
+                        None
+                    },
                     digest,
                     Some((
                         &preamble.owner_pub_keys.ecc_pub_key,
                         &preamble.owner_sigs.ecc_sig,
                     )),
-                    Some((
-                        &preamble.owner_pub_keys.lms_pub_keys
-                            [preamble.owner_lms_pub_key_idx as usize],
-                        &preamble.owner_sigs.lms_sig,
-                    )),
+                    if self.env.lms_verify_enabled() {
+                        if preamble.owner_lms_pub_key_idx >= OWNER_LMS_KEY_COUNT {
+                            return Err(CaliptraError::IMAGE_VERIFIER_ERR_OWNER_LMS_PUB_KEY_INDEX_OUT_OF_BOUNDS);
+                        } else {
+                            Some((
+                                &preamble.owner_pub_keys.lms_pub_keys
+                                    [preamble.owner_lms_pub_key_idx as usize],
+                                &preamble.owner_sigs.lms_sig,
+                            ))
+                        }
+                    } else {
+                        None
+                    },
                 )
             } else {
-                (OWNER_LMS_KEY_COUNT, ZERO_DIGEST, None, None)
+                (None, ZERO_DIGEST, None, None)
             };
 
         let info = HeaderInfo {
             vendor_ecc_pub_key_idx,
             vendor_lms_pub_key_idx,
-            vendor_info,
+            vendor_ecc_info,
             vendor_lms_info,
             owner_lms_pub_key_idx,
             owner_lms_info,
             owner_pub_keys_digest,
-            owner_info,
-            vendor_pub_key_revocation,
+            owner_ecc_info,
+            vendor_ecc_pub_key_revocation,
+            vendor_lms_pub_key_revocation,
         };
 
         Ok(info)
@@ -210,10 +230,10 @@ impl<Env: ImageVerificationEnv> ImageVerifier<Env> {
         reason: ResetReason,
     ) -> CaliptraResult<(u32, VendorPubKeyRevocation)> {
         const SECOND_LAST_KEY_IDX: u32 = VENDOR_ECC_KEY_COUNT - 2;
-        const LAST_KEY_IDX: u32 = VENDOR_ECC_KEY_COUNT - 1;
+        const LAST_KEY_IDX: u32 = SECOND_LAST_KEY_IDX + 1;
 
         let key_idx = preamble.vendor_ecc_pub_key_idx;
-        let revocation = self.env.vendor_pub_key_revocation();
+        let revocation = self.env.vendor_ecc_pub_key_revocation();
 
         match key_idx {
             0..=SECOND_LAST_KEY_IDX => {
@@ -238,6 +258,42 @@ impl<Env: ImageVerificationEnv> ImageVerifier<Env> {
         Ok((key_idx, revocation))
     }
 
+    /// Verify Vendor LMS Public Key Index
+    fn verify_vendor_lms_pk_idx(
+        &mut self,
+        preamble: &ImagePreamble,
+        _reason: ResetReason,
+    ) -> CaliptraResult<(Option<u32>, Option<VendorPubKeyRevocation>)> {
+        const SECOND_LAST_KEY_IDX: u32 = VENDOR_LMS_KEY_COUNT - 2;
+        const LAST_KEY_IDX: u32 = SECOND_LAST_KEY_IDX + 1;
+
+        let key_idx = preamble.vendor_lms_pub_key_idx;
+        let revocation = self.env.vendor_lms_pub_key_revocation();
+
+        match key_idx {
+            0..=SECOND_LAST_KEY_IDX => {
+                let key = VendorPubKeyRevocation::from_bits_truncate(0x01u32 << key_idx);
+                if revocation.contains(key) {
+                    Err(CaliptraError::IMAGE_VERIFIER_ERR_VENDOR_LMS_PUB_KEY_REVOKED)?;
+                }
+            }
+            LAST_KEY_IDX => {
+                // The last key is never revoked
+            }
+            _ => Err(CaliptraError::IMAGE_VERIFIER_ERR_VENDOR_LMS_PUB_KEY_INDEX_OUT_OF_BOUNDS)?,
+        }
+
+        // [TODO] Need to put the Vendor pub key index in datavault
+        // if reason == ResetReason::UpdateReset {
+        //     let expected = self.env.vendor_pub_key_idx_dv();
+        //     if expected != key_idx {
+        //         Err(CaliptraError::IMAGE_VERIFIER_ERR_UPDATE_RESET_VENDOR_PUB_KEY_IDX_MISMATCH)?;
+        //     }
+        // }
+
+        Ok((Some(key_idx), Some(revocation)))
+    }
+
     /// Verify vendor public key digest
     fn verify_vendor_pk_digest(&mut self) -> Result<(), NonZeroU32> {
         // We skip vendor public key check in unprovisioned state
@@ -317,31 +373,36 @@ impl<Env: ImageVerificationEnv> ImageVerifier<Env> {
             .map_err(|_| CaliptraError::IMAGE_VERIFIER_ERR_HEADER_DIGEST_FAILURE)?;
 
         // Verify vendor signature
-        let (pub_key, sig) = info.vendor_info;
-        let (lms_pub_key, lms_sig) = info.vendor_lms_info;
-        self.verify_vendor_sig(&digest_vendor, pub_key, lms_pub_key, sig, lms_sig)?;
+        self.verify_vendor_sig(&digest_vendor, info.vendor_ecc_info, info.vendor_lms_info)?;
 
-        // Verify the ECC public key index used verify header signature is encoded
+        // Verify the ECC public key index used to verify header signature is encoded
         // in the header
         if header.vendor_ecc_pub_key_idx != info.vendor_ecc_pub_key_idx {
             Err(CaliptraError::IMAGE_VERIFIER_ERR_VENDOR_ECC_PUB_KEY_INDEX_MISMATCH)?;
         }
 
-        if header.vendor_lms_pub_key_idx != info.vendor_lms_pub_key_idx {
-            return Err(CaliptraError::IMAGE_VERIFIER_ERR_VENDOR_LMS_PUB_KEY_INDEX_MISMATCH);
+        // Verify the LMS public key index used to verify header signature is encoded
+        // in the header
+        if let Some(idx) = info.vendor_lms_pub_key_idx {
+            if header.vendor_lms_pub_key_idx != idx {
+                return Err(CaliptraError::IMAGE_VERIFIER_ERR_VENDOR_LMS_PUB_KEY_INDEX_MISMATCH);
+            }
         }
 
+        // Verify owner LMS signature
         if let Some((owner_lms_pub_key, owner_lms_sig)) = info.owner_lms_info {
-            if header.owner_lms_pub_key_idx != info.owner_lms_pub_key_idx {
-                return Err(CaliptraError::IMAGE_VERIFIER_ERR_OWNER_LMS_PUB_KEY_INDEX_MISMATCH);
+            if let Some(idx) = info.owner_lms_pub_key_idx {
+                if header.owner_lms_pub_key_idx != idx {
+                    return Err(CaliptraError::IMAGE_VERIFIER_ERR_OWNER_LMS_PUB_KEY_INDEX_MISMATCH);
+                }
             }
 
             self.verify_owner_lms_sig(&digest_owner, owner_lms_pub_key, owner_lms_sig)?;
         }
 
-        // Verify owner signature
-        if let Some((pub_key, sig)) = info.owner_info {
-            self.verify_owner_sig(&digest_owner, pub_key, sig)?;
+        // Verify owner ECC signature
+        if let Some((owner_ecc_pub_key, owner_ecc_sig)) = info.owner_ecc_info {
+            self.verify_owner_ecc_sig(&digest_owner, owner_ecc_pub_key, owner_ecc_sig)?;
         }
 
         let verif_info = TocInfo {
@@ -353,14 +414,14 @@ impl<Env: ImageVerificationEnv> ImageVerifier<Env> {
     }
 
     /// Verify Owner Signature
-    fn verify_owner_sig(
+    fn verify_owner_ecc_sig(
         &mut self,
         digest: &ImageDigest,
         pub_key: &ImageEccPubKey,
         sig: &ImageEccSignature,
     ) -> CaliptraResult<()> {
         if pub_key.x == ZERO_DIGEST || pub_key.y == ZERO_DIGEST {
-            Err(CaliptraError::IMAGE_VERIFIER_ERR_OWNER_PUB_KEY_DIGEST_INVALID_ARG)?;
+            Err(CaliptraError::IMAGE_VERIFIER_ERR_OWNER_ECC_PUB_KEY_INVALID_ARG)?;
         }
         if sig.r == ZERO_DIGEST || sig.s == ZERO_DIGEST {
             Err(CaliptraError::IMAGE_VERIFIER_ERR_OWNER_ECC_SIGNATURE_INVALID_ARG)?;
@@ -382,33 +443,37 @@ impl<Env: ImageVerificationEnv> ImageVerifier<Env> {
     fn verify_vendor_sig(
         &mut self,
         digest: &ImageDigest,
-        pub_key: &ImageEccPubKey,
-        lms_pub_key: &ImageLmsPublicKey,
-        sig: &ImageEccSignature,
-        lms_sig: &ImageLmsSignature,
+        ecc_info: (&ImageEccPubKey, &ImageEccSignature),
+        lms_info: Option<(&ImageLmsPublicKey, &ImageLmsSignature)>,
     ) -> CaliptraResult<()> {
-        if pub_key.x == ZERO_DIGEST || pub_key.y == ZERO_DIGEST {
+        let (ecc_pub_key, ecc_sig) = ecc_info;
+        if ecc_pub_key.x == ZERO_DIGEST || ecc_pub_key.y == ZERO_DIGEST {
             Err(CaliptraError::IMAGE_VERIFIER_ERR_VENDOR_PUB_KEY_DIGEST_INVALID_ARG)?;
         }
-        if sig.r == ZERO_DIGEST || sig.s == ZERO_DIGEST {
+        if ecc_sig.r == ZERO_DIGEST || ecc_sig.s == ZERO_DIGEST {
             Err(CaliptraError::IMAGE_VERIFIER_ERR_VENDOR_ECC_SIGNATURE_INVALID_ARG)?;
         }
 
         let mut result = self
             .env
-            .ecc384_verify(digest, pub_key, sig)
+            .ecc384_verify(digest, ecc_pub_key, ecc_sig)
             .map_err(|_| CaliptraError::IMAGE_VERIFIER_ERR_VENDOR_ECC_VERIFY_FAILURE)?;
 
         if !result {
             Err(CaliptraError::IMAGE_VERIFIER_ERR_VENDOR_ECC_SIGNATURE_INVALID)?;
         }
 
-        result = self
-            .env
-            .lms_verify(digest, lms_pub_key, lms_sig)
-            .map_err(|_| CaliptraError::IMAGE_VERIFIER_ERR_VENDOR_LMS_VERIFY_FAILURE)?;
-        if !result {
-            return Err(CaliptraError::IMAGE_VERIFIER_ERR_VENDOR_LMS_SIGNATURE_INVALID);
+        if self.env.lms_verify_enabled() {
+            if let Some(info) = lms_info {
+                let (lms_pub_key, lms_sig) = info;
+                result = self
+                    .env
+                    .lms_verify(digest, lms_pub_key, lms_sig)
+                    .map_err(|_| CaliptraError::IMAGE_VERIFIER_ERR_VENDOR_LMS_VERIFY_FAILURE)?;
+                if !result {
+                    return Err(CaliptraError::IMAGE_VERIFIER_ERR_VENDOR_LMS_SIGNATURE_INVALID);
+                }
+            }
         }
 
         Ok(())
@@ -908,16 +973,19 @@ mod tests {
         let ecc_sig = ImageEccSignature::default();
         let owner_lms_pubkey = ImageLmsPublicKey::default();
         let owner_lms_sig = ImageLmsSignature::default();
+        let binding_vendor_lms_pubkey = vendor_lms_pubkey();
+        let binding_vendor_lms_sig = vendor_lms_sig();
         let header_info: HeaderInfo = HeaderInfo {
             vendor_ecc_pub_key_idx: 0,
-            vendor_lms_pub_key_idx: 0,
-            owner_lms_pub_key_idx: 0,
-            vendor_info: (&ImageEccPubKey::default(), &ImageEccSignature::default()),
-            vendor_lms_info: (&vendor_lms_pubkey(), &vendor_lms_sig()),
-            owner_info: Some((&ecc_pubkey, &ecc_sig)),
+            vendor_lms_pub_key_idx: Some(0),
+            owner_lms_pub_key_idx: Some(0),
+            vendor_ecc_info: (&ImageEccPubKey::default(), &ImageEccSignature::default()),
+            vendor_lms_info: Some((&binding_vendor_lms_pubkey, &binding_vendor_lms_sig)),
+            owner_ecc_info: Some((&ecc_pubkey, &ecc_sig)),
             owner_lms_info: Some((&owner_lms_pubkey, &owner_lms_sig)),
             owner_pub_keys_digest: ImageDigest::default(),
-            vendor_pub_key_revocation: Default::default(),
+            vendor_ecc_pub_key_revocation: Default::default(),
+            vendor_lms_pub_key_revocation: Default::default(),
         };
         let result = verifier.verify_header(&header, &header_info);
         assert_eq!(
@@ -935,16 +1003,19 @@ mod tests {
         let owner_ecc_sig = ImageEccSignature::default();
         let owner_lms_pubkey = ImageLmsPublicKey::default();
         let owner_lms_sig = ImageLmsSignature::default();
+        let binding_vendor_lms_pubkey = vendor_lms_pubkey();
+        let binding_vendor_lms_sig = vendor_lms_sig();
         let header_info: HeaderInfo = HeaderInfo {
             vendor_ecc_pub_key_idx: 0,
-            vendor_lms_pub_key_idx: 0,
-            owner_lms_pub_key_idx: 0,
-            vendor_info: (&VENDOR_ECC_PUBKEY, &ImageEccSignature::default()),
-            vendor_lms_info: (&vendor_lms_pubkey(), &vendor_lms_sig()),
-            owner_info: Some((&owner_ecc_pubkey, &owner_ecc_sig)),
+            vendor_lms_pub_key_idx: Some(0),
+            owner_lms_pub_key_idx: Some(0),
+            vendor_ecc_info: (&VENDOR_ECC_PUBKEY, &ImageEccSignature::default()),
+            vendor_lms_info: Some((&binding_vendor_lms_pubkey, &binding_vendor_lms_sig)),
+            owner_ecc_info: Some((&owner_ecc_pubkey, &owner_ecc_sig)),
             owner_lms_info: Some((&owner_lms_pubkey, &owner_lms_sig)),
             owner_pub_keys_digest: ImageDigest::default(),
-            vendor_pub_key_revocation: Default::default(),
+            vendor_ecc_pub_key_revocation: Default::default(),
+            vendor_lms_pub_key_revocation: Default::default(),
         };
         let result = verifier.verify_header(&header, &header_info);
         assert_eq!(
@@ -968,16 +1039,19 @@ mod tests {
         let owner_ecc_sig = ImageEccSignature::default();
         let owner_lms_pubkey = ImageLmsPublicKey::default();
         let owner_lms_sig = ImageLmsSignature::default();
+        let binding_vendor_lms_pubkey = vendor_lms_pubkey();
+        let binding_vendor_lms_sig = vendor_lms_sig();
         let header_info: HeaderInfo = HeaderInfo {
             vendor_ecc_pub_key_idx: 0,
-            vendor_lms_pub_key_idx: 0,
-            owner_lms_pub_key_idx: 0,
-            vendor_info: (&VENDOR_ECC_PUBKEY, &VENDOR_ECC_SIG),
-            vendor_lms_info: (&vendor_lms_pubkey(), &vendor_lms_sig()),
-            owner_info: Some((&owner_ecc_pubkey, &owner_ecc_sig)),
+            vendor_lms_pub_key_idx: Some(0),
+            owner_lms_pub_key_idx: Some(0),
+            vendor_ecc_info: (&VENDOR_ECC_PUBKEY, &VENDOR_ECC_SIG),
+            vendor_lms_info: Some((&binding_vendor_lms_pubkey, &binding_vendor_lms_sig)),
+            owner_ecc_info: Some((&owner_ecc_pubkey, &owner_ecc_sig)),
             owner_lms_info: Some((&owner_lms_pubkey, &owner_lms_sig)),
             owner_pub_keys_digest: ImageDigest::default(),
-            vendor_pub_key_revocation: Default::default(),
+            vendor_ecc_pub_key_revocation: Default::default(),
+            vendor_lms_pub_key_revocation: Default::default(),
         };
         let result = verifier.verify_header(&header, &header_info);
         assert_eq!(
@@ -1001,16 +1075,19 @@ mod tests {
         let owner_ecc_sig = ImageEccSignature::default();
         let owner_lms_pubkey = ImageLmsPublicKey::default();
         let owner_lms_sig = ImageLmsSignature::default();
+        let binding_vendor_lms_pubkey = vendor_lms_pubkey();
+        let binding_vendor_lms_sig = vendor_lms_sig();
         let header_info: HeaderInfo = HeaderInfo {
             vendor_ecc_pub_key_idx: 0,
-            vendor_lms_pub_key_idx: 0,
-            vendor_pub_key_revocation: Default::default(),
-            owner_lms_pub_key_idx: 0,
-            vendor_info: (&VENDOR_ECC_PUBKEY, &VENDOR_ECC_SIG),
-            vendor_lms_info: (&vendor_lms_pubkey(), &vendor_lms_sig()),
-            owner_info: Some((&owner_ecc_pubkey, &owner_ecc_sig)),
+            vendor_lms_pub_key_idx: Some(0),
+            vendor_ecc_pub_key_revocation: Default::default(),
+            owner_lms_pub_key_idx: Some(0),
+            vendor_ecc_info: (&VENDOR_ECC_PUBKEY, &VENDOR_ECC_SIG),
+            vendor_lms_info: Some((&binding_vendor_lms_pubkey, &binding_vendor_lms_sig)),
+            owner_ecc_info: Some((&owner_ecc_pubkey, &owner_ecc_sig)),
             owner_lms_info: Some((&owner_lms_pubkey, &owner_lms_sig)),
             owner_pub_keys_digest: ImageDigest::default(),
+            vendor_lms_pub_key_revocation: Default::default(),
         };
         let result = verifier.verify_header(&header, &header_info);
         assert_eq!(
@@ -1032,16 +1109,19 @@ mod tests {
         let owner_ecc_sig = ImageEccSignature::default();
         let owner_lms_pubkey = ImageLmsPublicKey::default();
         let owner_lms_sig = ImageLmsSignature::default();
+        let binding_vendor_lms_pubkey = vendor_lms_pubkey();
+        let binding_vendor_lms_sig = vendor_lms_sig();
         let header_info: HeaderInfo = HeaderInfo {
             vendor_ecc_pub_key_idx: 1,
-            vendor_lms_pub_key_idx: 0,
-            owner_lms_pub_key_idx: 0,
-            vendor_info: (&VENDOR_ECC_PUBKEY, &VENDOR_ECC_SIG),
-            vendor_lms_info: (&vendor_lms_pubkey(), &vendor_lms_sig()),
-            owner_info: Some((&owner_ecc_pubkey, &owner_ecc_sig)),
+            vendor_lms_pub_key_idx: Some(0),
+            owner_lms_pub_key_idx: Some(0),
+            vendor_ecc_info: (&VENDOR_ECC_PUBKEY, &VENDOR_ECC_SIG),
+            vendor_lms_info: Some((&binding_vendor_lms_pubkey, &binding_vendor_lms_sig)),
+            owner_ecc_info: Some((&owner_ecc_pubkey, &owner_ecc_sig)),
             owner_lms_info: Some((&owner_lms_pubkey, &owner_lms_sig)),
             owner_pub_keys_digest: ImageDigest::default(),
-            vendor_pub_key_revocation: Default::default(),
+            vendor_ecc_pub_key_revocation: Default::default(),
+            vendor_lms_pub_key_revocation: Default::default(),
         };
         let result = verifier.verify_header(&header, &header_info);
         assert_eq!(
@@ -1063,16 +1143,19 @@ mod tests {
         let owner_ecc_sig = ImageEccSignature::default();
         let owner_lms_pubkey = ImageLmsPublicKey::default();
         let owner_lms_sig = ImageLmsSignature::default();
+        let binding_vendor_lms_pubkey = vendor_lms_pubkey();
+        let binding_vendor_lms_sig = vendor_lms_sig();
         let header_info: HeaderInfo = HeaderInfo {
             vendor_ecc_pub_key_idx: 0,
-            vendor_lms_pub_key_idx: 1,
-            owner_lms_pub_key_idx: 0,
-            vendor_info: (&VENDOR_ECC_PUBKEY, &VENDOR_ECC_SIG),
-            vendor_lms_info: (&vendor_lms_pubkey(), &vendor_lms_sig()),
-            owner_info: Some((&owner_ecc_pubkey, &owner_ecc_sig)),
+            vendor_lms_pub_key_idx: Some(1),
+            owner_lms_pub_key_idx: Some(0),
+            vendor_ecc_info: (&VENDOR_ECC_PUBKEY, &VENDOR_ECC_SIG),
+            vendor_lms_info: Some((&binding_vendor_lms_pubkey, &binding_vendor_lms_sig)),
+            owner_ecc_info: Some((&owner_ecc_pubkey, &owner_ecc_sig)),
             owner_lms_info: Some((&owner_lms_pubkey, &owner_lms_sig)),
             owner_pub_keys_digest: ImageDigest::default(),
-            vendor_pub_key_revocation: Default::default(),
+            vendor_ecc_pub_key_revocation: Default::default(),
+            vendor_lms_pub_key_revocation: Default::default(),
         };
         let result = verifier.verify_header(&header, &header_info);
         assert_eq!(
@@ -1094,16 +1177,19 @@ mod tests {
         let owner_ecc_sig = ImageEccSignature::default();
         let owner_lms_pubkey = ImageLmsPublicKey::default();
         let owner_lms_sig = ImageLmsSignature::default();
+        let binding_vendor_lms_pubkey = vendor_lms_pubkey();
+        let binding_vendor_lms_sig = vendor_lms_sig();
         let header_info: HeaderInfo = HeaderInfo {
             vendor_ecc_pub_key_idx: 0,
-            vendor_lms_pub_key_idx: 0,
-            owner_lms_pub_key_idx: 1,
-            vendor_info: (&VENDOR_ECC_PUBKEY, &VENDOR_ECC_SIG),
-            vendor_lms_info: (&vendor_lms_pubkey(), &vendor_lms_sig()),
-            owner_info: Some((&owner_ecc_pubkey, &owner_ecc_sig)),
+            vendor_lms_pub_key_idx: Some(0),
+            owner_lms_pub_key_idx: Some(1),
+            vendor_ecc_info: (&VENDOR_ECC_PUBKEY, &VENDOR_ECC_SIG),
+            vendor_lms_info: Some((&binding_vendor_lms_pubkey, &binding_vendor_lms_sig)),
+            owner_ecc_info: Some((&owner_ecc_pubkey, &owner_ecc_sig)),
             owner_lms_info: Some((&owner_lms_pubkey, &owner_lms_sig)),
             owner_pub_keys_digest: ImageDigest::default(),
-            vendor_pub_key_revocation: Default::default(),
+            vendor_ecc_pub_key_revocation: Default::default(),
+            vendor_lms_pub_key_revocation: Default::default(),
         };
         let result = verifier.verify_header(&header, &header_info);
         assert_eq!(
@@ -1125,21 +1211,24 @@ mod tests {
         let owner_ecc_sig = ImageEccSignature::default();
         let owner_lms_pubkey = ImageLmsPublicKey::default();
         let owner_lms_sig = ImageLmsSignature::default();
+        let binding_vendor_lms_pubkey = vendor_lms_pubkey();
+        let binding_vendor_lms_sig = vendor_lms_sig();
         let header_info: HeaderInfo = HeaderInfo {
             vendor_ecc_pub_key_idx: 0,
-            vendor_lms_pub_key_idx: 0,
-            owner_lms_pub_key_idx: 0,
-            vendor_info: (&VENDOR_ECC_PUBKEY, &VENDOR_ECC_SIG),
-            vendor_lms_info: (&vendor_lms_pubkey(), &vendor_lms_sig()),
-            owner_info: Some((&owner_ecc_pubkey, &owner_ecc_sig)),
+            vendor_lms_pub_key_idx: Some(0),
+            owner_lms_pub_key_idx: Some(0),
+            vendor_ecc_info: (&VENDOR_ECC_PUBKEY, &VENDOR_ECC_SIG),
+            vendor_lms_info: Some((&binding_vendor_lms_pubkey, &binding_vendor_lms_sig)),
+            owner_ecc_info: Some((&owner_ecc_pubkey, &owner_ecc_sig)),
             owner_lms_info: Some((&owner_lms_pubkey, &owner_lms_sig)),
             owner_pub_keys_digest: ImageDigest::default(),
-            vendor_pub_key_revocation: Default::default(),
+            vendor_ecc_pub_key_revocation: Default::default(),
+            vendor_lms_pub_key_revocation: Default::default(),
         };
         let result = verifier.verify_header(&header, &header_info);
         assert_eq!(
             result.err(),
-            Some(CaliptraError::IMAGE_VERIFIER_ERR_OWNER_PUB_KEY_DIGEST_INVALID_ARG)
+            Some(CaliptraError::IMAGE_VERIFIER_ERR_OWNER_ECC_PUB_KEY_INVALID_ARG)
         );
     }
 
@@ -1155,16 +1244,19 @@ mod tests {
         let owner_ecc_sig = ImageEccSignature::default();
         let owner_lms_pubkey = ImageLmsPublicKey::default();
         let owner_lms_sig = ImageLmsSignature::default();
+        let binding_vendor_lms_pubkey = vendor_lms_pubkey();
+        let binding_vendor_lms_sig = vendor_lms_sig();
         let header_info: HeaderInfo = HeaderInfo {
             vendor_ecc_pub_key_idx: 0,
-            vendor_lms_pub_key_idx: 0,
-            owner_lms_pub_key_idx: 0,
-            vendor_info: (&VENDOR_ECC_PUBKEY, &VENDOR_ECC_SIG),
-            vendor_lms_info: (&vendor_lms_pubkey(), &vendor_lms_sig()),
-            owner_info: Some((&OWNER_ECC_PUBKEY, &owner_ecc_sig)),
+            vendor_lms_pub_key_idx: Some(0),
+            owner_lms_pub_key_idx: Some(0),
+            vendor_ecc_info: (&VENDOR_ECC_PUBKEY, &VENDOR_ECC_SIG),
+            vendor_lms_info: Some((&binding_vendor_lms_pubkey, &binding_vendor_lms_sig)),
+            owner_ecc_info: Some((&OWNER_ECC_PUBKEY, &owner_ecc_sig)),
             owner_lms_info: Some((&owner_lms_pubkey, &owner_lms_sig)),
             owner_pub_keys_digest: ImageDigest::default(),
-            vendor_pub_key_revocation: Default::default(),
+            vendor_ecc_pub_key_revocation: Default::default(),
+            vendor_lms_pub_key_revocation: Default::default(),
         };
         let result = verifier.verify_header(&header, &header_info);
         assert_eq!(
@@ -1188,16 +1280,19 @@ mod tests {
         };
         let owner_lms_pubkey = ImageLmsPublicKey::default();
         let owner_lms_sig = ImageLmsSignature::default();
+        let binding_vendor_lms_pubkey = vendor_lms_pubkey();
+        let binding_vendor_lms_sig = vendor_lms_sig();
         let header_info: HeaderInfo = HeaderInfo {
             vendor_ecc_pub_key_idx: 0,
-            vendor_lms_pub_key_idx: 0,
-            owner_lms_pub_key_idx: 0,
-            vendor_info: (&VENDOR_ECC_PUBKEY, &VENDOR_ECC_SIG),
-            vendor_lms_info: (&vendor_lms_pubkey(), &vendor_lms_sig()),
-            owner_info: Some((&OWNER_ECC_PUBKEY, &OWNER_ECC_SIG)),
+            vendor_lms_pub_key_idx: Some(0),
+            owner_lms_pub_key_idx: Some(0),
+            vendor_ecc_info: (&VENDOR_ECC_PUBKEY, &VENDOR_ECC_SIG),
+            vendor_lms_info: Some((&binding_vendor_lms_pubkey, &binding_vendor_lms_sig)),
+            owner_ecc_info: Some((&OWNER_ECC_PUBKEY, &OWNER_ECC_SIG)),
             owner_lms_info: Some((&owner_lms_pubkey, &owner_lms_sig)),
             owner_pub_keys_digest: ImageDigest::default(),
-            vendor_pub_key_revocation: Default::default(),
+            vendor_ecc_pub_key_revocation: Default::default(),
+            vendor_lms_pub_key_revocation: Default::default(),
         };
         let toc_info = verifier.verify_header(&header, &header_info).unwrap();
         assert_eq!(toc_info.len, 100);
@@ -1571,7 +1666,8 @@ mod tests {
         verify_result: bool,
         verify_lms_result: bool,
         vendor_pub_key_digest: ImageDigest,
-        vendor_pub_key_revocation: VendorPubKeyRevocation,
+        vendor_ecc_pub_key_revocation: VendorPubKeyRevocation,
+        vendor_lms_pub_key_revocation: VendorPubKeyRevocation,
         owner_pub_key_digest: ImageDigest,
         lifecycle: Lifecycle,
     }
@@ -1584,7 +1680,8 @@ mod tests {
                 verify_result: false,
                 verify_lms_result: false,
                 vendor_pub_key_digest: ImageDigest::default(),
-                vendor_pub_key_revocation: VendorPubKeyRevocation::default(),
+                vendor_ecc_pub_key_revocation: VendorPubKeyRevocation::default(),
+                vendor_lms_pub_key_revocation: VendorPubKeyRevocation::default(),
                 owner_pub_key_digest: ImageDigest::default(),
                 lifecycle: Lifecycle::Unprovisioned,
             }
@@ -1618,8 +1715,12 @@ mod tests {
             self.vendor_pub_key_digest
         }
 
-        fn vendor_pub_key_revocation(&self) -> VendorPubKeyRevocation {
-            self.vendor_pub_key_revocation
+        fn vendor_ecc_pub_key_revocation(&self) -> VendorPubKeyRevocation {
+            self.vendor_ecc_pub_key_revocation
+        }
+
+        fn vendor_lms_pub_key_revocation(&self) -> VendorPubKeyRevocation {
+            self.vendor_lms_pub_key_revocation
         }
 
         fn owner_pub_key_digest_fuses(&self) -> ImageDigest {
@@ -1660,5 +1761,9 @@ mod tests {
                 end: 0x40000000 + (128 * 1024),
             }
         }
+
+        fn lms_verify_enabled(&self) -> bool {
+            true
+        }
     }
 }
diff --git a/rom/dev/Makefile b/rom/dev/Makefile
index 2ead775d..d6da8b7a 100644
--- a/rom/dev/Makefile
+++ b/rom/dev/Makefile
@@ -94,6 +94,7 @@ objdump:
 	 cargo \
 		"--config=$(EXTRA_CARGO_CONFIG)" \
 		objdump \
+		--bin caliptra-rom \
 		--profile firmware \
 		--target=riscv32imc-unknown-none-elf \
 		--no-default-features \
@@ -145,6 +146,7 @@ size:
 		--profile firmware \
 		--target=riscv32imc-unknown-none-elf \
 		--no-default-features \
+		--bin caliptra-rom \
 
 nm:
 	 cargo \
diff --git a/rom/dev/src/flow/cold_reset/fw_processor.rs b/rom/dev/src/flow/cold_reset/fw_processor.rs
index 9960d4e7..63d304af 100644
--- a/rom/dev/src/flow/cold_reset/fw_processor.rs
+++ b/rom/dev/src/flow/cold_reset/fw_processor.rs
@@ -204,14 +204,17 @@ impl FirmwareProcessor {
     fn update_fuse_log(log_info: &ImageVerificationLogInfo) -> CaliptraResult<()> {
         // Log VendorPubKeyIndex
         log_fuse_data(
-            FuseLogEntryId::VendorPubKeyIndex,
+            FuseLogEntryId::VendorEccPubKeyIndex,
             log_info.vendor_ecc_pub_key_idx.as_bytes(),
         )?;
 
         // Log VendorPubKeyRevocation
         log_fuse_data(
-            FuseLogEntryId::VendorPubKeyRevocation,
-            log_info.fuse_vendor_pub_key_revocation.bits().as_bytes(),
+            FuseLogEntryId::VendorEccPubKeyRevocation,
+            log_info
+                .fuse_vendor_ecc_pub_key_revocation
+                .bits()
+                .as_bytes(),
         )?;
 
         // Log ManifestFmcSvn
@@ -249,6 +252,33 @@ impl FirmwareProcessor {
             FuseLogEntryId::FuseRtSvn,
             log_info.rt_log_info.fuse_svn.as_bytes(),
         )?;
+
+        // Log VendorLmsPubKeyIndex
+        if let Some(vendor_lms_pub_key_idx) = log_info.vendor_lms_pub_key_idx {
+            log_fuse_data(
+                FuseLogEntryId::VendorLmsPubKeyIndex,
+                vendor_lms_pub_key_idx.as_bytes(),
+            )?;
+        }
+
+        // Log VendorLmsPubKeyRevocation
+        if let Some(fuse_vendor_lms_pub_key_revocation) =
+            log_info.fuse_vendor_lms_pub_key_revocation
+        {
+            log_fuse_data(
+                FuseLogEntryId::VendorLmsPubKeyRevocation,
+                fuse_vendor_lms_pub_key_revocation.bits().as_bytes(),
+            )?;
+        }
+
+        // Log OwnerLmsPubKeyIndex
+        if let Some(owner_lms_pub_key_idx) = log_info.owner_lms_pub_key_idx {
+            log_fuse_data(
+                FuseLogEntryId::OwnerLmsPubKeyIndex,
+                owner_lms_pub_key_idx.as_bytes(),
+            )?;
+        }
+
         Ok(())
     }
 
@@ -313,6 +343,8 @@ impl FirmwareProcessor {
             info.vendor_ecc_pub_key_idx,
         );
 
+        // [TODO] Write the Vendor and Owner Public key Indices of LMS keys.
+
         data_vault.write_warm_reset_entry48(WarmResetEntry48::RtTci, &info.runtime.digest.into());
 
         data_vault.write_warm_reset_entry4(WarmResetEntry4::RtSvn, info.runtime.svn);
diff --git a/rom/dev/src/verifier.rs b/rom/dev/src/verifier.rs
index b085aba8..a1a3c6fa 100644
--- a/rom/dev/src/verifier.rs
+++ b/rom/dev/src/verifier.rs
@@ -88,9 +88,14 @@ impl<'a> ImageVerificationEnv for &mut RomImageVerificationEnv<'a> {
         self.soc_ifc.fuse_bank().vendor_pub_key_hash().into()
     }
 
-    /// Retrieve Vendor Public Key Revocation Bitmask
-    fn vendor_pub_key_revocation(&self) -> VendorPubKeyRevocation {
-        self.soc_ifc.fuse_bank().vendor_pub_key_revocation()
+    /// Retrieve Vendor ECC Public Key Revocation Bitmask
+    fn vendor_ecc_pub_key_revocation(&self) -> VendorPubKeyRevocation {
+        self.soc_ifc.fuse_bank().vendor_ecc_pub_key_revocation()
+    }
+
+    /// Retrieve Vendor LMS Public Key Revocation Bitmask
+    fn vendor_lms_pub_key_revocation(&self) -> VendorPubKeyRevocation {
+        self.soc_ifc.fuse_bank().vendor_lms_pub_key_revocation()
     }
 
     /// Retrieve Owner Public Key Digest from fuses
@@ -136,4 +141,8 @@ impl<'a> ImageVerificationEnv for &mut RomImageVerificationEnv<'a> {
     fn iccm_range(&self) -> Range<u32> {
         RomEnv::ICCM_RANGE
     }
+
+    fn lms_verify_enabled(&self) -> bool {
+        self.soc_ifc.fuse_bank().lms_verify() == LmsVerifyConfig::EcdsaAndLms
+    }
 }


Test patch:
diff --git a/rom/dev/doc/test-coverage/test-coverage.md b/rom/dev/doc/test-coverage/test-coverage.md
index c7e222b5..46ac2d66 100644
--- a/rom/dev/doc/test-coverage/test-coverage.md
+++ b/rom/dev/doc/test-coverage/test-coverage.md
@@ -6,26 +6,35 @@ Test Name | ROM Stage | Description | ROM Error Code
 **test_preamble_zero_vendor_pubkey_digest** | Image Verification - Preamble | Checks if vendor public key digest is not zero in the fuse | IMAGE_VERIFIER_ERR_VENDOR_PUB_KEY_DIGEST_INVALID
 **test_preamble_vendor_pubkey_digest_mismatch** | Image Verification - Preamble | Checks if the vendor public key hash from fuse matches the hash of the vendor public keys in the Preamble | IMAGE_VERIFIER_ERR_VENDOR_PUB_KEY_DIGEST_MISMATCH
 **test_preamble_owner_pubkey_digest_mismatch** | Image Verification - Preamble | Checks if the owner public key hash from fuse is not zero and matches the hash of the owner public key in the Preamble | IMAGE_VERIFIER_ERR_OWNER_PUB_KEY_DIGEST_MISMATCH
-**test_preamble_vendor_pubkey_revocation** | Image Verification - Preamble | * Checks revoking of key idx 0/1/2 <br> * Checks if last key (idx = 3) is revocable | IMAGE_VERIFIER_ERR_VENDOR_ECC_PUB_KEY_REVOKED
-**test_preamble_vendor_pubkey_out_of_bounds** | Image Verification - Preamble | Checks if key idx is >= 4 | IMAGE_VERIFIER_ERR_VENDOR_ECC_PUB_KEY_INDEX_OUT_OF_BOUNDS
-**test_preamble_vendor_lms_pubkey_out_of_bounds** | Image Verification - Preamble | Checks if LMS key idx is >= 4 | IMAGE_VERIFIER_ERR_VENDOR_LMS_PUBKEY_INDEX_OUT_OF_BOUNDS
-**test_preamble_owner_pubkey_out_of_bounds** | Image Verification - Preamble | Checks if key idx is >= 4 | IMAGE_VERIFIER_ERR_OWNER_ECC_PUB_KEY_INDEX_OUT_OF_BOUNDS
+**test_preamble_vendor_ecc_pubkey_revocation** | Image Verification - Preamble | Checks revoking of key idx 0/1/2 <br> * Checks if last key (idx = 3) is revocable | IMAGE_VERIFIER_ERR_VENDOR_ECC_PUB_KEY_REVOKED
+**test_preamble_vendor_lms_pubkey_revocation** | Image Verification - Preamble | Checks revoking of key idx 0/1/2 <br> * Checks if last key (idx = 3) is revocable | IMAGE_VERIFIER_ERR_VENDOR_LMS_PUB_KEY_REVOKED
+**test_preamble_vendor_lms_optional_no_pubkey_revocation_check** | Image Verification - Preamble | * Sets lms_verify fuse to false and checks vendor LMS key revocation | Success
+**test_preamble_vendor_ecc_pubkey_out_of_bounds** | Image Verification - Preamble | Checks if vendor ECC key idx is >= 4 | IMAGE_VERIFIER_ERR_VENDOR_ECC_PUB_KEY_INDEX_OUT_OF_BOUNDS
+**test_preamble_vendor_lms_pubkey_out_of_bounds** | Image Verification - Preamble | Checks if vendor LMS key idx is >= 4 | 
+IMAGE_VERIFIER_ERR_VENDOR_LMS_PUBKEY_INDEX_OUT_OF_BOUNDS
+**test_preamble_vendor_lms_optional_no_pubkey_out_of_bounds_check** | Image Verification - Preamble | Sets lms_verify fuse to false and checks if vendor LMS key idx is >= 4 |  Success
+IMAGE_VERIFIER_ERR_VENDOR_LMS_PUBKEY_INDEX_OUT_OF_BOUNDS
 **test_preamble_owner_lms_pubkey_out_of_bounds** | Image Verification - Preamble | Checks if LMS key idx is >= 4 | IMAGE_VERIFIER_ERR_OWNER_LMS_PUBKEY_INDEX_OUT_OF_BOUNDS
-**test_header_verify_vendor_sig_zero_pubkey** | Image Verification - Header | Checks if vendor ECC public key is non-zero | IMAGE_VERIFIER_ERR_VENDOR_PUB_KEY_DIGEST_INVALID_ARG
-**test_header_verify_vendor_sig_zero_signature** | Image Verification - Header | Checks if vendor signature is non-zero | IMAGE_VERIFIER_ERR_VENDOR_ECC_SIGNATURE_INVALID_ARG
-**test_header_verify_vendor_sig_mismatch** | Image Verification - Header | Checks if vendor ECC signature from Preamble and computed header signature match | IMAGE_VERIFIER_ERR_VENDOR_ECC_SIGNATURE_INVALID
+**test_preamble_owner_lms_optional_no_pubkey_out_of_bounds_check** | Image Verification - Preamble | Sets lms_verify fuse to false and checks if owner LMS key idx is >= 4 | Success
+**test_header_verify_vendor_sig_zero_ecc_pubkey** | Image Verification - Header | Checks if vendor ECC public key is non-zero | IMAGE_VERIFIER_ERR_VENDOR_PUB_KEY_DIGEST_INVALID_ARG
+**test_header_verify_vendor_sig_zero_ecc_signature** | Image Verification - Header | Checks if vendor signature is non-zero | IMAGE_VERIFIER_ERR_VENDOR_ECC_SIGNATURE_INVALID_ARG
+**test_header_verify_vendor_ecc_sig_mismatch** | Image Verification - Header | Checks if vendor ECC signature from Preamble and computed header signature match | IMAGE_VERIFIER_ERR_VENDOR_ECC_SIGNATURE_INVALID
 **test_header_verify_vendor_lms_sig_mismatch** | Image Verification - Header | Checks if vendor LMS signature from Preamble and computed header signature match | IMAGE_VERIFIER_ERR_VENDOR_LMS_SIGNATURE_INVALID
+**test_header_verify_vendor_lms_optional_no_sig_mismatch_check** | Image Verification - Header | Sets lms_verify fuse to false and checks if vendor LMS signature from Preamble and computed header signature match | Success
 **test_header_verify_owner_lms_sig_mismatch** | Image Verification - Header | Checks if owner LMS signature from Preamble and computed header signature match | IMAGE_VERIFIER_ERR_OWNER_LMS_SIGNATURE_INVALID
-**test_header_verify_vendor_pub_key_in_preamble_and_header** | Image Verification - Header | Checks if the vendor ECC public key index in Preamble and Header match | IMAGE_VERIFIER_ERR_VENDOR_ECC_PUB_KEY_INDEX_MISMATCH
+**test_header_verify_owner_lms_optional_no_sig_mismatch_check** | Image Verification - Header | Sets lms_verify fuse to false and checks if owner LMS signature from Preamble and computed header signature match | Success
+**test_header_verify_vendor_ecc_pub_key_in_preamble_and_header** | Image Verification - Header | Checks if the vendor ECC public key index in Preamble and Header match | IMAGE_VERIFIER_ERR_VENDOR_ECC_PUB_KEY_INDEX_MISMATCH
 **test_header_verify_vendor_lms_pub_key_in_preamble_and_header** | Image Verification - Header | Checks if the vendor LMS public key index in Preamble and Header match | IMAGE_VERIFIER_ERR_VENDOR_LMS_PUB_KEY_INDEX_MISMATCH
+**test_header_verify_vendor_lms_optional_no_pub_key_in_preamble_and_header_check** | Image Verification - Header |  Sets lms_verify fuse to false and checks if the vendor LMS public key index in Preamble and Header match | Success
 **test_header_verify_owner_lms_pub_key_in_preamble_and_header** | Image Verification - Header | Checks if the owner LMS public key index in Preamble and Header match | IMAGE_VERIFIER_ERR_OWNER_LMS_PUB_KEY_INDEX_MISMATCH
+**test_header_verify_owner_lms_optional_no_pub_key_in_preamble_and_header_check** | Image Verification - Header | Sets lms_verify fuse to false and checks if the owner LMS public key index in Preamble and Header match | Success
 **test_header_verify_owner_sig_zero_fuses_zero_pubkey_x** | Image Verification - Header | Checks if the owner ECC public key in Preamble is zero | IMAGE_VERIFIER_ERR_OWNER_PUB_KEY_DIGEST_INVALID_ARG
-**test_header_verify_owner_sig_zero_pubkey_x** | Image Verification - Header | Checks if the owner ECC public key in Preamble is zero | IMAGE_VERIFIER_ERR_OWNER_PUB_KEY_DIGEST_INVALID_ARG
-**test_header_verify_owner_sig_zero_pubkey_y** | Image Verification - Header | Checks if the owner ECC public key in Preamble is zero | IMAGE_VERIFIER_ERR_OWNER_PUB_KEY_DIGEST_INVALID_ARG
-**test_header_verify_owner_sig_zero_signature_r** | Image Verification - Header | Checks if the owner ECC signature in Preamble is zero | IMAGE_VERIFIER_ERR_OWNER_ECC_SIGNATURE_INVALID_ARG
-**test_header_verify_owner_sig_zero_signature_s** | Image Verification - Header | Checks if the owner ECC signature in Preamble is zero | IMAGE_VERIFIER_ERR_OWNER_ECC_SIGNATURE_INVALID_ARG
-**test_header_verify_owner_sig_invalid_signature_r** | Image Verification - Header | Checks if owner ECC signature from Preamble and computed header signature match | IMAGE_VERIFIER_ERR_OWNER_ECC_SIGNATURE_INVALID
-**test_header_verify_owner_sig_invalid_signature_s** | Image Verification - Header | Checks if owner ECC signature from Preamble and computed header signature match | IMAGE_VERIFIER_ERR_OWNER_ECC_SIGNATURE_INVALID
+**test_header_verify_owner_ecc_sig_zero_pubkey_x** | Image Verification - Header | Checks if the owner ECC public key.x in Preamble is zero | IMAGE_VERIFIER_ERR_OWNER_PUB_KEY_DIGEST_INVALID_ARG
+**test_header_verify_owner_ecc_sig_zero_pubkey_y** | Image Verification - Header | Checks if the owner ECC public key.y in Preamble is zero | IMAGE_VERIFIER_ERR_OWNER_PUB_KEY_DIGEST_INVALID_ARG
+**test_header_verify_owner_ecc_sig_zero_signature_r** | Image Verification - Header | Checks if the owner ECC signature.r in Preamble is zero | IMAGE_VERIFIER_ERR_OWNER_ECC_SIGNATURE_INVALID_ARG
+**test_header_verify_owner_ecc_sig_zero_signature_s** | Image Verification - Header | Checks if the owner ECC signature.s in Preamble is zero | IMAGE_VERIFIER_ERR_OWNER_ECC_SIGNATURE_INVALID_ARG
+**test_header_verify_owner_ecc_sig_invalid_signature_r** | Image Verification - Header | Checks if owner ECC signature.r from Preamble and computed header signature match | IMAGE_VERIFIER_ERR_OWNER_ECC_SIGNATURE_INVALID
+**test_header_verify_owner_ecc_sig_invalid_signature_s** | Image Verification - Header | Checks if owner ECC signature.s from Preamble and computed header signature match | IMAGE_VERIFIER_ERR_OWNER_ECC_SIGNATURE_INVALID
 **test_toc_invalid_entry_count** | Image Verification - TOC | Checks if header.toc_count equals MAX_TOC_ENTRY_COUNT (2) | IMAGE_VERIFIER_ERR_TOC_ENTRY_COUNT_INVALID
 **test_toc_invalid_toc_digest** | Image Verification - TOC | Checks if digest of [manifest.fmc_toc | manifest.rt_toc] matches header.toc_digest | IMAGE_VERIFIER_ERR_TOC_DIGEST_MISMATCH
 **test_toc_fmc_range_overlap** | Image Verification - TOC | Checks if FMC and Runtime images don't overlap in the image bundle | IMAGE_VERIFIER_ERR_FMC_RUNTIME_OVERLAP
@@ -64,10 +73,10 @@ Test Name | ROM Stage | Description | ROM Error Code
 # **Firmware Downloader Integration Tests**
 Test Name | ROM Stage | Description | ROM Error Code
 ---|---|---|---
-**test_zero_firmware_size** | FW Donwloader | Checks if firmware is zero-sized | FW_PROC_INVALID_IMAGE_SIZE
-**test_firmware_gt_max_size** | FW Donwloader |  Checks if firmware is not more than max. size (128K)  | FW_PROC_INVALID_IMAGE_SIZE
-**test_pcr_log** | FW Donwloader |  Checks if PCR log entries are correctly logged to DCCM  | N/A
-**ttest_fuse_log** | FW Donwloader |  Checks if Fuse log entries are correctly logged to DCCM  | N/A
+**test_zero_firmware_size** | FW Downloader | Checks if firmware is zero-sized | FW_PROC_INVALID_IMAGE_SIZE
+**test_firmware_gt_max_size** | FW Downloader |  Checks if firmware is not more than max. size (128K)  | FW_PROC_INVALID_IMAGE_SIZE
+**test_pcr_log** | FW Downloader |  Checks if PCR log entries are correctly logged to DCCM  | N/A
+**ttest_fuse_log** | FW Downloader |  Checks if Fuse log entries are correctly logged to DCCM  | N/A
 <br><br>
 ## **FMCALIAS Integration Tests**
 Test Name | ROM Stage | Description | ROM Error Code
diff --git a/rom/dev/tests/test_fmcalias_derivation.rs b/rom/dev/tests/test_fmcalias_derivation.rs
index 417ed411..9eeecc93 100644
--- a/rom/dev/tests/test_fmcalias_derivation.rs
+++ b/rom/dev/tests/test_fmcalias_derivation.rs
@@ -6,7 +6,7 @@ use caliptra_common::{FirmwareHandoffTable, FuseLogEntry, FuseLogEntryId};
 use caliptra_common::{PcrLogEntry, PcrLogEntryId};
 use caliptra_error::CaliptraError;
 use caliptra_hw_model::{BootParams, Fuses, HwModel, InitParams, ModelError, SecurityState};
-use caliptra_image_fake_keys::VENDOR_CONFIG_KEY_1;
+use caliptra_image_fake_keys::{OWNER_CONFIG, VENDOR_CONFIG_KEY_1};
 use caliptra_image_gen::ImageGenerator;
 use caliptra_image_openssl::OsslCrypto;
 use caliptra_image_types::IMAGE_BYTE_SIZE;
@@ -285,6 +285,7 @@ fn test_fuse_log() {
         anti_rollback_disable: true,
         fmc_key_manifest_svn: 0x0F,  // Value of FMC_SVN
         runtime_svn: [0xF, 0, 0, 0], // Value of RT_SVN
+        lms_verify: true,
         ..Default::default()
     };
 
@@ -309,11 +310,11 @@ fn test_fuse_log() {
 
     let image_options = ImageOptions {
         vendor_config: VENDOR_CONFIG_KEY_1,
+        owner_config: Some(OWNER_CONFIG),
         fmc_svn: FMC_SVN,
         fmc_min_svn: FMC_MIN_SVN,
         app_svn: FMC_SVN,
         app_min_svn: FMC_MIN_SVN,
-        ..Default::default()
     };
     let image_bundle =
         caliptra_builder::build_and_sign_image(&TEST_FMC_WITH_UART, &APP_WITH_UART, image_options)
@@ -338,7 +339,7 @@ fn test_fuse_log() {
 
     assert_eq!(
         fuse_log_entry.entry_id,
-        FuseLogEntryId::VendorPubKeyIndex as u32
+        FuseLogEntryId::VendorEccPubKeyIndex as u32
     );
 
     assert_eq!(fuse_log_entry.log_data[0], VENDOR_CONFIG_KEY_1.ecc_key_idx);
@@ -349,7 +350,7 @@ fn test_fuse_log() {
         FuseLogEntry::read_from_prefix(fuse_entry_arr[fuse_log_entry_offset..].as_bytes()).unwrap();
     assert_eq!(
         fuse_log_entry.entry_id,
-        FuseLogEntryId::VendorPubKeyRevocation as u32
+        FuseLogEntryId::VendorEccPubKeyRevocation as u32
     );
     assert_eq!(fuse_log_entry.log_data[0], 0,);
 
@@ -406,6 +407,36 @@ fn test_fuse_log() {
         FuseLogEntry::read_from_prefix(fuse_entry_arr[fuse_log_entry_offset..].as_bytes()).unwrap();
     assert_eq!(fuse_log_entry.entry_id, FuseLogEntryId::FuseRtSvn as u32);
     assert_eq!(fuse_log_entry.log_data[0], FMC_SVN);
+
+    // Validate the VendorLmsPubKeyIndex
+    fuse_log_entry_offset += core::mem::size_of::<FuseLogEntry>();
+    let fuse_log_entry =
+        FuseLogEntry::read_from_prefix(fuse_entry_arr[fuse_log_entry_offset..].as_bytes()).unwrap();
+    assert_eq!(
+        fuse_log_entry.entry_id,
+        FuseLogEntryId::VendorLmsPubKeyIndex as u32
+    );
+    assert_eq!(fuse_log_entry.log_data[0], VENDOR_CONFIG_KEY_1.lms_key_idx);
+
+    // Validate that the ID is VendorPubKeyRevocation
+    fuse_log_entry_offset += core::mem::size_of::<FuseLogEntry>();
+    let fuse_log_entry =
+        FuseLogEntry::read_from_prefix(fuse_entry_arr[fuse_log_entry_offset..].as_bytes()).unwrap();
+    assert_eq!(
+        fuse_log_entry.entry_id,
+        FuseLogEntryId::VendorLmsPubKeyRevocation as u32
+    );
+    assert_eq!(fuse_log_entry.log_data[0], 0,);
+
+    // Validate the OwnerLmsPubKeyIndex
+    fuse_log_entry_offset += core::mem::size_of::<FuseLogEntry>();
+    let fuse_log_entry =
+        FuseLogEntry::read_from_prefix(fuse_entry_arr[fuse_log_entry_offset..].as_bytes()).unwrap();
+    assert_eq!(
+        fuse_log_entry.entry_id,
+        FuseLogEntryId::OwnerLmsPubKeyIndex as u32
+    );
+    assert_eq!(fuse_log_entry.log_data[0], OWNER_CONFIG.lms_key_idx);
 }
 
 #[test]
diff --git a/rom/dev/tests/test_image_validation.rs b/rom/dev/tests/test_image_validation.rs
index a4d21f9d..fbf26897 100644
--- a/rom/dev/tests/test_image_validation.rs
+++ b/rom/dev/tests/test_image_validation.rs
@@ -2,6 +2,7 @@
 
 use caliptra_builder::FwId;
 use caliptra_builder::{ImageOptions, APP_WITH_UART, FMC_WITH_UART, ROM_WITH_UART};
+use caliptra_common::RomBootStatus::ColdResetComplete;
 use caliptra_drivers::Array4x12;
 use caliptra_drivers::MfgFlags;
 use caliptra_error::CaliptraError;
@@ -145,7 +146,7 @@ fn test_preamble_owner_pubkey_digest_mismatch() {
 }
 
 #[test]
-fn test_preamble_vendor_pubkey_revocation() {
+fn test_preamble_vendor_ecc_pubkey_revocation() {
     let rom = caliptra_builder::build_firmware_rom(&ROM_WITH_UART).unwrap();
     const LAST_KEY_IDX: u32 = VENDOR_ECC_KEY_COUNT - 1;
     const VENDOR_CONFIG_LIST: [ImageGeneratorVendorConfig; VENDOR_ECC_KEY_COUNT as usize] = [
@@ -186,8 +187,7 @@ fn test_preamble_vendor_pubkey_revocation() {
             // Last key is never revoked.
             hw.upload_firmware(&image_bundle.to_bytes().unwrap())
                 .unwrap();
-            hw.step_until_output_contains("Caliptra RT listening for mailbox commands...")
-                .unwrap();
+            hw.step_until_boot_status(ColdResetComplete.into(), true);
         } else {
             assert_eq!(
                 ModelError::MailboxCmdFailed(
@@ -201,7 +201,102 @@ fn test_preamble_vendor_pubkey_revocation() {
 }
 
 #[test]
-fn test_preamble_vendor_pubkey_out_of_bounds() {
+fn test_preamble_vendor_lms_pubkey_revocation() {
+    let rom = caliptra_builder::build_firmware_rom(&ROM_WITH_UART).unwrap();
+    const LAST_KEY_IDX: u32 = VENDOR_LMS_KEY_COUNT - 1;
+    const VENDOR_CONFIG_LIST: [ImageGeneratorVendorConfig; VENDOR_LMS_KEY_COUNT as usize] = [
+        VENDOR_CONFIG_KEY_0,
+        VENDOR_CONFIG_KEY_1,
+        VENDOR_CONFIG_KEY_2,
+        VENDOR_CONFIG_KEY_3,
+    ];
+
+    for vendor_config in VENDOR_CONFIG_LIST {
+        let mut image_options = ImageOptions::default();
+        let key_idx = vendor_config.lms_key_idx;
+        image_options.vendor_config = vendor_config;
+
+        let fuses = caliptra_hw_model::Fuses {
+            lms_verify: true,
+            fuse_lms_revocation: 1u32 << image_options.vendor_config.lms_key_idx,
+            ..Default::default()
+        };
+
+        let mut hw = caliptra_hw_model::new(BootParams {
+            init_params: InitParams {
+                rom: &rom,
+                ..Default::default()
+            },
+            fuses,
+            ..Default::default()
+        })
+        .unwrap();
+
+        let image_bundle =
+            caliptra_builder::build_and_sign_image(&FMC_WITH_UART, &APP_WITH_UART, image_options)
+                .unwrap();
+
+        if key_idx == LAST_KEY_IDX {
+            // Last key is never revoked.
+            hw.upload_firmware(&image_bundle.to_bytes().unwrap())
+                .unwrap();
+            hw.step_until_boot_status(ColdResetComplete.into(), true);
+        } else {
+            assert_eq!(
+                ModelError::MailboxCmdFailed(
+                    CaliptraError::IMAGE_VERIFIER_ERR_VENDOR_LMS_PUB_KEY_REVOKED.into()
+                ),
+                hw.upload_firmware(&image_bundle.to_bytes().unwrap())
+                    .unwrap_err()
+            );
+        }
+    }
+}
+
+#[test]
+fn test_preamble_vendor_lms_optional_no_pubkey_revocation_check() {
+    let rom = caliptra_builder::build_firmware_rom(&ROM_WITH_UART).unwrap();
+    const VENDOR_CONFIG_LIST: [ImageGeneratorVendorConfig; VENDOR_LMS_KEY_COUNT as usize] = [
+        VENDOR_CONFIG_KEY_0,
+        VENDOR_CONFIG_KEY_1,
+        VENDOR_CONFIG_KEY_2,
+        VENDOR_CONFIG_KEY_3,
+    ];
+
+    for vendor_config in VENDOR_CONFIG_LIST {
+        let image_options = caliptra_builder::ImageOptions {
+            vendor_config,
+            ..Default::default()
+        };
+
+        let fuses = caliptra_hw_model::Fuses {
+            lms_verify: false,
+            fuse_lms_revocation: 1u32 << image_options.vendor_config.lms_key_idx,
+            ..Default::default()
+        };
+
+        let mut hw = caliptra_hw_model::new(BootParams {
+            init_params: InitParams {
+                rom: &rom,
+                ..Default::default()
+            },
+            fuses,
+            ..Default::default()
+        })
+        .unwrap();
+
+        let image_bundle =
+            caliptra_builder::build_and_sign_image(&FMC_WITH_UART, &APP_WITH_UART, image_options)
+                .unwrap();
+
+        hw.upload_firmware(&image_bundle.to_bytes().unwrap())
+            .unwrap();
+        hw.step_until_boot_status(ColdResetComplete.into(), true);
+    }
+}
+
+#[test]
+fn test_preamble_vendor_ecc_pubkey_out_of_bounds() {
     let (mut hw, mut image_bundle) =
         helpers::build_hw_model_and_image_bundle(Fuses::default(), ImageOptions::default());
     image_bundle.manifest.preamble.vendor_ecc_pub_key_idx = VENDOR_ECC_KEY_COUNT;
@@ -217,28 +312,51 @@ fn test_preamble_vendor_pubkey_out_of_bounds() {
 
 #[test]
 fn test_preamble_vendor_lms_pubkey_out_of_bounds() {
+    let fuses = caliptra_hw_model::Fuses {
+        lms_verify: true,
+        ..Default::default()
+    };
     let (mut hw, mut image_bundle) =
-        helpers::build_hw_model_and_image_bundle(Fuses::default(), ImageOptions::default());
+        helpers::build_hw_model_and_image_bundle(fuses, ImageOptions::default());
     image_bundle.manifest.preamble.vendor_lms_pub_key_idx = VENDOR_LMS_KEY_COUNT;
 
     assert_eq!(
         ModelError::MailboxCmdFailed(
-            CaliptraError::IMAGE_VERIFIER_ERR_VENDOR_LMS_PUBKEY_INDEX_OUT_OF_BOUNDS.into()
+            CaliptraError::IMAGE_VERIFIER_ERR_VENDOR_LMS_PUB_KEY_INDEX_OUT_OF_BOUNDS.into()
         ),
         hw.upload_firmware(&image_bundle.to_bytes().unwrap())
             .unwrap_err()
     );
 }
 
+#[test]
+fn test_preamble_vendor_lms_optional_no_pubkey_out_of_bounds_check() {
+    let fuses = caliptra_hw_model::Fuses {
+        lms_verify: false,
+        ..Default::default()
+    };
+    let (mut hw, mut image_bundle) =
+        helpers::build_hw_model_and_image_bundle(fuses, ImageOptions::default());
+    image_bundle.manifest.preamble.vendor_lms_pub_key_idx = VENDOR_LMS_KEY_COUNT;
+
+    hw.upload_firmware(&image_bundle.to_bytes().unwrap())
+        .unwrap();
+    hw.step_until_boot_status(ColdResetComplete.into(), true);
+}
+
 #[test]
 fn test_preamble_owner_lms_pubkey_out_of_bounds() {
+    let fuses = caliptra_hw_model::Fuses {
+        lms_verify: true,
+        ..Default::default()
+    };
     let (mut hw, mut image_bundle) =
-        helpers::build_hw_model_and_image_bundle(Fuses::default(), ImageOptions::default());
+        helpers::build_hw_model_and_image_bundle(fuses, ImageOptions::default());
     image_bundle.manifest.preamble.owner_lms_pub_key_idx = OWNER_LMS_KEY_COUNT;
 
     assert_eq!(
         ModelError::MailboxCmdFailed(
-            CaliptraError::IMAGE_VERIFIER_ERR_OWNER_LMS_PUBKEY_INDEX_OUT_OF_BOUNDS.into()
+            CaliptraError::IMAGE_VERIFIER_ERR_OWNER_LMS_PUB_KEY_INDEX_OUT_OF_BOUNDS.into()
         ),
         hw.upload_firmware(&image_bundle.to_bytes().unwrap())
             .unwrap_err()
@@ -246,7 +364,22 @@ fn test_preamble_owner_lms_pubkey_out_of_bounds() {
 }
 
 #[test]
-fn test_header_verify_vendor_sig_zero_pubkey() {
+fn test_preamble_owner_lms_optional_no_pubkey_out_of_bounds_check() {
+    let fuses = caliptra_hw_model::Fuses {
+        lms_verify: false,
+        ..Default::default()
+    };
+    let (mut hw, mut image_bundle) =
+        helpers::build_hw_model_and_image_bundle(fuses, ImageOptions::default());
+    image_bundle.manifest.preamble.owner_lms_pub_key_idx = OWNER_LMS_KEY_COUNT;
+
+    hw.upload_firmware(&image_bundle.to_bytes().unwrap())
+        .unwrap();
+    hw.step_until_boot_status(ColdResetComplete.into(), true);
+}
+
+#[test]
+fn test_header_verify_vendor_sig_zero_ecc_pubkey() {
     let (mut hw, mut image_bundle) =
         helpers::build_hw_model_and_image_bundle(Fuses::default(), ImageOptions::default());
     let vendor_ecc_pub_key_idx = image_bundle.manifest.preamble.vendor_ecc_pub_key_idx as usize;
@@ -286,7 +419,7 @@ fn test_header_verify_vendor_sig_zero_pubkey() {
 }
 
 #[test]
-fn test_header_verify_vendor_sig_zero_signature() {
+fn test_header_verify_vendor_sig_zero_ecc_signature() {
     let (mut hw, mut image_bundle) =
         helpers::build_hw_model_and_image_bundle(Fuses::default(), ImageOptions::default());
 
@@ -319,7 +452,7 @@ fn test_header_verify_vendor_sig_zero_signature() {
 }
 
 #[test]
-fn test_header_verify_vendor_sig_mismatch() {
+fn test_header_verify_vendor_ecc_sig_mismatch() {
     let (mut hw, mut image_bundle) =
         helpers::build_hw_model_and_image_bundle(Fuses::default(), ImageOptions::default());
     let vendor_ecc_pub_key_idx = image_bundle.manifest.preamble.vendor_ecc_pub_key_idx as usize;
@@ -375,8 +508,12 @@ fn test_header_verify_vendor_sig_mismatch() {
 
 #[test]
 fn test_header_verify_vendor_lms_sig_mismatch() {
+    let fuses = caliptra_hw_model::Fuses {
+        lms_verify: true,
+        ..Default::default()
+    };
     let (mut hw, mut image_bundle) =
-        helpers::build_hw_model_and_image_bundle(Fuses::default(), ImageOptions::default());
+        helpers::build_hw_model_and_image_bundle(fuses, ImageOptions::default());
     let vendor_lms_pub_key_idx = image_bundle.manifest.preamble.vendor_lms_pub_key_idx as usize;
 
     // Modify the vendor public key.
@@ -393,8 +530,12 @@ fn test_header_verify_vendor_lms_sig_mismatch() {
             .unwrap_err()
     );
 
+    let fuses = caliptra_hw_model::Fuses {
+        lms_verify: true,
+        ..Default::default()
+    };
     let (mut hw, mut image_bundle) =
-        helpers::build_hw_model_and_image_bundle(Fuses::default(), ImageOptions::default());
+        helpers::build_hw_model_and_image_bundle(fuses, ImageOptions::default());
 
     // Modify the vendor signature.
     image_bundle.manifest.preamble.vendor_pub_keys.lms_pub_keys[vendor_lms_pub_key_idx] =
@@ -410,10 +551,51 @@ fn test_header_verify_vendor_lms_sig_mismatch() {
     );
 }
 
+#[test]
+fn test_header_verify_vendor_lms_optional_no_sig_mismatch_check() {
+    let fuses = caliptra_hw_model::Fuses {
+        lms_verify: false,
+        ..Default::default()
+    };
+    let (mut hw, mut image_bundle) =
+        helpers::build_hw_model_and_image_bundle(fuses, ImageOptions::default());
+    let vendor_lms_pub_key_idx = image_bundle.manifest.preamble.vendor_lms_pub_key_idx as usize;
+
+    // Modify the vendor public key.
+    let lms_pub_key_backup =
+        image_bundle.manifest.preamble.vendor_pub_keys.lms_pub_keys[vendor_lms_pub_key_idx];
+
+    image_bundle.manifest.preamble.vendor_pub_keys.lms_pub_keys[vendor_lms_pub_key_idx].digest =
+        [Default::default(); 6];
+    hw.upload_firmware(&image_bundle.to_bytes().unwrap())
+        .unwrap();
+    hw.step_until_boot_status(ColdResetComplete.into(), true);
+
+    let fuses = caliptra_hw_model::Fuses {
+        lms_verify: false,
+        ..Default::default()
+    };
+    let (mut hw, mut image_bundle) =
+        helpers::build_hw_model_and_image_bundle(fuses, ImageOptions::default());
+
+    // Modify the vendor signature.
+    image_bundle.manifest.preamble.vendor_pub_keys.lms_pub_keys[vendor_lms_pub_key_idx] =
+        lms_pub_key_backup;
+    image_bundle.manifest.preamble.vendor_sigs.lms_sig.tree_path[0] = [Default::default(); 6];
+
+    hw.upload_firmware(&image_bundle.to_bytes().unwrap())
+        .unwrap();
+    hw.step_until_boot_status(ColdResetComplete.into(), true);
+}
+
 #[test]
 fn test_header_verify_owner_lms_sig_mismatch() {
+    let fuses = caliptra_hw_model::Fuses {
+        lms_verify: true,
+        ..Default::default()
+    };
     let (mut hw, mut image_bundle) =
-        helpers::build_hw_model_and_image_bundle(Fuses::default(), ImageOptions::default());
+        helpers::build_hw_model_and_image_bundle(fuses, ImageOptions::default());
     let owner_lms_pub_key_idx = image_bundle.manifest.preamble.owner_lms_pub_key_idx as usize;
 
     // Modify the owner public key.
@@ -430,8 +612,12 @@ fn test_header_verify_owner_lms_sig_mismatch() {
             .unwrap_err()
     );
 
+    let fuses = caliptra_hw_model::Fuses {
+        lms_verify: true,
+        ..Default::default()
+    };
     let (mut hw, mut image_bundle) =
-        helpers::build_hw_model_and_image_bundle(Fuses::default(), ImageOptions::default());
+        helpers::build_hw_model_and_image_bundle(fuses, ImageOptions::default());
 
     // Modify the owner signature.
     image_bundle.manifest.preamble.owner_pub_keys.lms_pub_keys[owner_lms_pub_key_idx] =
@@ -448,7 +634,44 @@ fn test_header_verify_owner_lms_sig_mismatch() {
 }
 
 #[test]
-fn test_header_verify_vendor_pub_key_in_preamble_and_header() {
+fn test_header_verify_owner_lms_optional_no_sig_mismatch_check() {
+    let fuses = caliptra_hw_model::Fuses {
+        lms_verify: false,
+        ..Default::default()
+    };
+    let (mut hw, mut image_bundle) =
+        helpers::build_hw_model_and_image_bundle(fuses, ImageOptions::default());
+    let owner_lms_pub_key_idx = image_bundle.manifest.preamble.owner_lms_pub_key_idx as usize;
+
+    // Modify the owner public key.
+    let lms_pub_key_backup =
+        image_bundle.manifest.preamble.owner_pub_keys.lms_pub_keys[owner_lms_pub_key_idx];
+
+    image_bundle.manifest.preamble.owner_pub_keys.lms_pub_keys[owner_lms_pub_key_idx].digest =
+        [Default::default(); 6];
+    hw.upload_firmware(&image_bundle.to_bytes().unwrap())
+        .unwrap();
+    hw.step_until_boot_status(ColdResetComplete.into(), true);
+
+    let fuses = caliptra_hw_model::Fuses {
+        lms_verify: false,
+        ..Default::default()
+    };
+    let (mut hw, mut image_bundle) =
+        helpers::build_hw_model_and_image_bundle(fuses, ImageOptions::default());
+
+    // Modify the owner signature.
+    image_bundle.manifest.preamble.owner_pub_keys.lms_pub_keys[owner_lms_pub_key_idx] =
+        lms_pub_key_backup;
+    image_bundle.manifest.preamble.owner_sigs.lms_sig.tree_path[0] = [Default::default(); 6];
+
+    hw.upload_firmware(&image_bundle.to_bytes().unwrap())
+        .unwrap();
+    hw.step_until_boot_status(ColdResetComplete.into(), true);
+}
+
+#[test]
+fn test_header_verify_vendor_ecc_pub_key_in_preamble_and_header() {
     let (mut hw, mut image_bundle) =
         helpers::build_hw_model_and_image_bundle(Fuses::default(), ImageOptions::default());
 
@@ -468,8 +691,12 @@ fn test_header_verify_vendor_pub_key_in_preamble_and_header() {
 
 #[test]
 fn test_header_verify_vendor_lms_pub_key_in_preamble_and_header() {
+    let fuses = caliptra_hw_model::Fuses {
+        lms_verify: true,
+        ..Default::default()
+    };
     let (mut hw, mut image_bundle) =
-        helpers::build_hw_model_and_image_bundle(Fuses::default(), ImageOptions::default());
+        helpers::build_hw_model_and_image_bundle(fuses, ImageOptions::default());
 
     // Change vendor pubkey index.
     image_bundle.manifest.header.vendor_lms_pub_key_idx =
@@ -485,10 +712,34 @@ fn test_header_verify_vendor_lms_pub_key_in_preamble_and_header() {
     );
 }
 
+#[test]
+fn test_header_verify_vendor_lms_optional_no_pub_key_in_preamble_and_header_check() {
+    let fuses = caliptra_hw_model::Fuses {
+        lms_verify: false,
+        ..Default::default()
+    };
+    let (mut hw, mut image_bundle) =
+        helpers::build_hw_model_and_image_bundle(fuses, ImageOptions::default());
+
+    // Change vendor pubkey index.
+    image_bundle.manifest.header.vendor_lms_pub_key_idx =
+        image_bundle.manifest.preamble.vendor_lms_pub_key_idx + 1;
+    update_header(&mut image_bundle);
+
+    hw.upload_firmware(&image_bundle.to_bytes().unwrap())
+        .unwrap();
+    hw.step_until_boot_status(ColdResetComplete.into(), true);
+}
+
 #[test]
 fn test_header_verify_owner_lms_pub_key_in_preamble_and_header() {
+    let fuses = caliptra_hw_model::Fuses {
+        lms_verify: true,
+        ..Default::default()
+    };
+
     let (mut hw, mut image_bundle) =
-        helpers::build_hw_model_and_image_bundle(Fuses::default(), ImageOptions::default());
+        helpers::build_hw_model_and_image_bundle(fuses, ImageOptions::default());
 
     // Change vendor pubkey index.
     image_bundle.manifest.header.owner_lms_pub_key_idx =
@@ -505,50 +756,33 @@ fn test_header_verify_owner_lms_pub_key_in_preamble_and_header() {
 }
 
 #[test]
-fn test_header_verify_owner_sig_zero_fuses() {
-    let image_bundle = caliptra_builder::build_and_sign_image(
-        &FMC_WITH_UART,
-        &APP_WITH_UART,
-        ImageOptions::default(),
-    )
-    .unwrap();
+fn test_header_verify_owner_lms_optional_no_pub_key_in_preamble_and_header_check() {
+    let fuses = caliptra_hw_model::Fuses {
+        lms_verify: false,
+        ..Default::default()
+    };
 
-    let fuses = caliptra_hw_model::Fuses::default();
+    let (mut hw, mut image_bundle) =
+        helpers::build_hw_model_and_image_bundle(fuses, ImageOptions::default());
 
-    let rom = caliptra_builder::build_firmware_rom(&ROM_WITH_UART).unwrap();
-    let mut hw = caliptra_hw_model::new(BootParams {
-        init_params: InitParams {
-            rom: &rom,
-            security_state: SecurityState::from(fuses.life_cycle as u32),
-            ..Default::default()
-        },
-        fuses,
-        ..Default::default()
-    })
-    .unwrap();
+    // Change vendor pubkey index.
+    image_bundle.manifest.header.owner_lms_pub_key_idx =
+        image_bundle.manifest.preamble.owner_lms_pub_key_idx + 1;
+    update_header(&mut image_bundle);
 
     hw.upload_firmware(&image_bundle.to_bytes().unwrap())
         .unwrap();
-
-    assert_eq!(hw.soc_ifc().cptra_fw_error_fatal().read(), 0);
+    hw.step_until_boot_status(ColdResetComplete.into(), true);
 }
 
 #[test]
-fn test_header_verify_owner_sig_zero_fuses_zero_pubkey_x() {
-    let mut image_bundle = caliptra_builder::build_and_sign_image(
+fn test_header_verify_owner_sig_zero_fuses() {
+    let image_bundle = caliptra_builder::build_and_sign_image(
         &FMC_WITH_UART,
         &APP_WITH_UART,
         ImageOptions::default(),
     )
     .unwrap();
-    // Set ecc_pub_key.x to zero.
-    image_bundle
-        .manifest
-        .preamble
-        .owner_pub_keys
-        .ecc_pub_key
-        .x
-        .fill(0);
 
     let fuses = caliptra_hw_model::Fuses::default();
 
@@ -564,52 +798,14 @@ fn test_header_verify_owner_sig_zero_fuses_zero_pubkey_x() {
     })
     .unwrap();
 
-    assert_eq!(
-        ModelError::MailboxCmdFailed(
-            CaliptraError::IMAGE_VERIFIER_ERR_OWNER_PUB_KEY_DIGEST_INVALID_ARG.into()
-        ),
-        hw.upload_firmware(&image_bundle.to_bytes().unwrap())
-            .unwrap_err()
-    );
-}
-
-#[test]
-fn test_header_verify_owner_sig_corrupt_fuses() {
-    let image_bundle = caliptra_builder::build_and_sign_image(
-        &FMC_WITH_UART,
-        &APP_WITH_UART,
-        ImageOptions::default(),
-    )
-    .unwrap();
-
-    let fuses = caliptra_hw_model::Fuses {
-        owner_pk_hash: [1u32; 12],
-        ..Default::default()
-    };
-
-    let rom = caliptra_builder::build_firmware_rom(&ROM_WITH_UART).unwrap();
-    let mut hw = caliptra_hw_model::new(BootParams {
-        init_params: InitParams {
-            rom: &rom,
-            security_state: SecurityState::from(fuses.life_cycle as u32),
-            ..Default::default()
-        },
-        fuses,
-        ..Default::default()
-    })
-    .unwrap();
+    hw.upload_firmware(&image_bundle.to_bytes().unwrap())
+        .unwrap();
 
-    assert_eq!(
-        ModelError::MailboxCmdFailed(
-            CaliptraError::IMAGE_VERIFIER_ERR_OWNER_PUB_KEY_DIGEST_MISMATCH.into()
-        ),
-        hw.upload_firmware(&image_bundle.to_bytes().unwrap())
-            .unwrap_err()
-    );
+    assert_eq!(hw.soc_ifc().cptra_fw_error_fatal().read(), 0);
 }
 
 #[test]
-fn test_header_verify_owner_sig_zero_pubkey_x() {
+fn test_header_verify_owner_ecc_sig_zero_pubkey_x() {
     let mut image_bundle = caliptra_builder::build_and_sign_image(
         &FMC_WITH_UART,
         &APP_WITH_UART,
@@ -649,7 +845,7 @@ fn test_header_verify_owner_sig_zero_pubkey_x() {
 
     assert_eq!(
         ModelError::MailboxCmdFailed(
-            CaliptraError::IMAGE_VERIFIER_ERR_OWNER_PUB_KEY_DIGEST_INVALID_ARG.into()
+            CaliptraError::IMAGE_VERIFIER_ERR_OWNER_ECC_PUB_KEY_INVALID_ARG.into()
         ),
         hw.upload_firmware(&image_bundle.to_bytes().unwrap())
             .unwrap_err()
@@ -657,7 +853,7 @@ fn test_header_verify_owner_sig_zero_pubkey_x() {
 }
 
 #[test]
-fn test_header_verify_owner_sig_zero_pubkey_y() {
+fn test_header_verify_owner_ecc_sig_zero_pubkey_y() {
     let mut image_bundle = caliptra_builder::build_and_sign_image(
         &FMC_WITH_UART,
         &APP_WITH_UART,
@@ -697,7 +893,7 @@ fn test_header_verify_owner_sig_zero_pubkey_y() {
 
     assert_eq!(
         ModelError::MailboxCmdFailed(
-            CaliptraError::IMAGE_VERIFIER_ERR_OWNER_PUB_KEY_DIGEST_INVALID_ARG.into()
+            CaliptraError::IMAGE_VERIFIER_ERR_OWNER_ECC_PUB_KEY_INVALID_ARG.into()
         ),
         hw.upload_firmware(&image_bundle.to_bytes().unwrap())
             .unwrap_err()
@@ -705,7 +901,7 @@ fn test_header_verify_owner_sig_zero_pubkey_y() {
 }
 
 #[test]
-fn test_header_verify_owner_sig_zero_signature_r() {
+fn test_header_verify_owner_ecc_sig_zero_signature_r() {
     let mut image_bundle = caliptra_builder::build_and_sign_image(
         &FMC_WITH_UART,
         &APP_WITH_UART,
@@ -747,7 +943,7 @@ fn test_header_verify_owner_sig_zero_signature_r() {
 }
 
 #[test]
-fn test_header_verify_owner_sig_zero_signature_s() {
+fn test_header_verify_owner_ecc_sig_zero_signature_s() {
     let mut image_bundle = caliptra_builder::build_and_sign_image(
         &FMC_WITH_UART,
         &APP_WITH_UART,
@@ -789,7 +985,7 @@ fn test_header_verify_owner_sig_zero_signature_s() {
 }
 
 #[test]
-fn test_header_verify_owner_sig_invalid_signature_r() {
+fn test_header_verify_owner_ecc_sig_invalid_signature_r() {
     let mut image_bundle = caliptra_builder::build_and_sign_image(
         &FMC_WITH_UART,
         &APP_WITH_UART,
@@ -831,7 +1027,7 @@ fn test_header_verify_owner_sig_invalid_signature_r() {
 }
 
 #[test]
-fn test_header_verify_owner_sig_invalid_signature_s() {
+fn test_header_verify_owner_ecc_sig_invalid_signature_s() {
     let mut image_bundle = caliptra_builder::build_and_sign_image(
         &FMC_WITH_UART,
         &APP_WITH_UART,