WIP: Test warm reset with debug unlocked

jhand2 · jhand2 · commit 6717c2731174 · 2025-08-29T13:58:55.000-07:00
diff --git a/drivers/src/ecc384.rs b/drivers/src/ecc384.rs
@@ -14,8 +14,8 @@ Abstract:
 
 use crate::kv_access::{KvAccess, KvAccessErr};
 use crate::{
-    array_concat3, okmutref, wait, Array4x12, Array4xN, CaliptraError, CaliptraResult, KeyReadArgs,
-    KeyWriteArgs, Trng,
+    array_concat3, cprintln, okmutref, wait, Array4x12, Array4xN, CaliptraError, CaliptraResult,
+    KeyReadArgs, KeyWriteArgs, Trng,
 };
 #[cfg(not(feature = "no-cfi"))]
 use caliptra_cfi_derive::cfi_impl_fn;
@@ -516,11 +516,17 @@ impl Ecc384 {
 
         // Verify the signature just created
         let _r = self.verify_r(pub_key, data, sig)?;
+
+        cprintln!("{:?}", _r.0);
+        cprintln!("{:?}", sig.r.0);
+
         // Not using standard error flow here for increased CFI safety
         // An error here will end up reporting the CFI assert failure
         #[cfg(not(feature = "no-cfi"))]
         caliptra_cfi_lib::cfi_assert_eq_12_words(&_r.0, &sig.r.0);
 
+        cprintln!("fips check");
+
         #[cfg(feature = "fips-test-hooks")]
         let sig_result = Ok(unsafe {
             crate::FipsTestHook::corrupt_data_if_hook_set(
diff --git a/fmc/src/hand_off.rs b/fmc/src/hand_off.rs
@@ -61,7 +61,7 @@ impl HandOff {
             .fmc_pub_key_x_dv_hdl
             .try_into()
             .unwrap_or_else(|e: CaliptraError| {
-                cprintln!("[fht] Invalid FMC ALias Public Key X DV handle");
+                //cprintln!("[fht] Invalid FMC ALias Public Key X DV handle");
                 handle_fatal_error(e.into());
             });
 
@@ -78,7 +78,7 @@ impl HandOff {
             .fmc_pub_key_y_dv_hdl
             .try_into()
             .unwrap_or_else(|e: CaliptraError| {
-                cprintln!("[fht] Invalid FMC ALias Public Key Y DV handle");
+                //cprintln!("[fht] Invalid FMC ALias Public Key Y DV handle");
                 handle_fatal_error(e.into());
             });
 
@@ -110,17 +110,17 @@ impl HandOff {
             .fmc_priv_key_kv_hdl
             .try_into()
             .unwrap_or_else(|e: CaliptraError| {
-                cprintln!("[fht] Invalid FMC ALias Private Key KV handle");
+                //cprintln!("[fht] Invalid FMC ALias Private Key KV handle");
                 handle_fatal_error(e.into())
             });
 
         match ds {
             KeyVaultSlot(key_id) => {
-                cprintln!("[fht] FMC Alias Private Key: {:?}", u32::from(key_id));
+                //cprintln!("[fht] FMC Alias Private Key: {:?}", u32::from(key_id));
                 key_id
             }
             _ => {
-                cprintln!("[fht] Invalid KeySlot DV Entry");
+                //cprintln!("[fht] Invalid KeySlot DV Entry");
                 handle_fatal_error(CaliptraError::FMC_HANDOFF_INVALID_PARAM.into())
             }
         }
@@ -138,7 +138,7 @@ impl HandOff {
         match IccmAddr::<u32>::validate_addr(rt_entry_point) {
             Ok(_) => unsafe { transfer_control(rt_entry_point) },
             Err(e) => {
-                cprintln!("[fht] Invalid RT Entry Point");
+                //cprintln!("[fht] Invalid RT Entry Point");
                 handle_fatal_error(e.into());
             }
         }
@@ -151,7 +151,7 @@ impl HandOff {
                 .rt_tci_dv_hdl
                 .try_into()
                 .unwrap_or_else(|e: CaliptraError| {
-                    cprintln!("[fht] Invalid TCI DV handle");
+                    //cprintln!("[fht] Invalid TCI DV handle");
                     handle_fatal_error(e.into())
                 });
 
@@ -172,7 +172,7 @@ impl HandOff {
                 .rt_svn_dv_hdl
                 .try_into()
                 .unwrap_or_else(|e: CaliptraError| {
-                    cprintln!("[fht] Invalid RT SVN handle");
+                    //cprintln!("[fht] Invalid RT SVN handle");
                     handle_fatal_error(e.into())
                 });
 
@@ -193,7 +193,7 @@ impl HandOff {
                 .rt_min_svn_dv_hdl
                 .try_into()
                 .unwrap_or_else(|e: CaliptraError| {
-                    cprintln!("[fht] Invalid RT Min SVN handle");
+                    //cprintln!("[fht] Invalid RT Min SVN handle");
                     handle_fatal_error(e.into())
                 });
 
@@ -213,7 +213,7 @@ impl HandOff {
                 .rt_min_svn_dv_hdl
                 .try_into()
                 .unwrap_or_else(|e: CaliptraError| {
-                    cprintln!("[fht] Invalid RT Min SVN handle");
+                    //cprintln!("[fht] Invalid RT Min SVN handle");
                     handle_fatal_error(e.into())
                 });
 
@@ -247,7 +247,7 @@ impl HandOff {
             .rt_fw_entry_point_hdl
             .try_into()
             .unwrap_or_else(|e: CaliptraError| {
-                cprintln!("[fht] Invalid runtime entry point DV handle");
+                //cprintln!("[fht] Invalid runtime entry point DV handle");
                 handle_fatal_error(e.into());
             });
         // The data store is either a warm reset entry or a cold reset entry.
diff --git a/fmc/src/main.rs b/fmc/src/main.rs
@@ -98,12 +98,12 @@ pub extern "C" fn entry_point() -> ! {
 #[inline(never)]
 #[allow(clippy::empty_loop)]
 extern "C" fn exception_handler(trap_record: &TrapRecord) {
-    cprintln!(
-        "FMC EXCEPTION mcause=0x{:08X} mscause=0x{:08X} mepc=0x{:08X}",
-        trap_record.mcause,
-        trap_record.mscause,
-        trap_record.mepc
-    );
+    //cprintln!(
+    //"FMC EXCEPTION mcause=0x{:08X} mscause=0x{:08X} mepc=0x{:08X}",
+    //trap_record.mcause,
+    //trap_record.mscause,
+    //trap_record.mepc
+    //);
     log_trap_record(trap_record, None);
 
     handle_fatal_error(CaliptraError::FMC_GLOBAL_EXCEPTION.into());
@@ -125,13 +125,13 @@ extern "C" fn nmi_handler(trap_record: &TrapRecord) {
             .read(),
     );
     log_trap_record(trap_record, Some(err_interrupt_status));
-    cprintln!(
-        "FMC NMI mcause=0x{:08X} mscause=0x{:08X} mepc=0x{:08X}error_internal_intr_r={:08X}",
-        trap_record.mcause,
-        trap_record.mscause,
-        trap_record.mepc,
-        err_interrupt_status,
-    );
+    //cprintln!(
+    //"FMC NMI mcause=0x{:08X} mscause=0x{:08X} mepc=0x{:08X}error_internal_intr_r={:08X}",
+    //trap_record.mcause,
+    //trap_record.mscause,
+    //trap_record.mepc,
+    //err_interrupt_status,
+    //);
     let mut error = CaliptraError::FMC_GLOBAL_NMI;
 
     let wdt_status = soc_ifc.regs().cptra_wdt_status().read();
diff --git a/rom/dev/src/main.rs b/rom/dev/src/main.rs
@@ -73,13 +73,13 @@ pub extern "C" fn rom_entry() -> ! {
     };
 
     if !cfg!(feature = "no-cfi") {
-        cprintln!("[state] CFI Enabled");
+        //cprintln!("[state] CFI Enabled");
         let mut entropy_gen = || env.trng.generate().map(|a| a.0);
         CfiCounter::reset(&mut entropy_gen);
         CfiCounter::reset(&mut entropy_gen);
         CfiCounter::reset(&mut entropy_gen);
     } else {
-        cprintln!("[state] CFI Disabled");
+        //cprintln!("[state] CFI Disabled");
     }
 
     // Check if TRNG is correctly sourced as per hw config.
@@ -93,24 +93,24 @@ pub extern "C" fn rom_entry() -> ! {
         caliptra_drivers::Lifecycle::Production => "Production",
         caliptra_drivers::Lifecycle::Reserved2 => "Unknown",
     };
-    cprintln!("[state] LifecycleState = {}", _lifecyle);
+    //cprintln!("[state] LifecycleState = {}", _lifecyle);
 
     if cfg!(feature = "fake-rom")
         && (env.soc_ifc.lifecycle() == caliptra_drivers::Lifecycle::Production)
         && !(env.soc_ifc.prod_en_in_fake_mode())
     {
-        cprintln!("Fake ROM in Prod lifecycle disabled");
+        //cprintln!("Fake ROM in Prod lifecycle disabled");
         handle_fatal_error(CaliptraError::ROM_GLOBAL_FAKE_ROM_IN_PRODUCTION.into());
     }
 
-    cprintln!(
-        "[state] DebugLocked = {}",
-        if env.soc_ifc.debug_locked() {
-            "Yes"
-        } else {
-            "No"
-        }
-    );
+    //cprintln!(
+    //"[state] DebugLocked = {}",
+    //if env.soc_ifc.debug_locked() {
+    //"Yes"
+    //} else {
+    //"No"
+    //}
+    //);
 
     // Set the ROM version
     let rom_info = unsafe { &CALIPTRA_ROM_INFO };
@@ -202,7 +202,7 @@ pub extern "C" fn rom_entry() -> ! {
 fn run_fips_tests(env: &mut KatsEnv) -> CaliptraResult<()> {
     report_boot_status(KatStarted.into());
 
-    cprintln!("[kat] SHA2-256");
+    //cprintln!("[kat] SHA2-256");
     Sha256Kat::default().execute(env.sha256)?;
 
     #[cfg(feature = "fips-test-hooks")]
@@ -233,7 +233,7 @@ fn rom_integrity_test(env: &mut KatsEnv, expected_digest: &[u32; 8]) -> Caliptra
 
     let n_blocks = unsafe { &CALIPTRA_ROM_INFO as *const RomInfo as usize / 64 };
     let mut digest = unsafe { env.sha256.digest_blocks_raw(rom_start, n_blocks)? };
-    cprintln!("ROM Digest: {}", HexBytes(&<[u8; 32]>::from(digest)));
+    //cprintln!("ROM Digest: {}", HexBytes(&<[u8; 32]>::from(digest)));
     if digest.0 != *expected_digest {
         digest.zeroize();
         cprintln!("ROM integrity test failed");
diff --git a/runtime/tests/runtime_integration_tests/test_warm_reset.rs b/runtime/tests/runtime_integration_tests/test_warm_reset.rs
@@ -160,6 +160,57 @@ fn test_mbox_busy_during_warm_reset() {
     );
 }
 
+#[test]
+fn test_warm_reset_with_debug_unlock() {
+    let security_state = *SecurityState::default()
+        .set_debug_locked(false)
+        .set_device_lifecycle(DeviceLifecycle::Production);
+
+    let rom = caliptra_builder::rom_for_fw_integration_tests().unwrap();
+    let image = caliptra_builder::build_and_sign_image(
+        &FMC_WITH_UART,
+        &APP_WITH_UART,
+        ImageOptions::default(),
+    )
+    .unwrap();
+    let vendor_pk_hash =
+        bytes_to_be_words_48(&sha384(image.manifest.preamble.vendor_pub_keys.as_bytes()));
+    let owner_pk_hash =
+        bytes_to_be_words_48(&sha384(image.manifest.preamble.owner_pub_keys.as_bytes()));
+
+    let mut model = caliptra_hw_model::new(
+        InitParams {
+            rom: &rom,
+            security_state,
+            ..Default::default()
+        },
+        BootParams {
+            fuses: Fuses {
+                key_manifest_pk_hash: vendor_pk_hash,
+                owner_pk_hash,
+                ..Default::default()
+            },
+            fw_image: Some(&image.to_bytes().unwrap()),
+            ..Default::default()
+        },
+    )
+    .unwrap();
+
+    // Wait for boot
+    model.step_until(|m| m.soc_ifc().cptra_flow_status().read().ready_for_runtime());
+
+    // Perform warm reset
+    model.warm_reset_flow(&Fuses {
+        key_manifest_pk_hash: vendor_pk_hash,
+        owner_pk_hash,
+        ..Default::default()
+    });
+
+    // Wait for boot
+    model.step_until(|m| m.soc_ifc().cptra_flow_status().read().ready_for_runtime());
+    assert_eq!(model.soc_ifc().cptra_fw_error_non_fatal().read(), 0);
+}
+
 #[cfg(not(feature = "fpga_realtime"))]
 #[test]
 fn test_mbox_idle_during_warm_reset() {
