diff --git a/services/pddb/src/backend/hosted.rs b/services/pddb/src/backend/hosted.rs index f35d4df20..3cb9de467 100644 --- a/services/pddb/src/backend/hosted.rs +++ b/services/pddb/src/backend/hosted.rs @@ -54,6 +54,12 @@ impl EmuStorage { pub fn as_mut_slice(&mut self) -> &mut [u8] { flashmem().memory.as_mut_slice() } + /// used to reset the storage for repeated test case generation + pub fn reset(&mut self) { + for b in flashmem().memory.as_mut_slice() { + *b = 0xFF; + } + } pub fn dump_fs(&self, name: &Option) { let defaultname = String::from("pddb"); let rootname = name.as_ref().unwrap_or(&defaultname); diff --git a/services/pddb/src/backend/hw.rs b/services/pddb/src/backend/hw.rs index de38cecc0..75f91ea38 100644 --- a/services/pddb/src/backend/hw.rs +++ b/services/pddb/src/backend/hw.rs @@ -96,18 +96,10 @@ pub(crate) struct PddbOs { entropy: Rc>, /* - /// virtual to physical page map. It's the reverse mapping of the physical page table on disk. - v2p_map: HashMap>, /// 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. basis_keys: Vec::<[u8; AES_KEYSIZE]>, - /// An in-memory "priority vector" of Basis root data that have been unlocked. Right now, we keep all data resident. - /// Basis root data should be fairly compact -- it's just the directory data to find the keys and - /// 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::, */ } @@ -143,14 +135,11 @@ impl PddbOs { data_phys_base: PageAlignedPa::from(fscb_phys_base.as_u32() + FSCB_PAGES as u32 * PAGE_SIZE as u32), system_basis_key: None, cipher_ecb: None, - //v2p_map: HashMap::>::new(), fspace_cache: HashSet::::new(), fspace_log_addrs: Vec::::new(), fspace_log_next_addr: None, dna: llio.soc_dna().unwrap(), entropy: trngpool, - //basis_keys: Vec::new(), - //basis_cache: Vec::::new(), }; // emulated #[cfg(not(any(target_os = "none", target_os = "xous")))] @@ -167,14 +156,11 @@ impl PddbOs { data_phys_base: PageAlignedPa::from(fscb_phys_base.as_u32() + FSCB_PAGES as u32 * PAGE_SIZE as u32), system_basis_key: None, cipher_ecb: None, - //v2p_map: HashMap::>::new(), fspace_cache: HashSet::::new(), fspace_log_addrs: Vec::::new(), fspace_log_next_addr: None, dna: llio.soc_dna().unwrap(), entropy: trngpool, - //basis_keys: Vec::new(), - //basis_cache: Vec::::new(), } }; ret @@ -203,6 +189,16 @@ impl PddbOs { pub fn dbg_dump(&self, _name: Option) { // placeholder } + #[cfg(not(any(target_os = "none", target_os = "xous")))] + /// used to reset the hardware structure for repeated runs of testing within a single invocation + pub fn test_reset(&mut self) { + self.fspace_cache = HashSet::::new(); + self.fspace_log_addrs = Vec::::new(); + self.system_basis_key = None; + self.cipher_ecb = None; + self.fspace_log_next_addr = None; + self.pddb_mr.reset(); + } pub(crate) fn nonce_gen(&mut self) -> Nonce { let nonce_array = self.entropy.borrow_mut().get_nonce(); diff --git a/services/pddb/src/main.rs b/services/pddb/src/main.rs index 4e26e1b44..10f6ad3a0 100644 --- a/services/pddb/src/main.rs +++ b/services/pddb/src/main.rs @@ -369,93 +369,45 @@ fn xmain() -> ! { // shared entropy cache across all process-local services (it's more efficient to request entropy in blocks from the TRNG) let entropy = Rc::new(RefCell::new(TrngPool::new())); - // OS-specific PDDB driver - log::info!("creating PddbOs structure"); - let mut pddb_os = PddbOs::new(Rc::clone(&entropy)); - /* + // OS-specific PDDB driver + let mut pddb_os = PddbOs::new(Rc::clone(&entropy)); #[cfg(not(any(target_os = "none", target_os = "xous")))] { + log::info!("Creating `basecase1`"); create_testcase(&mut pddb_os, None, None, None); pddb_os.dbg_dump(Some("basecase1".to_string())); - }*/ - - log::info!("Initializing disk..."); - pddb_os.pddb_format().unwrap(); - log::info!("Done initializing disk"); - - // 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 let Some(sys_basis) = pddb_os.pddb_mount() { - log::info!("PDDB mount operation finished successfully"); - basis_cache.basis_add(sys_basis); - } else { - log::info!("PDDB did not mount; did you remember to format the PDDB region?"); } - log::info!("size of vpage: {}", VPAGE_SIZE); + { // a simple case that could be run directly on the hardware + log::info!("Running `manual` test case"); + #[cfg(not(any(target_os = "none", target_os = "xous")))] + pddb_os.test_reset(); - // add a "system settings" dictionary to the default basis - log::info!("adding 'system settings' dictionary"); - basis_cache.dict_add(&mut pddb_os, "system settings", None).expect("couldn't add system settings dictionary"); - basis_cache.key_update(&mut pddb_os, "system settings", "wifi/wpa_keys/Kosagi", "my_wpa_key_here".as_bytes(), None, None, None, false).expect("couldn't add a key"); - let mut readback = [0u8; 15]; - match basis_cache.key_read(&mut pddb_os, "system settings", "wifi/wpa_keys/Kosagi", &mut readback, None, None) { - Ok(readsize) => { - log::info!("read back {} bytes", readsize); - log::info!("read data: {}", String::from_utf8_lossy(&readback)); - }, - Err(e) => { - log::info!("couldn't read data: {:?}", e); + manual_testcase(&mut pddb_os); + + log::info!("Re-mount the PDDB"); + let mut basis_cache = BasisCache::new(); + if let Some(sys_basis) = pddb_os.pddb_mount() { + log::info!("PDDB mount operation finished successfully"); + basis_cache.basis_add(sys_basis); + } else { + log::info!("PDDB did not mount; did you remember to format the PDDB region?"); } - } - basis_cache.key_update(&mut pddb_os, "system settings", "wifi/wpa_keys/e4200", "12345678".as_bytes(), None, None, None, false).expect("couldn't add a key"); - - // add a "big" key - let mut bigdata = [0u8; 5000]; - for (i, d) in bigdata.iter_mut().enumerate() { - *d = i as u8; - } - basis_cache.key_update(&mut pddb_os, "system settings", "big_pool1", &bigdata, None, None, None, false).expect("couldn't add a key"); - - basis_cache.dict_add(&mut pddb_os, "test_dict_2", None).expect("couldn't add test dictionary 2"); - basis_cache.key_update(&mut pddb_os, "test_dict_2", "test key in dict 2", "some data".as_bytes(), None, Some(128), None, false).expect("couldn't add a key to second dict"); - - basis_cache.key_update(&mut pddb_os, "system settings", "wifi/wpa_keys/e4200", "ABC".as_bytes(), Some(2), None, None, false).expect("couldn't update e4200 key"); - - log::info!("test readback of wifi/wpa_keys/e4200"); - match basis_cache.key_read(&mut pddb_os, "system settings", "wifi/wpa_keys/e4200", &mut readback, None, None) { - Ok(readsize) => { - log::info!("read back {} bytes", readsize); - log::info!("read data: {}", String::from_utf8_lossy(&readback)); - }, - Err(e) => { - log::info!("couldn't read data: {:?}", e); + log::info!("test readback of wifi/wpa_keys/e4200"); + let mut readback = [0u8; 16]; // this buffer is bigger than the data in the key, but that's alright... + match basis_cache.key_read(&mut pddb_os, "system settings", "wifi/wpa_keys/e4200", &mut readback, None, None) { + Ok(readsize) => { + log::info!("read back {} bytes", readsize); + log::info!("read data: {}", String::from_utf8_lossy(&readback)); + }, + Err(e) => { + log::info!("couldn't read data: {:?}", e); + } } - } - #[cfg(not(any(target_os = "none", target_os = "xous")))] - pddb_os.dbg_dump(Some("basic1".to_string())); - - log::info!("Re-mount the PDDB"); - if let Some(sys_basis) = pddb_os.pddb_mount() { - log::info!("PDDB mount operation finished successfully"); - basis_cache.basis_add(sys_basis); - } else { - log::info!("PDDB did not mount; did you remember to format the PDDB region?"); + #[cfg(not(any(target_os = "none", target_os = "xous")))] + pddb_os.dbg_dump(Some("manual".to_string())); } - log::info!("test readback of wifi/wpa_keys/e4200"); - match basis_cache.key_read(&mut pddb_os, "system settings", "wifi/wpa_keys/e4200", &mut readback, None, None) { - Ok(readsize) => { - log::info!("read back {} bytes", readsize); - log::info!("read data: {}", String::from_utf8_lossy(&readback)); - }, - Err(e) => { - log::info!("couldn't read data: {:?}", e); - } - } - /* list of test cases: genenral integrity: allocate 4 dictionaries, each with 34 keys of various sizes ranging from 1k-9k. delete/add consistency: general integrity, delete a dictionary, then add a dictionary. diff --git a/services/pddb/src/tests.rs b/services/pddb/src/tests.rs index 174960f84..6765e6ef0 100644 --- a/services/pddb/src/tests.rs +++ b/services/pddb/src/tests.rs @@ -49,4 +49,61 @@ pub(crate) fn create_testcase(hw: &mut PddbOs, basis_cache.key_update(hw, &dictname, &keyname, &keydata, None, None, None, false).unwrap(); } } +} + +pub(crate) fn manual_testcase(hw: &mut PddbOs) { + log::info!("Initializing disk..."); + hw.pddb_format().unwrap(); + log::info!("Done initializing disk"); + + // 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 let Some(sys_basis) = hw.pddb_mount() { + log::info!("PDDB mount operation finished successfully"); + basis_cache.basis_add(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 "system settings" dictionary to the default basis + log::info!("adding 'system settings' dictionary"); + basis_cache.dict_add(hw, "system settings", None).expect("couldn't add system settings dictionary"); + basis_cache.key_update(hw, "system settings", "wifi/wpa_keys/Kosagi", "my_wpa_key_here".as_bytes(), None, None, None, false).expect("couldn't add a key"); + let mut readback = [0u8; 15]; + match basis_cache.key_read(hw, "system settings", "wifi/wpa_keys/Kosagi", &mut readback, None, None) { + Ok(readsize) => { + log::info!("read back {} bytes", readsize); + log::info!("read data: {}", String::from_utf8_lossy(&readback)); + }, + Err(e) => { + log::info!("couldn't read data: {:?}", e); + } + } + basis_cache.key_update(hw, "system settings", "wifi/wpa_keys/e4200", "12345678".as_bytes(), None, None, None, false).expect("couldn't add a key"); + + // add a "big" key + let mut bigdata = [0u8; 5000]; + for (i, d) in bigdata.iter_mut().enumerate() { + *d = i as u8; + } + basis_cache.key_update(hw, "system settings", "big_pool1", &bigdata, None, None, None, false).expect("couldn't add a key"); + + basis_cache.dict_add(hw, "test_dict_2", None).expect("couldn't add test dictionary 2"); + basis_cache.key_update(hw, "test_dict_2", "test key in dict 2", "some data".as_bytes(), None, Some(128), None, false).expect("couldn't add a key to second dict"); + + basis_cache.key_update(hw, "system settings", "wifi/wpa_keys/e4200", "ABC".as_bytes(), Some(2), None, None, false).expect("couldn't update e4200 key"); + + log::info!("test readback of wifi/wpa_keys/e4200"); + match basis_cache.key_read(hw, "system settings", "wifi/wpa_keys/e4200", &mut readback, None, None) { + Ok(readsize) => { + log::info!("read back {} bytes", readsize); + log::info!("read data: {}", String::from_utf8_lossy(&readback)); + }, + Err(e) => { + log::info!("couldn't read data: {:?}", e); + } + } } \ No newline at end of file