diff --git a/services/keystore/Cargo.toml b/services/keystore/Cargo.toml index 4d9db3fdb..73480aa2e 100644 --- a/services/keystore/Cargo.toml +++ b/services/keystore/Cargo.toml @@ -75,6 +75,9 @@ hkdf = "0.12.4" [features] bao1x = ["utralib/bao1x", "aes/bao1x"] + +debug-hal = ["bao1x-hal/debug-print-duart"] + board-baosec = [ "utralib/bao1x", "keystore-api/gen2", diff --git a/services/keystore/src/main.rs b/services/keystore/src/main.rs index 21ff99651..8ae6badce 100644 --- a/services/keystore/src/main.rs +++ b/services/keystore/src/main.rs @@ -3,6 +3,8 @@ use keystore_api::*; mod platform; fn main() -> ! { + #[cfg(feature = "debug-hal")] + bao1x_hal::claim_duart(); log_server::init_wait().unwrap(); log::set_max_level(log::LevelFilter::Info); log::info!("my PID is {}", xous::process::id()); @@ -57,8 +59,11 @@ fn attack_keystore() { let slot_mgr = bao1x_hal::acram::SlotManager::new(); // let slot = bao1x_api::baosec::ROOT_SEED; - let slot = - bao1x_api::offsets::SlotIndex::Key(0, bao1x_api::PartitionAccess::Fw0, bao1x_api::RwPerms::ReadOnly); + let slot = bao1x_api::offsets::SlotIndex::Data( + 256, + bao1x_api::PartitionAccess::Fw0, + bao1x_api::RwPerms::ReadOnly, + ); let data_index = slot.try_into_data_offset().unwrap(); let acl_index = slot.try_into_acl_offset().unwrap(); let user_states = [ @@ -74,8 +79,8 @@ fn attack_keystore() { cu.rmwf(utra::coreuser::USERVALUE_USER2, state.as_dense()); log::info!(" COREUSER STATUS {:x}", cu.r(utra::coreuser::STATUS)); unsafe { - let bytes = slot_mgr.read_key_slot(data_index); - let acl = slot_mgr.get_key_acl(acl_index); + let bytes = slot_mgr.read_data_slot(data_index); + let acl = slot_mgr.get_data_acl(acl_index); log::info!( " Key {} ({:x?}): {:x?}", data_index / bao1x_api::offsets::SLOT_ELEMENT_LEN_BYTES, diff --git a/services/keystore/src/platform/baosec/server.rs b/services/keystore/src/platform/baosec/server.rs index 54affb42a..05ad74622 100644 --- a/services/keystore/src/platform/baosec/server.rs +++ b/services/keystore/src/platform/baosec/server.rs @@ -8,7 +8,11 @@ use crate::platform::KeyStore; pub fn keystore(sid: SID) -> ! { let hal = bao1x_hal_service::Hal::new(); let mut rram = Reram::new(); - let mut store = KeyStore::init_from_hw(&mut rram); + let mut store = KeyStore::init_mappings(&mut rram); + // does nothing if the keys are already initialized + store.ensure_system_init(&mut rram); + // derive the master key + store.derive_master_key(); let mut msg_opt = None; diff --git a/services/keystore/src/platform/baosec/store.rs b/services/keystore/src/platform/baosec/store.rs index 7dc5b72f2..f8c3aa58c 100644 --- a/services/keystore/src/platform/baosec/store.rs +++ b/services/keystore/src/platform/baosec/store.rs @@ -1,6 +1,8 @@ use aes::Aes256; use aes::cipher::{BlockDecrypt, BlockEncrypt, KeyInit, generic_array::GenericArray}; -use bao1x_api::{BOOT0_PUBKEY_FAIL, CP_ID, DEVELOPER_MODE, OEM_MODE, UUID}; +use bao1x_api::{ + BOOT0_PUBKEY_FAIL, BoardTypeCoding, CP_ID, DEVELOPER_MODE, OEM_MODE, SLOT_ELEMENT_LEN_BYTES, UUID, +}; use bao1x_hal::{ acram::{OneWayCounter, SlotManager}, board::{CHAFF_KEYS, NUISANCE_KEYS_0, NUISANCE_KEYS_1, ROOT_SEED}, @@ -10,6 +12,7 @@ use hkdf::Hkdf; use keystore_api::KeyWrapper; use rand::prelude::*; use sha2::Sha256; +use utralib::utra::coresub_sramtrm; use crate::*; @@ -18,16 +21,74 @@ const KEY_LEN: usize = bao1x_api::SLOT_ELEMENT_LEN_BYTES; pub struct KeyStore { slot_mgr: SlotManager, owc: OneWayCounter, - master_key: [u8; KEY_LEN], + master_key: Option<[u8; KEY_LEN]>, } impl KeyStore { - pub fn init_from_hw(rram: &mut Reram) -> Self { + pub fn init_mappings(rram: &mut Reram) -> Self { let slot_mgr = SlotManager::new(); slot_mgr.register_mapping(rram); let owc = OneWayCounter::new(); owc.register_mapping(rram); + Self { slot_mgr, owc, master_key: None } + } + + pub fn ensure_system_init(&mut self, rram: &mut Reram) { + let coreuser_range = xous::map_memory( + xous::MemoryAddress::new(utralib::utra::coreuser::HW_COREUSER_BASE), + None, + 4096, + xous::MemoryFlags::R | xous::MemoryFlags::W, + ) + .expect("Couldn't map coreuser range"); + let mut coreuser = utralib::CSR::new(coreuser_range.as_mut_ptr() as *mut u32); + log::info!("coreuser status: {:x}", coreuser.r(utralib::utra::coreuser::STATUS)); + // one routine works for both dabao and baosec + let board_type = self.owc.get_decoded::().unwrap(); + if (board_type == bao1x_api::BoardTypeCoding::Baosec + && self.owc.get(bao1x_api::IN_SYSTEM_BOOT_SETUP_DONE).unwrap() == 0) + || (board_type == bao1x_api::BoardTypeCoding::Dabao + && self.owc.get(bao1x_api::INVOKE_DABAO_KEY_SETUP).unwrap() != 0 + && self.owc.get(bao1x_api::DABAO_KEY_SETUP_DONE).unwrap() == 0) + { + log::info!("System setup not yet done. Initializing secret identifiers..."); + let xns = xous_names::XousNames::new().unwrap(); + let mut trng = bao1x_hal_service::trng::Trng::new(&xns).unwrap(); + // generate all the keys + let key_set = if board_type == bao1x_api::BoardTypeCoding::Baosec { + &bao1x_api::baosec::KEY_SLOTS[..] + } else { + &bao1x_api::dabao::KEY_SLOTS[..] + }; + let mut success = true; + for key_range in key_set.iter() { + let mut storage = Vec::::with_capacity(key_range.len() * SLOT_ELEMENT_LEN_BYTES); + storage.resize(key_range.len() * SLOT_ELEMENT_LEN_BYTES, 0); + trng.fill_bytes(&mut storage); + match self.slot_mgr.write(rram, key_range, &storage) { + Ok(_) => {} + Err(e) => { + success = false; + log::error!("Couldn't initialize slot {:?}: {:?}", key_range, e); + } + } + } + // once all values are written, advance the IN_SYSTEM_BOOT_SETUP_DONE state + // safety: the offset is correct because we're pulling it from our pre-defined constants and + // those are manually checked. + if success { + if board_type == bao1x_api::BoardTypeCoding::Baosec { + unsafe { self.owc.inc(bao1x_api::IN_SYSTEM_BOOT_SETUP_DONE).unwrap() }; + } else if board_type == bao1x_api::BoardTypeCoding::Dabao { + unsafe { self.owc.inc(bao1x_api::DABAO_KEY_SETUP_DONE).unwrap() }; + } + } + log::info!("Secret ID init done."); + } + } + + pub fn derive_master_key(&mut self) { let mut ikm = Vec::::new(); let mut salt = Vec::::new(); let mut info = Vec::::new(); @@ -37,7 +98,7 @@ impl KeyStore { // should stop/panic at that line. Kicking the error up the stack isn't useful. // read key material - ikm.extend_from_slice(slot_mgr.read(&ROOT_SEED).unwrap()); + ikm.extend_from_slice(self.slot_mgr.read(&ROOT_SEED).unwrap()); // build nuisance key offsets - this is direct readout hardening let nk0 = NUISANCE_KEYS_0.try_into_data_iter().unwrap(); @@ -71,7 +132,7 @@ impl KeyStore { // safety: the offset is generated by the try_into_data_iter method, which generates // safe offsets for (cx, &src) in - chaff_xor.iter_mut().zip(unsafe { slot_mgr.read_key_slot(chaff_offset) }) + chaff_xor.iter_mut().zip(unsafe { self.slot_mgr.read_data_slot(chaff_offset) }) { *cx ^= src; } @@ -82,7 +143,7 @@ impl KeyStore { // safety: the offset is generated by the try_into_data_iter method, which generates // safe offsets for (cx, &src) in - ct_xor.iter_mut().zip(unsafe { slot_mgr.read_key_slot(chaff_offset) }) + ct_xor.iter_mut().zip(unsafe { self.slot_mgr.read_data_slot(chaff_offset) }) { *cx ^= src; } @@ -95,13 +156,15 @@ impl KeyStore { // get the nuisance key, in-order // safety: the offset is generated by the try_into_data_iter method, which generates safe offsets - ikm.extend_from_slice(unsafe { slot_mgr.read_key_slot(nk_offset) }); + ikm.extend_from_slice(unsafe { self.slot_mgr.read_data_slot(nk_offset) }); } // Drain the remainder. There's always going to be four keys left over because the NUISANCE array // isn't evenly sized due to the -A1 stepping bug. I think this isn't damning because the actual // ordering of the chaff is unknown at this point, and it's always the same amount. for remaining_chaff in chaff.drain(..) { - for (cx, &src) in chaff_xor.iter_mut().zip(unsafe { slot_mgr.read_key_slot(remaining_chaff) }) { + for (cx, &src) in + chaff_xor.iter_mut().zip(unsafe { self.slot_mgr.read_data_slot(remaining_chaff) }) + { *cx ^= src; } } @@ -113,24 +176,24 @@ impl KeyStore { // add salt // UUID is a random unique number made by the TRNG - salt.extend_from_slice(slot_mgr.read(&UUID).unwrap()); + salt.extend_from_slice(self.slot_mgr.read(&UUID).unwrap()); // CP_ID is a sequentially incrementing number that is included just in case something went horribly // wrong with the TRNG during ID generation - this gives us at least *some* guaranteed uniqueness, // but not randomness. - salt.extend_from_slice(slot_mgr.read(&CP_ID).unwrap()); + salt.extend_from_slice(self.slot_mgr.read(&CP_ID).unwrap()); // add info - if owc.get(DEVELOPER_MODE).unwrap() != 0 { + if self.owc.get(DEVELOPER_MODE).unwrap() != 0 { info.extend_from_slice(b"dev"); } else { info.extend_from_slice(b"sec"); } - if owc.get(OEM_MODE).unwrap() != 0 { + if self.owc.get(OEM_MODE).unwrap() != 0 { info.extend_from_slice(b"oem"); } - if owc.get(BOOT0_PUBKEY_FAIL).unwrap() != 0 { + if self.owc.get(BOOT0_PUBKEY_FAIL).unwrap() != 0 { info.extend_from_slice(b"tampered"); } @@ -148,18 +211,17 @@ impl KeyStore { log::warn!("Chaff result is all-0. Confirming that we're in developer mode"); // panic if we're not in developer mode assert!( - owc.get(DEVELOPER_MODE).unwrap() != 0, + self.owc.get(DEVELOPER_MODE).unwrap() != 0, "Either we have the most improbable chaff, or (more likely) the chaff is set to all 0's" ); } - - Self { slot_mgr, owc, master_key } + self.master_key = Some(master_key); } pub fn aes_kwp(&self, kwp: &mut KeyWrapper) -> Result<(), xous::Error> { use aes_kw::Kek; use aes_kw::KekAes256; - let keywrapper: KekAes256 = Kek::from(self.master_key); + let keywrapper: KekAes256 = Kek::from(self.master_key.ok_or(xous::Error::UseBeforeInit)?); match kwp.op { KeyWrapOp::Wrap => { match keywrapper.wrap_with_padding_vec(&kwp.data[..kwp.len as usize]) { @@ -226,7 +288,7 @@ impl KeyStore { AesOpType::Decrypt => AesOpType::Decrypt, AesOpType::Encrypt => AesOpType::Encrypt, }; - let hk = Hkdf::::new(None, &self.master_key); + let hk = Hkdf::::new(None, &self.master_key.ok_or(xous::Error::UseBeforeInit)?); let mut okm = [0u8; 32]; hk.expand(&aes_op.domain.as_bytes(), &mut okm).expect("32 is a valid length for Sha256 to output"); let cipher = Aes256::new(GenericArray::from_slice(&okm));