You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
374 lines
10 KiB
374 lines
10 KiB
//! Data structures for the in-memory map.
|
|
use super::*;
|
|
use std::{
|
|
collections::HashMap,
|
|
borrow::Cow,
|
|
error,
|
|
fmt,
|
|
};
|
|
use generational_arena::{
|
|
Arena, Index,
|
|
};
|
|
use bitflags::bitflags;
|
|
use cryptohelpers::{
|
|
rsa::{
|
|
RsaPublicKey, RsaPrivateKey,
|
|
Signature,
|
|
},
|
|
aes::{self, AesKey,},
|
|
sha256::Sha256Hash,
|
|
};
|
|
use tokio::io::{
|
|
AsyncRead, AsyncWrite,
|
|
};
|
|
|
|
/// An absolute (nested) index
|
|
#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Serialize, Deserialize)]
|
|
pub struct AbsoluteIndex(Vec<Index>);
|
|
|
|
/// Possible value types of the data map
|
|
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
|
|
pub enum Data
|
|
{
|
|
Byte(u8),
|
|
Char(char),
|
|
Bool(bool),
|
|
|
|
/// Signed integer
|
|
SI(i64),
|
|
/// Unsigned integer
|
|
UI(u64),
|
|
/// Floating-point integer
|
|
FI(f64),
|
|
|
|
/// A UTF-8 text string
|
|
Text(String),
|
|
/// A binary blob
|
|
Binary(Vec<u8>),
|
|
|
|
/// A reference index to an item within the same `Datamap` as this one.
|
|
RelativeRef(Index),
|
|
/// A reference to an item N deep within nested `Map` elements.
|
|
///
|
|
/// The first `Index` specifies the `Map` data item at the root `Datamap` that contains the next, et cetera. The pointed to value is the last index.
|
|
AbsoluteRef(AbsoluteIndex),
|
|
|
|
/// A list of atoms
|
|
List(Vec<Atom>),
|
|
/// Another datamap
|
|
Map(Datamap),
|
|
|
|
/// An AES key
|
|
AesKey(AesKey),
|
|
/// An RSA keypair
|
|
RsaKeypair(RsaPrivateKey, RsaPublicKey),
|
|
/// An RSA private key
|
|
RsaPrivate(RsaPrivateKey),
|
|
/// An RSA public key
|
|
RsaPublic(RsaPublicKey),
|
|
|
|
/// A SHA256 hash
|
|
Hash(Sha256Hash),
|
|
|
|
/// A unique ID
|
|
Uuid(uuid::Uuid),
|
|
|
|
/// An RSA signature
|
|
Signature(Signature),
|
|
|
|
/// Nothing
|
|
Null,
|
|
}
|
|
|
|
/// An entry that may or may not be encrypted
|
|
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
|
|
pub enum MaybeEncrypted
|
|
{
|
|
/// This is an encrypted serialized `Data`.
|
|
Encrypted(Vec<u8>),
|
|
/// An unencrypted `Data`
|
|
Unencrypted(Data),
|
|
}
|
|
|
|
#[non_exhaustive]
|
|
#[derive(Debug)]
|
|
enum EncryptedEntryErrorKind
|
|
{
|
|
KeyNeeded,
|
|
Decrypt(aes::Error),
|
|
Deserialize(serde_cbor::Error),
|
|
|
|
Encrypt(aes::Error),
|
|
Serialize(serde_cbor::Error),
|
|
}
|
|
|
|
/// Error type returned when performing encryption/decryption operations on `Data` through `MaybeEncrypted`.
|
|
#[non_exhaustive]
|
|
#[derive(Debug)]
|
|
pub struct EncryptedEntryError(Box<EncryptedEntryErrorKind>);
|
|
|
|
impl EncryptedEntryError
|
|
{
|
|
/// Consume into a nicely readable `eyre::Report`
|
|
pub fn report(self) -> eyre::Report
|
|
{
|
|
let (whe, sug) = match self.0.as_ref() {
|
|
EncryptedEntryErrorKind::Serialize(_) => ("Object serialisation", "Bad data?"),
|
|
EncryptedEntryErrorKind::Deserialize(_) => ("Object deserialisation", "Corrupted data?"),
|
|
EncryptedEntryErrorKind::Decrypt(_) => ("Data decryption", "Bad key?"),
|
|
EncryptedEntryErrorKind::Encrypt(_) => ("Data encryption" ,"Bad key?"),
|
|
EncryptedEntryErrorKind::KeyNeeded => return eyre::Report::from(self)
|
|
.with_suggestion(|| "Try providing a key"),
|
|
};
|
|
|
|
Err::<std::convert::Infallible, _>(self)
|
|
.with_section(|| whe.header("In operation"))
|
|
.with_warning(|| sug)
|
|
.unwrap_err()
|
|
}
|
|
}
|
|
|
|
impl error::Error for EncryptedEntryError
|
|
{
|
|
fn source(&self) -> Option<&(dyn error::Error + 'static)> {
|
|
Some(match self.0.as_ref() {
|
|
EncryptedEntryErrorKind::Decrypt(d) => d,
|
|
EncryptedEntryErrorKind::Deserialize(d) => d,
|
|
EncryptedEntryErrorKind::Encrypt(d) => d,
|
|
EncryptedEntryErrorKind::Serialize(d) => d,
|
|
_ => return None,
|
|
})
|
|
}
|
|
}
|
|
|
|
impl fmt::Display for EncryptedEntryError
|
|
{
|
|
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result
|
|
{
|
|
match self.0.as_ref() {
|
|
EncryptedEntryErrorKind::KeyNeeded => write!(f, "this entry needed a decryption key but none was provided"),
|
|
EncryptedEntryErrorKind::Decrypt(_) => write!(f, "decryption failed"),
|
|
EncryptedEntryErrorKind::Deserialize(_) => write!(f, "deserialisation failed"),
|
|
EncryptedEntryErrorKind::Encrypt(_) => write!(f, "encryption failed"),
|
|
EncryptedEntryErrorKind::Serialize(_) => write!(f, "serialisation failed"),
|
|
}
|
|
}
|
|
}
|
|
|
|
impl From<EncryptedEntryErrorKind> for EncryptedEntryError
|
|
{
|
|
#[inline] fn from(from: EncryptedEntryErrorKind) -> Self
|
|
{
|
|
Self(Box::new(from))
|
|
}
|
|
}
|
|
|
|
|
|
/// Encrypt a `Data` entry into this buffer
|
|
async fn encrypt_data_entry<T>(output: &mut T, data: &Data, key: &AesKey) -> Result<usize, EncryptedEntryError>
|
|
where T: ?Sized + AsyncWrite + Unpin
|
|
{
|
|
let bytes = serde_cbor::to_vec(data).map_err(EncryptedEntryErrorKind::Serialize)?;
|
|
Ok(aes::encrypt_stream(key, &mut &bytes[..], output).await.map_err(EncryptedEntryErrorKind::Encrypt)?)
|
|
}
|
|
|
|
/// Decrypt an encrypted `Data` entry
|
|
async fn decrypt_data_entry<T: ?Sized>(input: &mut T, key: &AesKey, init_buf: Option<Vec<u8>>) -> Result<Data, EncryptedEntryError>
|
|
where T: AsyncRead + Unpin
|
|
{
|
|
let mut output = init_buf.unwrap_or_default();
|
|
aes::decrypt_stream(key, input, &mut output).await.map_err(EncryptedEntryErrorKind::Decrypt)?;
|
|
Ok(serde_cbor::from_slice(&output[..]).map_err(EncryptedEntryErrorKind::Deserialize)?)
|
|
}
|
|
|
|
impl MaybeEncrypted
|
|
{
|
|
/// Create a new non-encrypted entry
|
|
#[inline(always)] pub const fn new_raw(data: Data) -> Self
|
|
{
|
|
Self::Unencrypted(data)
|
|
}
|
|
/// Create a new encrypted entry
|
|
#[inline] pub fn new_encrypted(data: Data, encrypt: &AesKey) -> Result<Self, EncryptedEntryError>
|
|
{
|
|
let mut buffer = Vec::new();
|
|
encrypt_data_entry(&mut buffer, &data, encrypt).now_or_never().unwrap()?;
|
|
Ok(Self::Encrypted(buffer))
|
|
}
|
|
|
|
/// Is this data entry encrypted
|
|
#[inline] pub fn is_encrypted(&self) -> bool
|
|
{
|
|
if let MaybeEncrypted::Encrypted(_) = &self {
|
|
true
|
|
} else {
|
|
false
|
|
}
|
|
}
|
|
|
|
/// Consume into a decrypted data instance
|
|
#[inline] pub fn into_unencrypted(self, key: Option<&AesKey>) -> Result<Self, EncryptedEntryError>
|
|
{
|
|
Ok(Self::Unencrypted(self.into_data(key)?))
|
|
}
|
|
|
|
|
|
/// Make this entry unencrypted
|
|
pub fn make_unencrypted(&mut self, key: Option<&AesKey>) -> Result<(), EncryptedEntryError>
|
|
{
|
|
match self {
|
|
MaybeEncrypted::Encrypted(bytes) => {
|
|
*self = MaybeEncrypted::Unencrypted(decrypt_data_entry(&mut &bytes[..], key.ok_or(EncryptedEntryErrorKind::KeyNeeded)?, Some(Vec::with_capacity(bytes.len()))).now_or_never().unwrap()?);
|
|
},
|
|
_ => (),
|
|
}
|
|
Ok(())
|
|
}
|
|
|
|
/// Make this entry encrypted
|
|
pub fn make_encrypted(&mut self, key: Option<&AesKey>) -> Result<(), EncryptedEntryError>
|
|
{
|
|
match self {
|
|
MaybeEncrypted::Unencrypted(data) => {
|
|
let mut buffer = Vec::new();
|
|
encrypt_data_entry(&mut buffer, data, key.ok_or(EncryptedEntryErrorKind::KeyNeeded)?).now_or_never().unwrap()?;
|
|
*self = Self::Encrypted(buffer);
|
|
},
|
|
_ => (),
|
|
}
|
|
Ok(())
|
|
}
|
|
/// Consume into an encrypted data instance
|
|
pub fn into_encrypted(self, key: Option<&AesKey>) -> Result<Self, EncryptedEntryError>
|
|
{
|
|
match self {
|
|
MaybeEncrypted::Unencrypted(data) => Self::new_encrypted(data, key.ok_or(EncryptedEntryErrorKind::KeyNeeded)?),
|
|
_ => Ok(self),
|
|
}
|
|
}
|
|
|
|
/// Attempt to get the `Data`, decrypting it if needed.
|
|
pub fn get_data<'a>(&'a self, key: Option<&AesKey>) -> Result<Cow<'a, Data>, EncryptedEntryError>
|
|
{
|
|
Ok(match self {
|
|
Self::Unencrypted(data) => Cow::Borrowed(&data),
|
|
Self::Encrypted(bytes) => {
|
|
// decrypt
|
|
Cow::Owned(decrypt_data_entry(&mut &bytes[..], key.ok_or(EncryptedEntryErrorKind::KeyNeeded)?, Some(Vec::with_capacity(bytes.len()))).now_or_never().unwrap()?)
|
|
},
|
|
})
|
|
}
|
|
|
|
/// Consume into the data object, decrypting it if needed.
|
|
pub fn into_data(self, key: Option<&AesKey>) -> Result<Data, EncryptedEntryError>
|
|
{
|
|
Ok(match self {
|
|
Self::Encrypted(bytes) => {
|
|
decrypt_data_entry(&mut &bytes[..], key.ok_or(EncryptedEntryErrorKind::KeyNeeded)?, Some(Vec::with_capacity(bytes.len()))).now_or_never().unwrap()?
|
|
},
|
|
Self::Unencrypted(data) => data,
|
|
})
|
|
}
|
|
}
|
|
|
|
bitflags! {
|
|
/// And additional metadata for values
|
|
#[derive(Serialize, Deserialize)]
|
|
struct Tags: u16
|
|
{
|
|
/// Default
|
|
const NONE = 0;
|
|
/// This value should be cloned on write unless specified elsewhere.
|
|
const COW = 1<<0;
|
|
/// This should not show up in searches.
|
|
const HIDDEN = 1<<1;
|
|
/// Versioning is enabled for this value.
|
|
///
|
|
/// When it is deleted, it should instead be moved away into a sperate entry.
|
|
const VERSIONED = 1<<2;
|
|
}
|
|
}
|
|
|
|
/// Information about a map entry.
|
|
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
|
|
pub struct Info
|
|
{
|
|
alt_name: Option<(String, String)>,
|
|
|
|
created: u64,
|
|
modified: u64,
|
|
|
|
tags: Tags,
|
|
|
|
/// Events to be emitted to `State` when this element does something.
|
|
///
|
|
/// Can be used for monitoring or logging and such.
|
|
hooks: event::Hooks,
|
|
|
|
owner: Option<Vec<user::EntityID>>, //starts as the user that created (i.e. same as `created_by`), or `None` if ownership is disabled
|
|
signed: Option<Vec<Signature>>,
|
|
|
|
perms: user::Permissions,
|
|
|
|
created_by: user::UserID,
|
|
log: Vec<event::InBandEvent>,
|
|
}
|
|
|
|
/// The root data containing map
|
|
#[derive(Debug, Clone, Serialize, Deserialize)]
|
|
pub struct Datamap
|
|
{
|
|
data: Arena<Atom>,
|
|
ident: HashMap<Identifier, Index>,
|
|
}
|
|
|
|
impl PartialEq for Datamap
|
|
{
|
|
fn eq(&self, other: &Self) -> bool
|
|
{
|
|
self.ident == other.ident && {
|
|
for (v1, v2) in self.ident.iter().map(|(_, v)| (self.data.get(*v), other.data.get(*v)))
|
|
{
|
|
if v1 != v2 {
|
|
return false;
|
|
}
|
|
}
|
|
true
|
|
}
|
|
}
|
|
}
|
|
|
|
/// A value in a datamap, contains the information about the value and the value itself.
|
|
///
|
|
/// May also contain previous versions of this atom.
|
|
///
|
|
/// # Note
|
|
/// `Atom` boxes most of itself. It's not needed to box `Atom` itself.
|
|
// Box these first two together, since they are hueg.
|
|
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
|
|
pub struct Atom(Box<(MaybeEncrypted, Info)>, Vec<Atom>);
|
|
|
|
/// An identifier for an item in a `Datamap`, or an item nested within many `Datamap`s.
|
|
#[derive(Debug, Clone, Ord, PartialOrd, Eq, PartialEq, Hash, Serialize, Deserialize)]
|
|
pub struct Identifier(String);
|
|
|
|
#[cfg(test)]
|
|
mod tests
|
|
{
|
|
#[test]
|
|
fn data_me_sync()
|
|
{
|
|
let data = super::Data::SI(-120);
|
|
let aes = super::aes::AesKey::generate().unwrap();
|
|
|
|
println!("Data: {:?}", data);
|
|
let enc = super::MaybeEncrypted::new_encrypted(data.clone(), &aes).expect("Couldn't encrypt");
|
|
println!("M/Enc: {:?}", enc);
|
|
let dec = enc.clone().into_unencrypted(Some(&aes)).expect("Couldn't decrypt");
|
|
println!("M/Dec: {:?}", dec);
|
|
let out = dec.into_data(Some(&aes)).unwrap();
|
|
|
|
assert_eq!(data, out);
|
|
}
|
|
}
|