From b3c89e5f09959312f93bdeff5624560bcce0f19d Mon Sep 17 00:00:00 2001 From: bunnie Date: Tue, 19 Apr 2022 04:50:15 +0800 Subject: [PATCH] add migration of secret basis for v1->v2; fix some interior mutability issues Probably nobody is really using secret Bases right now, but it's probably a good idea to lay out all the infrastructure and start testing it for when it comes time to do it with data that really matters. --- services/pddb/src/backend.rs | 3 + services/pddb/src/backend/hw.rs | 311 +++++++++++++-------- services/pddb/src/backend/migration1to2.rs | 33 +++ services/pddb/src/backend/trngpool.rs | 33 ++- services/pddb/src/main.rs | 6 +- 5 files changed, 244 insertions(+), 142 deletions(-) create mode 100644 services/pddb/src/backend/migration1to2.rs diff --git a/services/pddb/src/backend.rs b/services/pddb/src/backend.rs index 1abfec94f..7653f2c34 100644 --- a/services/pddb/src/backend.rs +++ b/services/pddb/src/backend.rs @@ -27,3 +27,6 @@ pub(crate) use hw::*; mod hosted; #[cfg(not(any(target_os = "none", target_os = "xous")))] pub(crate) use hosted::*; + +#[cfg(feature="migration1")] +mod migration1to2; diff --git a/services/pddb/src/backend/hw.rs b/services/pddb/src/backend/hw.rs index 9ab1e8f69..4f532ac6c 100644 --- a/services/pddb/src/backend/hw.rs +++ b/services/pddb/src/backend/hw.rs @@ -27,6 +27,9 @@ type FspaceSet = BTreeSet::; use zeroize::Zeroize; +#[cfg(feature="migration1")] +use crate::backend::migration1to2::*; + /// Implementation-specific PDDB structures: for Precursor/Xous OS pair pub(crate) const MBBB_PAGES: usize = 10; pub(crate) const FSCB_PAGES: usize = 16; @@ -41,10 +44,8 @@ pub const VPAGE_SIZE: usize = PAGE_SIZE - size_of::() - size_of::() /// does not include the MAC overhead pub const KCOM_CT_LEN: usize = 4004; -const WRAPPED_AES_KEYSIZE: usize = AES_KEYSIZE + 8; +pub(crate) const WRAPPED_AES_KEYSIZE: usize = AES_KEYSIZE + 8; const SCD_VERSION: u32 = 2; -#[cfg(feature="migration1")] -const SCD_VERSION_MIGRATION1: u32 = 1; #[derive(Zeroize)] #[zeroize(drop)] @@ -79,37 +80,6 @@ impl Deref for StaticCryptoData { } } -#[repr(C)] // this can map directly into Flash -#[cfg(feature="migration1")] -pub(crate) struct StaticCryptoDataV1 { - /// a version number for the block - pub(crate) version: u32, - /// aes-256 key of the system basis, encrypted with the User0 root key, and wrapped using NIST SP800-38F - pub(crate) system_key: [u8; WRAPPED_AES_KEYSIZE], - /// a pool of fixed data used as a salt - pub(crate) salt_base: [u8; 4096 - WRAPPED_AES_KEYSIZE - size_of::()], -} -#[cfg(feature="migration1")] -impl StaticCryptoDataV1 { - pub fn default() -> StaticCryptoDataV1 { - StaticCryptoDataV1 { - version: SCD_VERSION_MIGRATION1, - system_key: [0u8; WRAPPED_AES_KEYSIZE], - salt_base: [0u8; 4096 - WRAPPED_AES_KEYSIZE - size_of::()], - } - } -} -#[cfg(feature="migration1")] -impl Deref for StaticCryptoDataV1 { - type Target = [u8]; - fn deref(&self) -> &[u8] { - unsafe { - core::slice::from_raw_parts(self as *const StaticCryptoDataV1 as *const u8, size_of::()) - as &[u8] - } - } -} - #[derive(Zeroize)] #[zeroize(drop)] pub(crate) struct BasisKeys { @@ -274,19 +244,19 @@ impl PddbOs { self.pddb_mr.reset(); } - pub(crate) fn nonce_gen(&mut self) -> Nonce { + pub(crate) fn nonce_gen(&self) -> Nonce { let nonce_array = self.entropy.borrow_mut().get_nonce(); *Nonce::from_slice(&nonce_array) } #[allow(dead_code)] pub(crate) fn dna(&self) -> u64 {self.dna} - pub(crate) fn trng_slice(&mut self, slice: &mut [u8]) { + pub(crate) fn trng_slice(&self, slice: &mut [u8]) { self.entropy.borrow_mut().get_slice(slice); } - pub(crate) fn trng_u32(&mut self) -> u32 { + pub(crate) fn trng_u32(&self) -> u32 { self.entropy.borrow_mut().get_u32() } - pub(crate) fn trng_u8(&mut self) -> u8 { + pub(crate) fn trng_u8(&self) -> u8 { self.entropy.borrow_mut().get_u8() } pub(crate) fn timestamp_now(&self) -> u64 {self.tt.elapsed_ms()} @@ -399,7 +369,7 @@ impl PddbOs { /// physical mapping. Note that the `va` is an *address* (in units of bytes), and the `phy_page_num` is /// a *page number* (so a physical address divided by the page size). It's a slightly awkward units, but /// it saves a bit of math going back and forth between the native storage formats of the records. - pub(crate) fn pt_patch_mapping(&mut self, va: VirtAddr, phys_page_num: u32, cipher: &Aes256) { + pub(crate) fn pt_patch_mapping(&self, va: VirtAddr, phys_page_num: u32, cipher: &Aes256) { let mut pte = Pte::new(va, PtFlags::CLEAN, Rc::clone(&self.entropy)); let mut block = Block::from_mut_slice(pte.deref_mut()); //log::info!("pte pt: {:x?}", block); @@ -539,6 +509,7 @@ impl PddbOs { scd } #[cfg(feature="migration1")] + /// needs to reside in this object because it accesses the key_phys_base registers, which have good reason to be private fn static_crypto_data_get_v1(&self) -> &StaticCryptoDataV1 { let scd_ptr = self.pddb_mr.as_slice::()[self.key_phys_base.as_usize()..self.key_phys_base.as_usize() + PAGE_SIZE].as_ptr() as *const StaticCryptoDataV1; let scd: &StaticCryptoDataV1 = unsafe{scd_ptr.as_ref().unwrap()}; @@ -1220,15 +1191,6 @@ impl PddbOs { aad.extend_from_slice(&self.dna.to_le_bytes()); aad } - #[cfg(feature="migration1")] - pub(crate) fn data_aad_v1(&self, name: &str) -> Vec:: { - let mut aad = Vec::::new(); - aad.extend_from_slice(&name.as_bytes()); - let (old_version, _new_version) = PDDB_MIGRATE_1; - aad.extend_from_slice(&old_version.to_le_bytes()); - aad.extend_from_slice(&self.dna.to_le_bytes()); - aad - } /// returns a decrypted page that still includes the journal number at the very beginning /// We don't clip it off because it would require re-allocating a vector, and it's cheaper (although less elegant) to later @@ -1328,7 +1290,7 @@ impl PddbOs { } /// `data` includes the journal entry on top. The data passed in must be exactly one vpage plus the journal entry - pub(crate) fn data_encrypt_and_patch_page(&mut self, cipher: &Aes256GcmSiv, aad: &[u8], data: &mut [u8], pp: &PhysPage) { + pub(crate) fn data_encrypt_and_patch_page(&self, cipher: &Aes256GcmSiv, aad: &[u8], data: &mut [u8], pp: &PhysPage) { assert!(data.len() == VPAGE_SIZE + size_of::(), "did not get a page-sized region to patch"); let j = JournalType::from_le_bytes(data[..size_of::()].try_into().unwrap()).saturating_add(1); for (&src, dst) in j.to_le_bytes().iter().zip(data[..size_of::()].iter_mut()) { *dst = src; } @@ -1346,7 +1308,7 @@ impl PddbOs { /// `data` includes the journal entry on top. /// The data passed in must be exactly one vpage plus the journal entry minus the length of the commit structure (64 bytes), /// which is 4004 bytes total - pub(crate) fn data_encrypt_and_patch_page_with_commit(&mut self, key: &[u8], aad: &[u8], data: &mut [u8], pp: &PhysPage) { + pub(crate) fn data_encrypt_and_patch_page_with_commit(&self, key: &[u8], aad: &[u8], data: &mut [u8], pp: &PhysPage) { assert!(data.len() == KCOM_CT_LEN, "did not get a key-commit sized region to patch"); // updates the journal type let j = JournalType::from_le_bytes(data[..size_of::()].try_into().unwrap()).saturating_add(1); @@ -1907,6 +1869,7 @@ impl PddbOs { } /// legacy key derivation for migrations. This can be removed once the migration is de-supported. + /// Must be within this structure because it accesses the rootkeys, and we don't want to make that public. #[cfg(feature="migration1")] pub(crate) fn basis_derive_key_v00_00_01_01(&self, basis_name: &str, password: &str) -> [u8; AES_KEYSIZE] { use sha2::{FallbackStrategy, Sha512Trunc256}; @@ -1974,13 +1937,99 @@ impl PddbOs { key } + #[cfg(feature="migration1")] + fn migration_v1_to_v2_inner( + &mut self, + aad_v1: &Vec::, + aad_v2: &Vec::, + key_v1: &[u8; AES_KEYSIZE], // needed to decrypt page with commit + cipher_pt_v1: &Aes256, + cipher_data_v1: &Aes256GcmSiv, + key_data_v2: &[u8; AES_KEYSIZE], // this is needed because we have to do a key commitment + cipher_pt_v2: &Aes256, + cipher_data_v2: &Aes256GcmSiv, + used_pages: &mut BinaryHeap::>, + ) -> bool { + let blank = [0xffu8; aes::BLOCK_SIZE]; + let pt = self.pt_as_slice(); + let mut found_basis = false; + for (page_index, pt_page) in pt.chunks(PAGE_SIZE).enumerate() { + let clean_page = if pt_page[..aes::BLOCK_SIZE] == blank { + if let Some(page) = self.mbbb_retrieve() { + page + } else { + log::debug!("Blank page in PT found, but no MBBB entry exists. PT is either corrupted or not initialized!"); + pt_page + } + } else { + pt_page + }; + for (index, candidate) in clean_page.chunks(aes::BLOCK_SIZE).enumerate() { + let mut block = Block::clone_from_slice(candidate); + cipher_pt_v1.decrypt_block(&mut block); + // *** 2. if an entry matches, also decrypt the target page and store it here + if let Some(pte) = Pte::try_from_slice(block.as_slice()) { + // compute the physical page number that correspons to this entry, and store it in `pp` + let mut pp = PhysPage(0); + pp.set_page_number(((page_index * PAGE_SIZE / aes::BLOCK_SIZE) + index) as PhysAddr); + + // root records require key commitment (to avoid AES-GCM-SIV salamanders), so detect & handle that + if pte.vaddr_v1().get() == VPAGE_SIZE as u64 { // v1 addresses were full vaddrs, not page numbers + // retrieve the data at `pp` + let migrating_data = self.data_decrypt_page_with_commit(key_v1, aad_v1, &pp); + if let Some(vpage) = migrating_data { + found_basis = true; + let mut basis_root = BasisRoot::default(); + for (&src, dst) in (&vpage)[size_of::()..].iter().zip(basis_root.deref_mut().iter_mut()) { + *dst = src; + } + let (previous, _) = PDDB_MIGRATE_1; + if basis_root.version != previous { + log::warn!("Root basis record did not match expected version during migration. Ignoring and attempting to move on..."); + } + basis_root.version = PDDB_VERSION; // update the version to our current one + let slice_iter = + (&vpage[..size_of::()]).iter() // just copy the journal rev + .chain(basis_root.as_ref().iter()); + let mut block = [0 as u8; KCOM_CT_LEN]; + for (&src, dst) in slice_iter.zip(block.iter_mut()) { + *dst = src; + } + self.data_encrypt_and_patch_page_with_commit(key_data_v2, aad_v2, &mut block, &pp); + } else { + // could be a checksum collision that triggers this, so it's not a hard error. A later "real" version will succeed and all would be fine. + log::warn!("Root basis record did not decrypt correctly, ignoring and hoping for the best, but your chances are slim."); + } + } else { + // retrieve the data at `pp` + let migrating_data = self.data_decrypt_page(&cipher_data_v1, aad_v1, &pp); + // store the data back to the same location, but with the new keys + if let Some(mut vpage) = migrating_data { + self.data_encrypt_and_patch_page(&cipher_data_v2, aad_v2, &mut vpage, &pp); + } else { + log::warn!("Potential checksum collision found at pp {}; ignoring", pp.page_number()); + } + } + + // *** 3. re-encrypt the PTE and the target page to the v2 keys and corrected addressing scheme + // the pt_patch_mapping call will automatically insert the correct v2 addressing scheme + self.pt_patch_mapping(pte.vaddr_v1(), pp.page_number(), &cipher_pt_v2); + // track the used pages + used_pages.push(Reverse(pp.page_number())); + } + } + } + found_basis + } + /// Migrates a v1 database to a v2 database. The main change is a modification to the key /// derivation schedule to make different keys for the page table versus the pages themselves. /// /// note that v1 also had an error where page tables were encoded in full addresess, when /// we meant to encode them using page numbers. This code also handles that migration. + /// Must be within this structure because it accesses the rootkeys, and we don't want to make that public. #[cfg(feature="migration1")] - pub(crate) fn migration_v1_to_v2(&mut self) -> PasswordState { + pub(crate) fn migration_v1_to_v2(&mut self, pw_cid: xous::CID) -> PasswordState { let scd = self.static_crypto_data_get_v1(); if scd.version == 0xFFFF_FFFF { // system is in the blank state return PasswordState::Uninit @@ -2009,7 +2058,7 @@ impl PddbOs { for i in 0..syskey.len() { unsafe{nuke.add(i).write_volatile(0)}; } - modals.dynamic_notification(Some("PDDB v1->v2 migration"), Some("Migrating System keys to v2")); + modals.dynamic_notification(Some("PDDB v1->v2 migration"), Some("Migrating System keys to v2")).unwrap(); // ------ I. migrate the system basis ------- // *** 0. generate v2 keys. This will immediately overwrite the SCD -- if we have an error or power outage @@ -2055,87 +2104,101 @@ impl PddbOs { // now we have a copy of the AES key necessary to re-encrypt all the basis // build the data cipher for v1 pages let data_cipher_v1 = Aes256GcmSiv::new(Key::from_slice(&system_key_v1)); - let aad_v1 = self.data_aad_v1(PDDB_DEFAULT_SYSTEM_BASIS); + let aad_v1 = data_aad_v1(&self, PDDB_DEFAULT_SYSTEM_BASIS); // track used pages so we can create the FSCB at the end let mut used_pages = BinaryHeap::new(); // *** 1. scan the page table - let blank = [0xffu8; aes::BLOCK_SIZE]; - modals.dynamic_notification_update(None, Some("Migrating System Basis")); - let pt = self.pt_as_slice(); - for (page_index, pt_page) in pt.chunks(PAGE_SIZE).enumerate() { - let clean_page = if pt_page[..aes::BLOCK_SIZE] == blank { - if let Some(page) = self.mbbb_retrieve() { - page - } else { - log::debug!("Blank page in PT found, but no MBBB entry exists. PT is either corrupted or not initialized!"); - pt_page - } - } else { - pt_page - }; - for (index, candidate) in clean_page.chunks(aes::BLOCK_SIZE).enumerate() { - let mut block = Block::clone_from_slice(candidate); - cipher_v1.decrypt_block(&mut block); - // *** 2. if an entry matches, also decrypt the target page and store it here - if let Some(pte) = Pte::try_from_slice(block.as_slice()) { - // compute the physical page number that correspons to this entry, and store it in `pp` - let mut pp = PhysPage(0); - pp.set_page_number(((page_index * PAGE_SIZE / aes::BLOCK_SIZE) + index) as PhysAddr); - - // root records require key commitment (to avoid AES-GCM-SIV salamanders), so detect & handle that - if pte.vaddr_v1().get() == VPAGE_SIZE as u64 { // v1 addresses were full vaddrs, not page numbers - // retrieve the data at `pp` - let migrating_data = self.data_decrypt_page_with_commit(&system_key_v1, &aad_v1, &pp); - if let Some(vpage) = migrating_data { - let mut basis_root = BasisRoot::default(); - for (&src, dst) in (&vpage)[size_of::()..].iter().zip(basis_root.deref_mut().iter_mut()) { - *dst = src; - } - let (previous, _) = PDDB_MIGRATE_1; - if basis_root.version != previous { - log::warn!("Root basis record did not match expected version during migration. Ignoring and attempting to move on..."); - } - basis_root.version = PDDB_VERSION; // update the version to our current one - let slice_iter = - (&vpage[..size_of::()]).iter() // just copy the journal rev - .chain(basis_root.as_ref().iter()); - let mut block = [0 as u8; KCOM_CT_LEN]; - for (&src, dst) in slice_iter.zip(block.iter_mut()) { - *dst = src; - } - self.data_encrypt_and_patch_page_with_commit(&syskey_data_copy, &aad_v2, &mut block, &pp); - } else { - // could be a checksum collision that triggers this, so it's not a hard error. A later "real" version will succeed and all would be fine. - log::warn!("Root basis record did not decrypt correctly, ignoring and hoping for the best, but your chances are slim."); - } - } else { - // retrieve the data at `pp` - let migrating_data = self.data_decrypt_page(&data_cipher_v1, &aad_v1, &pp); - // store the data back to the same location, but with the new keys - if let Some(mut vpage) = migrating_data { - self.data_encrypt_and_patch_page(&data_cipher_v2, &aad_v2, &mut vpage, &pp); - } else { - log::warn!("Potential checksum collision found at pp {}; ignoring", pp.page_number()); - } - } - - // *** 3. re-encrypt the PTE and the target page to the v2 keys and corrected addressing scheme - // the pt_patch_mapping call will automatically insert the correct v2 addressing scheme - self.pt_patch_mapping(pte.vaddr_v1(), pp.page_number(), &cipher_v2); - // track the used pages - used_pages.push(Reverse(pp.page_number())); - } - } + modals.dynamic_notification_update(None, Some("Migrating System Basis")).unwrap(); + // *** 2. if an entry matches, also decrypt the target page and store it here + // *** 3. re-encrypt the PTE and the target page to the v2 keys and corrected addressing scheme + if !self.migration_v1_to_v2_inner( + &aad_v1, &aad_v2, + &system_key_v1, + &cipher_v1, + &data_cipher_v1, + &syskey_data_copy, + &cipher_v2, + &data_cipher_v2, + &mut used_pages, + ) { + log::warn!("System basis migration failed"); + } else { + log::info!("System basis migration successful"); } - // *** 5. The MBBB is natively migrated as part of this process, so nothing explictly needs to be done here. + + // *** 4. The MBBB is natively migrated as part of this process, so nothing explictly needs to be done here. // ------ II. migrate any hidden basis ------ - // break out the above scanning routine to an "inner" call that takes ciphers + modals.dynamic_notification_close().unwrap(); + let mut prompt = String::from("All secret Bases must be unlocked now to complete migration, or else their data will be lost. Unlock a Basis?"); + loop { + modals.add_list_item(t!("pddb.yes", xous::LANG)).expect("couldn't build radio item list"); + modals.add_list_item(t!("pddb.no", xous::LANG)).expect("couldn't build radio item list"); + match modals.get_radiobutton("Unlock a secret basis for migration?") { + Ok(response) => { + if response.as_str() == t!("pddb.yes", xous::LANG) { + match modals.get_text("Enter the Basis name", None, None) { + Ok(bname) => { + let request = BasisRequestPassword { + db_name: xous_ipc::String::from_str(bname.as_str()), + plaintext_pw: None, + }; + let mut buf = Buffer::into_buf(request).unwrap(); + buf.lend_mut(pw_cid, PwManagerOpcode::RequestPassword.to_u32().unwrap()).unwrap(); + let ret = buf.to_original::().unwrap(); + if let Some(pw) = ret.plaintext_pw { + // derive old and new keys + let basis_key_v1 = self.basis_derive_key_v00_00_01_01(bname.as_str(), pw.as_str().unwrap_or("UTF8-error")); + let basis_aad_v1 = data_aad_v1(&self, bname.as_str()); + let basis_aad_v2 = self.data_aad(bname.as_str()); + let basis_pt_cipher_v1 = Aes256::new(GenericArray::from_slice(&basis_key_v1)); + let basis_data_cipher_v1 = Aes256GcmSiv::new(Key::from_slice(&basis_key_v1)); + let basis_keys = self.basis_derive_key(bname.as_str(), pw.as_str().unwrap_or("UTF8 error")); + let basis_pt_cipher_2 = Aes256::new(GenericArray::from_slice(&basis_keys.pt)); + let basis_data_cipher_2 = Aes256GcmSiv::new(Key::from_slice(&basis_keys.data)); + // perform the migration + if self.migration_v1_to_v2_inner( + &basis_aad_v1, &basis_aad_v2, + &basis_key_v1, + &basis_pt_cipher_v1, + &basis_data_cipher_v1, + &basis_keys.data, + &basis_pt_cipher_2, + &basis_data_cipher_2, + &mut used_pages, + ) { + prompt.clear(); + prompt.push_str("Migration success, add another secret Basis?"); + } else { + prompt.clear(); + prompt.push_str("Migration failure, retry and/or add another secret Basis?"); + } + } else { + log::warn!("Couldn't retrieve password for the basis, ignoring and moving on"); + prompt.clear(); + prompt.push_str("Error unlocking Basis, retry?"); + } + } + Err(e) => { + log::warn!("error {:?} unlocking basis, aborting and moving on", e); + prompt.clear(); + prompt.push_str("Error unlocking Basis, retry?"); + } + } + } else if response.as_str() == t!("pddb.no", xous::LANG) { + break; + } else { + log::warn!("Got unexpected return from radiobutton: {}", response); + } + } + _ => log::warn!("get_radiobutton failed") + } + } // ------ III. nuke and regnerate fast space ----- - modals.dynamic_notification_update(None, Some("Regenerate FastSpace")); + modals.dynamic_notification(Some("Finalizing PDDB v1->v2 migration"), Some("Regenerate FastSpace")).unwrap(); let free_pool = self.fast_space_generate(used_pages); let mut fast_space = FastSpace { free_pool: [PhysPage(0); FASTSPACE_FREE_POOL_LEN], @@ -2152,7 +2215,7 @@ impl PddbOs { // this will ensure the data cache is fully in sync self.fast_space_read(); - modals.dynamic_notification_close(); + modals.dynamic_notification_close().unwrap(); // clear out the v1 key let sk_ptr = system_key_v1.as_mut_ptr(); diff --git a/services/pddb/src/backend/migration1to2.rs b/services/pddb/src/backend/migration1to2.rs new file mode 100644 index 000000000..e1bc5d836 --- /dev/null +++ b/services/pddb/src/backend/migration1to2.rs @@ -0,0 +1,33 @@ +use crate::*; +use core::ops::Deref; +use core::mem::size_of; + +pub(crate) const SCD_VERSION_MIGRATION1: u32 = 1; + +#[repr(C)] // this can map directly into Flash +pub(crate) struct StaticCryptoDataV1 { + /// a version number for the block + pub(crate) version: u32, + /// aes-256 key of the system basis, encrypted with the User0 root key, and wrapped using NIST SP800-38F + pub(crate) system_key: [u8; WRAPPED_AES_KEYSIZE], + /// a pool of fixed data used as a salt + pub(crate) salt_base: [u8; 4096 - WRAPPED_AES_KEYSIZE - size_of::()], +} +impl Deref for StaticCryptoDataV1 { + type Target = [u8]; + fn deref(&self) -> &[u8] { + unsafe { + core::slice::from_raw_parts(self as *const StaticCryptoDataV1 as *const u8, size_of::()) + as &[u8] + } + } +} + +pub(crate) fn data_aad_v1(pddb_os: &PddbOs, name: &str) -> Vec:: { + let mut aad = Vec::::new(); + aad.extend_from_slice(&name.as_bytes()); + let (old_version, _new_version) = PDDB_MIGRATE_1; + aad.extend_from_slice(&old_version.to_le_bytes()); + aad.extend_from_slice(&pddb_os.dna().to_le_bytes()); + aad +} diff --git a/services/pddb/src/backend/trngpool.rs b/services/pddb/src/backend/trngpool.rs index fcb8cb278..6c19456f5 100644 --- a/services/pddb/src/backend/trngpool.rs +++ b/services/pddb/src/backend/trngpool.rs @@ -2,14 +2,14 @@ use core::mem::size_of; use aes_gcm_siv::Nonce; use rand_core::RngCore; use std::convert::TryInto; -use core::cell::Cell; +use core::cell::RefCell; /// Crate-shared resource for TRNGs. pub(crate) struct TrngPool { - trng: Cell::, + trng: RefCell::, /// The PDDB eats a lot of entropy. Keep a local pool of entropy, so we're not wasting a lot of /// overhead passing messages to the TRNG hardware server. - e_cache: Cell::>, + e_cache: RefCell::>, } impl TrngPool { pub fn new() -> Self { @@ -18,37 +18,40 @@ impl TrngPool { let mut cache: [u8; 8192] = [0; 8192]; trng.fill_bytes(&mut cache); TrngPool { - trng: Cell::new(trng), - e_cache: Cell::new(cache.to_vec()) + trng: RefCell::new(trng), + e_cache: RefCell::new(cache.to_vec()) } } pub(crate) fn ensure_entropy(&self, amount: usize) { - if self.e_cache.get().len() < amount { + if self.e_cache.borrow().len() < amount { let mut cache: [u8; 8192] = [0; 8192]; - self.trng.get().fill_bytes(&mut cache); - self.e_cache.get().extend_from_slice(&cache); + self.trng.borrow_mut().fill_bytes(&mut cache); + self.e_cache.borrow_mut().extend_from_slice(&cache); } } pub(crate) fn get_u8(&self) -> u8 { self.ensure_entropy(1); - self.e_cache.get().pop().unwrap() + self.e_cache.borrow_mut().pop().unwrap() } pub(crate) fn get_u32(&self) -> u32 { self.ensure_entropy(4); - let ret = u32::from_le_bytes(self.e_cache.get()[self.e_cache.get().len() - 4..].try_into().unwrap()); - self.e_cache.get().truncate(self.e_cache.get().len() - 4); + let ret = u32::from_le_bytes(self.e_cache.borrow()[self.e_cache.borrow().len() - 4..].try_into().unwrap()); + let ecache_len = self.e_cache.borrow().len(); + self.e_cache.borrow_mut().truncate(ecache_len - 4); ret } pub(crate) fn get_u64(&self) -> u64 { self.ensure_entropy(8); - let ret = u64::from_le_bytes(self.e_cache.get()[self.e_cache.get().len() - 8..].try_into().unwrap()); - self.e_cache.get().truncate(self.e_cache.get().len() - 8); + let ret = u64::from_le_bytes(self.e_cache.borrow()[self.e_cache.borrow().len() - 8..].try_into().unwrap()); + let ecache_len = self.e_cache.borrow().len(); + self.e_cache.borrow_mut().truncate(ecache_len - 8); ret } pub(crate) fn get_slice(&self, bucket: &mut [u8]) { self.ensure_entropy(bucket.len()); - for (src, dst) in self.e_cache.get().drain( - (self.e_cache.get().len() - bucket.len()).. + let drain_start = self.e_cache.borrow().len() - bucket.len(); + for (src, dst) in self.e_cache.borrow_mut().drain( + drain_start.. ).zip(bucket.iter_mut()) { *dst = src; } diff --git a/services/pddb/src/main.rs b/services/pddb/src/main.rs index b4790166d..b35987a07 100644 --- a/services/pddb/src/main.rs +++ b/services/pddb/src/main.rs @@ -547,7 +547,7 @@ fn xmain() -> ! { // can't mount if we have no root keys xous::return_scalar(msg.sender, 0).expect("could't return scalar"); } else { - match ensure_password(&modals, &mut pddb_os) { + match ensure_password(&modals, &mut pddb_os, pw_cid) { PasswordState::Correct => { if try_mount_or_format(&modals, &mut pddb_os, &mut basis_cache, PasswordState::Correct, time_resetter) { is_mounted.store(true, Ordering::SeqCst); @@ -1178,7 +1178,7 @@ fn xmain() -> ! { xous::terminate_process(0) } -fn ensure_password(modals: &modals::Modals, pddb_os: &mut PddbOs) -> PasswordState { +fn ensure_password(modals: &modals::Modals, pddb_os: &mut PddbOs, pw_cid: xous::CID) -> PasswordState { log::info!("Requesting login password"); loop { match pddb_os.try_login() { @@ -1189,7 +1189,7 @@ fn ensure_password(modals: &modals::Modals, pddb_os: &mut PddbOs) -> PasswordSta // check for a migration event #[cfg(feature="migration1")] { - if pddb_os.migration_v1_to_v2() == PasswordState::Correct { + if pddb_os.migration_v1_to_v2(pw_cid) == PasswordState::Correct { if pddb_os.try_login() == PasswordState::Correct { log::info!("Migration v1->v2 successful"); return PasswordState::Correct