cleanup pddb for gen2 targets

gate out modals entirely from gen2 pddb

passwords in gen2 are now entirely handled outside of the
respective service crates, cleaning up the APIs

some history - on gen1 (precursor) devices, the thesis was to
reduce the amount of distance a password has to travel from
the point of a user entering it to the point of use. I think this
is academically interesting, but it pulls in a lot of code
into each service to manage the passwords, conflating services
with UI layers.

it was a nice experiment.

in gen2 (and hopefully beyond) targets, we now commit to
the idea that something else is passing in the sensitive key
materials. This means that, in fact, keying material has to
transition between process spaces, which increases the attack
surface to recover this. However, it also makes the crates
more portable and maintainable.

This is mitigated partially by the fact that in gen2 targets
the entirety of the code base runs within a piece of silicon,
so "sniffing" (passive observation of data going to memory)
attacks are a good bit harder.
This commit is contained in:
bunnie 2025-11-08 03:52:39 +08:00
parent 792de177b0
commit fa8325c2ed
5 changed files with 258 additions and 121 deletions

View file

@ -62,19 +62,20 @@ utralib = { version = "0.1.26", optional = true, default-features = false }
perflib = { path = "../../libs/perflib", optional = true } perflib = { path = "../../libs/perflib", optional = true }
# Gen-2 dependencies # Gen-2 dependencies
keystore = { path = "../keystore", optional = true } # contains all key handlers keystore = { path = "../keystore", optional = true } # contains all key handlers
xous-swapper = { path = "../xous-swapper", optional = true } # contains spinor xous-swapper = { path = "../xous-swapper", optional = true } # contains spinor
bao1x-hal-service = { path = "../bao1x-hal-service", optional = true } bao1x-hal-service = { path = "../bao1x-hal-service", optional = true }
bao1x-emu = { path = "../bao1x-emu", optional = true, default-features = false } bao1x-emu = { path = "../bao1x-emu", optional = true, default-features = false }
bao1x-hal = { path = "../../libs/bao1x-hal", optional = true } bao1x-hal = { path = "../../libs/bao1x-hal", optional = true }
hex = { version = "0.4.3", default-features = false, features = [
"alloc",
], optional = true }
[target.'cfg(any(windows,unix))'.dependencies] [target.'cfg(any(windows,unix))'.dependencies]
rand = "0.8.5" rand = "0.8.5"
rand_chacha = "0.3.1" rand_chacha = "0.3.1"
hex = { version = "0.4.3", default-features = false, features = [
"alloc",
], optional = true }
[features] [features]
gen1 = [ gen1 = [
@ -89,7 +90,7 @@ gen1 = [
"modals", "modals",
"precursor-hal", "precursor-hal",
] ]
gen2 = ["keystore", "keystore-api/gen2"] gen2 = ["keystore", "keystore-api/gen2", "hex"]
# gen 1 targets # gen 1 targets
precursor = ["utralib/precursor", "sha2/precursor", "gen1", "aes/precursor"] precursor = ["utralib/precursor", "sha2/precursor", "gen1", "aes/precursor"]
vexii-test = ["precursor-hal/vexii-test", "aes/vexii-test"] vexii-test = ["precursor-hal/vexii-test", "aes/vexii-test"]
@ -102,6 +103,7 @@ board-baosec = [
"xous-swapper/board-baosec", "xous-swapper/board-baosec",
"bao1x-hal-service/board-baosec", "bao1x-hal-service/board-baosec",
"bao1x-hal/board-baosec", "bao1x-hal/board-baosec",
# modals is needed exclusively to know the type to make a None for
"modals/board-baosec", "modals/board-baosec",
"keystore/board-baosec", "keystore/board-baosec",
"aes/bao1x", "aes/bao1x",

View file

@ -311,6 +311,7 @@ pub struct PddbBasisRequest {
pub name: String, pub name: String,
pub code: PddbRequestCode, pub code: PddbRequestCode,
pub policy: Option<BasisRetentionPolicy>, pub policy: Option<BasisRetentionPolicy>,
pub basis_key: Option<[u8; 32]>,
} }
#[derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize, Clone)] #[derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize, Clone)]
pub struct PddbDictRequest { pub struct PddbDictRequest {

View file

@ -8,15 +8,18 @@ use std::collections::HashMap;
#[cfg(any(all(feature = "pddbtest", feature = "autobasis"), not(feature = "deterministic")))] #[cfg(any(all(feature = "pddbtest", feature = "autobasis"), not(feature = "deterministic")))]
use std::collections::HashSet; use std::collections::HashSet;
use std::convert::TryInto; use std::convert::TryInto;
#[allow(unused_imports)]
use std::io::{Error, ErrorKind, Result}; use std::io::{Error, ErrorKind, Result};
#[cfg(feature = "gen1")]
use aes::BLOCK_SIZE;
use aes::cipher::{BlockDecrypt, BlockEncrypt, generic_array::GenericArray}; use aes::cipher::{BlockDecrypt, BlockEncrypt, generic_array::GenericArray};
use aes::{Aes256, BLOCK_SIZE, Block}; use aes::{Aes256, Block};
use aes_gcm_siv::aead::{Aead, Payload}; use aes_gcm_siv::aead::{Aead, Payload};
use aes_gcm_siv::{Aes256GcmSiv, Nonce, Tag}; use aes_gcm_siv::{Aes256GcmSiv, Nonce, Tag};
use backend::bcrypt::*; use backend::bcrypt::*;
#[cfg(all(feature = "gen2"))] #[cfg(all(feature = "gen2"))]
use bao1x_hal::board::{BOOKEND_END, BOOKEND_START, SPINOR_BULK_ERASE_SIZE, SPINOR_ERASE_SIZE}; use bao1x_hal::board::{SPINOR_BULK_ERASE_SIZE, SPINOR_ERASE_SIZE};
#[cfg(feature = "gen1")] #[cfg(feature = "gen1")]
use keystore_api::AesRootkeyType; use keystore_api::AesRootkeyType;
use keystore_api::{Checksums, KeywrapError}; use keystore_api::{Checksums, KeywrapError};
@ -960,12 +963,8 @@ impl PddbOs {
self.cipher_ecb = None; self.cipher_ecb = None;
} }
pub(crate) fn clear_password(&self) { #[cfg(feature = "gen1")]
#[cfg(feature = "gen1")] pub(crate) fn clear_password(&self) { self.rootkeys.clear_password(AesRootkeyType::User0); }
self.rootkeys.clear_password(AesRootkeyType::User0);
#[cfg(feature = "gen2")]
self.rootkeys.clear_password();
}
#[cfg(feature = "gen2")] #[cfg(feature = "gen2")]
pub(crate) fn ensure_password(&mut self) -> PasswordState { pub(crate) fn ensure_password(&mut self) -> PasswordState {
@ -977,7 +976,7 @@ impl PddbOs {
use aes::cipher::KeyInit; use aes::cipher::KeyInit;
if self.system_basis_key.is_none() || self.cipher_ecb.is_none() { if self.system_basis_key.is_none() || self.cipher_ecb.is_none() {
let scd = self.static_crypto_data_get(); let scd = self.static_crypto_data_get();
if scd.version == 0xFFFF_FFFF { if scd.version == 0xFFFF_FFFF || scd.version == 0x0000_0000 {
// system is in the blank state // system is in the blank state
return PasswordState::Uninit; return PasswordState::Uninit;
} }
@ -1077,6 +1076,7 @@ impl PddbOs {
} }
fn syskey_ensure(&mut self) { fn syskey_ensure(&mut self) {
#[cfg(feature = "gen1")]
while self.try_login() != PasswordState::Correct { while self.try_login() != PasswordState::Correct {
self.clear_password(); // clear the bad password entry self.clear_password(); // clear the bad password entry
let xns = xous_names::XousNames::new().unwrap(); let xns = xous_names::XousNames::new().unwrap();
@ -2176,6 +2176,7 @@ impl PddbOs {
} }
} }
#[cfg(feature = "gen1")]
fn pw_check(&self, modals: &modals::Modals) -> Result<()> { fn pw_check(&self, modals: &modals::Modals) -> Result<()> {
let mut success = false; let mut success = false;
while !success { while !success {
@ -2208,6 +2209,7 @@ impl PddbOs {
} }
/// this function attempts to change the PIN. returns Ok() if changed, error if not. /// this function attempts to change the PIN. returns Ok() if changed, error if not.
#[cfg(feature = "gen1")]
pub(crate) fn pddb_change_pin(&mut self, modals: &modals::Modals) -> Result<()> { pub(crate) fn pddb_change_pin(&mut self, modals: &modals::Modals) -> Result<()> {
if let Some(system_keys) = &self.system_basis_key { if let Some(system_keys) = &self.system_basis_key {
// get the new password // get the new password
@ -2251,6 +2253,7 @@ impl PddbOs {
)); ));
} }
// step 0. If we have a modal, confirm that the password entered was correct with a double-entry. // step 0. If we have a modal, confirm that the password entered was correct with a double-entry.
#[cfg(feature = "gen1")]
if let Some(modals) = progress { if let Some(modals) = progress {
self.pw_check(modals)?; self.pw_check(modals)?;
} }
@ -2258,6 +2261,7 @@ impl PddbOs {
// step 1. Erase the entire PDDB region - leaves the state in all 1's // step 1. Erase the entire PDDB region - leaves the state in all 1's
if !fast { if !fast {
log::info!("Erasing the PDDB region"); log::info!("Erasing the PDDB region");
#[cfg(feature = "gen1")]
if let Some(modals) = progress { if let Some(modals) = progress {
modals modals
.start_progress( .start_progress(
@ -2307,6 +2311,7 @@ impl PddbOs {
} }
} }
} }
#[cfg(feature = "gen1")]
if let Some(modals) = progress { if let Some(modals) = progress {
modals.update_progress(PDDB_A_LOC + PDDB_A_LEN as u32).expect("couldn't update progress bar"); modals.update_progress(PDDB_A_LOC + PDDB_A_LEN as u32).expect("couldn't update progress bar");
modals.finish_progress().expect("couldn't dismiss progress bar"); modals.finish_progress().expect("couldn't dismiss progress bar");
@ -2316,6 +2321,7 @@ impl PddbOs {
} }
// step 2. fill in the page table with junk, which marks it as cryptographically empty // step 2. fill in the page table with junk, which marks it as cryptographically empty
#[cfg(feature = "gen1")]
if let Some(modals) = progress { if let Some(modals) = progress {
modals modals
.start_progress(t!("pddb.initpt", locales::LANG), 0, size_of::<PageTableInFlash>() as u32, 0) .start_progress(t!("pddb.initpt", locales::LANG), 0, size_of::<PageTableInFlash>() as u32, 0)
@ -2331,6 +2337,7 @@ impl PddbOs {
} }
} }
} }
#[cfg(feature = "gen1")]
if let Some(modals) = progress { if let Some(modals) = progress {
modals modals
.update_progress(size_of::<PageTableInFlash>() as u32) .update_progress(size_of::<PageTableInFlash>() as u32)
@ -2348,6 +2355,7 @@ impl PddbOs {
} }
self.patch_pagetable_raw(&temp, remainder_start as u32); self.patch_pagetable_raw(&temp, remainder_start as u32);
} }
#[cfg(feature = "gen1")]
if let Some(modals) = progress { if let Some(modals) = progress {
modals.finish_progress().expect("couldn't dismiss progress bar"); modals.finish_progress().expect("couldn't dismiss progress bar");
#[cfg(feature = "ux-swap-delay")] #[cfg(feature = "ux-swap-delay")]
@ -2359,6 +2367,7 @@ impl PddbOs {
//if !self.rootkeys.ensure_aes_password() { //if !self.rootkeys.ensure_aes_password() {
// return Err(Error::new(ErrorKind::PermissionDenied, "unlock password was incorrect")); // return Err(Error::new(ErrorKind::PermissionDenied, "unlock password was incorrect"));
//} //}
#[cfg(feature = "gen1")]
if let Some(modals) = progress { if let Some(modals) = progress {
modals modals
.start_progress(t!("pddb.key", locales::LANG), 0, 100, 0) .start_progress(t!("pddb.key", locales::LANG), 0, 100, 0)
@ -2385,6 +2394,7 @@ impl PddbOs {
self.system_basis_key = Some(BasisKeys { pt: system_basis_key_pt, data: system_basis_key }); // this causes system_basis_key to be owned by self and go out of scope self.system_basis_key = Some(BasisKeys { pt: system_basis_key_pt, data: system_basis_key }); // this causes system_basis_key to be owned by self and go out of scope
let mut crypto_keys = StaticCryptoData::default(); let mut crypto_keys = StaticCryptoData::default();
crypto_keys.version = SCD_VERSION; // should already be set by `default()` but let's be sure. crypto_keys.version = SCD_VERSION; // should already be set by `default()` but let's be sure.
#[cfg(feature = "gen1")]
if let Some(modals) = progress { if let Some(modals) = progress {
modals.update_progress(50).expect("couldn't update progress bar"); modals.update_progress(50).expect("couldn't update progress bar");
#[cfg(feature = "ux-swap-delay")] #[cfg(feature = "ux-swap-delay")]
@ -2404,6 +2414,7 @@ impl PddbOs {
self.entropy.borrow_mut().get_slice(&mut crypto_keys.salt_base); self.entropy.borrow_mut().get_slice(&mut crypto_keys.salt_base);
// commit keys // commit keys
self.patch_keys(crypto_keys.deref(), 0); self.patch_keys(crypto_keys.deref(), 0);
#[cfg(feature = "gen1")]
if let Some(modals) = progress { if let Some(modals) = progress {
modals.update_progress(100).expect("couldn't update progress bar"); modals.update_progress(100).expect("couldn't update progress bar");
#[cfg(feature = "ux-swap-delay")] #[cfg(feature = "ux-swap-delay")]
@ -2425,6 +2436,7 @@ impl PddbOs {
// step 5. fscb handling // step 5. fscb handling
// pick a set of random pages from the free pool and assign it to the fscb // pick a set of random pages from the free pool and assign it to the fscb
// pass the generator an empty cache - this causes it to treat the entire disk as free space // pass the generator an empty cache - this causes it to treat the entire disk as free space
#[cfg(feature = "gen1")]
if let Some(modals) = progress { if let Some(modals) = progress {
modals modals
.start_progress(t!("pddb.fastspace", locales::LANG), 0, 100, 0) .start_progress(t!("pddb.fastspace", locales::LANG), 0, 100, 0)
@ -2436,6 +2448,7 @@ impl PddbOs {
for (&src, dst) in free_pool.iter().zip(fast_space.free_pool.iter_mut()) { for (&src, dst) in free_pool.iter().zip(fast_space.free_pool.iter_mut()) {
*dst = src; *dst = src;
} }
#[cfg(feature = "gen1")]
if let Some(modals) = progress { if let Some(modals) = progress {
modals.update_progress(50).expect("couldn't update progress bar"); modals.update_progress(50).expect("couldn't update progress bar");
#[cfg(feature = "ux-swap-delay")] #[cfg(feature = "ux-swap-delay")]
@ -2457,6 +2470,7 @@ impl PddbOs {
// step 5. salt the free space with random numbers. this can take a while, we might need a "progress // step 5. salt the free space with random numbers. this can take a while, we might need a "progress
// report" of some kind... this is coded using "direct disk" offsets...under the assumption // report" of some kind... this is coded using "direct disk" offsets...under the assumption
// that we only ever really want to do this here, and not re-use this routine elsewhere. // that we only ever really want to do this here, and not re-use this routine elsewhere.
#[cfg(feature = "gen1")]
if let Some(modals) = progress { if let Some(modals) = progress {
modals modals
.start_progress( .start_progress(
@ -2510,6 +2524,7 @@ impl PddbOs {
#[cfg(all(feature = "gen2", target_os = "xous"))] #[cfg(all(feature = "gen2", target_os = "xous"))]
self.patch(&temp, offset); self.patch(&temp, offset);
} }
#[cfg(feature = "gen1")]
if let Some(modals) = progress { if let Some(modals) = progress {
modals.update_progress(PDDB_A_LEN as u32).expect("couldn't update progress bar"); modals.update_progress(PDDB_A_LEN as u32).expect("couldn't update progress bar");
#[cfg(feature = "ux-swap-delay")] #[cfg(feature = "ux-swap-delay")]
@ -2520,6 +2535,7 @@ impl PddbOs {
} }
// step 6. create the system basis root structure // step 6. create the system basis root structure
#[cfg(feature = "gen1")]
if let Some(modals) = progress { if let Some(modals) = progress {
modals modals
.start_progress(t!("pddb.structure", locales::LANG), 0, 100, 0) .start_progress(t!("pddb.structure", locales::LANG), 0, 100, 0)
@ -2537,6 +2553,7 @@ impl PddbOs {
// step 7. Create a hashmap for our reverse PTE, allocate sectors, and add it to the Pddb's cache // step 7. Create a hashmap for our reverse PTE, allocate sectors, and add it to the Pddb's cache
self.fast_space_read(); // we reconstitute our fspace map even though it was just generated, partially as a sanity check that everything is ok self.fast_space_read(); // we reconstitute our fspace map even though it was just generated, partially as a sanity check that everything is ok
#[cfg(feature = "gen1")]
if let Some(modals) = progress { if let Some(modals) = progress {
modals.update_progress(33).expect("couldn't update progress bar"); modals.update_progress(33).expect("couldn't update progress bar");
#[cfg(feature = "ux-swap-delay")] #[cfg(feature = "ux-swap-delay")]
@ -2573,6 +2590,7 @@ impl PddbOs {
let syskey = self.system_basis_key.take().unwrap(); // take the key out let syskey = self.system_basis_key.take().unwrap(); // take the key out
self.data_encrypt_and_patch_page_with_commit(&syskey.data, &aad, &mut block, &pp); self.data_encrypt_and_patch_page_with_commit(&syskey.data, &aad, &mut block, &pp);
self.system_basis_key = Some(syskey); // put the key back self.system_basis_key = Some(syskey); // put the key back
#[cfg(feature = "gen1")]
if let Some(modals) = progress { if let Some(modals) = progress {
modals.update_progress(66).expect("couldn't update progress bar"); modals.update_progress(66).expect("couldn't update progress bar");
#[cfg(feature = "ux-swap-delay")] #[cfg(feature = "ux-swap-delay")]
@ -2585,6 +2603,7 @@ impl PddbOs {
// mark the entry as clean, as it has been sync'd to disk // mark the entry as clean, as it has been sync'd to disk
phys.set_clean(true); phys.set_clean(true);
} }
#[cfg(feature = "gen1")]
if let Some(modals) = progress { if let Some(modals) = progress {
modals.update_progress(100).expect("couldn't update progress bar"); modals.update_progress(100).expect("couldn't update progress bar");
#[cfg(feature = "ux-swap-delay")] #[cfg(feature = "ux-swap-delay")]
@ -2693,15 +2712,18 @@ impl PddbOs {
// 0. acquire all the keys // 0. acquire all the keys
if let Some(all_keys) = self.pddb_get_all_keys(&cache) { if let Some(all_keys) = self.pddb_get_all_keys(&cache) {
// build a modals for rekey progress // build a modals for rekey progress
#[cfg(feature = "gen1")]
let xns = xous_names::XousNames::new().unwrap(); let xns = xous_names::XousNames::new().unwrap();
#[cfg(feature = "gen1")]
let modals = modals::Modals::new(&xns).unwrap(); let modals = modals::Modals::new(&xns).unwrap();
#[cfg(feature = "gen1")]
modals.start_progress(t!("pddb.rekey.keys", locales::LANG), 0, all_keys.len() as u32, 0).ok(); modals.start_progress(t!("pddb.rekey.keys", locales::LANG), 0, all_keys.len() as u32, 0).ok();
// we need a map of page numbers to encryption keys. The keys are referenced by their basis name. // we need a map of page numbers to encryption keys. The keys are referenced by their basis name.
let mut pagemap = HashMap::<PhysAddr, &str>::new(); let mut pagemap = HashMap::<PhysAddr, &str>::new();
// transform the returned Vec into a HashMap that maps basis names into pre-keyed ciphers. // transform the returned Vec into a HashMap that maps basis names into pre-keyed ciphers.
let mut keymap = HashMap::<&str, MigrationCiphers>::new(); let mut keymap = HashMap::<&str, MigrationCiphers>::new();
for (index, (basis_keys, name)) in all_keys.iter().enumerate() { for (_index, (basis_keys, name)) in all_keys.iter().enumerate() {
if let Some(map) = self.pt_scan_key(&basis_keys.pt, &basis_keys.data, &name) { if let Some(map) = self.pt_scan_key(&basis_keys.pt, &basis_keys.data, &name) {
for pp in map.values() { for pp in map.values() {
log::info!("page {} -> basis {}", pp.page_number(), name); log::info!("page {} -> basis {}", pp.page_number(), name);
@ -2728,7 +2750,8 @@ impl PddbOs {
data_key: basis_keys.data.into(), data_key: basis_keys.data.into(),
}, },
); );
modals.update_progress(index as u32 + 1).ok(); #[cfg(feature = "gen1")]
modals.update_progress(_index as u32 + 1).ok();
} }
// check that we have no pages in the FSCB that aren't already mapped in the // check that we have no pages in the FSCB that aren't already mapped in the
@ -2746,6 +2769,7 @@ impl PddbOs {
} }
} }
} }
#[cfg(feature = "gen1")]
modals.finish_progress().ok(); modals.finish_progress().ok();
if !clean { if !clean {
log::warn!( log::warn!(
@ -2766,6 +2790,7 @@ impl PddbOs {
let pagetable: &[u8] = unsafe { &self.pddb_mr.as_slice()[..pddb_data_pages * size_of::<Pte>()] }; let pagetable: &[u8] = unsafe { &self.pddb_mr.as_slice()[..pddb_data_pages * size_of::<Pte>()] };
log::info!("Derived page table of len 0x{:x}", pagetable.len()); log::info!("Derived page table of len 0x{:x}", pagetable.len());
let entries_per_page = PAGE_SIZE / size_of::<Pte>(); let entries_per_page = PAGE_SIZE / size_of::<Pte>();
#[cfg(feature = "gen1")]
modals modals
.start_progress( .start_progress(
t!("pddb.rekey.running", locales::LANG), t!("pddb.rekey.running", locales::LANG),
@ -2875,8 +2900,10 @@ impl PddbOs {
self.patch_pagetable_raw(&new_pt_page[..chunk_len], chunk_start_address as u32); self.patch_pagetable_raw(&new_pt_page[..chunk_len], chunk_start_address as u32);
// this only updates once per page of PTEs, so, every 256 pages that get re-encrypted in the // this only updates once per page of PTEs, so, every 256 pages that get re-encrypted in the
// worst case. // worst case.
#[cfg(feature = "gen1")]
modals.update_progress(chunk_start_address as u32).ok(); modals.update_progress(chunk_start_address as u32).ok();
} }
#[cfg(feature = "gen1")]
modals.finish_progress().ok(); modals.finish_progress().ok();
self.dna_mode = DnaMode::Normal; // we're done with the legacy DNA! self.dna_mode = DnaMode::Normal; // we're done with the legacy DNA!
@ -2890,6 +2917,7 @@ impl PddbOs {
}; };
if do_fscb { if do_fscb {
log::info!("regenerating fast space..."); log::info!("regenerating fast space...");
#[cfg(feature = "gen1")]
modals.dynamic_notification(Some(t!("pddb.rekey.fastspace", locales::LANG)), None).ok(); modals.dynamic_notification(Some(t!("pddb.rekey.fastspace", locales::LANG)), None).ok();
// convert our used page map into the structure needed by fast_space_generate() // convert our used page map into the structure needed by fast_space_generate()
let mut page_heap = BinaryHeap::new(); let mut page_heap = BinaryHeap::new();
@ -2913,6 +2941,7 @@ impl PddbOs {
self.fast_space_write(&fast_space); self.fast_space_write(&fast_space);
// this will ensure the data cache is fully in sync // this will ensure the data cache is fully in sync
self.fast_space_read(); self.fast_space_read();
#[cfg(feature = "gen1")]
modals.dynamic_notification_close().ok(); modals.dynamic_notification_close().ok();
log::info!("fast space generation done."); log::info!("fast space generation done.");
} }
@ -2922,6 +2951,21 @@ impl PddbOs {
} }
} }
#[cfg(not(all(feature = "pddbtest", feature = "autobasis")))]
#[cfg(feature = "gen2")]
/// This is a bit unsafe in that it simply returns the list of all the known keys and doesn't
/// prompt the user to enter any hidden bases. However, for gen2-targets, we're simplifying
/// the basis logic and assuming that the UI is all handled outside of the PDDB.
pub(crate) fn pddb_get_all_keys(&self, cache: &Vec<BasisCacheEntry>) -> Option<Vec<(BasisKeys, String)>> {
// populate the "known" entries
let mut ret = Vec::<(BasisKeys, String)>::new();
for entry in cache {
ret.push((BasisKeys { pt: entry.pt_key.into(), data: entry.key.into() }, entry.name.to_string()));
}
log::info!("{} basis are open, with the following names:", cache.len());
Some(ret)
}
/// UX function that informs the user of the currently open Basis, and prompts the user to enter passwords /// UX function that informs the user of the currently open Basis, and prompts the user to enter passwords
/// for other basis that may not currently be open. This function is also responsible for validating /// for other basis that may not currently be open. This function is also responsible for validating
/// that the password is correct by doing a quick scan for "any" PTEs that happen to decrypt to something /// that the password is correct by doing a quick scan for "any" PTEs that happen to decrypt to something
@ -2929,6 +2973,7 @@ impl PddbOs {
/// a Vec of keys & names, not a BasisCacheEntry -- so it means that the Basis still are "closed" /// a Vec of keys & names, not a BasisCacheEntry -- so it means that the Basis still are "closed"
/// at the conclusion of the sweep, but their page use can be accounted for. /// at the conclusion of the sweep, but their page use can be accounted for.
#[cfg(not(all(feature = "pddbtest", feature = "autobasis")))] #[cfg(not(all(feature = "pddbtest", feature = "autobasis")))]
#[cfg(feature = "gen1")]
pub(crate) fn pddb_get_all_keys(&self, cache: &Vec<BasisCacheEntry>) -> Option<Vec<(BasisKeys, String)>> { pub(crate) fn pddb_get_all_keys(&self, cache: &Vec<BasisCacheEntry>) -> Option<Vec<(BasisKeys, String)>> {
#[cfg(feature = "ux-swap-delay")] #[cfg(feature = "ux-swap-delay")]
const SWAP_DELAY_MS: usize = 300; const SWAP_DELAY_MS: usize = 300;
@ -3074,6 +3119,7 @@ impl PddbOs {
} }
} }
#[cfg(feature = "gen1")]
fn yes_no_approval(&self, modals: &modals::Modals, request: &str) -> bool { fn yes_no_approval(&self, modals: &modals::Modals, request: &str) -> bool {
modals modals
.add_list(vec![t!("pddb.yes", locales::LANG), t!("pddb.no", locales::LANG)]) .add_list(vec![t!("pddb.yes", locales::LANG), t!("pddb.no", locales::LANG)])

View file

@ -318,7 +318,12 @@ impl Pddb {
/// returns the latest basis that is opened -- this is where all new values are being sent by default /// returns the latest basis that is opened -- this is where all new values are being sent by default
/// if the PDDB is not mounted, returns None /// if the PDDB is not mounted, returns None
pub fn latest_basis(&self) -> Option<String> { pub fn latest_basis(&self) -> Option<String> {
let mgmt = PddbBasisRequest { name: String::new(), code: PddbRequestCode::Uninit, policy: None }; let mgmt = PddbBasisRequest {
name: String::new(),
code: PddbRequestCode::Uninit,
policy: None,
basis_key: None,
};
let mut buf = Buffer::into_buf(mgmt).expect("Couldn't convert to memory structure"); let mut buf = Buffer::into_buf(mgmt).expect("Couldn't convert to memory structure");
buf.lend_mut(self.conn, Opcode::LatestBasis.to_u32().unwrap()) buf.lend_mut(self.conn, Opcode::LatestBasis.to_u32().unwrap())
.expect("Couldn't execute ListBasis opcode"); .expect("Couldn't execute ListBasis opcode");
@ -333,12 +338,17 @@ impl Pddb {
} }
} }
#[cfg(feature = "gen1")]
pub fn create_basis(&self, basis_name: &str) -> Result<()> { pub fn create_basis(&self, basis_name: &str) -> Result<()> {
if basis_name.len() > BASIS_NAME_LEN - 1 { if basis_name.len() > BASIS_NAME_LEN - 1 {
return Err(Error::new(ErrorKind::InvalidInput, "basis name too long")); return Err(Error::new(ErrorKind::InvalidInput, "basis name too long"));
} }
let mgmt = let mgmt = PddbBasisRequest {
PddbBasisRequest { name: String::from(basis_name), code: PddbRequestCode::Create, policy: None }; name: String::from(basis_name),
code: PddbRequestCode::Create,
policy: None,
basis_key: None,
};
let mut buf = Buffer::into_buf(mgmt).expect("Couldn't convert to memory structure"); let mut buf = Buffer::into_buf(mgmt).expect("Couldn't convert to memory structure");
buf.lend_mut(self.conn, Opcode::CreateBasis.to_u32().unwrap()) buf.lend_mut(self.conn, Opcode::CreateBasis.to_u32().unwrap())
.expect("Couldn't execute CreateBasis opcode"); .expect("Couldn't execute CreateBasis opcode");
@ -361,11 +371,85 @@ impl Pddb {
} }
} }
#[cfg(feature = "gen2")]
pub fn create_basis(&self, basis_name: &str, basis_key: &[u8; 32]) -> Result<()> {
if basis_name.len() > BASIS_NAME_LEN - 1 {
return Err(Error::new(ErrorKind::InvalidInput, "basis name too long"));
}
let mgmt = PddbBasisRequest {
name: String::from(basis_name),
code: PddbRequestCode::Create,
policy: None,
basis_key: Some(*basis_key),
};
let mut buf = Buffer::into_buf(mgmt).expect("Couldn't convert to memory structure");
buf.lend_mut(self.conn, Opcode::CreateBasis.to_u32().unwrap())
.expect("Couldn't execute CreateBasis opcode");
let ret = buf.to_original::<PddbBasisRequest, _>().expect("couldn't restore mgmt structure");
match ret.code {
PddbRequestCode::NoErr => Ok(()),
PddbRequestCode::NoFreeSpace => {
Err(Error::new(ErrorKind::OutOfMemory, "No free space to create basis"))
}
PddbRequestCode::InternalError => {
Err(Error::new(ErrorKind::Other, "Internal error creating basis"))
}
PddbRequestCode::DuplicateEntry => {
Err(Error::new(ErrorKind::AlreadyExists, "Basis already exists"))
}
_ => {
log::error!("Invalid return code");
panic!("Invalid return code");
}
}
}
#[cfg(feature = "gen1")]
pub fn unlock_basis(&self, basis_name: &str, policy: Option<BasisRetentionPolicy>) -> Result<()> { pub fn unlock_basis(&self, basis_name: &str, policy: Option<BasisRetentionPolicy>) -> Result<()> {
if basis_name.len() > BASIS_NAME_LEN - 1 { if basis_name.len() > BASIS_NAME_LEN - 1 {
return Err(Error::new(ErrorKind::InvalidInput, "basis name too long")); return Err(Error::new(ErrorKind::InvalidInput, "basis name too long"));
} }
let mgmt = PddbBasisRequest { name: String::from(basis_name), code: PddbRequestCode::Open, policy }; let mgmt = PddbBasisRequest {
name: String::from(basis_name),
code: PddbRequestCode::Open,
policy,
basis_key: None,
};
let mut buf = Buffer::into_buf(mgmt).expect("Couldn't convert to memory structure");
buf.lend_mut(self.conn, Opcode::OpenBasis.to_u32().unwrap())
.expect("Couldn't execute OpenBasis opcode");
let ret = buf.to_original::<PddbBasisRequest, _>().expect("couldn't restore mgmt structure");
match ret.code {
PddbRequestCode::NoErr => Ok(()),
PddbRequestCode::AccessDenied => {
Err(Error::new(ErrorKind::PermissionDenied, "Authentication error"))
}
PddbRequestCode::InternalError => {
Err(Error::new(ErrorKind::Other, "Internal error creating basis"))
}
_ => {
log::error!("Invalid return code");
panic!("Invalid return code");
}
}
}
#[cfg(feature = "gen2")]
pub fn unlock_basis(
&self,
basis_name: &str,
basis_key: &[u8; 32],
policy: Option<BasisRetentionPolicy>,
) -> Result<()> {
if basis_name.len() > BASIS_NAME_LEN - 1 {
return Err(Error::new(ErrorKind::InvalidInput, "basis name too long"));
}
let mgmt = PddbBasisRequest {
name: String::from(basis_name),
code: PddbRequestCode::Open,
policy,
basis_key: Some(*basis_key),
};
let mut buf = Buffer::into_buf(mgmt).expect("Couldn't convert to memory structure"); let mut buf = Buffer::into_buf(mgmt).expect("Couldn't convert to memory structure");
buf.lend_mut(self.conn, Opcode::OpenBasis.to_u32().unwrap()) buf.lend_mut(self.conn, Opcode::OpenBasis.to_u32().unwrap())
.expect("Couldn't execute OpenBasis opcode"); .expect("Couldn't execute OpenBasis opcode");
@ -389,8 +473,12 @@ impl Pddb {
if basis_name.len() > BASIS_NAME_LEN - 1 { if basis_name.len() > BASIS_NAME_LEN - 1 {
return Err(Error::new(ErrorKind::InvalidInput, "basis name too long")); return Err(Error::new(ErrorKind::InvalidInput, "basis name too long"));
} }
let mgmt = let mgmt = PddbBasisRequest {
PddbBasisRequest { name: String::from(basis_name), code: PddbRequestCode::Close, policy: None }; name: String::from(basis_name),
code: PddbRequestCode::Close,
policy: None,
basis_key: None,
};
let mut buf = Buffer::into_buf(mgmt).expect("Couldn't convert to memory structure"); let mut buf = Buffer::into_buf(mgmt).expect("Couldn't convert to memory structure");
buf.lend_mut(self.conn, Opcode::CloseBasis.to_u32().unwrap()) buf.lend_mut(self.conn, Opcode::CloseBasis.to_u32().unwrap())
.expect("Couldn't execute CloseBasis opcode"); .expect("Couldn't execute CloseBasis opcode");
@ -412,8 +500,12 @@ impl Pddb {
if basis_name.len() > BASIS_NAME_LEN - 1 { if basis_name.len() > BASIS_NAME_LEN - 1 {
return Err(Error::new(ErrorKind::InvalidInput, "basis name too long")); return Err(Error::new(ErrorKind::InvalidInput, "basis name too long"));
} }
let mgmt = let mgmt = PddbBasisRequest {
PddbBasisRequest { name: String::from(basis_name), code: PddbRequestCode::Delete, policy: None }; name: String::from(basis_name),
code: PddbRequestCode::Delete,
policy: None,
basis_key: None,
};
let mut buf = Buffer::into_buf(mgmt).expect("Couldn't convert to memory structure"); let mut buf = Buffer::into_buf(mgmt).expect("Couldn't convert to memory structure");
buf.lend_mut(self.conn, Opcode::DeleteBasis.to_u32().unwrap()) buf.lend_mut(self.conn, Opcode::DeleteBasis.to_u32().unwrap())
.expect("Couldn't execute DeleteBasis opcode"); .expect("Couldn't execute DeleteBasis opcode");

View file

@ -570,6 +570,7 @@ fn wrapped_main() -> ! {
let entropy = Rc::new(RefCell::new(TrngPool::new())); let entropy = Rc::new(RefCell::new(TrngPool::new()));
// for less-secured user prompts (everything but password entry) // for less-secured user prompts (everything but password entry)
#[cfg(feature = "gen1")]
let modals = modals::Modals::new(&xns).expect("can't connect to Modals server"); let modals = modals::Modals::new(&xns).expect("can't connect to Modals server");
// our very own password modal. Password modals are precious and privately owned, to avoid // our very own password modal. Password modals are precious and privately owned, to avoid
@ -699,8 +700,6 @@ fn wrapped_main() -> ! {
// it is the only server capable of doing this. // it is the only server capable of doing this.
#[cfg(feature = "gen1")] #[cfg(feature = "gen1")]
let time_resetter = xns.request_connection_blocking(crate::TIME_SERVER_PDDB).unwrap(); let time_resetter = xns.request_connection_blocking(crate::TIME_SERVER_PDDB).unwrap();
#[cfg(feature = "gen2")]
let time_resetter = 0; // dummy
// track processes that want a notification of a mount event // track processes that want a notification of a mount event
let mut mount_notifications = Vec::<xous::MessageSender>::new(); let mut mount_notifications = Vec::<xous::MessageSender>::new();
@ -800,67 +799,51 @@ fn wrapped_main() -> ! {
xous::msg_blocking_scalar_unpack!(msg, _, _, _, _, { xous::msg_blocking_scalar_unpack!(msg, _, _, _, _, {
match pddb_os.ensure_password() { match pddb_os.ensure_password() {
PasswordState::Correct => { PasswordState::Correct => {
log::info!("pw correct"); fn try_mount(
if try_mount_or_format( pddb_os: &mut PddbOs,
&modals, basis_cache: &mut BasisCache,
&mut pddb_os, basis_monitor_notifications: &mut Vec<xous::MessageEnvelope>,
&mut basis_cache, ) -> bool {
PasswordState::Correct, if let Some(sys_basis) = pddb_os.pddb_mount() {
time_resetter, log::info!("PDDB mount operation finished successfully");
&mut basis_monitor_notifications, basis_cache.basis_add(sys_basis);
) { if basis_monitor_notifications.len() > 0 {
is_mounted.store(true, Ordering::SeqCst); notify_basis_change(
for requester in mount_notifications.drain(..) { basis_monitor_notifications,
xous::return_scalar2(requester, 0, 0).expect("couldn't return scalar"); basis_cache.basis_list(),
);
}
true
} else {
false
} }
assert!(
mount_notifications.len() == 0,
"apparently I don't understand what drain() does"
);
log::info!("{}PDDB.MOUNTED,{}", BOOKEND_START, BOOKEND_END);
xous::return_scalar2(msg.sender, 0, 0).expect("couldn't return scalar");
} else {
xous::return_scalar2(msg.sender, 1, 0).expect("couldn't return scalar");
} }
// The behavior in gen2 is mount-or-format: no user approval
// is requested in case of format. This is silghtly dangerous in case
// of data corruption but I think this is the "right" user experience
if !try_mount(&mut pddb_os, &mut basis_cache, &mut basis_monitor_notifications) {
log::warn!("PDDB not formatted - formatting the PDDB!");
pddb_os.pddb_format(false, None).expect("couldn't format PDDB");
if !try_mount(
&mut pddb_os,
&mut basis_cache,
&mut basis_monitor_notifications,
) {
panic!("Couldn't format & mount PDDB");
}
}
log::info!("{}PDDB.MOUNTED,{}", BOOKEND_START, BOOKEND_END);
xous::return_scalar2(msg.sender, 0, 0).expect("couldn't return scalar");
} }
PasswordState::Uninit => { PasswordState::Uninit => {
log::info!("uninit"); unimplemented!("Password is always available on gen2")
if try_mount_or_format(
&modals,
&mut pddb_os,
&mut basis_cache,
PasswordState::Uninit,
time_resetter,
&mut basis_monitor_notifications,
) {
for requester in mount_notifications.drain(..) {
xous::return_scalar2(requester, 0, 0).expect("couldn't return scalar");
}
assert!(
mount_notifications.len() == 0,
"apparently I don't understand what drain() does"
);
log::info!("{}PDDB.MOUNTED,{}", BOOKEND_START, BOOKEND_END);
xous::return_scalar2(msg.sender, 0, 0).expect("couldn't return scalar");
is_mounted.store(true, Ordering::SeqCst);
} else {
xous::return_scalar2(msg.sender, 1, 0).expect("couldn't return scalar");
}
} }
PasswordState::ForcedAbort(failcount) => { PasswordState::ForcedAbort(_failcount) => {
log::info!("forced abort"); unreachable!();
xous::return_scalar2(
msg.sender,
2,
// failcount is a u64, but on u32-archs, this gets truncated going to
// usize. clip to u32::MAX.
failcount.min(u32::MAX as u64) as usize,
)
.expect("couldn't return scalar");
} }
PasswordState::Incorrect(failcount) => { PasswordState::Incorrect(_failcount) => {
xous::return_scalar2(msg.sender, 1, failcount.min(u32::MAX as u64) as usize) unreachable!();
.expect("couldn't return scalar")
} }
} }
}) })
@ -1086,16 +1069,9 @@ fn wrapped_main() -> ! {
buf.to_original::<BasisRequestPassword, _>().unwrap().plaintext_pw buf.to_original::<BasisRequestPassword, _>().unwrap().plaintext_pw
}; };
#[cfg(feature = "gen2")] #[cfg(feature = "gen2")]
let ret = match modals let pw_str = hex::encode(mgmt.basis_key.expect("No key provided"));
.alert_builder( #[cfg(feature = "gen2")]
format!("{}'{}'", t!("pddb.password_for", locales::LANG), mgmt.name).as_str(), let ret = Some(&pw_str);
)
.field(None, None)
.build()
{
Ok(text) => Some(text.content()[0].content.clone()),
_ => panic!("failure retrieving password"),
};
if let Some(pw) = ret { if let Some(pw) = ret {
match basis_cache.basis_create(&mut pddb_os, mgmt.name.as_str(), pw.as_str()) { match basis_cache.basis_create(&mut pddb_os, mgmt.name.as_str(), pw.as_str()) {
Ok(_) => { Ok(_) => {
@ -1144,17 +1120,9 @@ fn wrapped_main() -> ! {
buf.to_original::<BasisRequestPassword, _>().unwrap().plaintext_pw buf.to_original::<BasisRequestPassword, _>().unwrap().plaintext_pw
}; };
#[cfg(feature = "gen2")] #[cfg(feature = "gen2")]
let ret = match modals let pw_str = hex::encode(mgmt.basis_key.expect("No key provided"));
.alert_builder( #[cfg(feature = "gen2")]
format!("{}'{}'", t!("pddb.password_for", locales::LANG), &mgmt.name) let ret = Some(&pw_str);
.as_str(),
)
.field(None, None)
.build()
{
Ok(text) => Some(text.content()[0].content.clone()),
_ => panic!("failure retrieving password"),
};
if let Some(pw) = ret { if let Some(pw) = ret {
if let Some(basis) = basis_cache.basis_unlock( if let Some(basis) = basis_cache.basis_unlock(
&mut pddb_os, &mut pddb_os,
@ -1166,6 +1134,7 @@ fn wrapped_main() -> ! {
basis_cache basis_cache
.basis_unmount(&mut pddb_os, &basis.name) .basis_unmount(&mut pddb_os, &basis.name)
.expect("couldn't unmount previously mounted basis of same name"); .expect("couldn't unmount previously mounted basis of same name");
#[cfg(feature = "gen1")]
modals modals
.show_notification( .show_notification(
t!("pddb.unmount_previous", locales::LANG), t!("pddb.unmount_previous", locales::LANG),
@ -1195,27 +1164,35 @@ fn wrapped_main() -> ! {
mgmt.name.as_str(), mgmt.name.as_str(),
BOOKEND_END BOOKEND_END
); );
modals #[cfg(feature = "gen1")]
.add_list_item(t!("pddb.yes", locales::LANG)) {
.expect("couldn't build radio item list"); modals
modals .add_list_item(t!("pddb.yes", locales::LANG))
.add_list_item(t!("pddb.no", locales::LANG)) .expect("couldn't build radio item list");
.expect("couldn't build radio item list"); modals
match modals.get_radiobutton(t!("pddb.badpass", locales::LANG)) { .add_list_item(t!("pddb.no", locales::LANG))
Ok(response) => { .expect("couldn't build radio item list");
if response.as_str() == t!("pddb.yes", locales::LANG) { match modals.get_radiobutton(t!("pddb.badpass", locales::LANG)) {
finished = false; Ok(response) => {
// this will cause just another go-around if response.as_str() == t!("pddb.yes", locales::LANG) {
} else if response.as_str() == t!("pddb.no", locales::LANG) { finished = false;
finished = true; // this will cause just another go-around
mgmt.code = PddbRequestCode::AccessDenied; // this will cause a return of AccessDenied } else if response.as_str() == t!("pddb.no", locales::LANG) {
} else { finished = true;
panic!("Got unexpected return from radiobutton"); mgmt.code = PddbRequestCode::AccessDenied; // this will cause a return of AccessDenied
} else {
panic!("Got unexpected return from radiobutton");
}
} }
_ => panic!("get_radiobutton failed"),
} }
_ => panic!("get_radiobutton failed"), xous::yield_slice(); // allow a redraw to happen before repeating the request
}
#[cfg(feature = "gen2")]
{
mgmt.code = PddbRequestCode::AccessDenied; // this will cause a return of AccessDenied
finished = true;
} }
xous::yield_slice(); // allow a redraw to happen before repeating the request
} }
} else { } else {
finished = true; finished = true;
@ -2045,6 +2022,7 @@ fn wrapped_main() -> ! {
) { ) {
Ok(attr) => attr, Ok(attr) => attr,
Err(e) => { Err(e) => {
#[cfg(feature = "gen1")]
modals modals
.show_notification( .show_notification(
&format!( &format!(
@ -2061,6 +2039,14 @@ fn wrapped_main() -> ! {
None, None,
) )
.ok(); .ok();
#[cfg(feature = "gen2")]
log::error!(
"Error: key not found during bulk read:\n{:?}\n{:?}:{}:{}",
e,
if state.is_basis_specified { Some(&state.basis) } else { None },
&state.dict,
&key_name,
);
continue; continue;
} }
}; };
@ -2326,6 +2312,7 @@ fn wrapped_main() -> ! {
}; };
}), }),
#[cfg(feature = "gen1")]
Opcode::MenuListBasis => { Opcode::MenuListBasis => {
let bases = basis_cache.basis_list(); let bases = basis_cache.basis_list();
let mut note = String::from(t!("pddb.menu.listbasis_response", locales::LANG)); let mut note = String::from(t!("pddb.menu.listbasis_response", locales::LANG));
@ -2335,6 +2322,7 @@ fn wrapped_main() -> ! {
} }
modals.show_notification(&note, None).expect("couldn't show basis list"); modals.show_notification(&note, None).expect("couldn't show basis list");
} }
#[cfg(feature = "gen1")]
Opcode::MenuChangePin => { Opcode::MenuChangePin => {
if basis_cache.basis_count() == 0 { if basis_cache.basis_count() == 0 {
modals modals
@ -2482,7 +2470,10 @@ fn wrapped_main() -> ! {
Opcode::ComputeBackupHashes => { Opcode::ComputeBackupHashes => {
let mut buffer = let mut buffer =
unsafe { Buffer::from_memory_message_mut(msg.body.memory_message_mut().unwrap()) }; unsafe { Buffer::from_memory_message_mut(msg.body.memory_message_mut().unwrap()) };
#[cfg(feature = "gen1")]
let result = pddb_os.checksums(Some(&modals)); let result = pddb_os.checksums(Some(&modals));
#[cfg(feature = "gen2")]
let result = pddb_os.checksums(None);
buffer.replace(result).unwrap(); buffer.replace(result).unwrap();
} }
Opcode::Quit => { Opcode::Quit => {
@ -2503,6 +2494,10 @@ fn wrapped_main() -> ! {
Opcode::InvalidOpcode => { Opcode::InvalidOpcode => {
log::error!("couldn't convert opcode: {:?}", msg); log::error!("couldn't convert opcode: {:?}", msg);
} }
#[cfg(feature = "gen2")]
Opcode::MenuListBasis | Opcode::MenuChangePin => {
unimplemented!("Not available in gen2 targets")
}
} }
} }
// clean up our program // clean up our program
@ -2576,6 +2571,7 @@ fn ensure_password(modals: &modals::Modals, pddb_os: &mut PddbOs, _pw_cid: xous:
} }
} }
#[allow(unused_variables)] #[allow(unused_variables)]
#[cfg(feature = "gen1")]
fn try_mount_or_format( fn try_mount_or_format(
modals: &modals::Modals, modals: &modals::Modals,
pddb_os: &mut PddbOs, pddb_os: &mut PddbOs,