fix basis FSCB generation on full - basic fix in place and tested

This commit is contained in:
bunnie 2022-07-04 15:19:40 +08:00
parent 66f7f0a5ab
commit baa5097313
3 changed files with 47 additions and 32 deletions

View file

@ -39,8 +39,8 @@ pub(crate) const PDDB_VERSION: u32 = 0x00_00_02_01;
#[allow(dead_code)] #[allow(dead_code)]
// PDDB_A_LEN may be shorter than xous::PDDB_LEN, to speed up testing. // PDDB_A_LEN may be shorter than xous::PDDB_LEN, to speed up testing.
#[allow(dead_code)] #[allow(dead_code)]
pub(crate) const PDDB_A_LEN: usize = xous::PDDB_LEN as usize; // pub(crate) const PDDB_A_LEN: usize = xous::PDDB_LEN as usize;
// pub(crate) const PDDB_A_LEN: usize = 4 * 1024 * 1024; pub const PDDB_A_LEN: usize = 4 * 1024 * 1024;
/// range for the starting point of a journal number, picked from a random seed /// range for the starting point of a journal number, picked from a random seed
/// the goal is to reduce info leakage about the age of structures relative to each other /// the goal is to reduce info leakage about the age of structures relative to each other

View file

@ -801,7 +801,7 @@ impl BasisCache {
pub(crate) fn basis_unlock(&mut self, hw: &mut PddbOs, name: &str, password: &str, pub(crate) fn basis_unlock(&mut self, hw: &mut PddbOs, name: &str, password: &str,
policy: BasisRetentionPolicy) -> Option<BasisCacheEntry> { policy: BasisRetentionPolicy) -> Option<BasisCacheEntry> {
let basis_key = hw.basis_derive_key(name, password); let basis_key = hw.basis_derive_key(name, password);
if let Some(basis_map) = hw.pt_scan_key(&basis_key.pt, name) { if let Some(basis_map) = hw.pt_scan_key(&basis_key.pt, &basis_key.data, name) {
let aad = hw.data_aad(name); let aad = hw.data_aad(name);
if let Some(root_page) = basis_map.get(&VirtAddr::new(VPAGE_SIZE as u64).unwrap()) { if let Some(root_page) = basis_map.get(&VirtAddr::new(VPAGE_SIZE as u64).unwrap()) {
let vpage = match hw.data_decrypt_page_with_commit(&basis_key.data, &aad, root_page) { let vpage = match hw.data_decrypt_page_with_commit(&basis_key.data, &aad, root_page) {
@ -1090,7 +1090,11 @@ pub(crate) struct BasisCacheEntry {
pub cipher: AesGcmSiv::<Aes256>, pub cipher: AesGcmSiv::<Aes256>,
/// derived cipher for encrypting PTEs -- cache it, so we can save the time cost of constructing the cipher key schedule /// derived cipher for encrypting PTEs -- cache it, so we can save the time cost of constructing the cipher key schedule
pub cipher_ecb: Aes256, pub cipher_ecb: Aes256,
/// raw AES key -- needed because we have to use this to derive commitment keys for the basis root record, to work around AES-GCM-SIV salamanders /// raw AES page table key -- needed because we have to do a low-level PT scan to generate FSCB, and sometimes the key comes from
/// a copy cached here, or from one derived solely for the FSCB scan. There is no way to copy an Aes256 record, so, we include
/// the raw key because we can copy that. :P so much for semantics.
pub pt_key: GenericArray<u8, cipher::consts::U32>,
/// raw AES data key -- needed because we have to use this to derive commitment keys for the basis root record, to work around AES-GCM-SIV salamanders
pub key: GenericArray<u8, cipher::consts::U32>, pub key: GenericArray<u8, cipher::consts::U32>,
/// the AAD associated with this Basis /// the AAD associated with this Basis
pub aad: Vec::<u8>, pub aad: Vec::<u8>,
@ -1113,7 +1117,7 @@ impl BasisCacheEntry {
/// If it `lazy` is false, it will populate the dictionary cache and key cache entries, as well as /// If it `lazy` is false, it will populate the dictionary cache and key cache entries, as well as
/// discover the location of the `large_alloc_ptr`. /// discover the location of the `large_alloc_ptr`.
pub(crate) fn mount(hw: &mut PddbOs, name: &str, key: &BasisKeys, lazy: bool, policy: BasisRetentionPolicy) -> Option<BasisCacheEntry> { pub(crate) fn mount(hw: &mut PddbOs, name: &str, key: &BasisKeys, lazy: bool, policy: BasisRetentionPolicy) -> Option<BasisCacheEntry> {
if let Some(basis_map) = hw.pt_scan_key(&key.pt, name) { if let Some(basis_map) = hw.pt_scan_key(&key.pt, &key.data, name) {
let cipher = AesGcmSiv::<Aes256>::new(Key::from_slice(&key.data)); let cipher = AesGcmSiv::<Aes256>::new(Key::from_slice(&key.data));
let aad = hw.data_aad(name); let aad = hw.data_aad(name);
// get the first page, where the basis root is guaranteed to be // get the first page, where the basis root is guaranteed to be
@ -1149,6 +1153,7 @@ impl BasisCacheEntry {
dicts: HashMap::<String, DictCacheEntry>::new(), dicts: HashMap::<String, DictCacheEntry>::new(),
cipher, cipher,
cipher_ecb: Aes256::new(GenericArray::from_slice(&key.pt)), cipher_ecb: Aes256::new(GenericArray::from_slice(&key.pt)),
pt_key: GenericArray::clone_from_slice(&key.pt),
key: GenericArray::clone_from_slice(&key.data), key: GenericArray::clone_from_slice(&key.data),
aad, aad,
age: basis_root.age, age: basis_root.age,

View file

@ -444,8 +444,8 @@ impl PddbOs {
/// that also maps to the imposter), the imposter is effectively de-allocated because the FSCB report is inserted directly /// that also maps to the imposter), the imposter is effectively de-allocated because the FSCB report is inserted directly
/// into the page table, overwriting the impostor entry in the paget able. On the next mount, this turns into the "trivial conflict" /// into the page table, overwriting the impostor entry in the paget able. On the next mount, this turns into the "trivial conflict"
/// case, where one page will validate and the other will not. /// case, where one page will validate and the other will not.
pub(crate) fn pt_scan_key(&self, key: &[u8; AES_KEYSIZE], basis_name: &str) -> Option<HashMap::<VirtAddr, PhysPage>> { pub(crate) fn pt_scan_key(&self, pt_key: &[u8; AES_KEYSIZE], data_key: &[u8; AES_KEYSIZE], basis_name: &str) -> Option<HashMap::<VirtAddr, PhysPage>> {
let cipher = Aes256::new(&GenericArray::from_slice(key)); let cipher = Aes256::new(&GenericArray::from_slice(pt_key));
let pt = self.pt_as_slice(); let pt = self.pt_as_slice();
let mut map = HashMap::<VirtAddr, PhysPage>::new(); let mut map = HashMap::<VirtAddr, PhysPage>::new();
let blank = [0xffu8; aes::BLOCK_SIZE]; let blank = [0xffu8; aes::BLOCK_SIZE];
@ -473,7 +473,7 @@ impl PddbOs {
pp.set_space_state(SpaceState::Used); pp.set_space_state(SpaceState::Used);
// handle conflicting journal versions here // handle conflicting journal versions here
if let Some(prev_page) = map.get(&pte.vaddr()) { if let Some(prev_page) = map.get(&pte.vaddr()) {
let cipher = AesGcmSiv::<Aes256>::new(Key::from_slice(key)); let cipher = AesGcmSiv::<Aes256>::new(Key::from_slice(data_key));
let aad = self.data_aad(basis_name); let aad = self.data_aad(basis_name);
let prev_data = self.data_decrypt_page(&cipher, &aad, prev_page); let prev_data = self.data_decrypt_page(&cipher, &aad, prev_page);
let new_data = self.data_decrypt_page(&cipher, &aad, &pp); let new_data = self.data_decrypt_page(&cipher, &aad, &pp);
@ -1400,7 +1400,7 @@ impl PddbOs {
self.fast_space_read(); self.fast_space_read();
self.syskey_ensure(); self.syskey_ensure();
if let Some(syskey) = self.system_basis_key.take() { if let Some(syskey) = self.system_basis_key.take() {
if let Some(sysbasis_map) = self.pt_scan_key(&syskey.pt, PDDB_DEFAULT_SYSTEM_BASIS) { if let Some(sysbasis_map) = self.pt_scan_key(&syskey.pt, &syskey.data, PDDB_DEFAULT_SYSTEM_BASIS) {
let aad = self.data_aad(PDDB_DEFAULT_SYSTEM_BASIS); let aad = self.data_aad(PDDB_DEFAULT_SYSTEM_BASIS);
// get the first page, where the basis root is guaranteed to be // get the first page, where the basis root is guaranteed to be
if let Some(root_page) = sysbasis_map.get(&VirtAddr::new(VPAGE_SIZE as u64).unwrap()) { if let Some(root_page) = sysbasis_map.get(&VirtAddr::new(VPAGE_SIZE as u64).unwrap()) {
@ -1767,14 +1767,26 @@ impl PddbOs {
pub(crate) fn pddb_generate_used_map(&self, cache: &Vec::<BasisCacheEntry>) -> Option<BinaryHeap<Reverse<u32>>> { pub(crate) fn pddb_generate_used_map(&self, cache: &Vec::<BasisCacheEntry>) -> Option<BinaryHeap<Reverse<u32>>> {
if let Some(all_keys) = self.pddb_get_all_keys(&cache) { if let Some(all_keys) = self.pddb_get_all_keys(&cache) {
let mut page_heap = BinaryHeap::new(); let mut page_heap = BinaryHeap::new();
for (key, name) in all_keys { for (basis_keys, name) in all_keys {
// scan the disclosed bases // scan the disclosed bases
if let Some(map) = self.pt_scan_key(&key, &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() {
page_heap.push(Reverse(pp.page_number())) page_heap.push(Reverse(pp.page_number()))
} }
} else {
log::warn!("pt_scan for basis {} failed, data may be lost", name);
} }
} }
// need to incorporate all of the FSCB knowledge into the scan as well, because there could be
// cached pages inside "live" Basis that have not been committed to disk. However, it *should* be
// the case that any cached allocations came out of the previous FSCB pool, therefore, by merging
// in the "used list" from the existing FSCB we should be able to generate an accurate
// representation of the actually used pages
Some(page_heap) Some(page_heap)
} else { } else {
None None
@ -1788,20 +1800,13 @@ 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")))]
pub(crate) fn pddb_get_all_keys(&self, cache: &Vec::<BasisCacheEntry>) -> Option<Vec<([u8; AES_KEYSIZE], String)>> { pub(crate) fn pddb_get_all_keys(&self, cache: &Vec::<BasisCacheEntry>) -> Option<Vec<(BasisKeys, String)>> {
const SWAP_DELAY_MS: usize = 300; const SWAP_DELAY_MS: usize = 300;
let mut ret = Vec::<([u8; AES_KEYSIZE], String)>::new(); // populate the "known" entries
let mut ret = Vec::<(BasisKeys, String)>::new();
for entry in cache { for entry in cache {
ret.push((entry.key.into(), entry.name.to_string())); ret.push((BasisKeys { pt: entry.pt_key.into(), data: entry.key.into() }, entry.name.to_string()));
} }
/*
if let Some(sys_key) = &self.system_basis_key {
ret.push((sys_key.pt, PDDB_DEFAULT_SYSTEM_BASIS.to_string()));
} else {
log::error!("No default system basis was set up, this should be an illegal condition when requesting FSCB scan!");
panic!("No default system basis was set up, this should be an illegal condition when requesting FSCB scan!");
}
*/
log::info!("{} basis are open, with the following names:", cache.len()); log::info!("{} basis are open, with the following names:", cache.len());
for entry in cache { for entry in cache {
log::info!(" - {}", entry.name); log::info!(" - {}", entry.name);
@ -1846,14 +1851,16 @@ impl PddbOs {
&name, &name,
retpass.plaintext_pw.unwrap().as_str().unwrap() retpass.plaintext_pw.unwrap().as_str().unwrap()
); );
// validate the password by finding the root block of the basis. We rely entirely
// upon the AEAD with key commit to ensure the password is correct.
let maybe_entry = if let Some(basis_map) = let maybe_entry = if let Some(basis_map) =
self.pt_scan_key(&basis_key.pt, &name) { self.pt_scan_key(&basis_key.pt, &basis_key.data, &name) {
let aad = self.data_aad(&name); let aad = self.data_aad(&name);
if let Some(root_page) = basis_map.get(&VirtAddr::new(VPAGE_SIZE as u64).unwrap()) { if let Some(root_page) = basis_map.get(&VirtAddr::new(VPAGE_SIZE as u64).unwrap()) {
match self.data_decrypt_page_with_commit(&basis_key.data, &aad, root_page) { match self.data_decrypt_page_with_commit(&basis_key.data, &aad, root_page) {
Some(_data) => { Some(_data) => {
// if the root page decrypts, we accept the password; no further checking is done. // if the root page decrypts, we accept the password; no further checking is done.
Some((basis_key.pt, name.to_string())) Some((basis_key, name.to_string()))
}, },
None => None, None => None,
} }
@ -1864,8 +1871,8 @@ impl PddbOs {
None None
}; };
// 3. add to the Aes256 return vec // 3. add to the Aes256 return vec
if let Some((key, name)) = maybe_entry { if let Some((basis_key, name)) = maybe_entry {
ret.push((key, name)); ret.push((basis_key, name));
} else { } else {
modals.show_notification(t!("pddb.freespace.badpass", xous::LANG), None).ok(); modals.show_notification(t!("pddb.freespace.badpass", xous::LANG), None).ok();
self.tt.sleep_ms(SWAP_DELAY_MS).unwrap(); self.tt.sleep_ms(SWAP_DELAY_MS).unwrap();
@ -2041,11 +2048,11 @@ impl PddbOs {
} }
/// In testing, we want a way to automatically unlock all known test Bases. This stand-in feature automates that. /// 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"))] #[cfg(all(feature="pddbtest", feature="autobasis"))]
pub(crate) fn pddb_get_all_keys(&self, cache: &Vec::<BasisCacheEntry>) -> Option<Vec<([u8; AES_KEYSIZE], String)>> { pub(crate) fn pddb_get_all_keys<'a>(&'a self, cache: &'a Vec::<BasisCacheEntry>) -> Option<Vec<(BasisKeys, String)>> {
// populate the "known" entries // populate the "known" entries
let mut ret = Vec::<([u8; AES_KEYSIZE], String)>::new(); let mut ret = Vec::<(BasisKeys, String)>::new();
for entry in cache { for entry in cache {
ret.push((entry.key.into(), entry.name.to_string())); ret.push((BasisKeys { pt: entry.pt_key.into(), data: entry.key.into() }, entry.name.to_string()));
} }
// now iterate through the bases that have been enumerated so far, and populate the missing ones. // now iterate through the bases that have been enumerated so far, and populate the missing ones.
@ -2053,7 +2060,7 @@ impl PddbOs {
// if the entry isn't known already, add it // if the entry isn't known already, add it
// yah, this is O(n^2) awful. yolo! // yah, this is O(n^2) awful. yolo!
let mut exists = false; let mut exists = false;
for (_key, bname) in ret.iter() { for (_bk, bname) in ret.iter() {
if bname == name { if bname == name {
exists = true; exists = true;
break; break;
@ -2064,10 +2071,13 @@ impl PddbOs {
name, name,
name name
); );
ret.push((basis_key.pt, name.to_string())); ret.push((basis_key, name.to_string()));
} }
} }
log::info!("for FSCB testing, we auto-unlocked {} bases", ret.len()); log::info!("for FSCB testing, we auto-unlocked {} bases:", ret.len());
for (_bk, entry) in ret.iter() {
log::info!(" - {}", entry);
}
Some(ret) Some(ret)
} }
#[cfg(all(feature="pddbtest", feature="autobasis"))] #[cfg(all(feature="pddbtest", feature="autobasis"))]