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)]
// PDDB_A_LEN may be shorter than xous::PDDB_LEN, to speed up testing.
#[allow(dead_code)]
pub(crate) const PDDB_A_LEN: usize = xous::PDDB_LEN as usize;
// pub(crate) const PDDB_A_LEN: usize = 4 * 1024 * 1024;
// pub(crate) const PDDB_A_LEN: usize = xous::PDDB_LEN as usize;
pub const PDDB_A_LEN: usize = 4 * 1024 * 1024;
/// 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

View file

@ -801,7 +801,7 @@ impl BasisCache {
pub(crate) fn basis_unlock(&mut self, hw: &mut PddbOs, name: &str, password: &str,
policy: BasisRetentionPolicy) -> Option<BasisCacheEntry> {
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);
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) {
@ -1090,7 +1090,11 @@ pub(crate) struct BasisCacheEntry {
pub cipher: AesGcmSiv::<Aes256>,
/// derived cipher for encrypting PTEs -- cache it, so we can save the time cost of constructing the cipher key schedule
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>,
/// the AAD associated with this Basis
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
/// 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> {
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 aad = hw.data_aad(name);
// get the first page, where the basis root is guaranteed to be
@ -1149,6 +1153,7 @@ impl BasisCacheEntry {
dicts: HashMap::<String, DictCacheEntry>::new(),
cipher,
cipher_ecb: Aes256::new(GenericArray::from_slice(&key.pt)),
pt_key: GenericArray::clone_from_slice(&key.pt),
key: GenericArray::clone_from_slice(&key.data),
aad,
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
/// 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.
pub(crate) fn pt_scan_key(&self, key: &[u8; AES_KEYSIZE], basis_name: &str) -> Option<HashMap::<VirtAddr, PhysPage>> {
let cipher = Aes256::new(&GenericArray::from_slice(key));
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(pt_key));
let pt = self.pt_as_slice();
let mut map = HashMap::<VirtAddr, PhysPage>::new();
let blank = [0xffu8; aes::BLOCK_SIZE];
@ -473,7 +473,7 @@ impl PddbOs {
pp.set_space_state(SpaceState::Used);
// handle conflicting journal versions here
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 prev_data = self.data_decrypt_page(&cipher, &aad, prev_page);
let new_data = self.data_decrypt_page(&cipher, &aad, &pp);
@ -1400,7 +1400,7 @@ impl PddbOs {
self.fast_space_read();
self.syskey_ensure();
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);
// 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()) {
@ -1767,14 +1767,26 @@ impl PddbOs {
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) {
let mut page_heap = BinaryHeap::new();
for (key, name) in all_keys {
for (basis_keys, name) in all_keys {
// 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() {
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)
} else {
None
@ -1788,20 +1800,13 @@ impl PddbOs {
/// 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.
#[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;
let mut ret = Vec::<([u8; AES_KEYSIZE], String)>::new();
// populate the "known" entries
let mut ret = Vec::<(BasisKeys, String)>::new();
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());
for entry in cache {
log::info!(" - {}", entry.name);
@ -1846,14 +1851,16 @@ impl PddbOs {
&name,
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) =
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);
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) {
Some(_data) => {
// 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,
}
@ -1864,8 +1871,8 @@ impl PddbOs {
None
};
// 3. add to the Aes256 return vec
if let Some((key, name)) = maybe_entry {
ret.push((key, name));
if let Some((basis_key, name)) = maybe_entry {
ret.push((basis_key, name));
} else {
modals.show_notification(t!("pddb.freespace.badpass", xous::LANG), None).ok();
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.
#[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
let mut ret = Vec::<([u8; AES_KEYSIZE], String)>::new();
let mut ret = Vec::<(BasisKeys, String)>::new();
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.
@ -2053,7 +2060,7 @@ impl PddbOs {
// if the entry isn't known already, add it
// yah, this is O(n^2) awful. yolo!
let mut exists = false;
for (_key, bname) in ret.iter() {
for (_bk, bname) in ret.iter() {
if bname == name {
exists = true;
break;
@ -2064,10 +2071,13 @@ impl PddbOs {
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)
}
#[cfg(all(feature="pddbtest", feature="autobasis"))]