From 81d9fb3fda7ff5626e06924f0a2cad0c3dbefda7 Mon Sep 17 00:00:00 2001 From: bunnie Date: Sun, 7 Nov 2021 05:34:07 +0800 Subject: [PATCH] more incremental progress --- services/pddb/Cargo.toml | 4 ++- services/pddb/src/backend/basis.rs | 34 ++++++++++++++++-- services/pddb/src/backend/fastspace.rs | 2 +- services/pddb/src/backend/hw.rs | 50 ++++++++++++++++++++++---- services/pddb/src/backend/pagetable.rs | 20 +++++++---- services/pddb/src/backend/types.rs | 12 ++++--- services/pddb/src/main.rs | 1 + 7 files changed, 101 insertions(+), 22 deletions(-) diff --git a/services/pddb/Cargo.toml b/services/pddb/Cargo.toml index 7cc753808..51015f156 100644 --- a/services/pddb/Cargo.toml +++ b/services/pddb/Cargo.toml @@ -19,10 +19,12 @@ susres = {path = "../susres"} rkyv = {version = "0.4.3", features = ["const_generics"], default-features = false} trng = {path = "../trng"} spinor = {path = "../spinor"} -aes-xous = {path="../aes"} +aes = {path="../aes"} rand_core = "0.5" root-keys = {path="../root-keys"} cipher = "0.3" +bitfield = "0.13.2" +aes-gcm-siv = "0.10.3" [target.'cfg(not(any(windows,unix)))'.dependencies] utralib = { path = "../../utralib"} diff --git a/services/pddb/src/backend/basis.rs b/services/pddb/src/backend/basis.rs index ff7ecf49c..3cf417e31 100644 --- a/services/pddb/src/backend/basis.rs +++ b/services/pddb/src/backend/basis.rs @@ -6,7 +6,7 @@ use core::ops::{Deref, DerefMut}; use core::{mem, slice}; pub(crate) const FREE_CACHE_SIZE: usize = 16; - +pub type BasisRootName = [u8; PDDB_MAX_BASIS_NAME_LEN]; /// In basis space, the BasisRoot is located at 0 /// The first 4GiB is reserved for the Basis Root. /// Keys begin at the next 4GiB. @@ -27,7 +27,7 @@ pub(crate) struct BasisRoot { pub(crate) magic: [u8; 4], pub(crate) version: u16, pub(crate) journal_rev: u32, - pub(crate) name: [u8; PDDB_MAX_BASIS_NAME_LEN], + pub(crate) name: BasisRootName, /// increments every time the BasisRoot is modified. This field must saturate, not roll over. pub(crate) age: u32, /* @@ -41,11 +41,39 @@ pub(crate) struct BasisRoot { /// less than this value. This can be grown and shrunk with allocation and compaction processes. pub(crate) prealloc_open_end: PageAlignedU64, pub(crate) num_dictionaries: u32, - // dict_slice: [DictPointer], // DictPointers + num_dictionaries above can be turned into a dict_slice + // 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 // pad: [u8], // padding out to the next 4096-byte block less 16 bytes // p_tag: [u8; 16], // auth tag output of the AES-GCM-SIV } +impl BasisRoot { + /// Compute the number of memory pages consumed by the BasisRoot structure itself. + /// This is the size of BasisRoot, plus the dictionaries allocated within the Basis. + /// It does mean that your memory usage scales directly with the number of dictionaries + /// you put in the Basis, because there is no way to chain or defer the Basis structure + /// if you get thousands of Dictionaries. Note that the intent is to have typcially no + /// more than a couple dozen dictionaries; if you want to store a lot of different records, + /// you can create thousands of Keys more efficiently, than you can dictionaries. + pub(crate) fn len_pages(&self) -> usize { + let min_len = core::mem::size_of::() + + ((self.num_dictionaries as usize) + * core::mem::size_of::()) + + core::mem::size_of::(); + if (min_len & (1 - PAGE_SIZE)) == 0 { + min_len / PAGE_SIZE + } else { + min_len / PAGE_SIZE + 1 + } + } + /// Number of bytes needed to pad between the length of the BasisRoot structure and the plaintext + /// tag that will get appended to the end + pub(crate) fn padding_count(&self) -> usize { + self.len_pages() * PAGE_SIZE - + (core::mem::size_of::() + + ((self.num_dictionaries as usize) * core::mem::size_of::()) + ) + } +} impl Deref for BasisRoot { type Target = [u8]; fn deref(&self) -> &[u8] { diff --git a/services/pddb/src/backend/fastspace.rs b/services/pddb/src/backend/fastspace.rs index 7090cde72..00d253637 100644 --- a/services/pddb/src/backend/fastspace.rs +++ b/services/pddb/src/backend/fastspace.rs @@ -21,7 +21,7 @@ pub(crate) enum SpaceState { pub (crate) struct FastSpace { p_nonce: [u8; 12], journal_rev: [u8; 4], - free_pool: [Option; (PAGE_SIZE - 16 - 4 -12) / 4], + free_pool: [PhysPage; (PAGE_SIZE - 16 - 4 -12) / 4], p_tag: [u8; 16], } diff --git a/services/pddb/src/backend/hw.rs b/services/pddb/src/backend/hw.rs index 37bd2dab5..02531e5a9 100644 --- a/services/pddb/src/backend/hw.rs +++ b/services/pddb/src/backend/hw.rs @@ -1,6 +1,8 @@ use std::convert::TryInto; use crate::*; +use aes_gcm_siv::{Aes256GcmSiv, Nonce, Key}; +use aes_gcm_siv::aead::{NewAead, Aead}; use rand_core::{CryptoRng, RngCore}; use cipher::{BlockCipher, BlockDecrypt}; use root_keys::api::{AesRootkeyType, Block}; @@ -53,7 +55,7 @@ pub(crate) struct PddbOs { fscb_phys_base: PageAlignedU32, data_phys_base: PageAlignedU32, system_basis_key: Option<[u8; 32]>, - v2p_map: HashMap>, + v2p_map: HashMap>, } impl PddbOs { @@ -82,7 +84,7 @@ impl PddbOs { fscb_phys_base, data_phys_base: PageAlignedU32::from(fscb_phys_base.as_u32() + FSCB_PAGES as u32 * PAGE_SIZE as u32), system_basis_key: None, - v2p_map: HashMap::>::new(), + v2p_map: HashMap::>::new(), } } @@ -166,14 +168,49 @@ impl PddbOs { // step 4. Create a hashmap for our reverse PTE, and add it to the Pddb's cache // we don't have a fscb yet, and everything is free space, so we will manually place these initial entries. - let mut basis_v2p_map = HashMap::::new(); - for phys_page in ( + let mut basis_v2p_map = HashMap::::new(); + for (virt_page, phys_addr) in ( self.data_phys_base.as_u32()..self.data_phys_base.as_u32() + basis_root.prealloc_open_end.as_u32() - ).step_by(PAGE_SIZE) { + ).step_by(PAGE_SIZE).enumerate() { + let mut rpte = PhysPage(0); + rpte.set_page_number(phys_addr / PAGE_SIZE as u32); + rpte.set_clean(true); + rpte.set_valid(true); + basis_v2p_map.insert((virt_page * PAGE_SIZE) as VirtAddr, rpte); + } + self.v2p_map.insert(basis_root.name, basis_v2p_map); + // step 5. write the basis to Flash, at the physical locations noted above + let mut basis_ser = vec![]; + for &b in br_slice { + basis_ser.push(b) + } + for _ in (0..basis_root.padding_count()) { + basis_ser.push(0) + } + // basis_ser can now be passed to an encryption function + 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 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 + } else { + panic!("invalid state"); // we should never hit this because we created the key earlier in the same routine. } - // step 5. generate & write initial page table entries + // step 6. generate & write initial page table entries // page table organization: // // offset from | @@ -194,6 +231,7 @@ impl PddbOs { // ... // 0x0008_5000 | data_phys_base - start of basis + dictionary + key data region + Ok(()) } } \ No newline at end of file diff --git a/services/pddb/src/backend/pagetable.rs b/services/pddb/src/backend/pagetable.rs index a851fd4f1..d84beae14 100644 --- a/services/pddb/src/backend/pagetable.rs +++ b/services/pddb/src/backend/pagetable.rs @@ -1,10 +1,10 @@ use super::PAGE_SIZE; -use super::PhysAddr; use core::num::NonZeroU8; use core::num::NonZeroU32; use core::num::NonZeroU64; use bitflags::bitflags; +use bitfield::bitfield; bitflags! { /// flags used by the page table @@ -21,7 +21,10 @@ impl Default for PtFlags { fn default() -> PtFlags {PtFlags::INVALID} } -/// A Page Table Entry. Contains the address map of the corresponding entry, +/// A Page Table Entry. Must be equual in length to one AES block size (128 bits). +/// This is stored in the FLASH itself, so size is not as much of a constraint. +/// +/// Contains the address map of the corresponding entry, /// plus a nonce, and a checksum. Due to the Page Table being deliberately /// srtuctured to have invalid entries that don't decrypt correctly, you /// can't use a chaining approach. Thus these entries are encrypted closer to @@ -47,11 +50,14 @@ pub(crate) struct Pte { checksum: [u8; 4], } -#[repr(C, packed)] -pub(crate) struct ReversePte { - phys_addr: PhysAddr, - /// this maps to a u8 - flags: PtFlags, +/// 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; diff --git a/services/pddb/src/backend/types.rs b/services/pddb/src/backend/types.rs index 8d70bda76..201cee262 100644 --- a/services/pddb/src/backend/types.rs +++ b/services/pddb/src/backend/types.rs @@ -120,13 +120,17 @@ impl Add for PageAlignedU32 { }*/ } - +/* #[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") ) + } +} +*/ -#[derive(Hash, Copy, Clone, PartialEq, Eq)] -pub struct VirtAddr(NonZeroU64); - +pub type VirtAddr = u64; mod tests { use super::*; diff --git a/services/pddb/src/main.rs b/services/pddb/src/main.rs index 2e9c9ec4d..bfa55802e 100644 --- a/services/pddb/src/main.rs +++ b/services/pddb/src/main.rs @@ -2,6 +2,7 @@ #![cfg_attr(target_os = "none", no_main)] extern crate bitflags; +extern crate bitfield; mod api; use api::*;