From 8f28533f31d6a7ee6368d444337dc8c5be691475 Mon Sep 17 00:00:00 2001 From: tv Date: Mon, 16 Nov 2026 18:45:59 +0000 Subject: federation: fixed bytes of events, versions, roots and sizes MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Vectors (`docs/federation-tests.md`, Fixed bytes) for a write and its signature and ID, the first version of two parties and its hash, the root it makes and its ID, a version event, an event whose value holds names that UTF-16 units sort otherwise than bytes, and events at federation 1's sizes and just past them: 256 KiB, 32 segments of 255 bytes, 64 nodes, integers to 2⁵³. Each value was computed apart from this code, by a script of its own: JCS by hand, Ed25519 by another library, and the signature's blob as OpenSSH's `PROTOCOL.sshsig` describes it, as `ssh-keygen -Y sign` makes it. Checking one against `ssh-keygen` itself is left to whoever has it at hand. --- src/federation/mod.rs | 2 + src/federation/vectors.rs | 125 ++++++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 127 insertions(+) create mode 100644 src/federation/vectors.rs (limited to 'src/federation') diff --git a/src/federation/mod.rs b/src/federation/mod.rs index 8f6f351..c3e4431 100644 --- a/src/federation/mod.rs +++ b/src/federation/mod.rs @@ -18,4 +18,6 @@ mod model; #[cfg(test)] mod properties; pub(crate) mod store; +#[cfg(test)] +mod vectors; pub(crate) mod version; diff --git a/src/federation/vectors.rs b/src/federation/vectors.rs new file mode 100644 index 0000000..8f2d57c --- /dev/null +++ b/src/federation/vectors.rs @@ -0,0 +1,125 @@ +//! The federation's fixed bytes (`docs/federation-tests.md`, Fixed bytes). Each was +//! computed apart from this code, by a script of its own: JCS written by hand, Ed25519 by +//! another library, the signature's blob as OpenSSH's `PROTOCOL.sshsig` describes it, as +//! `ssh-keygen -Y sign -n continuum-federation` makes it. A vector that changes is a +//! change of the federation, which takes its next number. + +use super::event::{self, Checkpoint, Event}; +use super::harness::{self, Party, Spec}; +use super::jcs::Json; +use super::store::Id; +use super::version::{self, Version}; + +/// A write by tv (keys from seeds: tv's of 1s, lass's of 2s), on the ID of +/// `a dependency`. +const WRITE: &str = r#"{"deps":["dce3d8e42443079366ace8c08adf3b2fa874d96c0cd82077784425f72009e4e2"],"key":"ssh-ed25519 AAAAC3NzaC1lZDI1NTE5AAAAIIqI4910CfGV/VLbLTy6XXLKZwm/HZQSG/N0iAG0D29c","party":"tv","sig":"U1NIU0lHAAAAAQAAADMAAAALc3NoLWVkMjU1MTkAAAAgiojj3XQJ8ZX9UtstPLpdcspnCb8dlBIb83SIAbQPb1wAAAAUY29udGludXVtLWZlZGVyYXRpb24AAAAAAAAABnNoYTUxMgAAAFMAAAALc3NoLWVkMjU1MTkAAABA/vW3yl3aMYoxZUQlMDKWni9/LHTNJazS/C24hA5U2tzcg7i45WzOahfdHSYnn8r+eyxckuhVWGiiZ2/QedwPDg==","write":{"path":"home/tv/laptop","value":"10.243.7.3"}}"#; +const WRITE_ID: &str = "fc0741fd5a5be1d3e58002b717591fde50de425a8450b725aca3cf33f81eda4f"; + +/// The first version for tv and lass, with tv's node (its key of 128s), a namespace each +/// and `names/r/wiki` lass's; and the root it makes. +const VERSION: &str = r#"{"changes":null,"federation":1,"keys":{"lass":{"keys":["ssh-ed25519 AAAAC3NzaC1lZDI1NTE5AAAAIIE5dw6ofRdfVqNUZsNMfszLjYqRtO43ol32D1uPybOU"],"since":0},"tv":{"keys":["ssh-ed25519 AAAAC3NzaC1lZDI1NTE5AAAAIIqI4910CfGV/VLbLTy6XXLKZwm/HZQSG/N0iAG0D29c"],"since":0}},"nodes":{"lass":{"nodes":[],"since":0},"tv":{"nodes":["continuum:e5687b6d11ccfb632abbafe844f8f1693d160aa582156ed66eea38ab5e7d1e12"],"since":0}},"number":0,"rules":[{"path":"home/{party}/**","writer":"{party}"},{"path":"names/r/wiki","writer":"lass"}]}"#; +const VERSION_HASH: &str = "33bba83de429c577d94eef5b6b3ec235a1bc8694fc834a86721ad67770ebd47f"; +const ROOT_ID: &str = "f65d862fb679df035b4c7bb5debfb69f5fbb89575fbf7f1ca87e4c5078799cd4"; + +/// A version event writing that version, on the root. +const VERSION_EVENT: &str = r#"{"deps":["f65d862fb679df035b4c7bb5debfb69f5fbb89575fbf7f1ca87e4c5078799cd4"],"version":"33bba83de429c577d94eef5b6b3ec235a1bc8694fc834a86721ad67770ebd47f"}"#; +const VERSION_EVENT_ID: &str = "b5bb686361a5657c7a549a05c14e588199069a2048c2ae8641cb60c8d76b6ed0"; + +/// A write by tv whose value holds two names that UTF-16 units sort otherwise than bytes: +/// U+E000 and U+10000. +const NAMES_ID: &str = "f19850573b605b3a640302bc68ef1755ff1954aede11e5e575fdd3d2def9c5a2"; + +fn tv() -> Party { + Party::new("tv", 1) +} + +fn first() -> Spec { + Spec::first( + &[&tv(), &Party::new("lass", 2)], + &[("names/r/wiki", harness::str("lass"))], + ) +} + +fn dep() -> Id { + Id::of(b"a dependency") +} + +#[test] +fn an_event_its_signature_and_its_id() { + let event = tv().write(&[dep()], "home/tv/laptop", harness::str("10.243.7.3")); + assert_eq!(String::from_utf8(event.clone()).expect("UTF-8"), WRITE); + assert_eq!(Id::of(&event).to_string(), WRITE_ID); + assert!(Event::read(WRITE.as_bytes()).is_some()); +} + +#[test] +fn a_version_its_hash_and_its_root() { + let spec = first(); + assert_eq!( + String::from_utf8(spec.json().bytes()).expect("UTF-8"), + VERSION + ); + assert_eq!(spec.hash().to_string(), VERSION_HASH); + let root = Checkpoint { + at: Vec::new(), + keeps: Vec::new(), + version: Version::read(&spec.json()).expect("a version"), + }; + assert_eq!(Id::of(&root.bytes()).to_string(), ROOT_ID); +} + +#[test] +fn a_version_event_and_its_id() { + let root = Id::from_hex(ROOT_ID).expect("an ID"); + let hash = Id::from_hex(VERSION_HASH).expect("a hash"); + let event = harness::version_event(&[root], hash); + assert_eq!( + String::from_utf8(event.clone()).expect("UTF-8"), + VERSION_EVENT + ); + assert_eq!(Id::of(&event).to_string(), VERSION_EVENT_ID); +} + +#[test] +fn names_in_the_order_of_their_utf16_units() { + let value = harness::object(vec![ + ("\u{e000}", Json::Int(1)), + ("\u{10000}", Json::Int(2)), + ]); + let event = tv().write(&[dep()], "home/tv/names", value); + assert_eq!(Id::of(&event).to_string(), NAMES_ID); +} + +#[test] +fn events_at_federation_1s_sizes_and_just_past_them() { + let tv = tv(); + // 256 KiB. + let base = tv.write(&[dep()], "home/tv/x", harness::str("")).len(); + let at = tv.write( + &[dep()], + "home/tv/x", + harness::str(&"x".repeat(event::LARGEST - base)), + ); + assert_eq!(at.len(), event::LARGEST); + assert!(Event::read(&at).is_some()); + let past = tv.write( + &[dep()], + "home/tv/x", + harness::str(&"x".repeat(event::LARGEST - base + 1)), + ); + assert!(Event::read(&past).is_none()); + // 32 segments of 255 bytes. + let segment = "s".repeat(version::SEGMENT_BYTES); + let path = |segments: usize| vec![segment.as_str(); segments].join("/"); + assert!(Event::read(&tv.write(&[dep()], &path(version::SEGMENTS), Json::Null)).is_some()); + assert!(Event::read(&tv.write(&[dep()], &path(version::SEGMENTS + 1), Json::Null)).is_none()); + let longer = format!("{segment}s"); + assert!(Event::read(&tv.write(&[dep()], &longer, Json::Null)).is_none()); + // 64 nodes. + let nodes: Vec = (0..=version::NODES as u8).map(harness::node_id).collect(); + assert!(Event::read(&tv.nodes(&[dep()], &nodes[..version::NODES])).is_some()); + assert!(Event::read(&tv.nodes(&[dep()], &nodes)).is_none()); + // Integers to 2⁵³. + let largest = Json::Int(super::jcs::LARGEST_INTEGER); + assert!(Event::read(&tv.write(&[dep()], "home/tv/n", largest)).is_some()); +} -- cgit v1.3.1