mirror of
https://github.com/saymrwulf/xous-core.git
synced 2026-11-17 08:40:52 +00:00
refactor structure; fix mutability issue with fast space allocations.
see comments in code for more details, but, the Rust borrow checker found a problem where the virtual to physical map could be concurrently modified with additional entries during an allocation, so now the code works on an "look-before-you-leap" allocation basis (where it's assumed you either ensured sufficient space or allocated as you ran along previously), versus a "oops we need memory let's stop the world and redo everything while in the middle of anything" situation. The latter is obviously more convevient, but, alas, I have to agree with the borrow checker -- probably not the safest way to do things.
This commit is contained in:
parent
6fa2332ff5
commit
70a478795d
4 changed files with 515 additions and 444 deletions
|
|
@ -25,6 +25,11 @@ pub(crate) const PDDB_A_LEN: usize = 4 * 1024 * 1024;
|
|||
/// 0.5: with this setting, we won't be more than a factor of 2 off from the ideal setting!
|
||||
#[allow(dead_code)]
|
||||
pub(crate) const FSCB_FILL_COEFFICIENT: f32 = 0.5;
|
||||
/// This adds some uncertainty to the fill coeffiecient. This adds "noise" to the free space
|
||||
/// top-up, to try and mitigate analysis patterns of the amount of free space available based
|
||||
/// on a fixed ratio reduction over time. Expressed as the extents of a random +/- offset
|
||||
/// from the FILL_COEFFICIENT.
|
||||
pub(crate) const FSCB_FILL_UNCERTAINTY: f32 = 0.1;
|
||||
|
||||
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
|
||||
|
|
|
|||
|
|
@ -14,6 +14,8 @@ use rkyv::Aligned;
|
|||
use rkyv::ser::serializers::BufferSerializer;
|
||||
use std::iter::IntoIterator;
|
||||
use std::collections::HashMap;
|
||||
use std::io::{Result, Error, ErrorKind};
|
||||
|
||||
|
||||
/// In basis space, the BasisRoot is located at VPAGE #1 (VPAGE #0 is always invalid).
|
||||
/// A VPAGE is 0xFE0 (4,064) bytes long, which is equal to a PAGE of 4k minus 32 bytes of encryption+journal
|
||||
|
|
@ -152,8 +154,86 @@ impl DerefMut for BasisRoot {
|
|||
}
|
||||
}
|
||||
|
||||
/// This is the RAM cached copy of a basis as maintained in the PDDB.
|
||||
pub(crate) struct BasisCache {
|
||||
/// the cache entries themselves
|
||||
cache: Vec::<BasisCacheEntry>,
|
||||
}
|
||||
impl BasisCache {
|
||||
pub(crate) fn new() -> Self {
|
||||
BasisCache { cache: Vec::new() }
|
||||
}
|
||||
pub(crate) fn add_basis(&mut self, basis: BasisCacheEntry) {
|
||||
self.cache.push(basis);
|
||||
}
|
||||
// placeholder reminder: deleting a basis is a bit more complicated, as it requires
|
||||
// syncing its contents.
|
||||
|
||||
fn select_basis(&mut self, basis_name: Option<&str>) -> Option<&mut BasisCacheEntry> {
|
||||
if self.cache.len() == 0 {
|
||||
log::error!("Can't select basis: PDDB is not mounted");
|
||||
return None
|
||||
}
|
||||
if let Some(n) = basis_name {
|
||||
self.cache.iter_mut().filter(|bc| bc.name == n).next()
|
||||
} else {
|
||||
self.cache.last_mut()
|
||||
}
|
||||
}
|
||||
|
||||
/// Adds a dictionary with `name` to:
|
||||
/// - if `basis_name` is None, the most recently opened basis
|
||||
/// - if `basis_name` is Some, searches for the given basis and adds the dictionary to that.
|
||||
/// If the dictionary already exists, it returns an informative error.
|
||||
pub(crate) fn dict_add(&mut self, hw: &mut PddbOs, name: &str, basis_name: Option<&str>) -> Result<()> {
|
||||
if !hw.ensure_fast_space_alloc(1, &self.cache) {
|
||||
return Err(Error::new(ErrorKind::OutOfMemory, "No free space to allocate dict"));
|
||||
}
|
||||
if let Some(basis) = self.select_basis(basis_name) {
|
||||
basis.age = basis.age.saturating_add(1);
|
||||
if basis.dicts.get(&String::from(name)).is_some() {
|
||||
// quick exit if we see the dictionary is hot in the cache
|
||||
return Err(Error::new(ErrorKind::AlreadyExists, "Dictionary already exists"));
|
||||
} else {
|
||||
// if the dictionary doesn't exist in our cache it doesn't necessarily mean it
|
||||
// doesn't exist. Do a comprehensive search if our cache isn't complete.
|
||||
if basis.root.num_dictionaries as usize != basis.dicts.len() {
|
||||
if basis.dict_deep_search(hw, name).is_some() {
|
||||
return Err(Error::new(ErrorKind::AlreadyExists, "Dictionary already exists"));
|
||||
}
|
||||
}
|
||||
}
|
||||
basis.clean = false;
|
||||
// allocate a vpage offset for the dictionary
|
||||
let dict_index = basis.dict_get_free_offset(hw);
|
||||
let dict_offset = VirtAddr::new(dict_index as u64 * DICT_VSIZE).unwrap();
|
||||
let pp = basis.v2p_map.entry(dict_offset).or_insert_with(||
|
||||
hw.try_fast_space_alloc().expect("No free space to allocate dict"));
|
||||
|
||||
// create the cache entry
|
||||
let mut dict_name = [0u8; DICT_NAME_LEN];
|
||||
for (src, dst) in name.bytes().into_iter().zip(dict_name.iter_mut()) {
|
||||
*dst = src;
|
||||
}
|
||||
let dict_cache = DictCacheEntry {
|
||||
index: dict_index,
|
||||
keys: HashMap::<String, KeyCacheEntry>::new(),
|
||||
clean: false,
|
||||
age: 0,
|
||||
flags: 0,
|
||||
key_count: 0,
|
||||
};
|
||||
basis.dicts.insert(String::from(name), dict_cache);
|
||||
// encrypt and write the dict entry to disk
|
||||
basis.dict_sync(hw, name)?;
|
||||
Ok(())
|
||||
} else {
|
||||
Err(Error::new(ErrorKind::NotFound, "Requested basis not found, or PDDB not mounted."))
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// This is the RAM cached copy of a basis as maintained in the PDDB.
|
||||
pub(crate) struct BasisCacheEntry {
|
||||
/// the name of this basis
|
||||
pub name: String,
|
||||
/// set if synched to what's on disk
|
||||
|
|
@ -163,7 +243,7 @@ pub(crate) struct BasisCache {
|
|||
/// the basis root record, as read in from disk
|
||||
pub root: BasisRoot,
|
||||
/// dictionary array.
|
||||
pub dicts: HashMap::<String, DictCache>,
|
||||
pub dicts: HashMap::<String, DictCacheEntry>,
|
||||
/// A cached copy of the absolute offset of the next free dictionary slot,
|
||||
/// expressed as a number that needs to be multiplied by DICT_VSIZE to arrive at a virtual address
|
||||
pub free_dict_offset: Option<u32>,
|
||||
|
|
@ -173,17 +253,280 @@ pub(crate) struct BasisCache {
|
|||
pub aad: Vec::<u8>,
|
||||
/// modification count
|
||||
pub age: u32,
|
||||
/// virtual to physical page map. It's the reverse mapping of the physical page table on disk.
|
||||
pub v2p_map: HashMap<VirtAddr, PhysPage>,
|
||||
}
|
||||
impl BasisCacheEntry {
|
||||
/*
|
||||
/// If `paranoid` is true, it recurses through each key and replaces its data with random junk.
|
||||
/// Otherwise, it does a "shallow" delete and just removes the directory entry, which is much
|
||||
/// more performant. Note that the intended "fast" way to secure-erase data is to store sensitive
|
||||
/// data in its own Basis, and then remove the Basis itself. This is much faster than picking
|
||||
/// through compounded data and re-writing partias sectors, and because of this, initially,
|
||||
/// the `paranoid` erase is `unimplemented`.
|
||||
pub(crate) fn dict_delete(&self, name: &str, basis_name: Option<&str>, paranoid: bool) -> Result<()> {
|
||||
if self.basis_cache.len() == 0 {
|
||||
return Err(Error::new(ErrorKind::NotConnected, "PDDB is not mounted"));
|
||||
}
|
||||
let maybe_basis = if let Some(n) = basis_name {
|
||||
self.basis_cache.iter_mut().filter(|&bc| bc.name == n).next()
|
||||
} else {
|
||||
self.basis_cache.last_mut()
|
||||
};
|
||||
if let Some(basis) = maybe_basis {
|
||||
if let Some((index, _dict)) = self.dict_deep_search(&mut basis, name) {
|
||||
let map = self.v2p_map.get_mut(&basis.name).expect("No v2p map despite extant BasisCacheEntry record. Shouldn't be possible...");
|
||||
if !paranoid {
|
||||
// erase the header by writing over with random data. This makes the dictionary unsearchable, but if you
|
||||
// have the key, you can of course do a hard-scan and try partially re-assemble the dictionary.
|
||||
if let Some(pp) = map.get(&VirtAddr::new(index as u64 * DICT_VSIZE as u64).unwrap()) {
|
||||
let mut random = [0u8; PAGE_SIZE];
|
||||
self.entropy.borrow_mut().get_slice(&mut random);
|
||||
self.patch_data(&random, pp.page_number() * PAGE_SIZE as u32);
|
||||
} else {
|
||||
log::warn!("Inconsistent internal state: requested dictionary didn't have a mapping in the page table.");
|
||||
}
|
||||
} else {
|
||||
unimplemented!("For now store sensitive data in its own Basis, and then delete the Basis.");
|
||||
// this is a bit of an arduous code path, it involves recursing through all the keys and nuking
|
||||
// them. Let's write this after we've actually _got keys_ (we're just figuring out how to add a dictionary
|
||||
// in the first place right now!).
|
||||
}
|
||||
|
||||
// de-allocate all of the dictionary entries
|
||||
Ok(())
|
||||
} else {
|
||||
Err(Error::new(ErrorKind::NotFound, "Dictionary not found"))
|
||||
}
|
||||
} else {
|
||||
Err(Error::new(ErrorKind::NotFound, "Requested basis not found"))
|
||||
}
|
||||
}
|
||||
*/
|
||||
|
||||
pub(crate) fn dict_get_free_offset(&mut self, hw: &mut PddbOs) -> u32 {
|
||||
if let Some(offset) = self.free_dict_offset.take() {
|
||||
return offset;
|
||||
} else {
|
||||
let mut try_entry = 1;
|
||||
while try_entry <= DICT_MAXCOUNT {
|
||||
let dict_vaddr = VirtAddr::new(try_entry as u64 * DICT_VSIZE).unwrap();
|
||||
if let Some(pp) = self.v2p_map.get(&dict_vaddr) {
|
||||
if self.dict_decrypt(hw, &pp).is_none() {
|
||||
// mapping exists, but the data is invalid. It's a free entry.
|
||||
return try_entry as u32
|
||||
}
|
||||
} else {
|
||||
// mapping doesn't exist yet, that's a free entry
|
||||
return try_entry as u32
|
||||
}
|
||||
try_entry += 1;
|
||||
}
|
||||
}
|
||||
// maybe we should handle this better? but, I think this should be super-rare, as we allow 16384 dictionaries per Basis,
|
||||
// so if we got here I'm guessing it's more likely due to a coding error than an actually full Basis.
|
||||
panic!("Basis full, can't allocate dictionary");
|
||||
}
|
||||
|
||||
/// Returns a tuple of "dictionary offset" , "dictionary"; the "dictionary offset" needs to be multiplied by DICT_VSIZE to arrive
|
||||
/// at a fully expanded virtual address.
|
||||
pub(crate) fn dict_deep_search(&mut self, hw: &mut PddbOs, name: &str) -> Option<(u32, Dictionary)> {
|
||||
let mut try_entry = 1;
|
||||
let mut dict_count = 0;
|
||||
while try_entry <= DICT_MAXCOUNT && dict_count < self.root.num_dictionaries {
|
||||
let dict_vaddr = VirtAddr::new(try_entry as u64 * DICT_VSIZE).unwrap();
|
||||
if let Some(pp) = self.v2p_map.get(&dict_vaddr) {
|
||||
if let Some(dict) = self.dict_decrypt(hw, &pp) {
|
||||
if cstr_to_string(&dict.name) == name {
|
||||
return Some((try_entry as u32, dict))
|
||||
}
|
||||
dict_count += 1;
|
||||
} else {
|
||||
// this is an empty dictionary entry. we could stick a dictionary in here later on, take note if we haven't already computed that
|
||||
if self.free_dict_offset.is_none() {
|
||||
self.free_dict_offset = Some(try_entry as u32);
|
||||
}
|
||||
}
|
||||
} else {
|
||||
// this is an empty dictionary entry. we could stick a dictionary in here later on, take note if we haven't already computed that
|
||||
if self.free_dict_offset.is_none() {
|
||||
self.free_dict_offset = Some(try_entry as u32);
|
||||
}
|
||||
}
|
||||
try_entry += 1;
|
||||
}
|
||||
None
|
||||
}
|
||||
|
||||
/// The `pp` must be the resolved physical page storing the top of the given
|
||||
/// dictionary index for this to work.
|
||||
pub(crate) fn dict_decrypt(&self, hw: &mut PddbOs, pp: &PhysPage) -> Option<Dictionary> {
|
||||
if let Some(data) = hw.data_decrypt_page(&self.cipher, &self.aad, &pp) {
|
||||
let mut dict = Dictionary {
|
||||
flags: 0, age: 0, num_keys: 0, name: [0; DICT_NAME_LEN]
|
||||
};
|
||||
for (&src, dst) in data[size_of::<JournalType>()..].iter().zip(dict.deref_mut().iter_mut()) {
|
||||
*dst = src;
|
||||
}
|
||||
Some(dict)
|
||||
} else {
|
||||
None
|
||||
}
|
||||
}
|
||||
|
||||
/// This will sync the named Dictionary header + dirty *key descriptors*. It does not
|
||||
/// sync the key data itself. Note this does not mark the surrounding basis structure as clean
|
||||
/// when it exits, even if there are no more dirty entries within.
|
||||
///
|
||||
/// Significantly, this routine assumes that every dictionary entry has already had a v2p mapping
|
||||
/// allocated. You can try calling it without pre-allocating the entries, but if the FastSpace structure
|
||||
/// doesn't have enough space, the routine will return an error indicating we're out of memory.
|
||||
/// You could then try to allocate more FastSpace, and re-try the sync operation.
|
||||
pub(crate) fn dict_sync(&mut self, hw: &mut PddbOs, name: &str) -> Result<()> {
|
||||
if let Some(dict) = self.dicts.get_mut(&String::from(name)) {
|
||||
let dict_offset = VirtAddr::new(dict.index as u64 * DICT_VSIZE).unwrap();
|
||||
if !dict.clean {
|
||||
let mut dict_name = [0u8; DICT_NAME_LEN];
|
||||
for (src, dst) in name.bytes().into_iter().zip(dict_name.iter_mut()) {
|
||||
*dst = src;
|
||||
}
|
||||
let dict_disk = Dictionary {
|
||||
flags: dict.flags,
|
||||
age: dict.age,
|
||||
num_keys: dict.key_count,
|
||||
name: dict_name,
|
||||
};
|
||||
// observation: all keys to be flushed to disk will be in the KeyCacheEntry. Some may be clean,
|
||||
// but definitely all the dirty ones are in there (if they aren't, where else would they be??)
|
||||
|
||||
// this is the virtual page within the dictionary region that we're currently serializing
|
||||
let mut vpage_num = 0;
|
||||
loop {
|
||||
// 1. resolve the virtual address to a target page
|
||||
let cur_vpage = VirtAddr::new(dict_offset.get() + (vpage_num as u64 * VPAGE_SIZE as u64)).unwrap();
|
||||
if !self.v2p_map.contains_key(&cur_vpage) {
|
||||
if let Some(pp) = hw.try_fast_space_alloc() {
|
||||
self.v2p_map.insert(cur_vpage, pp);
|
||||
} else {
|
||||
return Err(Error::new(ErrorKind::OutOfMemory, "FastSpace empty"));
|
||||
}
|
||||
}
|
||||
let pp = self.v2p_map.get(&cur_vpage).unwrap();
|
||||
|
||||
// 2(a). fill in the target vpage with data: header special case
|
||||
let mut dk_vpage = DictKeyVpage::default();
|
||||
// the dict always occupies the first entry of the first vpage in the dictionary region
|
||||
if vpage_num == 0 {
|
||||
let mut dk_entry = DictKeyEntry::default();
|
||||
for (&src, dst) in dict_disk.deref().iter().zip(dk_entry.data.iter_mut()) {
|
||||
*dst = src;
|
||||
}
|
||||
dk_vpage.elements[0] = Some(dk_entry);
|
||||
}
|
||||
|
||||
// 2(b). fill in the target vpage with data: general key case
|
||||
// Scan the DictCacheEntry.keys record for dirty keys within the current target vpage's range
|
||||
// this is not a terribly efficient operation right now, because the DictCacheEntry is designed to
|
||||
// be searched by name, but in this case, we want to check for an index range. There's a lot
|
||||
// of things we could do to optimize this, depending on the memory/time trade-off we want to
|
||||
// make, but for now, let's do it with a dumb O(N) scan through the KeyCacheEntry, running under
|
||||
// the assumption that the KeyCacheEntry doesn't ever get to a very large N.
|
||||
let next_vpage = VirtAddr::new(cur_vpage.get() + VPAGE_SIZE as u64).unwrap();
|
||||
for (key_name, key) in dict.keys.iter_mut() {
|
||||
if !key.clean {
|
||||
if key.descriptor_vaddr(dict_offset) >= cur_vpage &&
|
||||
key.descriptor_vaddr(dict_offset) < next_vpage {
|
||||
// key is within the current page, add it to the target list
|
||||
let mut dk_entry = DictKeyEntry::default();
|
||||
let mut kn = [0u8; KEY_NAME_LEN];
|
||||
for (&src, dst) in key_name.as_bytes().iter().zip(kn.iter_mut()) {
|
||||
*dst = src;
|
||||
}
|
||||
let key_desc = KeyDescriptor {
|
||||
start: key.start,
|
||||
len: key.len,
|
||||
reserved: key.reserved,
|
||||
flags: key.flags,
|
||||
age: key.age,
|
||||
name: kn,
|
||||
};
|
||||
for (&src, dst) in key_desc.deref().iter().zip(dk_entry.data.iter_mut()) {
|
||||
*dst = src;
|
||||
}
|
||||
dk_vpage.elements[key.descriptor_modulus()] = Some(dk_entry);
|
||||
}
|
||||
key.clean = true;
|
||||
}
|
||||
}
|
||||
|
||||
// 3. merge the vpage modifications into the disk
|
||||
let mut page = if let Some(data) = hw.data_decrypt_page(&self.cipher, &self.aad, &pp) {
|
||||
data
|
||||
} else {
|
||||
// the existing data was invalid (this happens e.g. on the first time a dict is created). Just overwrite the whole page.
|
||||
vec![0u8; VPAGE_SIZE + size_of::<JournalType>()]
|
||||
};
|
||||
for (index, stride) in page[size_of::<JournalType>()..].chunks_mut(DK_STRIDE).enumerate() {
|
||||
if let Some(elem) = dk_vpage.elements[index] {
|
||||
for (&src, dst) in elem.data.iter().zip(stride.iter_mut()) {
|
||||
*dst = src;
|
||||
}
|
||||
}
|
||||
}
|
||||
// bump the journal rev. This means that revs start at "1", because the empty data array as passed has a 0 in it by default.
|
||||
let newrev = JournalType::from_le_bytes(page[..size_of::<JournalType>()].try_into().unwrap()).saturating_add(1);
|
||||
for (&src, dst) in newrev.to_le_bytes().iter().zip(page[..size_of::<JournalType>()].iter_mut()) {
|
||||
*dst = src;
|
||||
}
|
||||
// generate nonce and write out
|
||||
let nonce = hw.nonce_gen();
|
||||
let payload = Payload {
|
||||
msg: &page,
|
||||
aad: &self.aad,
|
||||
};
|
||||
let ciphertext = self.cipher.encrypt(&nonce, payload).expect("failed to encrypt DictKeys");
|
||||
hw.patch_data(&ciphertext, pp.page_number() * PAGE_SIZE as u32);
|
||||
|
||||
// 4. Check for dirty keys, if there are still some, update vpage_num to target them; otherwise
|
||||
// exit the loop
|
||||
let mut found_next = false;
|
||||
for key in dict.keys.values() {
|
||||
if !key.clean {
|
||||
found_next = true;
|
||||
// note: we don't care *which* vpage we do next -- so we just break after finding the first one
|
||||
vpage_num = key.descriptor_vpage_num();
|
||||
break;
|
||||
}
|
||||
}
|
||||
if !found_next {
|
||||
break;
|
||||
}
|
||||
}
|
||||
dict.clean = true;
|
||||
}
|
||||
Ok(())
|
||||
} else {
|
||||
Err(Error::new(ErrorKind::NotFound, "dict_sync called with an invalid dictionary name"))
|
||||
}
|
||||
}
|
||||
|
||||
/// Runs through the dictionary listing in a basis and compacts them. Call when the
|
||||
/// the dictionary space becomes sufficiently fragmented that accesses are becoming
|
||||
/// inefficient.
|
||||
pub(crate) fn dict_compact(&self, basis_name: Option<&str>) -> Result<()> {
|
||||
unimplemented!();
|
||||
}
|
||||
}
|
||||
|
||||
/// RAM based copy of the dictionary structures on disk.
|
||||
pub(crate) struct DictCache {
|
||||
pub(crate) struct DictCacheEntry {
|
||||
/// Use this to compute the virtual address of the dictionary's location
|
||||
/// multiply this by DICT_VSIZE to get at the virtual address. This /could/ be a
|
||||
/// NonZeroU32 type as it should never be 0. Maybe that's a thing to fix later on.
|
||||
pub(crate) index: u32,
|
||||
/// A cache of the keys within the dictionary. If the key does not exist in
|
||||
/// the cache, one should consult the on-disk copy, assuming the record is clean.
|
||||
pub(crate) keys: HashMap::<String, KeyCache>,
|
||||
pub(crate) keys: HashMap::<String, KeyCacheEntry>,
|
||||
/// count of total keys in the dictionary -- may be equal to or larger than the number of elements in `keys`
|
||||
pub(crate) key_count: u32,
|
||||
/// set if synced to disk. should be cleared if the dict is modified, and/or if a subordinate key descriptor is modified.
|
||||
|
|
@ -284,19 +627,19 @@ impl DerefMut for KeyDescriptor {
|
|||
}
|
||||
}
|
||||
|
||||
pub(crate) struct KeyCache {
|
||||
pub(crate) struct KeyCacheEntry {
|
||||
pub(crate) start: u64,
|
||||
pub(crate) len: u64,
|
||||
pub(crate) reserved: u64,
|
||||
pub(crate) flags: u32,
|
||||
pub(crate) age: u32,
|
||||
/// the current on-disk index of the KeyCache item, enumerated as "0" being the first DictKeyEntry
|
||||
/// the current on-disk index of the KeyCacheEntry item, enumerated as "0" being the first DictKeyEntry
|
||||
/// slot past the first record which is the descriptor of the dictionary.
|
||||
pub(crate) descriptor_index: u32,
|
||||
/// indicates if it's clean
|
||||
pub(crate) clean: bool,
|
||||
}
|
||||
impl KeyCache {
|
||||
impl KeyCacheEntry {
|
||||
/// Given a base offset of the dictionary containing the key, compute the starting VirtAddr of the key itself.
|
||||
pub(crate) fn descriptor_vaddr(&self, dict_offset: VirtAddr) -> VirtAddr {
|
||||
VirtAddr::new(dict_offset.get() + ((self.descriptor_index as u64 + 1) * DK_STRIDE as u64)).unwrap()
|
||||
|
|
@ -313,7 +656,7 @@ impl KeyCache {
|
|||
|
||||
/// used to identify cached/chunked data from a key
|
||||
/// maybe we should detach the cache_page because this is meant to be a key, and cache_page is the payload.
|
||||
pub(crate) struct KeyCacheEntry {
|
||||
pub(crate) struct KeyCacheEntryEntry {
|
||||
basis: String,
|
||||
dict: String,
|
||||
key: KeyDescriptor,
|
||||
|
|
|
|||
|
|
@ -78,8 +78,6 @@ pub(crate) struct PddbOs {
|
|||
fscb_phys_base: PageAlignedPa,
|
||||
data_phys_base: PageAlignedPa,
|
||||
system_basis_key: Option<[u8; AES_KEYSIZE]>,
|
||||
/// virtual to physical page map. It's the reverse mapping of the physical page table on disk.
|
||||
v2p_map: HashMap<String, HashMap<VirtAddr, PhysPage>>,
|
||||
/// fast space cache
|
||||
fspace_cache: HashSet<PhysPage>,
|
||||
/// memoize the location of the fscb log pages
|
||||
|
|
@ -90,6 +88,10 @@ pub(crate) struct PddbOs {
|
|||
dna: u64,
|
||||
/// reference to a TrngPool object that's shared among all the hardware functions
|
||||
entropy: Rc<RefCell<TrngPool>>,
|
||||
|
||||
/*
|
||||
/// virtual to physical page map. It's the reverse mapping of the physical page table on disk.
|
||||
v2p_map: HashMap<String, HashMap<VirtAddr, PhysPage>>,
|
||||
/// keys to non-system basis that may or may not be mounted
|
||||
/// We don't blend the System basis into this one because we need to refer to the System basis specifically
|
||||
/// for decrypting management structures like the FSCB.
|
||||
|
|
@ -99,7 +101,8 @@ pub(crate) struct PddbOs {
|
|||
/// dictionaries, so unless you create 1k's of dictionaries and keys, it'll probably all fit in RAM.
|
||||
/// When searching for dictionaries and keys, the search always starts with the LAST item added to the
|
||||
/// basis_cache.
|
||||
basis_cache: Vec::<BasisCache>,
|
||||
basis_cache: Vec::<BasisCacheEntry>,
|
||||
*/
|
||||
}
|
||||
|
||||
impl PddbOs {
|
||||
|
|
@ -133,14 +136,14 @@ impl PddbOs {
|
|||
fscb_phys_base,
|
||||
data_phys_base: PageAlignedPa::from(fscb_phys_base.as_u32() + FSCB_PAGES as u32 * PAGE_SIZE as u32),
|
||||
system_basis_key: None,
|
||||
v2p_map: HashMap::<String, HashMap<VirtAddr, PhysPage>>::new(),
|
||||
//v2p_map: HashMap::<String, HashMap<VirtAddr, PhysPage>>::new(),
|
||||
fspace_cache: HashSet::<PhysPage>::new(),
|
||||
fspace_log_addrs: Vec::<PageAlignedPa>::new(),
|
||||
fspace_log_next_addr: None,
|
||||
dna: llio.soc_dna().unwrap(),
|
||||
entropy: trngpool,
|
||||
basis_keys: Vec::new(),
|
||||
basis_cache: Vec::<BasisCache>::new(),
|
||||
//basis_keys: Vec::new(),
|
||||
//basis_cache: Vec::<BasisCacheEntry>::new(),
|
||||
};
|
||||
// emulated
|
||||
#[cfg(not(any(target_os = "none", target_os = "xous")))]
|
||||
|
|
@ -156,14 +159,14 @@ impl PddbOs {
|
|||
fscb_phys_base,
|
||||
data_phys_base: PageAlignedPa::from(fscb_phys_base.as_u32() + FSCB_PAGES as u32 * PAGE_SIZE as u32),
|
||||
system_basis_key: None,
|
||||
v2p_map: HashMap::<String, HashMap<VirtAddr, PhysPage>>::new(),
|
||||
//v2p_map: HashMap::<String, HashMap<VirtAddr, PhysPage>>::new(),
|
||||
fspace_cache: HashSet::<PhysPage>::new(),
|
||||
fspace_log_addrs: Vec::<PageAlignedPa>::new(),
|
||||
fspace_log_next_addr: None,
|
||||
dna: llio.soc_dna().unwrap(),
|
||||
entropy: trngpool,
|
||||
basis_keys: Vec::new(),
|
||||
basis_cache: Vec::<BasisCache>::new(),
|
||||
//basis_keys: Vec::new(),
|
||||
//basis_cache: Vec::<BasisCacheEntry>::new(),
|
||||
}
|
||||
};
|
||||
ret
|
||||
|
|
@ -193,9 +196,14 @@ impl PddbOs {
|
|||
// placeholder
|
||||
}
|
||||
|
||||
pub(crate) fn nonce_gen(&mut self) -> Nonce {
|
||||
let nonce_array = self.entropy.borrow_mut().get_nonce();
|
||||
*Nonce::from_slice(&nonce_array)
|
||||
}
|
||||
|
||||
/// patches data at an offset starting from the data physical base address, which corresponds
|
||||
/// exactly to the first entry in the page table
|
||||
fn patch_data(&self, data: &[u8], offset: u32) {
|
||||
pub(crate) fn patch_data(&self, data: &[u8], offset: u32) {
|
||||
log::trace!("patch offset: {:x} len: {:x}", offset, data.len());
|
||||
assert!(data.len() + offset as usize <= PDDB_A_LEN - self.data_phys_base.as_usize(), "attempt to store past disk boundary");
|
||||
self.spinor.patch(
|
||||
|
|
@ -340,7 +348,7 @@ impl PddbOs {
|
|||
// handle conflicting journal versions here
|
||||
if let Some(prev_page) = map.get(&pte.vaddr()) {
|
||||
let cipher = Aes256GcmSiv::new(Key::from_slice(key));
|
||||
let aad = self.data_aad(PDDB_DEFAULT_SYSTEM_BASIS);
|
||||
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);
|
||||
if let Some(new_d) = new_data {
|
||||
|
|
@ -502,10 +510,7 @@ impl PddbOs {
|
|||
}
|
||||
}
|
||||
|
||||
/// WARNING: only call this function when all knows Basis have been unlocked, otherwise locked
|
||||
/// Basis will be marked in the freespace sweep for deletion.
|
||||
///
|
||||
/// Sweeps through the entire set of known data (as loaded in v2p_map) and
|
||||
/// Sweeps through the entire set of known data (as indicated in `page_heap`) and
|
||||
/// returns a subset of the total free space in a PhysPage vector that is a list of physical pages,
|
||||
/// in random order, that can be used by PDDB operations in the future without worry about
|
||||
/// accidentally overwriting Basis data that are locked.
|
||||
|
|
@ -514,19 +519,12 @@ impl PddbOs {
|
|||
/// needs to run in a fairly memory-constrained environment, keeping in mind that if the PDDB
|
||||
/// structures were to be extended to run on say, an external USB drive with gigabytes of space,
|
||||
/// we cannot afford to naively allocate vectors that count every single page.
|
||||
fn fast_space_generate(&mut self) -> Vec::<PhysPage> {
|
||||
fn fast_space_generate(&mut self, mut page_heap: BinaryHeap<Reverse<u32>>) -> Vec::<PhysPage> {
|
||||
let mut free_pool = Vec::<usize>::new();
|
||||
let max_entries = FASTSPACE_PAGES * PAGE_SIZE / size_of::<PhysPage>();
|
||||
free_pool.reserve_exact(max_entries);
|
||||
// 1. scan through all of the known physical pages, and add them to a binary heap.
|
||||
// WARNING: this could get really big for a very large filesystem. It's capped at ~100k for
|
||||
// Precursor's ~100MiB storage increment.
|
||||
let mut page_heap = BinaryHeap::new();
|
||||
for (_, basismap) in &self.v2p_map {
|
||||
for (_, pp) in basismap {
|
||||
page_heap.push(Reverse(pp.page_number()));
|
||||
}
|
||||
}
|
||||
|
||||
// 1. check that the page_heap has enough entries
|
||||
let total_used_pages = page_heap.len();
|
||||
let total_free_pages = (PDDB_A_LEN - self.data_phys_base.as_usize()) / PAGE_SIZE;
|
||||
log::info!("page alloc: {} used; {} free", total_used_pages, total_free_pages);
|
||||
|
|
@ -572,8 +570,12 @@ impl PddbOs {
|
|||
}
|
||||
log::info!("free_pool initial count: {}", free_pool.len());
|
||||
|
||||
// 4. ensure that the free pool stays within the defined deniability ratio
|
||||
let deniable_free_pages = (total_free_pages as f32 * FSCB_FILL_COEFFICIENT) as usize;
|
||||
// 4. ensure that the free pool stays within the defined deniability ratio + noise
|
||||
let mut noise = (self.entropy.borrow_mut().get_u32() as f32 / u32::MAX as f32) * FSCB_FILL_UNCERTAINTY;
|
||||
if self.entropy.borrow_mut().get_u8() > 127 {
|
||||
noise = -noise;
|
||||
}
|
||||
let deniable_free_pages = (total_free_pages as f32 * (FSCB_FILL_COEFFICIENT + noise)) as usize;
|
||||
// we're guarantede to have at least one free page, because we errored out if the pages was 0 above.
|
||||
let deniable_free_pages = if deniable_free_pages == 0 { 1 } else { deniable_free_pages };
|
||||
free_pool.truncate(deniable_free_pages);
|
||||
|
|
@ -744,7 +746,6 @@ impl PddbOs {
|
|||
}
|
||||
}
|
||||
/// returns a count of the number of pages in the fspace cache
|
||||
#[allow(dead_code)]
|
||||
pub fn fast_space_len(&self) -> usize {
|
||||
self.fspace_cache.len()
|
||||
}
|
||||
|
|
@ -797,8 +798,14 @@ impl PddbOs {
|
|||
}
|
||||
}
|
||||
}
|
||||
/// attempts to allocate a page out of the fspace cache (in RAM)
|
||||
/// If None is returned, try calling fast_space_generate() to create a new pool of FastSpace pages.
|
||||
/// Attempts to allocate a page out of the fspace cache (in RAM). This is the "normal" route for allocating pages.
|
||||
/// This call should be prefixed by a call to ensure_fast_space_alloc() to make sure it doesn't fail.
|
||||
/// We do a two-stage "look before you leap" because trying to dynamically redo the fast space allocation tables
|
||||
/// in the middle of trying to allocate pages causes a borrow checker problem -- because you're already using the
|
||||
/// page maps to figure out you ran out of space, but then you're trying to mutate them to allocate more space.
|
||||
/// This can lead to concurrency issues, so we do a "look before you leap" method instead, where we just check that
|
||||
/// the correct amount of free space is available before doing an allocation, and if not, we mutate the map to populate
|
||||
/// new free space; and if so, we mutate the map to remove the allocated page.
|
||||
pub fn try_fast_space_alloc(&mut self) -> Option<PhysPage> {
|
||||
// 1. Confirm that the fspace_log_next_addr is valid. If not, regenerate it, or fail.
|
||||
if !self.fast_space_ensure_next_log() {
|
||||
|
|
@ -848,38 +855,38 @@ impl PddbOs {
|
|||
maybe_alloc
|
||||
}
|
||||
}
|
||||
/// This is the "try really hard" version of fast_space alloc. If the easy path doesn't work,
|
||||
/// It will try to rescan the entire system and allocate a new FastSpace cache.
|
||||
///
|
||||
/// If this returns None, we really are out of free space, *or* the user has cancelled out of the
|
||||
/// "unlock all Basis" request and the system will act like it's out of free space.
|
||||
pub fn fast_space_alloc(&mut self) -> Option<PhysPage> {
|
||||
match self.try_fast_space_alloc() {
|
||||
Some(alloc) => Some(alloc),
|
||||
None => {
|
||||
if self.basis_request_unlock_all() {
|
||||
let free_pool = self.fast_space_generate();
|
||||
if free_pool.len() == 0 {
|
||||
// we're out of free space
|
||||
None
|
||||
} else {
|
||||
let mut fast_space = FastSpace {
|
||||
free_pool: [PhysPage(0); FASTSPACE_FREE_POOL_LEN],
|
||||
};
|
||||
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
|
||||
self.fast_space_write(&fast_space);
|
||||
// this will ensure the data cache is fully in sync
|
||||
self.fast_space_read();
|
||||
|
||||
// retry the alloc -- this /should/ return a Some, but if it doesn't...we're out of space!
|
||||
self.try_fast_space_alloc()
|
||||
}
|
||||
/// This is a "look before you leap" function that will potentially pause all system operations
|
||||
/// and do a deep scan for space if the required amount is not available.
|
||||
pub fn ensure_fast_space_alloc(&mut self, pages: usize, cache: &Vec::<BasisCacheEntry>) -> bool {
|
||||
if self.fast_space_len() > pages {
|
||||
true
|
||||
} else {
|
||||
if let Some(used_pages) = self.pddb_generate_used_map(cache) {
|
||||
let free_pool = self.fast_space_generate(used_pages);
|
||||
if free_pool.len() == 0 {
|
||||
// we're out of free space
|
||||
false
|
||||
} else {
|
||||
None
|
||||
let mut fast_space = FastSpace {
|
||||
free_pool: [PhysPage(0); FASTSPACE_FREE_POOL_LEN],
|
||||
};
|
||||
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
|
||||
self.fast_space_write(&fast_space);
|
||||
// this will ensure the data cache is fully in sync
|
||||
self.fast_space_read();
|
||||
|
||||
// check that we have enough space now -- if not, we're just out of disk space!
|
||||
if self.fast_space_len() > pages {
|
||||
true
|
||||
} else {
|
||||
false
|
||||
}
|
||||
}
|
||||
} else {
|
||||
false
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -927,11 +934,9 @@ impl PddbOs {
|
|||
|
||||
/// Meant to be called on boot. This will read the FastSpace record, and then attempt to load
|
||||
/// in the system basis.
|
||||
pub(crate) fn pddb_mount(&mut self) -> bool {
|
||||
pub(crate) fn pddb_mount(&mut self) -> Option<BasisCacheEntry> {
|
||||
self.fast_space_read();
|
||||
self.syskey_ensure();
|
||||
// this call will nuke whatever hashmap existed before
|
||||
self.v2p_map = HashMap::<String, HashMap<VirtAddr, PhysPage>>::new();
|
||||
if let Some(syskey) = self.system_basis_key {
|
||||
if let Some(sysbasis_map) = self.pt_scan_key(&syskey, PDDB_DEFAULT_SYSTEM_BASIS) {
|
||||
let cipher = Aes256GcmSiv::new(Key::from_slice(&syskey));
|
||||
|
|
@ -940,7 +945,7 @@ impl PddbOs {
|
|||
if let Some(root_page) = sysbasis_map.get(&VirtAddr::new(VPAGE_SIZE as u64).unwrap()) {
|
||||
let vpage = match self.data_decrypt_page(&cipher, &aad, root_page) {
|
||||
Some(data) => data,
|
||||
None => {log::error!("System basis decryption did not authenticate. Unrecoverable error."); return false;},
|
||||
None => {log::error!("System basis decryption did not authenticate. Unrecoverable error."); return None;},
|
||||
};
|
||||
// if the below assertion fails, you will need to re-code this to decrypt more than one VPAGE and stripe into a basis root struct
|
||||
assert!(size_of::<BasisRoot>() <= VPAGE_SIZE, "BasisRoot has grown past a single VPAGE, this routine needs to be re-coded to accommodate the extra bulk");
|
||||
|
|
@ -950,42 +955,42 @@ impl PddbOs {
|
|||
}
|
||||
if basis_root.magic != PDDB_MAGIC {
|
||||
log::error!("Basis root did not deserialize correctly, unrecoverable error.");
|
||||
return false;
|
||||
return None;
|
||||
}
|
||||
if basis_root.version != PDDB_VERSION {
|
||||
log::error!("PDDB version mismatch in system basis root. Unrecoverable error.");
|
||||
return false;
|
||||
return None;
|
||||
}
|
||||
let basis_name = cstr_to_string(&basis_root.name.0);
|
||||
if basis_name != String::from(PDDB_DEFAULT_SYSTEM_BASIS) {
|
||||
log::error!("PDDB system basis name is incorrect: {}; aborting mount operation.", basis_name);
|
||||
return false;
|
||||
return None;
|
||||
}
|
||||
// at this point, we would fill out the cache more, but let's just put in the minimal info so we can do some testing
|
||||
let bcache = BasisCache {
|
||||
// for example, perhaps we should recurse through the dictionaries and load some keys...
|
||||
let bcache = BasisCacheEntry {
|
||||
name: basis_name.clone(),
|
||||
clean: true,
|
||||
last_sync: Some(self.tt.elapsed_ms()),
|
||||
root: basis_root,
|
||||
dicts: HashMap::<String, DictCache>::new(),
|
||||
dicts: HashMap::<String, DictCacheEntry>::new(),
|
||||
cipher,
|
||||
aad,
|
||||
age: 0,
|
||||
free_dict_offset: None,
|
||||
v2p_map: sysbasis_map,
|
||||
};
|
||||
log::info!("System BasisRoot record found, saving in cache");
|
||||
self.basis_cache.push(bcache);
|
||||
// save the v2p reverse mapping too.
|
||||
self.v2p_map.insert(basis_name, sysbasis_map);
|
||||
return true;
|
||||
return Some(bcache);
|
||||
} else {
|
||||
// i guess technically we could try a brute-force search for the page, but meh.
|
||||
log::error!("System basis did not contain a root page -- unrecoverable error.");
|
||||
return false;
|
||||
return None;
|
||||
}
|
||||
}
|
||||
}
|
||||
false
|
||||
None
|
||||
}
|
||||
|
||||
/// this function is dangerous in that calling it will completely erase all of the previous data
|
||||
|
|
@ -1063,7 +1068,8 @@ impl PddbOs {
|
|||
|
||||
// step 5. fscb handling
|
||||
// pick a set of random pages from the free pool and assign it to the fscb
|
||||
let free_pool = self.fast_space_generate();
|
||||
// pass the generator an empty cache - this causes it to treat the entire disk as free space
|
||||
let free_pool = self.fast_space_generate(BinaryHeap::<Reverse<u32>>::new());
|
||||
let mut fast_space = FastSpace {
|
||||
free_pool: [PhysPage(0); FASTSPACE_FREE_POOL_LEN],
|
||||
};
|
||||
|
|
@ -1106,7 +1112,7 @@ impl PddbOs {
|
|||
|
||||
let mut basis_v2p_map = HashMap::<VirtAddr, PhysPage>::new();
|
||||
// allocate one page for the basis root
|
||||
if let Some(alloc) = self.fast_space_alloc() {
|
||||
if let Some(alloc) = self.try_fast_space_alloc() {
|
||||
let mut rpte = alloc.clone();
|
||||
rpte.set_clean(true); // it's not clean _right now_ but it will be by the time this routine is done...
|
||||
rpte.set_valid(true);
|
||||
|
|
@ -1114,9 +1120,9 @@ impl PddbOs {
|
|||
log::info!("adding basis va {:x?} with pte {:?}", va, rpte);
|
||||
basis_v2p_map.insert(va, rpte);
|
||||
}
|
||||
self.v2p_map.insert(String::from(PDDB_DEFAULT_SYSTEM_BASIS), basis_v2p_map);
|
||||
|
||||
// step 8. write the System basis to Flash, at the physical locations noted above
|
||||
// step 8. write the System basis to Flash, at the physical locations noted above. The routine is coded to
|
||||
// handle many pages, but currently only one is allocated during formatting.
|
||||
if let Some(syskey) = self.system_basis_key {
|
||||
let key = Key::from_slice(&syskey);
|
||||
let cipher = Aes256GcmSiv::new(key);
|
||||
|
|
@ -1127,25 +1133,20 @@ impl PddbOs {
|
|||
0,
|
||||
Rc::clone(&self.entropy),
|
||||
);
|
||||
if let Some(basis_v2p_map) = self.v2p_map.get(&String::from(PDDB_DEFAULT_SYSTEM_BASIS)) {
|
||||
for (&k, &v) in basis_v2p_map.iter() {
|
||||
log::info!("basis_v2p_map retrieved va: {:x?} pp: {:x?}", k, v);
|
||||
}
|
||||
for (vpage_no, ppage_data) in basis_encryptor.into_iter().enumerate() {
|
||||
let vaddr = VirtAddr::new( ((vpage_no + 1) * VPAGE_SIZE) as u64 ).unwrap();
|
||||
match basis_v2p_map.get(&vaddr) {
|
||||
Some(pp) => {
|
||||
self.patch_data(&ppage_data, pp.page_number() * PAGE_SIZE as u32);
|
||||
}
|
||||
None => {
|
||||
log::error!("Previously allocated page was not found in our map!");
|
||||
panic!("Inconsistent internal state");
|
||||
}
|
||||
for (&k, &v) in basis_v2p_map.iter() {
|
||||
log::info!("basis_v2p_map retrieved va: {:x?} pp: {:x?}", k, v);
|
||||
}
|
||||
for (vpage_no, ppage_data) in basis_encryptor.into_iter().enumerate() {
|
||||
let vaddr = VirtAddr::new( ((vpage_no + 1) * VPAGE_SIZE) as u64 ).unwrap();
|
||||
match basis_v2p_map.get(&vaddr) {
|
||||
Some(pp) => {
|
||||
self.patch_data(&ppage_data, pp.page_number() * PAGE_SIZE as u32);
|
||||
}
|
||||
None => {
|
||||
log::error!("Previously allocated page was not found in our map!");
|
||||
panic!("Inconsistent internal state");
|
||||
}
|
||||
}
|
||||
} else {
|
||||
log::error!("Couldn't find the system basis!");
|
||||
panic!("Inconsistent internal state");
|
||||
}
|
||||
} else {
|
||||
log::error!("System key was not found, but it should be present!");
|
||||
|
|
@ -1156,345 +1157,20 @@ impl PddbOs {
|
|||
if let Some(system_key) = self.system_basis_key {
|
||||
log::info!("encryption key: {:x?}", system_key);
|
||||
let cipher = Aes256::new(GenericArray::from_slice(&system_key));
|
||||
if let Some(basis_v2p_map) = self.v2p_map.get(&String::from(PDDB_DEFAULT_SYSTEM_BASIS)) {
|
||||
for (&virt, &phys) in basis_v2p_map.into_iter() {
|
||||
let mut pte = Pte::new(virt, PtFlags::CLEAN, Rc::clone(&self.entropy));
|
||||
let mut block = Block::from_mut_slice(pte.deref_mut());
|
||||
//log::info!("pte pt: {:x?}", block);
|
||||
cipher.encrypt_block(&mut block);
|
||||
//log::info!("pte ct: {:x?}", block);
|
||||
self.patch_pagetable(&block, phys.page_number() * aes::BLOCK_SIZE as u32);
|
||||
//log::info!("pte ct loc: {:x?}", phys.page_number() * aes::BLOCK_SIZE as u32);
|
||||
}
|
||||
for (&virt, &phys) in basis_v2p_map.iter() {
|
||||
let mut pte = Pte::new(virt, PtFlags::CLEAN, Rc::clone(&self.entropy));
|
||||
let mut block = Block::from_mut_slice(pte.deref_mut());
|
||||
//log::info!("pte pt: {:x?}", block);
|
||||
cipher.encrypt_block(&mut block);
|
||||
//log::info!("pte ct: {:x?}", block);
|
||||
self.patch_pagetable(&block, phys.page_number() * aes::BLOCK_SIZE as u32);
|
||||
//log::info!("pte ct loc: {:x?}", phys.page_number() * aes::BLOCK_SIZE as u32);
|
||||
}
|
||||
}
|
||||
|
||||
Ok(())
|
||||
}
|
||||
|
||||
/// Adds a dictionary with `name` to:
|
||||
/// - if `basis_name` is None, the most recently opened basis
|
||||
/// - if `basis_name` is Some, searches for the given basis and adds the dictionary to that.
|
||||
/// If the dictionary already exists, it returns an informative error.
|
||||
pub(crate) fn dict_add(&mut self, name: &str, basis_name: Option<&str>) -> Result<()> {
|
||||
if self.basis_cache.len() == 0 {
|
||||
return Err(Error::new(ErrorKind::NotConnected, "PDDB is not mounted"));
|
||||
}
|
||||
let maybe_basis = if let Some(n) = basis_name {
|
||||
self.basis_cache.iter_mut().filter(|bc| bc.name == n).next()
|
||||
} else {
|
||||
self.basis_cache.last_mut()
|
||||
};
|
||||
if let Some(basis) = maybe_basis {
|
||||
basis.age = basis.age.saturating_add(1);
|
||||
if basis.dicts.get(&String::from(name)).is_some() {
|
||||
// quick exit if we see the dictionary is hot in the cache
|
||||
return Err(Error::new(ErrorKind::AlreadyExists, "Dictionary already exists"));
|
||||
} else {
|
||||
// if the dictionary doesn't exist in our cache it doesn't necessarily mean it
|
||||
// doesn't exist. Do a comprehensive search if our cache isn't complete.
|
||||
if basis.root.num_dictionaries as usize != basis.dicts.len() {
|
||||
if self.dict_deep_search(&mut basis, name).is_some() {
|
||||
return Err(Error::new(ErrorKind::AlreadyExists, "Dictionary already exists"));
|
||||
}
|
||||
}
|
||||
}
|
||||
basis.clean = false;
|
||||
// allocate a vpage offset for the dictionary
|
||||
let dict_index = self.dict_get_free_offset(&mut basis);
|
||||
let dict_offset = VirtAddr::new(dict_index as u64 * DICT_VSIZE).unwrap();
|
||||
let map = self.v2p_map.get_mut(&basis.name).expect("No v2p map despite extant BasisCache record. Shouldn't be possible...");
|
||||
let pp = if let Some(pp) = map.get(&dict_offset) {
|
||||
pp
|
||||
} else {
|
||||
if let Some(pp) = self.fast_space_alloc() {
|
||||
map.insert(dict_offset, pp.clone());
|
||||
&pp
|
||||
} else {
|
||||
return Err(Error::new(ErrorKind::OutOfMemory, "No free space to allocate dict"))
|
||||
}
|
||||
};
|
||||
// create the cache entry
|
||||
let mut dict_name = [0u8; DICT_NAME_LEN];
|
||||
for (src, dst) in name.bytes().into_iter().zip(dict_name.iter_mut()) {
|
||||
*dst = src;
|
||||
}
|
||||
let dict_cache = DictCache {
|
||||
index: dict_index,
|
||||
keys: HashMap::<String, KeyCache>::new(),
|
||||
clean: false,
|
||||
age: 0,
|
||||
flags: 0,
|
||||
key_count: 0,
|
||||
};
|
||||
basis.dicts.insert(String::from(name), dict_cache);
|
||||
// encrypt and write the dict entry to disk
|
||||
self.dict_sync(basis, name);
|
||||
Ok(())
|
||||
} else {
|
||||
Err(Error::new(ErrorKind::NotFound, "Requested basis not found"))
|
||||
}
|
||||
}
|
||||
|
||||
/// If `paranoid` is true, it recurses through each key and replaces its data with random junk.
|
||||
/// Otherwise, it does a "shallow" delete and just removes the directory entry, which is much
|
||||
/// more performant. Note that the intended "fast" way to secure-erase data is to store sensitive
|
||||
/// data in its own Basis, and then remove the Basis itself. This is much faster than picking
|
||||
/// through compounded data and re-writing partias sectors, and because of this, initially,
|
||||
/// the `paranoid` erase is `unimplemented`.
|
||||
pub(crate) fn dict_delete(&self, name: &str, basis_name: Option<&str>, paranoid: bool) -> Result<()> {
|
||||
if self.basis_cache.len() == 0 {
|
||||
return Err(Error::new(ErrorKind::NotConnected, "PDDB is not mounted"));
|
||||
}
|
||||
let maybe_basis = if let Some(n) = basis_name {
|
||||
self.basis_cache.iter_mut().filter(|&bc| bc.name == n).next()
|
||||
} else {
|
||||
self.basis_cache.last_mut()
|
||||
};
|
||||
if let Some(basis) = maybe_basis {
|
||||
if let Some((index, _dict)) = self.dict_deep_search(&mut basis, name) {
|
||||
let map = self.v2p_map.get_mut(&basis.name).expect("No v2p map despite extant BasisCache record. Shouldn't be possible...");
|
||||
if !paranoid {
|
||||
// erase the header by writing over with random data. This makes the dictionary unsearchable, but if you
|
||||
// have the key, you can of course do a hard-scan and try partially re-assemble the dictionary.
|
||||
if let Some(pp) = map.get(&VirtAddr::new(index as u64 * DICT_VSIZE as u64).unwrap()) {
|
||||
let mut random = [0u8; PAGE_SIZE];
|
||||
self.entropy.borrow_mut().get_slice(&mut random);
|
||||
self.patch_data(&random, pp.page_number() * PAGE_SIZE as u32);
|
||||
} else {
|
||||
log::warn!("Inconsistent internal state: requested dictionary didn't have a mapping in the page table.");
|
||||
}
|
||||
} else {
|
||||
unimplemented!("For now store sensitive data in its own Basis, and then delete the Basis.");
|
||||
// this is a bit of an arduous code path, it involves recursing through all the keys and nuking
|
||||
// them. Let's write this after we've actually _got keys_ (we're just figuring out how to add a dictionary
|
||||
// in the first place right now!).
|
||||
}
|
||||
|
||||
// de-allocate all of the dictionary entries
|
||||
Ok(())
|
||||
} else {
|
||||
Err(Error::new(ErrorKind::NotFound, "Dictionary not found"))
|
||||
}
|
||||
} else {
|
||||
Err(Error::new(ErrorKind::NotFound, "Requested basis not found"))
|
||||
}
|
||||
}
|
||||
|
||||
/// this will sync the named Dictionary header + dirty *key descriptors*. It does not
|
||||
/// sync the key data itself. Note this does not mark the surrounding basis structure as clean
|
||||
/// when it exits, even if there are no more dirty entries within.
|
||||
pub(crate) fn dict_sync(&self, basis: &mut BasisCache, name: &str) {
|
||||
let map = self.v2p_map.get(&basis.name).expect("No v2p map despite extant BasisCache record. Shouldn't be possible...");
|
||||
if let Some(dict) = basis.dicts.get_mut(&String::from(name)) {
|
||||
let dict_offset = VirtAddr::new(dict.index as u64 * DICT_VSIZE).unwrap();
|
||||
if !dict.clean {
|
||||
let mut dict_name = [0u8; DICT_NAME_LEN];
|
||||
for (src, dst) in name.bytes().into_iter().zip(dict_name.iter_mut()) {
|
||||
*dst = src;
|
||||
}
|
||||
let dict_disk = Dictionary {
|
||||
flags: dict.flags,
|
||||
age: dict.age,
|
||||
num_keys: dict.key_count,
|
||||
name: dict_name,
|
||||
};
|
||||
// observation: all keys to be flushed to disk will be in the KeyCache. Some may be clean,
|
||||
// but definitely all the dirty ones are in there (if they aren't, where else would they be??)
|
||||
|
||||
// this is the virtual page within the dictionary region that we're currently serializing
|
||||
let mut vpage_num = 0;
|
||||
loop {
|
||||
// 1. resolve the virtual address to a target page
|
||||
let mut cur_vpage = VirtAddr::new(dict_offset.get() + (vpage_num as u64 * VPAGE_SIZE as u64)).unwrap();
|
||||
let pp = if let Some(pp) = map.get(&cur_vpage) {
|
||||
pp
|
||||
} else {
|
||||
if let Some(pp) = self.fast_space_alloc() {
|
||||
map.insert(dict_offset, pp.clone());
|
||||
&pp
|
||||
} else {
|
||||
panic!("No free space to allocate dict");
|
||||
}
|
||||
};
|
||||
|
||||
// 2(a). fill in the target vpage with data: header special case
|
||||
let mut dk_vpage = DictKeyVpage::default();
|
||||
// the dict always occupies the first entry of the first vpage in the dictionary region
|
||||
if vpage_num == 0 {
|
||||
let mut dk_entry = DictKeyEntry::default();
|
||||
for (&src, dst) in dict_disk.deref().iter().zip(dk_entry.data.iter_mut()) {
|
||||
*dst = src;
|
||||
}
|
||||
dk_vpage.elements[0] = Some(dk_entry);
|
||||
}
|
||||
|
||||
// 2(b). fill in the target vpage with data: general key case
|
||||
// Scan the DictCache.keys record for dirty keys within the current target vpage's range
|
||||
// this is not a terribly efficient operation right now, because the DictCache is designed to
|
||||
// be searched by name, but in this case, we want to check for an index range. There's a lot
|
||||
// of things we could do to optimize this, depending on the memory/time trade-off we want to
|
||||
// make, but for now, let's do it with a dumb O(N) scan through the KeyCache, running under
|
||||
// the assumption that the KeyCache doesn't ever get to a very large N.
|
||||
let next_vpage = VirtAddr::new(cur_vpage.get() + VPAGE_SIZE as u64).unwrap();
|
||||
for (key_name, key) in dict.keys.iter_mut() {
|
||||
if !key.clean {
|
||||
if key.descriptor_vaddr(dict_offset) >= cur_vpage &&
|
||||
key.descriptor_vaddr(dict_offset) < next_vpage {
|
||||
// key is within the current page, add it to the target list
|
||||
let mut dk_entry = DictKeyEntry::default();
|
||||
let mut kn = [0u8; KEY_NAME_LEN];
|
||||
for (&src, dst) in key_name.as_bytes().iter().zip(kn.iter_mut()) {
|
||||
*dst = src;
|
||||
}
|
||||
let key_desc = KeyDescriptor {
|
||||
start: key.start,
|
||||
len: key.len,
|
||||
reserved: key.reserved,
|
||||
flags: key.flags,
|
||||
age: key.age,
|
||||
name: kn,
|
||||
};
|
||||
for (&src, dst) in key_desc.deref().iter().zip(dk_entry.data.iter_mut()) {
|
||||
*dst = src;
|
||||
}
|
||||
dk_vpage.elements[key.descriptor_modulus()] = Some(dk_entry);
|
||||
}
|
||||
key.clean = true;
|
||||
}
|
||||
}
|
||||
|
||||
// 3. merge the vpage modifications into the disk
|
||||
let page = if let Some(data) = self.data_decrypt_page(&basis.cipher, &basis.aad, &pp) {
|
||||
data
|
||||
} else {
|
||||
// the existing data was invalid (this happens e.g. on the first time a dict is created). Just overwrite the whole page.
|
||||
vec![0u8; VPAGE_SIZE + size_of::<JournalType>()]
|
||||
};
|
||||
for (index, stride) in page[size_of::<JournalType>()..].chunks_mut(DK_STRIDE).enumerate() {
|
||||
if let Some(elem) = dk_vpage.elements[index] {
|
||||
for (&src, dst) in elem.data.iter().zip(stride.iter_mut()) {
|
||||
*dst = src;
|
||||
}
|
||||
}
|
||||
}
|
||||
// bump the journal rev. This means that revs start at "1", because the empty data array as passed has a 0 in it by default.
|
||||
let newrev = JournalType::from_le_bytes(page[..size_of::<JournalType>()].try_into().unwrap()).saturating_add(1);
|
||||
for (&src, dst) in newrev.to_le_bytes().iter().zip(page[..size_of::<JournalType>()].iter_mut()) {
|
||||
*dst = src;
|
||||
}
|
||||
// generate nonce and write out
|
||||
let nonce_array = self.entropy.borrow_mut().get_nonce();
|
||||
let nonce = Nonce::from_slice(&nonce_array);
|
||||
let payload = Payload {
|
||||
msg: &page,
|
||||
aad: &basis.aad,
|
||||
};
|
||||
let ciphertext = basis.cipher.encrypt(nonce, payload).expect("failed to encrypt DictKeys");
|
||||
self.patch_data(&ciphertext, pp.page_number() * PAGE_SIZE as u32);
|
||||
|
||||
// 4. Check for dirty keys, if there are still some, update vpage_num to target them; otherwise
|
||||
// exit the loop
|
||||
let mut found_next = false;
|
||||
for key in dict.keys.values() {
|
||||
if !key.clean {
|
||||
found_next = true;
|
||||
// note: we don't care *which* vpage we do next -- so we just break after finding the first one
|
||||
vpage_num = key.descriptor_vpage_num();
|
||||
break;
|
||||
}
|
||||
}
|
||||
if !found_next {
|
||||
break;
|
||||
}
|
||||
}
|
||||
dict.clean = true;
|
||||
}
|
||||
} else {
|
||||
log::warn!("dict_sync() calleld with an invalid dictionary name; ignoring");
|
||||
}
|
||||
}
|
||||
|
||||
pub(crate) fn dict_get_free_offset(&self, basis: &mut BasisCache) -> u32 {
|
||||
let map = self.v2p_map.get(&basis.name).expect("No v2p map despite extant BasisCache record. Shouldn't be possible...");
|
||||
if let Some(offset) = basis.free_dict_offset.take() {
|
||||
return offset;
|
||||
} else {
|
||||
let mut try_entry = 1;
|
||||
while try_entry <= DICT_MAXCOUNT {
|
||||
let dict_vaddr = VirtAddr::new(try_entry as u64 * DICT_VSIZE).unwrap();
|
||||
if let Some(pp) = map.get(&dict_vaddr) {
|
||||
if self.dict_decrypt(&basis, &pp).is_none() {
|
||||
// mapping exists, but the data is invalid. It's a free entry.
|
||||
return try_entry as u32
|
||||
}
|
||||
} else {
|
||||
// mapping doesn't exist yet, that's a free entry
|
||||
return try_entry as u32
|
||||
}
|
||||
try_entry += 1;
|
||||
}
|
||||
}
|
||||
// maybe we should handle this better? but, I think this should be super-rare, as we allow 16384 dictionaries per Basis,
|
||||
// so if we got here I'm guessing it's more likely due to a coding error than an actually full Basis.
|
||||
panic!("Basis full, can't allocate dictionary");
|
||||
}
|
||||
|
||||
/// Returns a tuple of "dictionary offset" , "dictionary"; the "dictionary offset" needs to be multiplied by DICT_VSIZE to arrive
|
||||
/// at a fully expanded virtual address.
|
||||
pub(crate) fn dict_deep_search(&mut self, basis: &mut BasisCache, name: &str) -> Option<(u32, Dictionary)> {
|
||||
let map = self.v2p_map.get(&basis.name).expect("No v2p map despite extant BasisCache record. Shouldn't be possible...");
|
||||
|
||||
let mut try_entry = 1;
|
||||
let mut dict_count = 0;
|
||||
while try_entry <= DICT_MAXCOUNT && dict_count < basis.root.num_dictionaries {
|
||||
let dict_vaddr = VirtAddr::new(try_entry as u64 * DICT_VSIZE).unwrap();
|
||||
if let Some(pp) = map.get(&dict_vaddr) {
|
||||
if let Some(dict) = self.dict_decrypt(&basis, &pp) {
|
||||
if cstr_to_string(&dict.name) == name {
|
||||
return Some((try_entry as u32, dict))
|
||||
}
|
||||
dict_count += 1;
|
||||
} else {
|
||||
// this is an empty dictionary entry. we could stick a dictionary in here later on, take note if we haven't already computed that
|
||||
if basis.free_dict_offset.is_none() {
|
||||
basis.free_dict_offset = Some(try_entry as u32);
|
||||
}
|
||||
}
|
||||
} else {
|
||||
// this is an empty dictionary entry. we could stick a dictionary in here later on, take note if we haven't already computed that
|
||||
if basis.free_dict_offset.is_none() {
|
||||
basis.free_dict_offset = Some(try_entry as u32);
|
||||
}
|
||||
}
|
||||
try_entry += 1;
|
||||
}
|
||||
None
|
||||
}
|
||||
|
||||
/// The `pp` must be the resolved physical page storing the top of the given
|
||||
/// dictionary index for this to work.
|
||||
pub(crate) fn dict_decrypt(&self, basis: &BasisCache, pp: &PhysPage) -> Option<Dictionary> {
|
||||
if let Some(data) = self.data_decrypt_page(&basis.cipher, &basis.aad, &pp) {
|
||||
let mut dict = Dictionary {
|
||||
flags: 0, age: 0, num_keys: 0, name: [0; DICT_NAME_LEN]
|
||||
};
|
||||
for (&src, dst) in data[size_of::<JournalType>()..].iter().zip(dict.deref_mut().iter_mut()) {
|
||||
*dst = src;
|
||||
}
|
||||
Some(dict)
|
||||
} else {
|
||||
None
|
||||
}
|
||||
}
|
||||
|
||||
/// Runs through the dictionary listing in a basis and compacts them. Call when the
|
||||
/// the dictionary space becomes sufficiently fragmented that accesses are becoming
|
||||
/// inefficient.
|
||||
pub(crate) fn dict_compact(&self, basis_name: Option<&str>) -> Result<()> {
|
||||
unimplemented!();
|
||||
}
|
||||
|
||||
/// syncs up the named basis
|
||||
pub(crate) fn basis_sync(&self, name: &str) {
|
||||
////// TODO HERE
|
||||
|
|
@ -1504,11 +1180,54 @@ impl PddbOs {
|
|||
/// Basis have been unlocked, the function returns `true`. The other option is the user
|
||||
/// can decline to unlock all the Basis right now, cancelling out of the process, which will
|
||||
/// cause the requesting free space sweep to fail.
|
||||
pub(crate) fn basis_request_unlock_all(&self) -> bool {
|
||||
// this function is a morass of UX code that has to be written. Let's save it until later,
|
||||
// once we've got some core functionality in the PDDB; or for testing, we could just "return true"
|
||||
// and YOLO it.
|
||||
unimplemented!();
|
||||
pub(crate) fn pddb_generate_used_map(&self, cache: &Vec::<BasisCacheEntry>) -> Option<BinaryHeap<Reverse<u32>>> {
|
||||
if let Some(extra_keys) = self.pddb_get_additional_keys(&cache) {
|
||||
let mut page_heap = BinaryHeap::new();
|
||||
// 1. check the extra keys, if any
|
||||
for (key, name) in extra_keys {
|
||||
// scan the extra closed basis
|
||||
if let Some(map) = self.pt_scan_key(&key, &name) {
|
||||
for pp in map.values() {
|
||||
page_heap.push(Reverse(pp.page_number()))
|
||||
}
|
||||
}
|
||||
}
|
||||
// 2. scan through all of the physical pages in our caches, and add them to a binary heap.
|
||||
// WARNING: this could get really big for a very large filesystem. It's capped at ~100k for
|
||||
// Precursor's ~100MiB storage increment.
|
||||
for entry in cache {
|
||||
for pp in entry.v2p_map.values() {
|
||||
page_heap.push(Reverse(pp.page_number()));
|
||||
}
|
||||
}
|
||||
Some(page_heap)
|
||||
} else {
|
||||
None
|
||||
}
|
||||
}
|
||||
|
||||
/// 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
|
||||
/// valid (it'll scan up and stop as soon as one Pte checks out). Note that it then only returns
|
||||
/// 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.
|
||||
pub(crate) fn pddb_get_additional_keys(&self, cache: &Vec::<BasisCacheEntry>) -> Option<Vec<([u8; AES_KEYSIZE], String)>> {
|
||||
log::info!("{} basis are open, with the following names:", cache.len());
|
||||
for entry in cache {
|
||||
log::info!(" - {}", entry.name);
|
||||
}
|
||||
|
||||
// 0. allow user to cancel out of the operation -- this will abort everything and cause the current
|
||||
// alloc operation to fail
|
||||
|
||||
// 1. prompt user to enter any name/password combos for other basis we want to keep
|
||||
// 2. validate the name/password combo
|
||||
// 3. add to the Aes256 return vec
|
||||
// 4. repeat summary print-out
|
||||
|
||||
// for now, do nothing -- just indicate success with a returned empty set
|
||||
Some(Vec::<([u8; AES_KEYSIZE], String)>::new())
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -374,16 +374,20 @@ fn xmain() -> ! {
|
|||
#[cfg(not(any(target_os = "none", target_os = "xous")))]
|
||||
pddb_os.dbg_dump();
|
||||
|
||||
// it's a vector because order is important: by default access to keys/dicts go into the latest entry first, and then recurse to the earliest
|
||||
let mut basis_cache = BasisCache::new();
|
||||
|
||||
log::info!("Attempting to mount the PDDB");
|
||||
if pddb_os.pddb_mount() {
|
||||
if let Some(sys_basis) = pddb_os.pddb_mount() {
|
||||
log::info!("PDDB mount operation finished successfully");
|
||||
basis_cache.add_basis(sys_basis);
|
||||
} else {
|
||||
log::info!("PDDB did not mount; did you remember to format the PDDB region?");
|
||||
}
|
||||
log::info!("size of vpage: {}", VPAGE_SIZE);
|
||||
|
||||
// add a "wifi access points" dictionary to the default basis
|
||||
pddb_os.dict_add("wifi access points", None);
|
||||
// add a "system settings" dictionary to the default basis
|
||||
basis_cache.dict_add(&mut pddb_os, "system settings", None).expect("couldn't add system settings dictionary");
|
||||
|
||||
// register a suspend/resume listener
|
||||
let sr_cid = xous::connect(pddb_sid).expect("couldn't create suspend callback connection");
|
||||
|
|
|
|||
Loading…
Reference in a new issue