free_pool scanning first cut

This commit is contained in:
bunnie 2021-11-08 05:41:39 +08:00
parent 81d9fb3fda
commit 7858aaad0e
8 changed files with 414 additions and 185 deletions

View file

@ -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 = []

View file

@ -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::<PddbBuf>() == 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 {

View file

@ -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

View file

@ -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::<PhysPage>()],
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::<FastSpace>() & !(PAGE_SIZE - 1) == 0, "FastSpace is not exactly a multiple of one page in size");
}
}

View file

@ -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<BasisRootName, HashMap<VirtAddr, PhysPage>>,
/// 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::<u8>,
}
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::<PageTableInFlash>());
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::<PageTableInFlash>());
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::<BasisRootName, HashMap<VirtAddr, PhysPage>>::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::<PhysPage> {
let mut free_pool = Vec::<usize>::new();
let max_entries = FASTSPACE_PAGES * PAGE_SIZE / core::mem::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()));
}
}
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::<PhysPage>::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::<u8>::new(); // bools also take up a byte
// step 8. generate & write initial page table entries
// page table organization:
//
// offset from |

View file

@ -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

View file

@ -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<u64> 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<PageAlignedU32> for PageAlignedU64 {
fn from(arg: PageAlignedU32) -> Self { PageAlignedU64(arg.0 as u64) } // already aligned, and it fits.
}
impl From<u32> 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<usize> 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::<PhysAddr>() * 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<u32> 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<usize> 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<usize> for PageAlignedU32 {
type Error = &'static str;
fn try_from(arg: usize) -> Result<Self, Self::Error> {
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<PageAlignedU32> 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<u32> 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<u64> 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<PageAlignedPa> for PageAlignedVa {
fn from(arg: PageAlignedPa) -> Self { PageAlignedVa(arg.0 as VirtAddr) } // already aligned, and it fits.
}
impl From<u32> 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<usize> 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<u32> 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<usize> 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<PageAlignedPa> 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!");
}

View file

@ -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