some structure on a more refined version of the pddb api.

doesn't compile tho, need to figure out what the status of
Path is on Xous.
This commit is contained in:
bunnie 2021-11-01 04:30:19 +08:00
parent 6f522b0844
commit edb43a17a3
6 changed files with 162 additions and 89 deletions

10
Cargo.lock generated
View file

@ -1383,10 +1383,13 @@ dependencies = [
"num-derive",
"num-traits",
"rkyv",
"spinor",
"susres",
"ticktimer-server",
"trng",
"utralib",
"xous",
"xous-ipc",
"xous-names",
]
@ -1642,7 +1645,6 @@ dependencies = [
"memoffset",
"ptr_meta",
"rkyv_derive",
"seahash",
]
[[package]]
@ -1822,12 +1824,6 @@ dependencies = [
"version-compare",
]
[[package]]
name = "seahash"
version = "4.1.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "1c107b6f4780854c8b126e228ea8869f4d7b71260f962fefb57b996b8959ba6b"
[[package]]
name = "semver"
version = "1.0.4"

View file

@ -7,6 +7,7 @@ description = "Plausibly Deniable Database"
[dependencies]
xous = { path = "../../xous-rs" }
xous-ipc = { path = "../../xous-ipc" }
log-server = { path = "../log-server" }
ticktimer-server = { path = "../ticktimer-server" }
xous-names = { path = "../xous-names" }
@ -14,7 +15,9 @@ log = "0.4"
num-derive = {version = "0.3", default-features = false}
num-traits = {version = "0.2", default-features = false}
susres = {path = "../susres"}
rkyv = "0.4.3"
rkyv = {version = "0.4.3", features = ["const_generics"], default-features = false}
trng = {path = "../trng"}
spinor = {path = "../spinor"}
[target.'cfg(not(any(windows,unix)))'.dependencies]
utralib = { path = "../../utralib"}

View file

@ -3,6 +3,7 @@ pub(crate) const SERVER_NAME_PDDB: &str = "_Plausibly Deniable Database_";
#[allow(dead_code)]
#[derive(num_derive::FromPrimitive, num_derive::ToPrimitive, Debug)]
pub(crate) enum Opcode {
KeyRequest,
/// Suspend/resume callback
SuspendResume,

View file

@ -1,9 +1,20 @@
use std::io::{Error, ErrorKind, Result};
use xous::MemoryRange;
use std::io::SeekFrom;
//use std::io::{Error, ErrorKind, Result};
//use xous::MemoryRange;
//use std::io::SeekFrom;
use crate::PddbDict;
//use crate::*;
use rkyv::{Archive, Deserialize, Serialize};
use xous_ipc::String;
#[derive(Debug, Archive, Serialize, Deserialize, Copy, Clone)]
pub(crate) struct PddbKeyRequest {
pub(crate) dict: String::</*PDDB_MAX_DICT_NAME_LEN*/ 64>, // pending https://github.com/rust-lang/rust/issues/90195
pub(crate) key: String::</*PDDB_MAX_KEY_NAME_LEN*/ 256>, // pending https://github.com/rust-lang/rust/issues/90195
pub(crate) token: Option<[u32; 3]>,
}
/*
/// PddbKey is somewhat isomorphic to a File in Rust, in that it provides slices of [u8] that
/// can be `read()`, `write()` and `seek()`.
/// this is definitely a user-facing structure
@ -42,3 +53,5 @@ impl<'a> PddbKey<'a> {
pub fn seek(&mut self, pos: SeekFrom) -> Result<u64> { Ok(0) }
*/
}
*/

View file

@ -6,89 +6,77 @@ pub mod frontend;
pub use frontend::*;
use xous::{CID, send_message};
use xous_ipc::Buffer;
use num_traits::*;
use std::io::{Result, Error, ErrorKind};
use std::path::Path;
use std::format;
pub const PDDB_MAX_DICT_NAME_LEN: usize = 64;
pub const PDDB_MAX_KEY_NAME_LEN: usize = 256;
/// This constant maps onto a region that's "unused" by Xous, and claimable by user
/// processes.
const PDDB_BACKING_BASE: usize = 0x8000_0000;
/// This designates the largest contiguous extent that we could allocate for a file.
/// The backing isn't allocated -- it is merely reserved. Accesses to the backing trigger
/// page faults that are handled by the PDDB, and just the pages actively being dereferenced is
/// swapped into physical memory on demand. This does put a pretty hard upper limit on file sizes
/// on a 32-bit system, but PDDB is coded such that we could extend to a 64-bit system and
/// increase this limit my changing the constants here.
const PDDB_BACKING_SIZE: usize = 0x4000_0000;
fn handle_exception(exception: xous::Exception) -> isize {
use xous::Exception::*;
match exception {
IllegalInstruction(epc, instruction) => {
println!(
"Caught illegal instruction {:08x} at {:08x}, just skipping it...",
epc, instruction
);
4
}
InstructionAddressMisaligned(epc, addr) => {
println!(
"Misaligned instruction at {:08x} ({:08x}), trying to nudge forward a bit",
epc, addr
);
1
}
InstructionAccessFault(epc, addr)
| LoadAccessFault(epc, addr)
| StoreAccessFault(epc, addr) => {
panic!(
"Access fault of some sort: ({:08x} {:08x}): {:?}",
epc, addr, epc
);
}
LoadAddressMisaligned(epc, addr) | StoreAddressMisaligned(epc, addr) => {
println!(
"Load was misaligned ({:08x} @ {:08x}). Just skipping the instruction and hoping nobody notices.", epc, addr
);
4
}
InstructionPageFault(epc, addr) | LoadPageFault(epc, addr) | StorePageFault(epc, addr) => {
println!("Memory access fault at address 0x{:08x} (pc is at 0x{:08x}), allocating a new page", addr, epc);
let base = addr & !4095;
let size = 4096;
xous::map_memory(
None,
xous::MemoryAddress::new(base),
size,
xous::MemoryFlags::R | xous::MemoryFlags::W,
)
.expect("couldn't map memory");
// Retry the instruction
0
}
Unknown(a1, a2, a3) => panic!("unknown exception: {:08x} {:08x} {:08x}", a1, a2, a3),
}
}
pub struct Pddb {
pub struct PddbKey {
conn: CID,
backing: MemoryRange,
dict: String,
key: String,
token: [u32; 3],
}
impl Pddb {
pub fn new(xns: &xous_names::XousNames) -> core::result::Result<Self, xous::Error> {
impl PddbKey {
pub fn get<P: AsRef<Path>>(path: P) -> Result<PddbKey> {
let xns = xous_names::XousNames::new().unwrap();
REFCOUNT.store(REFCOUNT.load(Ordering::Relaxed) + 1, Ordering::Relaxed);
let conn = xns.request_connection_blocking(api::SERVER_NAME_PDDB).expect("Can't connect to Pddb server");
xous::syscall::set_exception_handler(handle_exception).unwrap();
if !path.is_absolute() {
return Err(Error::new(ErrorKind::InvalidInput, "All Xous keys must be fully specified relative to a dictionary"));
}
let mut dict = String::new();
let mut key = String::new();
if let Some(pathstr) = path.to_str() {
if let Some(path_lstrip) = path.strip_prefix("/") {
if let Some((dictstr, keystr)) = path_lstrip.split_once("/") {
if dictstr.len() < PDDB_MAX_DICT_NAME_LEN {
dict.push_str(dictstr);
} else {
return Err(Error::new(ErrorKind::InvalidInput, format!("Xous dictionary names must be shorter than {} bytes", PDDB_MAX_DICT_NAME_LEN)));
}
if keystr.len() < PDDB_MAX_KEY_NAME_LEN {
key.push_str(keystr);
} else {
return Err(Error::new(ErrorKind::InvalidInput, format!("Xous key names must be shorter than {} bytes", PDDB_MAX_DICT_NAME_LEN)));
}
} else {
return Err(Error::new(ErrorKind::InvalidInput, "All Xous keys must be of the format /dict/key; the key may contain more /'s"));
}
} else {
return Err(Error::new(ErrorKind::InvalidInput, "All Xous keys must be absolute and start with a /"));
}
} else {
return Err(Error::new(ErrorKind::InvalidInput, "All Xous keys must be valid UTF-8"));
}
let backing = unsafe {MemoryRange::new(
0x8000_0000,
0x1000_0000,
).expect("couldn't reserve pages for file backing region") };
let request = PddbKeyRequest {
dict: xous_ipc::String::<PDDB_MAX_DICT_NAME_LEN>::from_str(dict.as_str()),
key: xous_ipc::String::<PDDB_MAX_KEY_NAME_LEN>::from_str(key.as_str()),
token: None,
};
let mut buf = Buffer::into_buf(request)
.or(Err(Error::new(ErrorKind::Other, "Xous internal error")))?;
buf.lend_mut(conn, Opcode::KeyRequest.to_u32().unwrap())
.or(Err(Error::new(ErrorKind::Other, "Xous internal error")))?;
Ok(Pddb {
conn,
backing
})
let response = buf.to_original::<PddbKeyRequest, _>().unwrap();
if let Some(token) = response.token {
Ok(PddbKey {
conn,
dict,
key,
token,
})
} else {
Err(Error::new(ErrorKind::PermissionDenied, "Dict/Key access denied"))
}
}
pub(crate) fn conn(&self) -> CID {
@ -98,7 +86,7 @@ impl Pddb {
use core::sync::atomic::{AtomicU32, Ordering};
static REFCOUNT: AtomicU32 = AtomicU32::new(0);
impl Drop for Pddb {
impl Drop for PddbKey {
fn drop(&mut self) {
// the connection to the server side must be reference counted, so that multiple instances of this object within
// a single process do not end up de-allocating the CID on other threads before they go out of scope.
@ -118,7 +106,6 @@ impl Drop for Pddb {
use xous::MemoryRange;
use std::collections::HashMap;
use std::io::SeekFrom;
use std::io::{Error, ErrorKind, Result};
// this is an intenal structure for managing the overall PDDB
pub(crate) struct PddbManager {
@ -141,7 +128,7 @@ impl PddbBasis {
// this structure can be shared on the user side?
pub struct PddbDict<'a> {
contents: HashMap<PddbKey<'a>, &'a [u8]>,
contents: HashMap<PddbKey, &'a [u8]>,
callback: Box<dyn FnMut() + 'a>,
}
impl<'a> PddbDict<'a> {

View file

@ -2,9 +2,79 @@
#![cfg_attr(target_os = "none", no_main)]
mod api;
use api::*;
use num_traits::*;
/// PDDB - Plausibly Deniable DataBase
///
/// Glossary:
/// Basis - a unionizeable dictionary that can be unlocked with a password-protected key.
/// Dictionary - similar to a "volume" on a typical filesystem. Contains a group of k/v pairs
/// that share attributes such as access permissions
/// Key - a unique string that identifies a piece of data in the PDDB
/// Path - Rust's notion of how to locate a file, except we interpret it as a PDDB key, where
/// the "root" directory is the dictionary, and the remainder is the "key"
/// Value - the value associated with a key, isomorphic ot a "file" in Rust
/// Open Basis - A Basis that is decryptable and known to the system.
/// Closed Basis - A Basis that is not decryptable. It's unknown to the system and potentially treated
/// identically to free disk space, e.g., it could be partially overwritten.
///
/// A `Path` like the following is deconstructed as follows by the PDDB:
///
/// Dictionary
/// | Key
/// | |
/// --+- --------+---------------------
/// /logs/matrix/alice/oct30_2021/bob.txt
///
/// It could equally have an arbitrary name like "logs/Matrix - alice to bob Oct 30 2021";
/// as long as the string that identifies a Key is unique, it's stored in the database
/// all the same. Any valid utf-8 unicode characters are acceptable.
///
/// Likewise, something like this:
/// /settings/wifi/Kosagi.json
/// Would be deconstructed into the "settings" dictionary with a key of wifi/Kosagi.json.
///
/// General Operation:
///
/// The initial Basis is known as the "System" Basis. It's a low-security framework basis
/// onto which all other Basis overlay. The initial set of Dictionaries, along with their
/// Key/Value pairs, are available to any and all processes.
///
/// Each new Basis opened will contain zero or more dictionaries. If the dictionary within
/// the new Basis has the same name as an existing dictionary, the Keys are searched in
/// the reverse order of opening. In other words, a new Basis can temporarily override or
/// mask existing Keys. When updating a Key, one may specify the following modes of
/// operation:
///
/// - UpdateLatest: updates only the copy in the latest Basis to be opened
/// - UpdateOpened: updates copies in other currently opened Basis
///
/// Note that `UpdateOpened` is dangerous in the sense that if you have a Basis that is
/// is currently Closed, it cannot update copies in the closed Basis. Thus any global
/// update of database schema requires a user to open any and all knows Basis so that
/// synchronization can be maintained.
///
/// Furthermore, it is possible for a Basis to be closed on a "File" that is currently open.
/// In this case, two things happen:
/// - If a notification callback is registered, it's pinged by the PDDB. The notification
/// of closure callback is an additional feature to the typical Rust File interface.
/// - If the client attempts to read or write to any keys that span a Basis modification,
/// the now-ambiguous key operation will return a `BrokenPipe` error to the caller.
/// This constant maps onto a region that's "unused" by Xous, and claimable by user
/// processes.
const PDDB_BACKING_BASE: usize = 0x8000_0000;
/// This designates the largest contiguous extent that we could allocate for a file.
/// The backing isn't allocated -- it is merely reserved. Accesses to the backing trigger
/// page faults that are handled by the PDDB, and just the pages actively being dereferenced is
/// swapped into physical memory on demand. This does put a pretty hard upper limit on file sizes
/// on a 32-bit system, but PDDB is coded such that we could extend to a 64-bit system and
/// increase this limit my changing the constants here.
const PDDB_BACKING_SIZE: usize = 0x4000_0000;
#[xous::xous_main]
fn xmain() -> ! {
log_server::init_wait().unwrap();
@ -24,7 +94,10 @@ fn xmain() -> ! {
loop {
let msg = xous::receive_message(pddb_sid).unwrap();
match FromPrimitive::from_usize(msg.body.id()) {
Some(api::Opcode::SuspendResume) => xous::msg_scalar_unpack!(msg, token, _, _, _, {
Some(Opcode::KeyRequest) => {
// placeholder
}
Some(Opcode::SuspendResume) => xous::msg_scalar_unpack!(msg, token, _, _, _, {
/* pddb.suspend();
susres.suspend_until_resume(token).expect("couldn't execute suspend/resume");
pddb.resume(); */