diff --git a/services/llio/Cargo.toml b/services/llio/Cargo.toml index d622dfcce..ac4cf78ef 100644 --- a/services/llio/Cargo.toml +++ b/services/llio/Cargo.toml @@ -38,5 +38,6 @@ chrono = "0.4.19" debugprint = [] wfi_off = [] # useful for serial port debugging, forces power on so the UART characters can finish printing tts = [] +test-rekey = [] default = [] # "debugprint" #default = ["debugprint"] # , "fccagent" diff --git a/services/llio/src/llio_hosted.rs b/services/llio/src/llio_hosted.rs index d8eea5e7b..9356e0749 100644 --- a/services/llio/src/llio_hosted.rs +++ b/services/llio/src/llio_hosted.rs @@ -21,6 +21,9 @@ impl Llio { pub fn gpio_int_pending(&self, ) -> u32 { 0x0 } pub fn gpio_int_ena(&self, _d: u32) {} pub fn set_uart_mux(&self, _mux: UartType) {} + #[cfg(feature="test-rekey")] + pub fn get_info_dna(&self, ) -> (usize, usize) { (0, 1) } + #[cfg(not(feature="test-rekey"))] pub fn get_info_dna(&self, ) -> (usize, usize) { (0, 0) } pub fn get_info_git(&self, ) -> (usize, usize) { (0, 0) } pub fn get_info_platform(&self, ) -> (usize, usize) { (0, 0) } diff --git a/services/pddb/Cargo.toml b/services/pddb/Cargo.toml index ed17e610f..7c3034e5f 100644 --- a/services/pddb/Cargo.toml +++ b/services/pddb/Cargo.toml @@ -75,4 +75,5 @@ tts = [] migration1 = [] # hazardous debug flag decorates any debug paths that might accidentally leak key material hazardous-debug = [] +test-rekey = [] default = ["mbbb"] diff --git a/services/pddb/locales/i18n.json b/services/pddb/locales/i18n.json index 26dda5198..1f0fb1257 100644 --- a/services/pddb/locales/i18n.json +++ b/services/pddb/locales/i18n.json @@ -1,10 +1,34 @@ { + "pddb.rekey.keys": { + "en": "Generating encryption mappings...", + "ja": "暗号化マッピングの生成...", + "zh": "生成加密映射...", + "en-tts": "Generating encryption mappings..." + }, + "pddb.rekey.running": { + "en": "Rekeying the database...", + "ja": "データベースのキーの再生成...", + "zh": "重新加密数据库...", + "en-tts": "Rekeying the database..." + }, + "pddb.rekey.fastspace": { + "en": "Regenerating free space cache...", + "ja": "空き領域キャッシュの再生成...", + "zh": "重新生成可用空间缓存...", + "en-tts": "Regenerating free space cache..." + }, "pddb.freespace.request": { "en": "⚠ PDDB needs to allocate more free space. ⚠\nIn order to do this safely, you must enumerate all secret Bases now. Any Basis not disclosed could be overwritten.", "ja": "⚠ PDDBは、より多くの空き領域を割り当てる必要があります。⚠\nこれを安全に行うには、今すぐすべてのシークレットベースのロックを解除する必要があります。 ロックされたままのベーシスは上書きされる可能性があります。", "zh": "⚠ PDDB 需要分配更多可用空间。⚠\n为了安全地执行此操作,您现在必须解锁所有秘密基地。 任何被锁定的基础都可以被覆盖。", "en-tts": "⚠ PDDB needs to allocate more free space. ⚠\nIn order to do this safely, you must enumerate all secret Bases now. Any Basis not disclosed could be overwritten." }, + "pddb.rekey.request": { + "en": "⚠ PDDB needs to be keyed to this device. ⚠\nIn order to do this safely, you must enumerate all secret Bases now. Any Basis not disclosed could be overwritten.", + "ja": "⚠ PDDBのキーを再入力する必要があります. ⚠\nこれを安全に行うには、今すぐすべてのシークレットベースのロックを解除する必要があります。 ロックされたままのベーシスは上書きされる可能性があります。", + "zh": "⚠ PDDB 需要重新加密。⚠\n为了安全地执行此操作,您现在必须解锁所有秘密基地。 任何被锁定的基础都可以被覆盖。", + "en-tts": "⚠ PDDB needs to be keyed to this device. ⚠\nIn order to do this safely, you must enumerate all secret Bases now. Any Basis not disclosed could be overwritten." + }, "pddb.freespace.enumerate": { "en": "Enumerate a Basis?", "ja": "根拠を開示しますか?", @@ -41,6 +65,12 @@ "zh": "我们要继续生成可用空间缓存吗?", "en-tts": "Enumeration terminated.\n\nShall we proceed to generate the free space cache?" }, + "pddb.rekey.finished": { + "en": "Enumeration terminated.\n\nShall we proceed to rekeying?", + "ja": "キーの再生成に進みましょう?", + "zh": "继续重新加密?", + "en-tts": "Enumeration terminated.\n\nShall we proceed to rekeying?" + }, "pddb.okay": { "en": "Okay", "ja": "OK", diff --git a/services/pddb/src/api.rs b/services/pddb/src/api.rs index 2bd5db353..4df3e2cd1 100644 --- a/services/pddb/src/api.rs +++ b/services/pddb/src/api.rs @@ -76,6 +76,26 @@ pub(crate) const FSCB_FILL_COEFFICIENT: f32 = 0.5; #[allow(dead_code)] pub(crate) const FSCB_FILL_UNCERTAINTY: f32 = 0.1; +/// This is a number that represents a fraction out of 255 that is the chance of a given +/// block of unused data being recycled with noise. (So 26 would be roughly a 10% chance). +/// This is an optimization that makes PDDB migrations/restores faster, while maintaining +/// some amount of deniability. The higher the chance of rekey, the better the deniability. +/// +/// If you set the REKEY_CHANCE to 0, then after a migration or rekey operation, +/// exactly the set of data that is used will have its ciphertext changed, which is a precise +/// leak of the amount of information in the PDDB. +/// +/// If you set REKEY_CHANCE to 256 or greater, then, every block is mutated, regardless of +/// the usage state of the PDDB, and full deniability is preserved. However, this will cause +/// the rekey operation to always take about a half hour, even if the PDDB is basically empty. +/// +/// The initial 10% threshold gives us sufficient deniability for e.g. small secrets like +/// passwords, TOTP tokens, U2F keys while incurring just a couple extra minutes overhead. +/// However it would probably not be sufficient if you routinely use the PDDB to store +/// large objects like images, audio, or large blocks of text. +#[allow(dead_code)] +pub(crate) const FAST_REKEY_CHANCE: u32 = 26; + #[allow(dead_code)] pub const PDDB_DEFAULT_SYSTEM_BASIS: &'static str = ".System"; // this isn't an "official" basis, but it is used for the AAD for encrypting the FastSpace structure @@ -178,6 +198,9 @@ pub(crate) enum Opcode { /// Remove an empty dict DeleteDictStd = 41, + /// Rekey the PDDB + RekeyPddb = 42, + /// This key type could not be decoded InvalidOpcode = u32::MAX as _, } @@ -388,6 +411,46 @@ impl PddbKeyAttrIpc { } } +#[derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize, Eq, PartialEq)] +pub enum PddbRekeyOp { + /// rekeys the a restored PDDB to the current device DNA using the "fast" method. + /// The "fast" method is significantly faster on PDDBs with a small amount of data, but + /// it will leak information on the amount of data in the PDDB, in a manner that can be + /// trivially recovered by doing comparative ciphertext analysis between the backup and + /// the current database image. *Some* amount of chaffe data is written, but only a + /// small amount. + FromDnaFast(u64), + /// same as the above, but blank space is also turned over, guaranteeing the deniability + /// of stored data even if an attacker has the previous backup copy of the PDDB. + FromDnaSafe(u64), + /// Basically the same as FromDnaSafe, but doing a self-to-self "safe" rekey + Churn, + /* + // skip this implementation for now. This opcode fits generally into this code flow, + // but requires some rework of the UX to actually acquire the old and new passwords. + // this UX work is off-topic from the mission of getting backup restoration done, + // but the potential to integrate the password rotation scheme into this function is + // noted here for future efforts. + // + /// Requests a single secret basis to have its password changed. This will reveal the size + /// of the Basis if the attacker has a before-and-after image of the PDDB. + /// Recommended to call `Churn` after this operation is done for optimal safety. + /// + /// Note: changing the password on the .System basis is a different flow. The + /// system basis keys are encrypted directly by the rootkeys enclave, so changing + /// its password requires calling a routine in root_keys (that does not exist + /// at this current time). + ChangePass(xous_ipc::String), + */ + + /// Return codes + Success, + AuthFail, + UserAbort, + VerifyFail, + InternalError, +} + /// Debugging commands, available only in hosted mode #[cfg(not(any(target_os = "none", target_os = "xous")))] #[derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize)] diff --git a/services/pddb/src/backend/basis.rs b/services/pddb/src/backend/basis.rs index 2441e8484..7b7d9f87c 100644 --- a/services/pddb/src/backend/basis.rs +++ b/services/pddb/src/backend/basis.rs @@ -268,6 +268,9 @@ impl BasisCache { } al } + pub(crate) fn rekey(&self, hw: &mut PddbOs, op: PddbRekeyOp) -> PddbRekeyOp { + hw.pddb_rekey(op, &self.cache) + } fn select_basis(&self, basis_name: Option<&str>) -> Option { if self.cache.len() == 0 { log::error!("Can't select basis: PDDB is not mounted"); diff --git a/services/pddb/src/backend/hw.rs b/services/pddb/src/backend/hw.rs index 54771c384..107e4a5cb 100644 --- a/services/pddb/src/backend/hw.rs +++ b/services/pddb/src/backend/hw.rs @@ -82,7 +82,11 @@ impl Deref for StaticCryptoData { } } } - +#[derive(Eq, PartialEq)] +enum DnaMode { + Normal, + Migration, +} #[derive(Zeroize)] #[zeroize(drop)] pub(crate) struct BasisKeys { @@ -90,6 +94,14 @@ pub(crate) struct BasisKeys { pub(crate) data: [u8; AES_KEYSIZE] } +struct MigrationCiphers { + pt_ecb: Aes256, + data_gcm_siv: AesGcmSiv, + data_key: [u8; 32], + aad_incoming: Vec::, + aad_local: Vec::, +} + // emulated #[cfg(not(any(target_os = "none", target_os = "xous")))] type EmuMemoryRange = EmuStorage; @@ -131,6 +143,10 @@ pub(crate) struct PddbOs { fspace_log_len: usize, /// a cached copy of the FPGA's DNA ID, used in the AAA records. dna: u64, + /// DNA for migrations from restored backups coming from different devices + migration_dna: u64, + /// set which DNA to use + dna_mode: DnaMode, /// reference to a TrngPool object that's shared among all the hardware functions entropy: Rc>, /// connection to the password request manager @@ -162,6 +178,7 @@ impl PddbOs { log::debug!("fscb_phys_base: {:x?}", fscb_phys_base); let llio = llio::Llio::new(&xns); + let dna = llio.soc_dna().unwrap(); // native hardware #[cfg(any(target_os = "none", target_os = "xous"))] let ret = PddbOs { @@ -180,7 +197,10 @@ impl PddbOs { fspace_log_addrs: Vec::::new(), fspace_log_next_addr: None, fspace_log_len: 0, - dna: llio.soc_dna().unwrap(), + dna, + // default to our own DNA in this case + migration_dna: dna, + dna_mode: DnaMode::Normal, entropy: trngpool, pw_cid, #[cfg(all(feature="pddbtest", feature="autobasis"))] @@ -205,7 +225,10 @@ impl PddbOs { fspace_log_addrs: Vec::::new(), fspace_log_next_addr: None, fspace_log_len: 0, - dna: llio.soc_dna().unwrap(), + dna, + // default to our own DNA in this case + migration_dna: dna, + dna_mode: DnaMode::Normal, entropy: trngpool, pw_cid, #[cfg(all(feature="pddbtest", feature="autobasis"))] @@ -661,7 +684,10 @@ impl PddbOs { fn fast_space_aad(&self, aad: &mut Vec::) { aad.extend_from_slice(PDDB_FAST_SPACE_SYSTEM_BASIS.as_bytes()); aad.extend_from_slice(&PDDB_VERSION.to_le_bytes()); - aad.extend_from_slice(&self.dna.to_le_bytes()); + match self.dna_mode { + DnaMode::Normal => aad.extend_from_slice(&self.dna.to_le_bytes()), + DnaMode::Migration => aad.extend_from_slice(&self.migration_dna.to_le_bytes()), + } } /// Assumes you are writing a "most recent" version of FastSpace. Thus /// Anytime the fscb is updated, all the partial records are nuked, as well as any existing record. @@ -1210,7 +1236,10 @@ impl PddbOs { let mut aad = Vec::::new(); aad.extend_from_slice(&name.as_bytes()); aad.extend_from_slice(&PDDB_VERSION.to_le_bytes()); - aad.extend_from_slice(&self.dna.to_le_bytes()); + match self.dna_mode { + DnaMode::Normal => aad.extend_from_slice(&self.dna.to_le_bytes()), + DnaMode::Migration => aad.extend_from_slice(&self.migration_dna.to_le_bytes()), + } aad } @@ -1806,6 +1835,243 @@ impl PddbOs { } } + /// pddb_rekey() must be called from a state where all the data has been synchronized to disk. + /// + /// If there are items allocated in the FSCB that have not had their corresponding physical + /// page table entries on disk written, the operation will fail. + pub(crate) fn pddb_rekey(&mut self, op: PddbRekeyOp, cache: &Vec::) -> PddbRekeyOp { + match op { + PddbRekeyOp::FromDnaFast(dna) | + PddbRekeyOp::FromDnaSafe(dna) => { + if cache.len() != 0 { + log::error!("We can't have any previously mounted Bases if the PDDB has the wrong key."); + return PddbRekeyOp::InternalError; + } + self.migration_dna = dna; + // acquire the .System basis key. + self.dna_mode = DnaMode::Migration; + self.syskey_ensure(); // this routine will continue to bang the user for a password. There is no way out otherwise. + log::info!("migrating from dna 0x{:x} -> 0x{:x}", self.migration_dna, self.dna); + self.fast_space_read(); // we hawe to re-read the FSCB, because it would have failed previously with lots of warnings + }, + _ => (), + }; + + // clean up any MBBB, as it will mess up our algorithm + if let Some(mbbb) = self.mbbb_retrieve() { + if let Some(erased_offset) = self.pt_find_erased_slot() { + self.spinor.patch( + self.pddb_mr.as_slice(), + xous::PDDB_LOC, + &mbbb, + self.pt_phys_base.as_u32() + erased_offset, + ).expect("couldn't write to page table"); + } + self.mbbb_erase(); + } + + // 0. acquire all the keys + if let Some(all_keys) = self.pddb_get_all_keys(&cache) { + // build a modals for rekey progress + let xns = xous_names::XousNames::new().unwrap(); + let modals = modals::Modals::new(&xns).unwrap(); + + modals.start_progress(t!("pddb.rekey.keys", xous::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. + let mut pagemap = HashMap::::new(); + // transform the returned Vec into a HashMap that maps basis names into pre-keyed ciphers. + let mut keymap = HashMap::<&str, MigrationCiphers>::new(); + 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) { + for pp in map.values() { + log::info!("page {} -> basis {}", pp.page_number(), name); + if pagemap.insert(pp.page_number(), &name).is_some() { + log::warn!("double-insert detected of page number {}", pp.page_number()); + } + } + } else { + log::warn!("pt_scan for basis {} failed, data may be lost", name); + } + let pt_ecb = Aes256::new(&GenericArray::from_slice(&basis_keys.pt)); + let data_gcm_siv = AesGcmSiv::::new(Key::from_slice(&basis_keys.data)); + self.dna_mode = DnaMode::Normal; + let aad_local = self.data_aad(&name); + self.dna_mode = DnaMode::Migration; + let aad_incoming = self.data_aad(&name); + keymap.insert(&name, MigrationCiphers { pt_ecb, data_gcm_siv, aad_incoming, aad_local, data_key: basis_keys.data.into() }); + modals.update_progress(index as u32 + 1).ok(); + } + + // check that we have no pages in the FSCB that aren't already mapped in the + // page table. + let mut clean = true; + for pp in self.fspace_cache.iter() { + if pp.space_state() == SpaceState::Used || pp.space_state() == SpaceState::MaybeUsed { + if !pagemap.contains_key(&pp.page_number()) { + log::warn!( + "FSCB records page {} ({:x?}) as used, but it's not defined in the page table. Please sync the PDDB before calling rekey.", + pp.page_number(), + pp + ); + clean = false; // allow full enumeration of all errors, to help with debugging + } + } + } + modals.finish_progress().ok(); + if !clean { + return PddbRekeyOp::VerifyFail + } + + // future note: if changing the password on just one basis, we'd want to ask for the new + // password now, so we can use its new key to re-encrypt things. But for now, let's just + // focus on rotating the DNA out. + + // iterate through every possible page in the system. + // First, map the PageTableInFlash structure directly onto the region. It's located + // at the base of the `pddb_mr`. + let pddb_data_len = PDDB_A_LEN - self.data_phys_base.as_usize(); + let pddb_data_pages = pddb_data_len / PAGE_SIZE; + let pagetable: &[u8] = &self.pddb_mr.as_slice()[..pddb_data_pages * size_of::()]; + log::info!("page table of len 0x{:x}", pagetable.len()); + let entries_per_page = PAGE_SIZE / size_of::(); + modals.start_progress(t!("pddb.rekey.running", xous::LANG), 0, (pddb_data_pages * size_of::()) as u32, 0).ok(); + for (chunk_enum, page) in pagetable.chunks(PAGE_SIZE).enumerate() { + // this is the actual offset into pagetable[] that the page[] slice comes from + let chunk_start_address = chunk_enum * PAGE_SIZE; + let chunk_start_ppn = chunk_enum * entries_per_page; + let mut chunk_len = 0; // we have to track this because the .chunks() will return a less-than-page sized chunk on the last iteration + log::info!("processing chunk at 0x{:x} (page number {}", chunk_start_address, chunk_start_ppn); + + let mut new_pt_page = [0u8; PAGE_SIZE]; + assert!(page.len() % size_of::() == 0); + for (index, (enc_pte, new_pte)) in + page.chunks_exact(size_of::()) + .zip(new_pt_page.chunks_exact_mut(size_of::())) + .enumerate() { + let ppn = (chunk_start_ppn + index) as u32; + chunk_len += size_of::(); + if let Some(&keyname) = pagemap.get(&ppn) { + log::info!("re-encrypt page {} of {}", ppn, keyname); + let ciphers = keymap.get(keyname).expect("How do we have a mapping to a key that we don't have?"); + // ok, we know the physical page table number, and thus the page location, and the keys. we can + // now do the following: + // 1. re-encrypt the page table. It is relatively "free" to do a thorough re-encryption + // so we will always either redo the nonce on every entry and/or fill the unused entries + // with fresh noise. + let mut block = Block::clone_from_slice(enc_pte); + ciphers.pt_ecb.decrypt_block(&mut block); + if let Some(mut pte) = Pte::try_from_slice(block.as_slice()) { + pte.re_nonce(Rc::clone(&self.entropy)); + let mut enc_entry = Block::from_mut_slice(pte.deref_mut()); + ciphers.pt_ecb.encrypt_block(&mut enc_entry); + new_pte.copy_from_slice(enc_entry.as_slice()); + } + + // 2. re-encrypt the disclosed basis data from the previous DNA to the current DNA. Redo all the nonces + // while we are at it. + if let Some(mut data) = self.data_decrypt_page( + &ciphers.data_gcm_siv, + &ciphers.aad_incoming, + &PhysPage(ppn)) { + // this routine also redoes the nonce correctly. + self.data_encrypt_and_patch_page( + &ciphers.data_gcm_siv, + &ciphers.aad_local, + &mut data, + &PhysPage(ppn) + ); + } else { + // see if it's a root page, which is encrypted differently due to AES-GCM-SIV salamanders and key commits. + if let Some(mut data) = self.data_decrypt_page_with_commit( + &ciphers.data_key, + &ciphers.aad_incoming, + &PhysPage(ppn)) { + log::info!("...as basis root page..."); + self.data_encrypt_and_patch_page_with_commit( + &ciphers.data_key, + &ciphers.aad_local, + &mut data, + &PhysPage(ppn) + ); + } else { + log::warn!("Page number {} failed to decrypt. This data is now lost.", ppn); + } + } + } else { + // it's an unused page. fill in the PTE with garbage, and *maybe* fill in the mapped page + // with new garbage, too. + self.trng_slice(new_pte); + + // the chance is expressed as a number from 0-255. It is compared against an 8-bit + // random number, and if the random number is less than the fraction, a rekey op will happen + let blank_rekey_chance = match op { + PddbRekeyOp::FromDnaFast(_) => FAST_REKEY_CHANCE, + PddbRekeyOp::FromDnaSafe(_) => 256, // 100% chance of rekey + PddbRekeyOp::Churn => 256, // 100% chance of rekey + _ => continue, // don't rekey blanks for all other ops + }; + if (self.trng_u8() as u32) < blank_rekey_chance { + log::info!("re-noising unused page {}", ppn); + let mut noise = [0u8; PAGE_SIZE]; + self.trng_slice(&mut noise); + self.patch_data(&noise, ppn * PAGE_SIZE as u32); + } else { + log::trace!("skipping unused page {}", ppn); + } + } + } + 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 worst case. + modals.update_progress(chunk_start_address as u32).ok(); + } + modals.finish_progress().ok(); + + self.dna_mode = DnaMode::Normal; // we're done with the legacy DNA! + + // 3. if we are not just changing the password on one Basis, regenerate the FSCB, since we + // have all the Bases open + let do_fscb = match op { + PddbRekeyOp::FromDnaFast(_dna) | + PddbRekeyOp::FromDnaSafe(_dna) => true, + PddbRekeyOp::Churn => true, + _ => false, + }; + if do_fscb { + log::info!("regenerating fast space..."); + modals.dynamic_notification(Some(t!("pddb.rekey.fastspace", xous::LANG)), None).ok(); + // convert our used page map into the structure needed by fast_space_generate() + let mut page_heap = BinaryHeap::new(); + // drain doesn't actually de-allocate memory, but it gives us an opportunity + // to recode this to use shrink_to_fit() every so many iterations to save on RAM + // if we're bumping our head into that problem. + for (ppn, _name) in pagemap.drain() { + page_heap.push(Reverse(ppn)); + } + // generate and nuke old free space records + let free_pool = self.fast_space_generate(page_heap); + let mut fast_space = FastSpace { + free_pool: [PhysPage(0); FASTSPACE_FREE_POOL_LEN], + }; + for pp in fast_space.free_pool.iter_mut() { + pp.set_journal(self.trng_u8() % FSCB_JOURNAL_RAND_RANGE) + } + for (&src, dst) in free_pool.iter().zip(fast_space.free_pool.iter_mut()) { + *dst = src; + } + // write just commits a new record to disk, but doesn't update our internal data cache + // this also clears the fast space log. + self.fast_space_write(&fast_space); + // this will ensure the data cache is fully in sync + self.fast_space_read(); + modals.dynamic_notification_close().ok(); + log::info!("fast space generation done."); + } + PddbRekeyOp::Success + } else { + PddbRekeyOp::UserAbort + } + } + /// 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 /// that the password is correct by doing a quick scan for "any" PTEs that happen to decrypt to something @@ -1824,12 +2090,31 @@ impl PddbOs { for entry in cache { log::info!(" - {}", entry.name); } + // In the case of a migration, the basis cache would be empty, but the system basis key is already set up + if self.dna_mode == DnaMode::Migration { + let syskeys = self.system_basis_key.as_ref() + .expect("Internal error: syskey_ensure() must be called prior to get_all_keys()"); + ret.push(( + BasisKeys { + pt: syskeys.pt.into(), + data: syskeys.data.into(), + }, + PDDB_DEFAULT_SYSTEM_BASIS.to_string() + )); + // note: because self.dna_mode is in 'Migration', the AAD checks in this section will be + // using the original DNA, so they should pass. + } // 0. allow user to cancel out of the operation -- this will abort everything and cause the current // alloc operation to fail let xns = xous_names::XousNames::new().unwrap(); let modals = modals::Modals::new(&xns).unwrap(); - modals.show_notification(t!("pddb.freespace.request", xous::LANG), None).ok(); + modals.show_notification( + match self.dna_mode { + DnaMode::Normal => t!("pddb.freespace.request", xous::LANG), + DnaMode::Migration => t!("pddb.rekey.request", xous::LANG), + }, + None).ok(); self.tt.sleep_ms(SWAP_DELAY_MS).unwrap(); // 0.5 display the Bases that we know @@ -1904,7 +2189,12 @@ impl PddbOs { self.tt.sleep_ms(SWAP_DELAY_MS).unwrap(); } // done! - if self.yes_no_approval(&modals, t!("pddb.freespace.finished", xous::LANG)) { + if self.yes_no_approval( + &modals, + match self.dna_mode { + DnaMode::Normal => t!("pddb.freespace.finished", xous::LANG), + DnaMode::Migration => t!("pddb.rekey.finished", xous::LANG), + }) { Some(ret) } else { None @@ -2061,7 +2351,7 @@ impl PddbOs { } /// In testing, we want a way to automatically unlock all known test Bases. This stand-in feature automates that. #[cfg(all(feature="pddbtest", feature="autobasis"))] - pub(crate) fn pddb_get_all_keys<'a>(&'a self, cache: &'a Vec::) -> Option> { + pub(crate) fn pddb_get_all_keys<'a>(&'a self, cache: &'a Vec::, _op: GetKeyOp) -> Option> { // populate the "known" entries let mut ret = Vec::<(BasisKeys, String)>::new(); for entry in cache { diff --git a/services/pddb/src/backend/pagetable.rs b/services/pddb/src/backend/pagetable.rs index 9b6428b6a..5414c3a2b 100644 --- a/services/pddb/src/backend/pagetable.rs +++ b/services/pddb/src/backend/pagetable.rs @@ -112,6 +112,16 @@ impl Pte { None } } + /// Normally you should be using pt_patch_mapping(), which generates a new nonce every + /// time the entry is patched. However, this function is provided for "bulk" operations + /// such as migrations where we violate the abstractions to improve performance. + pub fn re_nonce(&mut self, entropy: Rc>) { + let nonce_u32 = entropy.borrow_mut().get_u32(); + self.nonce = nonce_u32.to_le_bytes(); + let pte_data = self.deref(); + let checksum = murmur3_32(&pte_data[..12], nonce_u32); + self.checksum = checksum.to_le_bytes(); + } } impl Deref for Pte { type Target = [u8]; diff --git a/services/pddb/src/lib.rs b/services/pddb/src/lib.rs index 774dd1b6e..9f64b281d 100644 --- a/services/pddb/src/lib.rs +++ b/services/pddb/src/lib.rs @@ -628,6 +628,24 @@ impl Pddb { panic!("Internal error: wrong return code for is_efuse_secured()"); } } + /// Rekey the PDDB. This can be a very long-running blocking operation that will definitely. + /// interrupt normal user flow. + pub fn rekey_pddb(&self, op: PddbRekeyOp) -> Result<()> { + let mut buf = Buffer::into_buf(op) + .or(Err(Error::new(ErrorKind::Other, "Xous internal error")))?; + buf.lend_mut(self.conn, Opcode::RekeyPddb.to_u32().unwrap()) + .or(Err(Error::new(ErrorKind::Other, "Xous internal error"))).map(|_| ())?; + let result = buf.to_original::() + .or(Err(Error::new(ErrorKind::Other, "Xous internal error")))?; + match result { + PddbRekeyOp::Success => Ok(()), + PddbRekeyOp::AuthFail => Err(Error::new(ErrorKind::PermissionDenied, "Permission error")), + PddbRekeyOp::UserAbort => Err(Error::new(ErrorKind::Interrupted, "User aborted operation")), + PddbRekeyOp::InternalError => Err(Error::new(ErrorKind::Other, "Xous internal error")), + PddbRekeyOp::VerifyFail => Err(Error::new(ErrorKind::InvalidData, "Data verification error while rekeying")), + _ => Err(Error::new(ErrorKind::Unsupported, "Return code was never set")), + } + } /// Triggers a dump of the PDDB to host disk #[cfg(not(any(target_os = "none", target_os = "xous")))] pub fn dbg_dump(&self, name: &str) -> Result<()> { diff --git a/services/pddb/src/main.rs b/services/pddb/src/main.rs index a52ffc245..5610a42cc 100644 --- a/services/pddb/src/main.rs +++ b/services/pddb/src/main.rs @@ -1390,6 +1390,12 @@ fn wrapped_main() -> ! { } modals.show_notification(¬e, None).expect("couldn't show basis list"); }, + Opcode::RekeyPddb => { + let mut buffer = unsafe { Buffer::from_memory_message_mut(msg.body.memory_message_mut().unwrap()) }; + let rekey_op = buffer.to_original::().unwrap(); + let result = basis_cache.rekey(&mut pddb_os, rekey_op); + buffer.replace(result).unwrap(); + } #[cfg(not(any(target_os = "none", target_os = "xous")))] Opcode::DangerousDebug => { let buffer = unsafe { Buffer::from_memory_message(msg.body.memory_message().unwrap()) }; @@ -1507,7 +1513,7 @@ fn try_mount_or_format(modals: &modals::Modals, pddb_os: &mut PddbOs, basis_cach } // correct password but no mount -> offer to format; uninit -> offer to format if pw_state == PasswordState::Correct || pw_state == PasswordState::Uninit { - #[cfg(any(target_os = "none", target_os = "xous"))] + #[cfg(any(target_os = "none", target_os = "xous", feature="test-rekey"))] { log::debug!("PDDB did not mount; requesting format"); modals.add_list_item(t!("pddb.okay", xous::LANG)).expect("couldn't build radio item list"); @@ -1576,7 +1582,7 @@ fn try_mount_or_format(modals: &modals::Modals, pddb_os: &mut PddbOs, basis_cach false } } - #[cfg(not(any(target_os = "none", target_os = "xous")))] + #[cfg(not(any(target_os = "none", target_os = "xous", feature="test-rekey")))] { pddb_os.pddb_format(false, Some(&modals)).expect("couldn't format PDDB"); let _ = xous::send_message(time_resetter, diff --git a/services/shellchat/Cargo.toml b/services/shellchat/Cargo.toml index 3e7519912..a95c3583b 100644 --- a/services/shellchat/Cargo.toml +++ b/services/shellchat/Cargo.toml @@ -107,4 +107,5 @@ autobasis-ci = [] ditherpunk = ["png"] tracking-alloc = ["tracking-allocator", "tracing", "tracing-subscriber"] dbg-ecupdate = [] # for issuing manual commands to initiate an EC update (vs UX). Also need to enable this feature in the status crate. Intended for debug only. +test-rekey = [] default = [] # "debugprint" diff --git a/services/shellchat/src/cmds/pddb_cmd.rs b/services/shellchat/src/cmds/pddb_cmd.rs index ff3f4a720..ebb3d32a6 100644 --- a/services/shellchat/src/cmds/pddb_cmd.rs +++ b/services/shellchat/src/cmds/pddb_cmd.rs @@ -216,6 +216,19 @@ impl<'a> ShellCmdApi<'a> for PddbCmd { Err(_) => write!(ret, "Error encountered listing dictionaries").ok().unwrap_or(()), } } + #[cfg(feature="test-rekey")] + "rekey" => { + let old_dna = if let Some(dna_str) = tokens.next() { + dna_str.parse::().unwrap_or(0) + } else { + 0 + }; + log::info!("rekey result: {:?}", self.pddb.rekey_pddb(pddb::PddbRekeyOp::FromDnaFast(old_dna))); + } + #[cfg(feature="pddbtest")] + "dump" => { + self.pddb.dbg_dump("full").unwrap(); + } #[cfg(feature="pddbtest")] "largetest" => { // fill memory with junk diff --git a/services/status/Cargo.toml b/services/status/Cargo.toml index fc262c498..f92924e88 100644 --- a/services/status/Cargo.toml +++ b/services/status/Cargo.toml @@ -55,4 +55,5 @@ tts = [] # default = ["debugprint"] # "debugprint" dbg-ecupdate = [] ditherpunk = [] +test-rekey = [] default = [] diff --git a/services/status/locales/i18n.json b/services/status/locales/i18n.json index b08c3ae3e..fe2efe3bc 100644 --- a/services/status/locales/i18n.json +++ b/services/status/locales/i18n.json @@ -5,6 +5,12 @@ "zh": "找到了网关软件的更新候选者。\n\n我们应该应用它吗?", "en-tts": "An update candidate for the SoC was found.\n\nShould we apply it?" }, + "rekey.fail": { + "ja": "キーの再生成に失敗しました。再起動して再試行してください。\n理由:", + "en": "Rekey operation failed, please reboot and try again.\n Reason: ", + "zh": "重新生成密钥操作失败,请重新启动并重试。\n原因:", + "en-tts": "Rekey operation failed, please reboot and try again.\nReason: " + }, "socup.ignore": { "ja": "この更新を無視する", "en": "Ignore this update", diff --git a/services/status/src/main.rs b/services/status/src/main.rs index 6af886e15..e0868fe7f 100644 --- a/services/status/src/main.rs +++ b/services/status/src/main.rs @@ -396,15 +396,14 @@ fn wrapped_main() -> ! { Ok(Some(header)) => { match header.op { BackupOp::Restore => { - { /* remove this check once the restore process for this case is complete */ - let backup_dna = u64::from_le_bytes(header.dna); - if backup_dna != llio.soc_dna().unwrap() { - log::info!("backup_dna is 0x{:x}", backup_dna); - log::info!("reported dna is 0x{:x}", llio.soc_dna().unwrap()); - panic!("Backups to new devices not yet supported: add DNA re-encryption flow"); - } + let backup_dna = u64::from_le_bytes(header.dna); + if backup_dna != llio.soc_dna().unwrap() { + log::info!("This will be a two-stage restore because this is to a new device."); + log::info!("backup_dna is 0x{:x}", backup_dna); + log::info!("reported dna is 0x{:x}", llio.soc_dna().unwrap()); } keys.lock().unwrap().do_restore_backup_ux_flow(); + // if the DNA matches the backup, the backup header is automatically erased. restore_running = true; // set the keyboard layout according to the restore record. let map_deserialize: BackupKeyboardLayout = header.kbd_layout.into(); @@ -413,12 +412,19 @@ fn wrapped_main() -> ! { kbd.set_keymap(map).ok(); } BackupOp::RestoreDna => { - unimplemented!(); - // need to call a PDDB function that does the DNA upgrade. - // this is also the 'churn' function that's been on the to-do list, btw, just called with the same DNA as before. - - // once this step is done & successful, we have to erase the backup block to avoid re-doing this flow - keys.lock().unwrap().do_erase_backup(); + let pddb = pddb::Pddb::new(); + let backup_dna = u64::from_le_bytes(header.dna); + match pddb.rekey_pddb(pddb::PddbRekeyOp::FromDnaFast(backup_dna)) { + Ok(_) => { + // once this step is done & successful, we have to erase the backup block to avoid re-doing this flow + keys.lock().unwrap().do_erase_backup(); + log::info!("Rekey of PDDB to current device completed successfully") + }, + Err(e) => { + modals.show_notification(&format!("{}{:?}", t!("rekey.fail", xous::LANG), e), None).ok(); + log::error!("Backup was aborted. Reason: {:?}", e); + } + } } BackupOp::Backup => { // once we have unlocked the PDDB and know our timezone, we'll compare the embedded timestamp to @@ -998,6 +1004,9 @@ fn wrapped_main() -> ! { com.set_backlight(0, 0).expect("cannot set backlight off"); }, Some(StatusOpcode::PrepareBackup) => { + // sync the PDDB to disk prior to making backups + let pddb = pddb::Pddb::new(); + pddb.sync().expect("couldn't synchronize PDDB to disk"); let mut metadata = root_keys::api::BackupHeader::default(); // note: default() should set the language correctly by default since it's a systemwide constant metadata.timestamp = localtime.get_local_time_ms().unwrap_or(0); diff --git a/tools/pddbdbg.py b/tools/pddbdbg.py index fb12d5c87..be66eed8a 100755 --- a/tools/pddbdbg.py +++ b/tools/pddbdbg.py @@ -15,6 +15,8 @@ VPAGE_SIZE = 4064 MBBB_PAGES = 10 DO_CI_TESTS = True VERSION = 0x02_01 +DNA=0 +#DNA=0x1_0000_0000 # build a table mapping all non-printable characters to None NOPRINT_TRANS_TABLE = { @@ -138,7 +140,7 @@ def keycommit_decrypt(key, aad, pp_data): raise Exception(ValueError) return pt_data -def basis_aad(name, version=VERSION, dna=0): +def basis_aad(name, version=VERSION, dna=DNA): name_bytes = bytearray(name, 'utf-8') # name_bytes += bytearray(([0] * (Basis.MAX_NAME_LEN - len(name)))) name_bytes += version.to_bytes(4, 'little') @@ -757,7 +759,7 @@ class Fscb: logging.warning("Duplicate journal number found:\n {} (in table)\n {} (incoming)".format(cur_pp.as_str(), pp.as_str())) # this is the "AAD" used to encrypt the FastSpace - def aad(version=VERSION, dna=0): + def aad(version=VERSION, dna=DNA): return bytearray([46, 70, 97, 115, 116, 83, 112, 97, 99, 101]) + version.to_bytes(4, 'little') + dna.to_bytes(8, 'little') class SpaceUpdate: diff --git a/xtask/src/main.rs b/xtask/src/main.rs index 533436a9b..4427dba12 100644 --- a/xtask/src/main.rs +++ b/xtask/src/main.rs @@ -431,6 +431,7 @@ fn main() -> Result<(), Box> { "--features", "pddbtest", "--features", "ditherpunk", "--features", "tracking-alloc", + // "--features", "test-rekey", ]), false)? } Some("hosted-ci") => {