other boot0 hardening

- harden the check that the boot0 public keys match those in the
data array
- security mesh setup
- insertion of random delays & bollards
- upgrade API on signature verification to allow for random delays
during the signature check
This commit is contained in:
bunnie 2025-12-04 15:28:52 +08:00
parent b00acba907
commit 1c210b3541
No known key found for this signature in database
2 changed files with 54 additions and 14 deletions

View file

@ -14,8 +14,10 @@ use alloc::collections::VecDeque;
#[cfg(feature = "unsafe-dev")] #[cfg(feature = "unsafe-dev")]
use core::cell::RefCell; use core::cell::RefCell;
use bao1x_api::{BOOT0_PUBKEY_FAIL, signatures::FunctionCode}; use bao1x_api::HardenedBool;
use bao1x_api::{BOOT0_PUBKEY_FAIL, bollard, signatures::FunctionCode};
use bao1x_hal::acram::OneWayCounter; use bao1x_hal::acram::OneWayCounter;
use bao1x_hal::hardening::{check_pll, die, mesh_setup};
#[cfg(feature = "unsafe-dev")] #[cfg(feature = "unsafe-dev")]
use critical_section::Mutex; use critical_section::Mutex;
use platform::*; use platform::*;
@ -53,15 +55,27 @@ pub fn uart_irq_handler() {
#[export_name = "rust_entry"] #[export_name = "rust_entry"]
pub unsafe extern "C" fn rust_entry() -> ! { pub unsafe extern "C" fn rust_entry() -> ! {
// set the security bits on the RRAM - without these set, most security is bypassed // set the security bits on the RRAM - without these set, most security is bypassed
// this issue is fixed on A1 silicon stepping (which is production silicon). // this issue is fixed on A1 silicon stepping (which is production silicon)
// glitch_safety: this is fixed by metal mask so no hardening is needed
let mut rram = CSR::new(utra::rrc::HW_RRC_BASE as *mut u32); let mut rram = CSR::new(utra::rrc::HW_RRC_BASE as *mut u32);
rram.wfo(utra::rrc::SFR_RRCCR_SFR_RRCCR, bao1x_hal::rram::SECURITY_MODE); rram.wfo(utra::rrc::SFR_RRCCR_SFR_RRCCR, bao1x_hal::rram::SECURITY_MODE);
// set user level so we can access keys
// set user level so we can access keys.
// glitch_safety: failing to execute this would actually reduce access permissions
let mut cu = bao1x_hal::coreuser::Coreuser::new(); let mut cu = bao1x_hal::coreuser::Coreuser::new();
cu.set(); cu.set();
crate::platform::early_init(); let mut csprng = crate::platform::early_init();
csprng.random_delay();
bollard!(4);
// Mesh check takes 100ms for the signal to propagate. Setup the mesh check here, then check the
// result in boot1. In boot1, the opposite state (`true`) is checked.
mesh_setup(false, None);
bollard!(4);
crate::println!("\n~~boot0 up! ({})~~\n", crate::version::SEMVER); crate::println!("\n~~boot0 up! ({})~~\n", crate::version::SEMVER);
csprng.random_delay(); // always random-delay after printing
#[cfg(feature = "unsafe-dev")] #[cfg(feature = "unsafe-dev")]
let mut repl = crate::repl::Repl::new(); let mut repl = crate::repl::Repl::new();
@ -92,28 +106,45 @@ pub unsafe extern "C" fn rust_entry() -> ! {
#[cfg(feature = "print-ifr")] #[cfg(feature = "print-ifr")]
print_ifr(); print_ifr();
// glitch_safety: another delay and PLL check, for good measure
csprng.random_delay();
check_pll();
bollard!(die, 4);
let owc = OneWayCounter::new();
// check that the boot0 pub keys match those burned into the indelible key area // check that the boot0 pub keys match those burned into the indelible key area
// glitch_safety: I'd imagine that glitching in this routine would lead to good_compare being `false`,
// so no additional hardening is done.
let pubkey_ptr = bao1x_api::BOOT0_START as *const bao1x_api::signatures::SignatureInFlash; let pubkey_ptr = bao1x_api::BOOT0_START as *const bao1x_api::signatures::SignatureInFlash;
let pk_src: &bao1x_api::signatures::SignatureInFlash = unsafe { pubkey_ptr.as_ref().unwrap() }; let pk_src: &bao1x_api::signatures::SignatureInFlash = unsafe { pubkey_ptr.as_ref().unwrap() };
let reference_keys = let reference_keys =
[bao1x_api::BAO1_PUBKEY, bao1x_api::BAO2_PUBKEY, bao1x_api::BETA_PUBKEY, bao1x_api::DEV_PUBKEY]; [bao1x_api::BAO1_PUBKEY, bao1x_api::BAO2_PUBKEY, bao1x_api::BETA_PUBKEY, bao1x_api::DEV_PUBKEY];
let slot_mgr = bao1x_hal::acram::SlotManager::new(); let slot_mgr = bao1x_hal::acram::SlotManager::new();
let mut good_compare = true; let mut good_compare = HardenedBool::TRUE;
for (boot0_key, ref_key) in pk_src.sealed_data.pubkeys.iter().zip(reference_keys.iter()) { for (boot0_key, ref_key) in pk_src.sealed_data.pubkeys.iter().zip(reference_keys.iter()) {
let ref_data = slot_mgr.read(&ref_key).unwrap(); let ref_data = slot_mgr.read(&ref_key).unwrap();
if ref_data != &boot0_key.pk { if ref_data != &boot0_key.pk {
good_compare = false; good_compare = HardenedBool::FALSE;
} }
} }
if !good_compare {
let owc = OneWayCounter::new(); csprng.random_delay();
// safety: the offset is from a pre-validated constant, which meets the safety requirement match good_compare.is_true() {
unsafe { Some(false) => {
owc.inc(BOOT0_PUBKEY_FAIL).unwrap(); bollard!(die, 4);
// safety: the offset is from a pre-validated constant, which meets the safety requirement
unsafe {
owc.inc(BOOT0_PUBKEY_FAIL).unwrap();
}
// erase secrets if the boot0 pubkey doesn't check out.
bollard!(die, 4);
bao1x_hal::sigcheck::erase_secrets(&mut Some(&mut csprng));
} }
// erase secrets if the boot0 pubkey doesn't check out. Some(true) => (),
bao1x_hal::sigcheck::erase_secrets(); None => die(),
} }
bollard!(die, 4);
// self-validate the image with the keys we put in, just to make sure our code wasn't tampered with // self-validate the image with the keys we put in, just to make sure our code wasn't tampered with
if bao1x_hal::sigcheck::validate_image( if bao1x_hal::sigcheck::validate_image(
bao1x_api::BOOT0_START as *const u32, bao1x_api::BOOT0_START as *const u32,
@ -122,10 +153,13 @@ pub unsafe extern "C" fn rust_entry() -> ! {
&[FunctionCode::Boot0 as u32], // only boot0 is allowed for boot0 &[FunctionCode::Boot0 as u32], // only boot0 is allowed for boot0
false, false,
None, None,
Some(&mut csprng),
) )
.is_ok() .is_ok()
{ {
seal_boot0_keys(); seal_boot0_keys();
bollard!(die, 4);
let allowed_functions = let allowed_functions =
[FunctionCode::Boot1 as u32, FunctionCode::UpdatedBoot1 as u32, FunctionCode::Developer as u32]; [FunctionCode::Boot1 as u32, FunctionCode::UpdatedBoot1 as u32, FunctionCode::Developer as u32];
let one_way_access = bao1x_hal::acram::OneWayCounter::new(); let one_way_access = bao1x_hal::acram::OneWayCounter::new();
@ -139,6 +173,7 @@ pub unsafe extern "C" fn rust_entry() -> ! {
&allowed_functions, &allowed_functions,
true, true,
None, None,
Some(&mut csprng),
) )
.ok(); .ok();
bao1x_hal::sigcheck::validate_image( bao1x_hal::sigcheck::validate_image(
@ -148,6 +183,7 @@ pub unsafe extern "C" fn rust_entry() -> ! {
&allowed_functions, &allowed_functions,
true, true,
None, None,
Some(&mut csprng),
) )
.ok(); .ok();
} }
@ -160,6 +196,7 @@ pub unsafe extern "C" fn rust_entry() -> ! {
&allowed_functions, &allowed_functions,
true, true,
None, None,
Some(&mut csprng),
) )
.ok(); .ok();
bao1x_hal::sigcheck::validate_image( bao1x_hal::sigcheck::validate_image(
@ -169,6 +206,7 @@ pub unsafe extern "C" fn rust_entry() -> ! {
&allowed_functions, &allowed_functions,
true, true,
None, None,
Some(&mut csprng),
) )
.ok(); .ok();
} }

View file

@ -140,8 +140,9 @@ impl Repl {
&[FunctionCode::Boot0 as u32], // only boot0 is allowed for boot0 &[FunctionCode::Boot0 as u32], // only boot0 is allowed for boot0
false, false,
None, None,
None,
) { ) {
Ok(key_number) => crate::println!("sigcheck passed on key {}", key_number), Ok(key_number, _key_number2, _id) => crate::println!("sigcheck passed on key {}", key_number),
Err(e) => crate::println!("sigcheck failed: {}", e), Err(e) => crate::println!("sigcheck failed: {}", e),
}, },
"reps" => { "reps" => {
@ -169,6 +170,7 @@ impl Repl {
&[FunctionCode::Boot0 as u32], // only boot0 is allowed for boot0 &[FunctionCode::Boot0 as u32], // only boot0 is allowed for boot0
false, false,
None, None,
None,
) )
.ok(); .ok();
count += 1; count += 1;