diff --git a/services/pddb/Cargo.toml b/services/pddb/Cargo.toml index 51015f156..bb709890d 100644 --- a/services/pddb/Cargo.toml +++ b/services/pddb/Cargo.toml @@ -30,4 +30,7 @@ aes-gcm-siv = "0.10.3" utralib = { path = "../../utralib"} [features] +# when selected, physical disk addresses are set to 64 bits, otherwise, they are 32 bits. +# 32 bit addressing is recommended for Precursor, as its disk is only 128MiB and it has limited RAM for bookkeeping. +u64_pa = [] default = [] diff --git a/services/pddb/src/api.rs b/services/pddb/src/api.rs index 9ba11d531..04069e4e7 100644 --- a/services/pddb/src/api.rs +++ b/services/pddb/src/api.rs @@ -6,6 +6,20 @@ pub(crate) const PDDB_MAX_DICT_NAME_LEN: usize = 64; pub(crate) const PDDB_MAX_KEY_NAME_LEN: usize = 128; pub(crate) const PDDB_MAGIC: [u8; 4] = [0x50, 0x44, 0x44, 0x42]; pub(crate) const PDDB_VERSION: u16 = 0; +/// PDDB_A_LEN may be shorter than xous::PDDB_LEN, to speed up testing +pub(crate) const PDDB_A_LEN: usize = 16 * 1024 * 1024; + +/// A number between (0, 1] that defines how many of the "truly free" pages we +/// should put into the FSCB. A value of 0.0 is not allowed as that leaves no free pages. +/// A value of 1.0 would allow an attacker to deduce the real size of data because all +/// the freee space would be tracked in the FSCB. Thus the trade-off is deniability versus +/// performance: a fill coefficient of 1.0 means we'd never have to do a brute force scan +/// for free pages, but you would have no deniability; a fill coefficient of near-0 means +/// we could plausibly deny a lot of pages as being free space, but every time you wanted +/// to grow a record, you'd have to unlock all your Basis and do a brute force scan, otherwise +/// you risk overwriting hidden data by mistaking it as free space. The initial setting is +/// 0.5: with this setting, we won't be more than a factor of 2 off from the ideal setting! +pub(crate) const FSCB_FILL_COEFFICIENT: f32 = 0.5; pub const PDDB_DEFAULT_SYSTEM_BASIS: &'static str = ".System"; pub(crate) const PDDB_FAST_SPACE_SYSTEM_BASIS: &'static str = ".FastSpace"; @@ -72,6 +86,9 @@ mod tests { fn test_pddbuf_size() { assert!(core::mem::size_of::() == 4096, "PddBuf record has the wrong size"); } + fn test_pddb_len() { + assert!(PDDB_A_LEN <= xous::PDDB_LEN, "PDDB_A_LEN is larger than the maximum extents available in the hardware"); + } } impl PddbBuf { pub(crate) fn from_slice_mut(slice: &mut [u8]) -> &mut PddbBuf { diff --git a/services/pddb/src/backend/basis.rs b/services/pddb/src/backend/basis.rs index 3cf417e31..187b774b1 100644 --- a/services/pddb/src/backend/basis.rs +++ b/services/pddb/src/backend/basis.rs @@ -39,7 +39,7 @@ pub(crate) struct BasisRoot { */ /// "open end" of the pre-allocated space for the Basis. All Basis data must exist in an extent that is /// less than this value. This can be grown and shrunk with allocation and compaction processes. - pub(crate) prealloc_open_end: PageAlignedU64, + pub(crate) prealloc_open_end: PageAlignedVa, pub(crate) num_dictionaries: u32, // dict_slice: [DictPointer; num_dictionaries], // DictPointers + num_dictionaries above can be turned into a dict_slice ////// the following records are appended by the Serialization routine diff --git a/services/pddb/src/backend/fastspace.rs b/services/pddb/src/backend/fastspace.rs index 00d253637..4f5276dc8 100644 --- a/services/pddb/src/backend/fastspace.rs +++ b/services/pddb/src/backend/fastspace.rs @@ -3,33 +3,72 @@ use core::num::NonZeroU32; use super::PAGE_SIZE; use crate::*; +/// Each free_pool entry takes about 4 bytes, so give-or-take we have about 1000 free_pool +/// entries per page of storage for the free_pool, or 4k * 1000 ~ 4MiB per page, when PhysAddr is a u32 +pub(crate) const FASTSPACE_PAGES: usize = 2; + #[repr(u8)] pub(crate) enum SpaceState { /// pages that are completely un-spoken for - Free, + Free = 0, /// pages that are in the process of being used, but the journal has yet to be committed - MaybeUsed, - /// pages that are now fully used - Used, + /// in other words, these are pages that might be in the RAM cache. + MaybeUsed = 1, + /// pages that are confirm plus chop fully used + Used = 2, /// pages that are no longer used and need to be erased - Dirty, + Dirty = 3, } /// FastSpace tracks a limited set of physical pages -/// This is designed to fill exactly one erase sector of 4096 bytes +/// An optimal implementation of this would fill whole pages with the free_pool array. +/// This record is meant to be updated rarely, and atomically, in a make-before-break fashion: +/// Make-before-break: (maybe it's COW? idk, I'm a hardware guy, so I'm switched on to make-before-break) +/// Write a new version of this with a higher journal number, verify its +/// integrity, and then erase the previous version. +/// Atomically: +/// The entire contents of this structure is written in the update operation; there are no partial updates +/// possible to the structure +/// Rarely: +/// Instead of partial updates to this structure, individual "SpaceUpdate" records are encrypted to the +/// system basis and stored in a non-cryptographically free region. These are decrypted and merged +/// into an in-RAM cache that facilitates the "rare" update of this large-ish structure. This creates +/// a side-channel, where an attacker would be able to observe the rate at which pages are modified... +/// and hopefully nothing else? +/// The "rare" property is important especially as the disk size scales up; if we wanted to keep +/// 100MiB of "fast space" on hand, this structure would span 25 pages. #[repr(C, packed)] pub (crate) struct FastSpace { p_nonce: [u8; 12], + /// u32 in lsb byte order journal_rev: [u8; 4], - free_pool: [PhysPage; (PAGE_SIZE - 16 - 4 -12) / 4], + /// Not sure if there is a "better" way to compute things, but we want the number of entries in the + /// free_pool array to "round out" the FastSpace record to be equal to exactly one page + free_pool: [PhysPage; ((PAGE_SIZE * FASTSPACE_PAGES) - (12 + 4 + 16)) / core::mem::size_of::()], p_tag: [u8; 16], } -/// a 128-bit record that stores an encrypted update to the FastSpace pool +/// a 128-bit record that stores an encrypted update to the FastSpace pool, facilitating the "rarely" trait of the structure. #[repr(C, packed)] +#[cfg(not(feature = "u64_pa"))] pub (crate) struct SpaceUpdate { nonce: u64, - page_number: u32, - reserved: [u8; 3], - state: SpaceState, + page_number: PhysAddr, + reserved: [u8; 4], +} +#[cfg(feature = "u64_pa")] +pub (crate) struct SpaceUpdate { + nonce: u64, + page_number: PhysAddr, +} +impl SpaceUpdate { + // add accessors, decryptors, and constructors so we don't shoot ourselves in the foot so much. +} + +mod tests { + use super::*; + #[test] + fn test_fast_space_size() { + assert!(core::mem::size_of::() & !(PAGE_SIZE - 1) == 0, "FastSpace is not exactly a multiple of one page in size"); + } } diff --git a/services/pddb/src/backend/hw.rs b/services/pddb/src/backend/hw.rs index 02531e5a9..182961ec0 100644 --- a/services/pddb/src/backend/hw.rs +++ b/services/pddb/src/backend/hw.rs @@ -10,12 +10,14 @@ use core::ops::Deref; use core::convert::TryFrom; use std::collections::HashMap; +use std::collections::BinaryHeap; +use std::cmp::Reverse; use std::io::{Result, Error, ErrorKind}; /// Implementation-specific PDDB structures: for Precursor/Xous OS pair pub(crate) const MBBB_PAGES: usize = 10; -pub(crate) const FSCB_PAGES: usize = 10; +pub(crate) const FSCB_PAGES: usize = 16; pub(crate) const INITIAL_BASIS_ALLOC: usize = 16; pub const PAGE_SIZE: usize = spinor::SPINOR_ERASE_SIZE as usize; @@ -45,17 +47,20 @@ pub(crate) struct PddbOs { pddb_mr: xous::MemoryRange, trng: trng::Trng, /// page table base -- location in FLASH, offset from physical bottom of pddb_mr - pt_phys_base: PageAlignedU32, + pt_phys_base: PageAlignedPa, /// local key store -- one page, to store exactly one key, used for the system basis. /// the rest of the keys are generated on the fly entirely from the user password + a salt also stored in this page - key_phys_base: PageAlignedU32, + key_phys_base: PageAlignedPa, /// make before break buffer base -- location in FLASH, offset from physical bottom of pddb_mr - mbbb_phys_base: PageAlignedU32, + mbbb_phys_base: PageAlignedPa, /// free space circular buffer base -- location in FLASH, offset from physical bottom of pddb_mr - fscb_phys_base: PageAlignedU32, - data_phys_base: PageAlignedU32, + fscb_phys_base: PageAlignedPa, + data_phys_base: PageAlignedPa, system_basis_key: Option<[u8; 32]>, v2p_map: HashMap>, + /// The PDDB eats a lot of entropy. Keep a local pool of entropy, so we're not wasting a lot of + /// overhead passing messages to the TRNG. + e_cache: Vec::, } impl PddbOs { @@ -64,37 +69,189 @@ impl PddbOs { let pddb = xous::syscall::map_memory( xous::MemoryAddress::new(xous::PDDB_LOC as usize), None, - xous::PDDB_LEN as usize, + PDDB_A_LEN as usize, xous::MemoryFlags::R, ) .expect("Couldn't map the PDDB memory range"); // the mbbb is located one page off from the Page Table - let key_phys_base = PageAlignedU32::from(core::mem::size_of::()); - let mbbb_phys_base = key_phys_base + PageAlignedU32::from(PAGE_SIZE); - let fscb_phys_base = PageAlignedU32::from(mbbb_phys_base.as_u32() + MBBB_PAGES as u32 * PAGE_SIZE as u32); + let key_phys_base = PageAlignedPa::from(core::mem::size_of::()); + let mbbb_phys_base = key_phys_base + PageAlignedPa::from(PAGE_SIZE); + let fscb_phys_base = PageAlignedPa::from(mbbb_phys_base.as_u32() + MBBB_PAGES as u32 * PAGE_SIZE as u32); + + let mut trng = trng::Trng::new(&xns).unwrap(); + let mut cache: [u8; 8192] = [0; 8192]; + trng.fill_bytes(&mut cache); + PddbOs { spinor: spinor::Spinor::new(&xns).unwrap(), rootkeys: root_keys::RootKeys::new(&xns, Some(AesRootkeyType::User0)).expect("FATAL: couldn't access RootKeys!"), pddb_mr: pddb, - trng: trng::Trng::new(&xns).unwrap(), - pt_phys_base: PageAlignedU32::from(0 as u32), + trng, + pt_phys_base: PageAlignedPa::from(0 as u32), key_phys_base, mbbb_phys_base, fscb_phys_base, - data_phys_base: PageAlignedU32::from(fscb_phys_base.as_u32() + FSCB_PAGES as u32 * PAGE_SIZE as u32), + 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::>::new(), + e_cache: cache.to_vec(), } } + /// 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) { + assert!(data.len() + offset as usize <= PDDB_A_LEN - self.data_phys_base.as_usize(), "attempt to store past disk boundary"); + self.spinor.patch( + self.pddb_mr.as_slice(), + xous::PDDB_LOC, + &data, + offset + self.data_phys_base.as_u32(), + ).expect("couldn't write to data region in the PDDB"); + } + fn patch_keys(&self, data: &[u8], offset: u32) { + assert!(data.len() + offset as usize <= PAGE_SIZE, "attempt to burn key data that is outside the key region"); + self.spinor.patch( + self.pddb_mr.as_slice(), + xous::PDDB_LOC, + data, + self.key_phys_base.as_u32() + offset + ).expect("couldn't burn keys"); + } + fn patch_mbbb(&self, data: &[u8], offset: u32) { + assert!(data.len() + offset as usize <= PAGE_SIZE * MBBB_PAGES, "mbbb patch would go out of bounds"); + self.spinor.patch( + self.pddb_mr.as_slice(), + xous::PDDB_LOC, + data, + self.mbbb_phys_base.as_u32() + offset + ).expect("couldn't burn mbbb"); + } + fn patch_fscb(&self, data: &[u8], offset: u32) { + assert!(data.len() + offset as usize <= PAGE_SIZE * FSCB_PAGES, "fscb patch would go out of bounds"); + self.spinor.patch( + self.pddb_mr.as_slice(), + xous::PDDB_LOC, + data, + self.fscb_phys_base.as_u32() + offset + ).expect("couldn't burn fscb"); + } + + fn ensure_entropy(&mut self, amount: usize) { + if self.e_cache.len() < amount { + let mut cache: [u8; 8192] = [0; 8192]; + self.trng.fill_bytes(&mut cache); + self.e_cache.extend_from_slice(&cache); + } + } + fn trng_cache_u8(&mut self) -> u8 { + self.ensure_entropy(1); + self.e_cache.pop().unwrap() + } + fn trng_cache_u32(&mut self) -> u32 { + self.ensure_entropy(4); + let ret = u32::from_le_bytes(self.e_cache[self.e_cache.len() - 4..].try_into().unwrap()); + self.e_cache.truncate(self.e_cache.len() - 4); + ret + } + fn trng_cache_u64(&mut self) -> u64 { + self.ensure_entropy(8); + let ret = u64::from_le_bytes(self.e_cache[self.e_cache.len() - 8..].try_into().unwrap()); + self.e_cache.truncate(self.e_cache.len() - 8); + ret + } + fn trng_cache_slice(&mut self, bucket: &mut [u8]) { + self.ensure_entropy(bucket.len()); + for (src, dst) in self.e_cache.drain( + (self.e_cache.len() - bucket.len()).. + ).zip(bucket.iter_mut()) { + *dst = src; + } + } /// generates a 96-bit nonce using the CPRNG pub fn gen_nonce(&mut self) -> [u8; 12] { let mut nonce: [u8; 12] = [0; 12]; - self.trng.fill_bytes(&mut nonce); + self.trng_cache_slice(&mut nonce); nonce } + + /// 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 + /// 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. + /// + /// The function is coded to prioritize small peak memory footprint over speed, as it + /// 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 collect_fastspace(&self) -> Vec:: { + let mut free_pool = Vec::::new(); + let max_entries = FASTSPACE_PAGES * PAGE_SIZE / core::mem::size_of::(); + 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())); + } + } + let total_free_pages = page_heap.len(); + if total_free_pages == 0 { + log::warn!("Disk is out of space, no free pages available!"); + // return an empty free_pool vector. + return Vec::::new(); + } + // 2. fill the free_pool, avoiding entries in the page_heap. This algorithm + // uses a fixed amount of storage regardless of the size of the disk, but + // it produces a free_pool that has entries biased toward the high + // addresses. + let mut min_used_page = page_heap.pop(); + // consider every page + for page_candidate in (0..PDDB_A_LEN / PAGE_SIZE) { + // if the page is used, skip it. + if let Some(Reverse(mp)) = min_used_page { + if page_candidate == mp as usize { + min_used_page = page_heap.pop(); + continue; + } + } + // page is free. if we've space in the pool, just deposit it there + if free_pool.len() < max_entries { + free_pool.push(page_candidate); + } else { + // page is free, but we have no space in the pool. + // pick a random page from the pool, and replace it with the current page + free_pool[self.trng_cache_u32() as usize % free_pool.len()] = page_candidate; + } + } + // 3. shuffle the contents of free_pool. This is important in the case that the + // amount of free space starts to approach the size of the free pool, as it will + // essentially come out of step 2 as a sorted list. + // this shuffle is stolen out of the rand crate directly -- it's a small function, + // and pulling in the ENTIRE rand crate for this code seemed very unnecessary. + // https://github.com/rust-random/rand/blob/0f4fc6b4c303696bd5f8765a375162ac7142b1df/src/seq/mod.rs#L586-L592 + for i in (1..free_pool.len()).rev() { + // invariant: elements with index > i have been locked in place. + free_pool.swap(i, self.trng_cache_u32() as usize % (i+1)); + } + + // 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; + // 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); + + /// TODO: translate the free_pool into a PhysPage vector with the right bitfields attached to it. + free_pool + } + /// this function is dangerous in that calling it will completely erase all of the previous data /// in the PDDB an replace it with a brand-spanking new, blank PDDB. /// The number of servers that can connect to the Spinor crate is strictly tracked, so we borrow a reference @@ -107,12 +264,13 @@ impl PddbOs { log::info!("Erasing the PDDB region"); let blank_sector: [u8; PAGE_SIZE] = [0xff; PAGE_SIZE]; - for offset in (0..xous::PDDB_LEN).step_by(PAGE_SIZE) { + // there is no convenience routine for erasing the entire disk. Maybe that's a good thing? + for offset in (0..PDDB_A_LEN).step_by(PAGE_SIZE) { self.spinor.patch( self.pddb_mr.as_slice(), xous::PDDB_LOC, &blank_sector, - offset + offset as u32 ).expect("couldn't erase memory"); } @@ -129,7 +287,7 @@ impl PddbOs { name, age: 0, num_dictionaries: 0, - prealloc_open_end: PageAlignedU64::from(INITIAL_BASIS_ALLOC * PAGE_SIZE), + prealloc_open_end: PageAlignedVa::from(INITIAL_BASIS_ALLOC * PAGE_SIZE), }; // extract a slice-u8 that maps onto the basis_root record, allowing us to patch this into a FLASH page let br_slice: &[u8] = basis_root.deref(); @@ -158,12 +316,7 @@ impl PddbOs { } self.trng.fill_bytes(&mut crypto_keys.salt_base); self.trng.fill_bytes(&mut crypto_keys.reserved); - self.spinor.patch( - self.pddb_mr.as_slice(), - xous::PDDB_LOC, - crypto_keys.deref(), - self.key_phys_base.as_u32() - ).expect("couldn't burn keys"); + self.patch_keys(crypto_keys.deref(), 0); // now we have a copy of the AES key necessary to encrypt the default System basis that we created in step 2. // step 4. Create a hashmap for our reverse PTE, and add it to the Pddb's cache @@ -192,25 +345,35 @@ impl PddbOs { if let Some(system_basis_key) = self.system_basis_key { let key = Key::from_slice(&system_basis_key); let cipher = Aes256GcmSiv::new(key); - let nonce = Nonce::from_slice(&basis_root.p_nonce); + let nonce_array = self.gen_nonce(); + let nonce = Nonce::from_slice(&nonce_array); let ciphertext = cipher.encrypt(nonce, &basis_ser[12..]); let ct_to_flash: &[u8] = ciphertext.as_ref().unwrap(); // this now contains the encrypted basis + 16-byte tag at the very end assert!( ( ct_to_flash.len() + basis_root.p_nonce.len()) & (PAGE_SIZE - 1) == 0, "Padding failure during basis serialization!"); // we're now ready to write the encrypted basis to Flash. - self.spinor.patch( - self.pddb_mr.as_slice(), - xous::PDDB_LOC, - &[&basis_root.p_nonce, ct_to_flash].concat(), - self.data_phys_base.as_u32() - ).expect("couldn't write basis structure"); - // now fill in the rest of Flash with random data. Because the rest of the Basis is blank, random data is "just fine". - // LEFT OFF HERE + self.patch_data(&[&nonce_array, ct_to_flash].concat(), 0); + + // now fill in the rest of Flash with random data. This includes filling in the current Basis allocation + // with random data, as that is the "free" state (as well as, at least facially, the "used" state) + let start_offset = PageAlignedPa::from(ct_to_flash.len() + basis_root.p_nonce.len()); + let mut erase_buf: [u8; 4096] = [0; 4096]; + for page_offset in (start_offset.as_u32()..PDDB_A_LEN as u32).step_by(PAGE_SIZE) { + self.trng.fill_bytes(&mut erase_buf); + self.patch_data(&erase_buf, page_offset); + } } else { panic!("invalid state"); // we should never hit this because we created the key earlier in the same routine. } - // step 6. generate & write initial page table entries + // step 6. mbbb handling + // mbbb should just be blank at this point, so there's nothing to do. + + // step 7. fscb handling + // pick a set of random pages from the free pool and assign it to the fscb + let page_state = Vec::::new(); // bools also take up a byte + + // step 8. generate & write initial page table entries // page table organization: // // offset from | diff --git a/services/pddb/src/backend/pagetable.rs b/services/pddb/src/backend/pagetable.rs index d84beae14..11cbcc3b9 100644 --- a/services/pddb/src/backend/pagetable.rs +++ b/services/pddb/src/backend/pagetable.rs @@ -4,7 +4,6 @@ use core::num::NonZeroU32; use core::num::NonZeroU64; use bitflags::bitflags; -use bitfield::bitfield; bitflags! { /// flags used by the page table @@ -50,17 +49,7 @@ pub(crate) struct Pte { checksum: [u8; 4], } -/// Physical page information, coded as a bitfield, because space is a premium! -bitfield! { - #[derive(Copy, Clone, Hash)] - pub struct PhysPage(u32); - impl Debug; - pub page_number, set_page_number: 20, 0; - pub clean, set_clean: 21; - pub valid, set_valid: 22; -} - -pub const PDDB_SIZE_PAGES: usize = xous::PDDB_LEN as usize / PAGE_SIZE; +pub const PDDB_SIZE_PAGES: usize = crate::PDDB_A_LEN as usize / PAGE_SIZE; /// This structure is mapped into the top of FLASH memory, starting at /// xous::PDDB_LOC. This actually slightly over-sizes the page table, /// because the page table does not map the locations for the page table diff --git a/services/pddb/src/backend/types.rs b/services/pddb/src/backend/types.rs index 201cee262..363ef053a 100644 --- a/services/pddb/src/backend/types.rs +++ b/services/pddb/src/backend/types.rs @@ -2,139 +2,122 @@ use core::num::{NonZeroU32, NonZeroU64}; use core::convert::TryFrom; use core::ops::Add; use super::PAGE_SIZE; -/// PAGE_SIZE is required to be a power of two. 0x1000 -> 0x1000 - 1 = 0xFFF, which forms the bitmasks below. -#[derive(Copy, Clone)] -pub(crate) struct PageAlignedU64(u64); -impl PageAlignedU64 { - pub(crate) fn as_u32(&self) -> u32 { - if self.0 <= u32::MAX as u64 { - self.0 as u32 - } else { - panic!("This PageAlignedU64 would not fit into a PageAlignedU32"); - } - } - pub(crate) fn as_u64(&self) -> u64 {self.0} -} -impl From for PageAlignedU64 { - fn from(arg: u64) -> Self { - if arg & (PAGE_SIZE as u64 - 1) == 0 { - PageAlignedU64(arg & !(PAGE_SIZE as u64 - 1)) - } else { - PageAlignedU64((arg & !(PAGE_SIZE as u64 - 1)) + PAGE_SIZE as u64) - } - } -} -impl From for PageAlignedU64 { - fn from(arg: PageAlignedU32) -> Self { PageAlignedU64(arg.0 as u64) } // already aligned, and it fits. -} -impl From for PageAlignedU64 { - fn from(arg: u32) -> Self { - if arg & (PAGE_SIZE as u32 - 1) == 0 { - PageAlignedU64(arg as u64 & !(PAGE_SIZE as u64 - 1)) - } else { - PageAlignedU64((arg as u64 & !(PAGE_SIZE as u64 - 1)) + PAGE_SIZE as u64) - } - } -} -impl From for PageAlignedU64 { - fn from(arg: usize) -> Self { - if arg & (PAGE_SIZE - 1) == 0 { - PageAlignedU64(arg as u64 & !(PAGE_SIZE as u64 - 1)) - } else { - PageAlignedU64((arg as u64 & !(PAGE_SIZE as u64 - 1)) + PAGE_SIZE as u64) - } - } -} -impl Add for PageAlignedU64 { - type Output = PageAlignedU64; - fn add(self, other: PageAlignedU64) -> PageAlignedU64 { - PageAlignedU64(self.0 + other.0) - } +use bitfield::bitfield; + +/// We should be able to change this to a u64 and everything should "just work", but +/// we'd end up using 2x the amount of data for overhead and bookkeeping. +#[cfg(not(feature = "u64_pa"))] +pub type PhysAddr = u32; +#[cfg(feature = "u64_pa")] +pub type PhysAddr = u64; +const BITFIELD_PAGE_WIDTH: usize = (core::mem::size_of::() * 8 - 12); +/// Physical page information, coded as a bitfield, because space is a premium! +bitfield! { + #[derive(Copy, Clone, Hash)] + pub struct PhysPage(PhysAddr); + impl Debug; + pub page_number, set_page_number: BITFIELD_PAGE_WIDTH - 1, 0; + pub clean, set_clean: BITFIELD_PAGE_WIDTH + 0; + pub valid, set_valid: BITFIELD_PAGE_WIDTH + 1; + // these are only used by the FastSpace mechanism; they have no meaning in other contexts + pub space_state, set_space_state: BITFIELD_PAGE_WIDTH + 3, BITFIELD_PAGE_WIDTH + 2; } -#[derive(Copy, Clone)] -pub(crate) struct PageAlignedU32(u32); -impl PageAlignedU32 { - pub(crate) fn as_u32(&self) -> u32 {self.0} - pub(crate) fn as_u64(&self) -> u64 {self.0 as u64} -} -impl From for PageAlignedU32 { - fn from(arg: u32) -> Self { - if arg & (PAGE_SIZE as u32 - 1) == 0 { - PageAlignedU32(arg & !(PAGE_SIZE as u32 - 1)) - } else { - PageAlignedU32((arg & !(PAGE_SIZE as u32 - 1)) + PAGE_SIZE as u32) - } - } -} -impl From for PageAlignedU32 { - fn from(arg: usize) -> Self { - if arg & (PAGE_SIZE as usize - 1) == 0 { - PageAlignedU32(arg as u32 & !(PAGE_SIZE as u32 - 1)) - } else { - PageAlignedU32((arg as u32 & !(PAGE_SIZE as u32 - 1)) + PAGE_SIZE as u32) - } - } -} -/* // let's get real, this is kind of a waste of cycles to check this... -impl TryFrom for PageAlignedU32 { - type Error = &'static str; - fn try_from(arg: usize) -> Result { - if arg > u32::MAX as usize { - Err("PageAlignedU32 only accepts usize less than u32::MAX") - } else { - Ok( - if arg & (PAGE_SIZE - 1) == 0 { - PageAlignedU32(arg as u32 & !(PAGE_SIZE as u32 - 1)) - } else { - PageAlignedU32((arg as u32 & !(PAGE_SIZE as u32 - 1)) + PAGE_SIZE as u32) - } - ) - } - } -} -*/ -impl From for u32 { - fn from(arg: PageAlignedU32) -> Self { - arg.0 - } -} -impl Add for PageAlignedU32 { - type Output = PageAlignedU32; - fn add(self, other: PageAlignedU32) -> PageAlignedU32 { - PageAlignedU32(self.0 + other.0 as u32) - } - /* - fn add(self, other: usize) -> PageAlignedU32 { - let page_aligned_other = if other & (PAGE_SIZE - 1) == 0 { - other & !(PAGE_SIZE - 1) - } else { - (other & !(PAGE_SIZE - 1)) + PAGE_SIZE - }; - // saturate adds - if self.0 as usize + page_aligned_other > u32::MAX as usize { - PageAlignedU32(u32::MAX) - } else { - PageAlignedU32(self.0 + page_aligned_other as u32) - } - }*/ -} - -/* -#[derive(Hash, Copy, Clone, PartialEq, Eq)] -pub struct PhysAddr(NonZeroU32); -impl From for PhysAddr { - fn from(arg: u32) -> Self { - PhysAddr( NonZeroU32::try_from(arg).expect("Physical addresses must not be zero") ) - } -} -*/ pub type VirtAddr = u64; +#[derive(Copy, Clone)] +pub(crate) struct PageAlignedVa(VirtAddr); +impl PageAlignedVa { + pub(crate) fn as_u32(&self) -> u32 { + if self.0 <= u32::MAX as VirtAddr { + self.0 as u32 + } else { + panic!("This PageAlignedVa would not fit into a PageAlignedPa"); + } + } + pub(crate) fn as_u64(&self) -> u64 {self.0 as u64} + pub(crate) fn as_usize(&self) -> usize {self.0 as usize} +} +impl From for PageAlignedVa { + fn from(arg: u64) -> Self { + if arg & (PAGE_SIZE as u64 - 1) == 0 { + PageAlignedVa(arg & !(PAGE_SIZE as VirtAddr - 1)) + } else { + PageAlignedVa((arg & !(PAGE_SIZE as VirtAddr - 1)) + PAGE_SIZE as VirtAddr) + } + } +} +impl From for PageAlignedVa { + fn from(arg: PageAlignedPa) -> Self { PageAlignedVa(arg.0 as VirtAddr) } // already aligned, and it fits. +} +impl From for PageAlignedVa { + fn from(arg: u32) -> Self { + if arg & (PAGE_SIZE as u32 - 1) == 0 { + PageAlignedVa(arg as VirtAddr & !(PAGE_SIZE as VirtAddr - 1)) + } else { + PageAlignedVa((arg as VirtAddr & !(PAGE_SIZE as VirtAddr - 1)) + PAGE_SIZE as VirtAddr) + } + } +} +impl From for PageAlignedVa { + fn from(arg: usize) -> Self { + if arg & (PAGE_SIZE - 1) == 0 { + PageAlignedVa(arg as VirtAddr & !(PAGE_SIZE as VirtAddr - 1)) + } else { + PageAlignedVa((arg as VirtAddr & !(PAGE_SIZE as VirtAddr - 1)) + PAGE_SIZE as VirtAddr) + } + } +} +impl Add for PageAlignedVa { + type Output = PageAlignedVa; + fn add(self, other: PageAlignedVa) -> PageAlignedVa { + PageAlignedVa(self.0 + other.0) + } +} + +#[derive(Copy, Clone)] +pub(crate) struct PageAlignedPa(PhysAddr); +impl PageAlignedPa { + pub(crate) fn as_u32(&self) -> u32 {self.0 as u32} + pub(crate) fn as_u64(&self) -> u64 {self.0 as u64} + pub(crate) fn as_usize(&self) -> usize {self.0 as usize} +} +impl From for PageAlignedPa { + fn from(arg: u32) -> Self { + if arg & (PAGE_SIZE as u32 - 1) == 0 { + PageAlignedPa( (arg & !(PAGE_SIZE as u32 - 1)) as PhysAddr ) + } else { + PageAlignedPa( ((arg & !(PAGE_SIZE as u32 - 1)) + PAGE_SIZE as u32) as PhysAddr ) + } + } +} +impl From for PageAlignedPa { + fn from(arg: usize) -> Self { + if arg & (PAGE_SIZE as usize - 1) == 0 { + PageAlignedPa( (arg as u32 & !(PAGE_SIZE as u32 - 1)) as PhysAddr ) + } else { + PageAlignedPa( ((arg as u32 & !(PAGE_SIZE as u32 - 1)) + PAGE_SIZE as u32) as PhysAddr ) + } + } +} +impl From for u32 { + fn from(arg: PageAlignedPa) -> Self { + arg.0 as u32 + } +} +impl Add for PageAlignedPa { + type Output = PageAlignedPa; + fn add(self, other: PageAlignedPa) -> PageAlignedPa { + PageAlignedPa(self.0 + other.0 as PhysAddr) + } +} + + mod tests { use super::*; #[test] + /// PAGE_SIZE is required to be a power of two. 0x1000 -> 0x1000 - 1 = 0xFFF, which forms the bitmasks. fn test_page_size() { assert!(PAGE_SIZE & !(PAGE_SIZE - 1) == 0, "PAGE_SIZE is not a power of two!"); } diff --git a/services/pddb/src/main.rs b/services/pddb/src/main.rs index bfa55802e..066208d2e 100644 --- a/services/pddb/src/main.rs +++ b/services/pddb/src/main.rs @@ -42,6 +42,34 @@ use xous::{msg_blocking_scalar_unpack, msg_scalar_unpack}; /// settings:wifi/Kosagi.json /// Would be deconstructed into the "settings" dictionary with a key of wifi/Kosagi.json. /// +/// +/// Threat model: +/// +/// The user is forced to divulge "all the Basis passwords" on the device, through +/// coercion, blackmail, subpoena, customs checkpoint etc. The adversary has physical +/// access to the device, and is able to take a static disk image; they may even have +/// the opportunity to take several disk images over time and diff the images. +/// The adversary may be able to decrypt the root key of the cryptographic enclave. +/// The adversary may also be able to observe the contents of encrypted data within the +/// "system" basis, which includes some of the bookkeeping information for the PDDB, +/// as the user will have at least been forced to divulge the system basis password as +/// this is a password that every device requires and they cannot deny its existence. +/// +/// Under these conditions, it should be impossible for the adversary to conclusively prove or +/// disprove that every Basis password has been presented and unlocked for inspection +/// through forensic analysis of the PDDB alone (significantly, we cannot prevent disclosure +/// by poorly constructed end-user applications storing things like "last opened Basis" +/// convenience lists, or if the user themselves wrote a note referring to a secret +/// Basis in a less secret area). Furthermore, if a device is permanently seized by +/// the adversary for extensive analysis, any Basis whose password that has not been +/// voluntarily disclosed should be "as good as deleted". +/// +/// The PDDB also cannot protect against key loggers or surveillance cameras recording +/// key strokes as the user operates the device. Resistance to key loggers is instead +/// a problem handled by the OS, and it is up to the user to not type secret passwords +/// in areas that may be under camera surveillance. +/// +/// /// General Operation: /// /// The initial Basis is known as the "System" Basis. It's a low-security framework basis @@ -97,7 +125,7 @@ const PDDB_BACKING_SIZE: usize = 0x4000_0000; /// an encrypted, plausibly deniable filesystem, as you have to trade-off the side channel of partially /// erased blocks versus the finite write lifetime of flash storage. /// -/// When a Basis is created, it starts with 64k of FLASH allocated to it. Most of this is blank (but encrypted +/// When a Basis is created, it starts with 64k of space allocated to it. Most of this is blank (but encrypted /// in flash), but it is important in a PD filesystem to claim some freespace for day-to-day operations. This /// is because when you need to allocate more data, you have to make a guess as to what is free, and what /// previously allocated but currently denied to exist (locked Basis look identical to free space when locked). @@ -109,9 +137,17 @@ const PDDB_BACKING_SIZE: usize = 0x4000_0000; /// Blocks on disk are mapped into a virtual PDDB space via a page table. The virtual PDDB space is 64-bit. /// Each Basis gets its own 48-bit address space, allowing for up to 64k Basis. /// The PDDB page table guarantees that no matter the order of allocation in FLASH, a Basis can linearly -/// access its blocks by doing a page table lookup. A reverse-lookup structure is constructed on boot +/// access its blocks through a page table lookup. A reverse-lookup structure is constructed on boot /// by scanning the entire PDDB, and creating a HashMap of (basis, offset) -> pddb_addr tuples. /// +/// Physical addresses can be 32 or 64 bit based upon the specific implementation. The physical address +/// type is defined in types.rs. For Precursor, it's defined as a u32, which limits the physical address +/// size to 32 bits. This is important because Precursor operates out of a very small amount of RAM, +/// and doubling the size of the overhead bookkeeping structures to handle disk sizes that are well +/// beyond the current implementation has a real impact on the system's free memory footprint. However, +/// the PDDB is coded in a way such that one "should" be able to swap out the u32 for a u64 in the +/// "newtype" definition for a PhysAddr, and the system will work. +/// /// Page table entries don't define themselves with a Basis -- every time a Basis is opened, the entire /// table must be scanned, brute-force decrypting every entry against the Basis key, and seeing if the /// checksum in the table entry matches the address. If there's a match, then that entry is recorded as @@ -134,7 +170,6 @@ const PDDB_BACKING_SIZE: usize = 0x4000_0000; /// to all 1's) in a circular buffer basis. The state of where the .FastSpace record is in the "clean" pages /// disclose nothing other than the fact that the system has been used. /// -/// TODO: define .FastSpace records and structures. /// /// /// Basis Deniability