//! What a signed value says, read the one way every part of continuum reads it: a //! string `cv2...` (each base64url, unpadded), the value JSON, //! the meta JSON with exactly its fields, neither holding a newline, the signature //! decoding. A string that isn't one in every respect is a plain string, wherever it //! is read: the store's order and reads (`store`), the checks (`access::envelope`), the //! API. use base64::{Engine, engine::general_purpose::URL_SAFE_NO_PAD as B64URL}; use serde::{Deserialize, Serialize}; use serde_json::Value as JsonValue; /// What every envelope starts with. pub(crate) const START: &str = "cv2."; /// What a signed value says: its value, and its meta. #[derive(Debug, Clone, PartialEq)] pub(crate) struct Payload { pub(crate) value: JsonValue, /// The swarm it is for: one user, with the same name and key in two swarms, signs /// for one only. pub(crate) swarm: String, pub(crate) path: Vec, pub(crate) user: String, pub(crate) at: u64, /// One more than that of the envelope it replaces; 0 where it replaces none. pub(crate) seq: u64, pub(crate) prev: String, } /// An envelope's meta, as it is written: these fields, no other. #[derive(Serialize, Deserialize)] #[serde(deny_unknown_fields)] struct Meta { swarm: String, path: Vec, user: String, at: u64, seq: u64, prev: String, } impl Payload { /// The bytes its user signs: the value, a newline, the meta. #[cfg(test)] pub(crate) fn signed(&self) -> Vec { let meta = Meta { swarm: self.swarm.clone(), path: self.path.clone(), user: self.user.clone(), at: self.at, seq: self.seq, prev: self.prev.clone(), }; let mut bytes = serde_json::to_vec(&self.value).expect("a value is JSON"); bytes.push(b'\n'); bytes.extend(serde_json::to_vec(&meta).expect("a meta is JSON")); bytes } } /// An envelope opened, unchecked: the bytes signed, what it says, the signature's blob. pub(crate) struct Opened { pub(crate) signed: Vec, pub(crate) payload: Payload, pub(crate) signature: Vec, } /// `text` opened as an envelope, unchecked; why not, if it isn't one. pub(crate) fn open(text: &str) -> Result { let not_one = || "not a signed value (cv2...)".to_owned(); let mut parts = text.strip_prefix(START).ok_or_else(not_one)?.split('.'); let (Some(value), Some(meta), Some(signature), None) = (parts.next(), parts.next(), parts.next(), parts.next()) else { return Err(not_one()); }; let decoded = |part: &str, what: &str| { let bytes = B64URL .decode(part) .map_err(|error| format!("its {what} doesn't decode: {error}"))?; // One line each: the bytes signed part at the one newline between them. if bytes.contains(&b'\n') { return Err(format!("its {what} holds a newline")); } Ok(bytes) }; let mut signed = decoded(value, "value")?; let value: JsonValue = serde_json::from_slice(&signed) .map_err(|error| format!("its value isn't JSON: {error}"))?; let meta = decoded(meta, "meta")?; let Meta { swarm, path, user, at, seq, prev, } = serde_json::from_slice(&meta).map_err(|error| format!("its meta isn't one: {error}"))?; signed.push(b'\n'); signed.extend(meta); let signature = B64URL .decode(signature) .map_err(|error| format!("its signature doesn't decode: {error}"))?; let payload = Payload { value, swarm, path, user, at, seq, prev, }; Ok(Opened { signed, payload, signature, }) } /// What `text` says, if it is an envelope. pub(crate) fn read(text: &str) -> Option { open(text).ok().map(|opened| opened.payload) } #[cfg(test)] mod tests { use super::*; use serde_json::json; fn envelope(value: &str, meta: &str, signature: &str) -> String { format!( "{START}{}.{}.{}", B64URL.encode(value), B64URL.encode(meta), B64URL.encode(signature) ) } const META: &str = r#"{"swarm":"s","path":["a"],"user":"alice","at":1,"seq":2,"prev":""}"#; /// One reading: what isn't an envelope in every respect is none. #[test] fn what_an_envelope_is() { let good = envelope("1", META, "sig"); let payload = read(&good).unwrap(); assert_eq!(payload.value, json!(1)); assert_eq!(payload.seq, 2); for not_one in [ // A meta short of its fields, or with one more. envelope("1", r#"{"seq":2}"#, "sig"), envelope( "1", r#"{"swarm":"s","path":["a"],"user":"alice","at":1,"seq":2,"prev":"","more":1}"#, "sig", ), // A field twice. envelope( "1", r#"{"swarm":"s","path":["a"],"user":"alice","at":1,"seq":2,"seq":3,"prev":""}"#, "sig", ), // A fifth part, a value that isn't JSON, a newline, another prefix. format!("{good}.more"), envelope("not json", META, "sig"), envelope("1\n", META, "sig"), good.replacen("cv2.", "cv1.", 1), ] { assert!(read(¬_one).is_none(), "{not_one}"); } } }