weirdnet-net 0.4.0

Weirdnet networking: a libp2p node (TCP, QUIC, Noise, Yamux, mDNS, Kademlia, relays, hole punching, AutoNAT) carrying the application's own request and response types, signed key-exchange offers and answers with short codes, invitation tokens and links, sealed exchange messaging, node identities, user certificates and cards, under versioned identifier profiles.
Documentation
//! Signed peer records, withdrawals, the names server and key-only dialing.
use crate::names::*;
use crate::node::{Handler, Node, NodeConfig, RelayLimits};
use crate::user::{NodeCert, user_id};
use crate::{Keypair, Multiaddr, PeerId, WEIRDNET, now_ms};
use serde::{Deserialize, Serialize};
use std::sync::Arc;
use std::time::{Duration, Instant};

const HOUR: i64 = 3600 * 1000;

struct User {
    key: Keypair,
    id: String,
}

fn user() -> User {
    let key = Keypair::generate_ed25519();
    let id = user_id(&key.public());
    User { key, id }
}

fn cert(u: &User, node: &Keypair) -> NodeCert {
    WEIRDNET.certify(&u.key, &u.id, &node.public().to_peer_id().to_string(), "phone", now_ms() - 1000).unwrap()
}

fn record(u: &User, node: &Keypair, seq: u64) -> PeerRecord {
    let addr: Multiaddr = "/ip4/203.0.113.7/udp/4747/quic-v1".parse().unwrap();
    WEIRDNET.peer_record(node, &u.key.public(), &cert(u, node), &[addr], None, seq, now_ms(), HOUR).unwrap()
}

#[test]
fn records_verify_and_tampering_does_not() {
    let (u, n) = (user(), Keypair::generate_ed25519());
    let r = record(&u, &n, 1);
    let now = now_ms();
    assert_eq!(WEIRDNET.verify_record(&r, now).unwrap(), n.public().to_peer_id());
    assert!(r.addrs[0].ends_with(&format!("/p2p/{}", n.public().to_peer_id())));
    assert_eq!(WEIRDNET.record_key(&u.id).len(), 32);

    let mut t = r.clone();
    t.addrs.push(format!("/ip4/198.51.100.1/tcp/1/p2p/{}", n.public().to_peer_id()));
    assert!(WEIRDNET.verify_record(&t, now).is_err(), "an added address breaks the signature");
    let mut t = r.clone();
    t.seq += 1;
    assert!(WEIRDNET.verify_record(&t, now).is_err());
    assert!(WEIRDNET.verify_record(&r, r.expires).is_err(), "expired");

    // another user's key under this user's id
    let mut t = r.clone();
    t.user_key = user().key.public().encode_protobuf();
    assert!(WEIRDNET.verify_record(&t, now).is_err());
    // a revoked node
    let mut c = cert(&u, &n);
    let at = now_ms();
    c.revocation = Some(WEIRDNET.revoke(&u.key, &u.id, &c.peer_id, at).unwrap());
    c.revoked_at = Some(at);
    assert!(WEIRDNET.peer_record(&n, &u.key.public(), &c, &[], None, 2, now, HOUR).is_err());
    // a node another user certified
    let other = user();
    assert!(WEIRDNET.peer_record(&n, &u.key.public(), &cert(&other, &n), &[], None, 2, now, HOUR).is_err());
    // too long-lived, or a certificate for another node
    assert!(WEIRDNET.peer_record(&n, &u.key.public(), &cert(&u, &n), &[], None, 2, now, MAX_RECORD_TTL_MS + 1).is_err());
    assert!(WEIRDNET.peer_record(&Keypair::generate_ed25519(), &u.key.public(), &cert(&u, &n), &[], None, 2, now, HOUR).is_err());
    // an address of another node
    let stranger: Multiaddr = format!("/ip4/1.2.3.4/tcp/1/p2p/{}", PeerId::random()).parse().unwrap();
    let mut t = WEIRDNET.peer_record(&n, &u.key.public(), &cert(&u, &n), &[], None, 3, now, HOUR).unwrap();
    t.addrs = vec![stranger.to_string()];
    assert!(WEIRDNET.verify_record(&t, now).is_err());

    let e = Entry::Record(r.clone());
    assert_eq!(Entry::decode(&e.encode()).unwrap(), e);
    assert!(Entry::decode(&vec![b' '; MAX_ENTRY_BYTES + 1]).is_err());
}

#[test]
fn a_higher_seq_wins_and_withdrawals_hold_until_they_expire() {
    let (u, phone, laptop) = (user(), Keypair::generate_ed25519(), Keypair::generate_ed25519());
    let now = now_ms();
    let r1 = Entry::Record(record(&u, &phone, 10));
    let r2 = Entry::Record(record(&u, &laptop, 11));
    assert!(WEIRDNET.accept(None, &r1, now).is_ok());
    assert!(WEIRDNET.accept(Some(&r1), &r2, now).is_ok(), "the user's other device, later");
    assert!(WEIRDNET.accept(Some(&r2), &r1, now).is_err(), "lower seq");
    assert!(WEIRDNET.accept(Some(&r1), &r1, now).is_err(), "same seq");

    let w = WEIRDNET.withdrawal(&laptop, &u.key.public(), &cert(&u, &laptop), 12, now, MIN_WITHDRAWAL_TTL_MS).unwrap();
    let w = Entry::Withdrawn(w);
    assert!(WEIRDNET.accept(Some(&r2), &w, now).is_ok());
    assert!(WEIRDNET.accept(Some(&w), &r2, now).is_err(), "a stale republish can't bring it back");
    assert!(WEIRDNET.accept(Some(&w), &Entry::Record(record(&u, &phone, 13)), now).is_ok(), "re-hosting uses a higher seq");
    // once the withdrawal expired, it no longer blocks
    assert!(WEIRDNET.accept(Some(&w), &Entry::Record(record(&u, &phone, 5)), w.expires() + 1).is_err(), "and r expired too by then");
    // another user can't withdraw this user's record
    let mallory = user();
    let mw = WEIRDNET.withdrawal(&laptop, &mallory.key.public(), &cert(&mallory, &laptop), 99, now, MIN_WITHDRAWAL_TTL_MS).unwrap();
    assert!(WEIRDNET.accept(Some(&r2), &Entry::Withdrawn(mw), now).is_err());
    assert!(WEIRDNET.withdrawal(&laptop, &u.key.public(), &cert(&u, &laptop), 12, now, HOUR).is_err(), "too short-lived");

    match WEIRDNET.newest(&u.id, &[r1.clone(), r2.clone(), w.clone()], now) {
        Lookup::Withdrawn(x) => assert_eq!(x.seq, 12),
        other => panic!("{other:?}"),
    }
    match WEIRDNET.newest(&u.id, &[r1, r2], now) {
        Lookup::Found(x) => assert_eq!(x.seq, 11),
        other => panic!("{other:?}"),
    }
    assert_eq!(WEIRDNET.newest(&u.id, &[], now), Lookup::NotFound);
}

#[test]
fn name_bindings_round_trip() {
    let u = user();
    assert_eq!(binding_name("home.example.com."), "_weirdnet.home.example.com");
    assert_eq!(parse_binding(&binding_txt(&u.id)).unwrap(), u.id);
    assert_eq!(parse_binding(&format!("\"v=1 user={}\"", u.id)).unwrap(), u.id);
    assert!(parse_binding("v=2 user=00").is_err());
    assert!(parse_binding("v=1").is_err());
    assert!(parse_binding("v=1 user=NOTHEX").is_err());
}

#[test]
fn the_names_server_takes_only_a_nodes_own_record() {
    let (u, n) = (user(), Keypair::generate_ed25519());
    let store = MemoryNames::default();
    let e = Entry::Record(record(&u, &n, 1));
    let now = now_ms();
    assert!(matches!(serve(&WEIRDNET, &store, &PeerId::random(), NamesRequest::Register(Box::new(e.clone())), now), NamesResponse::Refused(_)));
    assert!(matches!(
        serve(&WEIRDNET, &store, &n.public().to_peer_id(), NamesRequest::Register(Box::new(e.clone())), now),
        NamesResponse::Registered
    ));
    match serve(&WEIRDNET, &store, &PeerId::random(), NamesRequest::Discover { user_id: u.id.clone() }, now) {
        NamesResponse::Found(Some(found)) => assert_eq!(*found, e),
        other => panic!("{other:?}"),
    }
    store.prune(e.expires() + 1);
    assert!(store.get(&u.id).is_none());
}

// over the in-memory transport

#[derive(Debug, Clone, Serialize, Deserialize)]
struct Hello(String);

struct Greeter;
impl Handler<Hello, Hello> for Greeter {
    fn request(&self, from: &PeerId, Hello(s): Hello) -> Hello {
        Hello(format!("hello {s} from {}", crate::short_peer_id(from)))
    }
}

fn mem(listen: bool) -> NodeConfig {
    NodeConfig { listen: if listen { vec!["/memory/0".parse().unwrap()] } else { vec![] }, memory: true, ..Default::default() }
}

fn wait(what: &str, mut f: impl FnMut() -> bool) {
    let deadline = Instant::now() + Duration::from_secs(20);
    while !f() {
        assert!(Instant::now() < deadline, "timed out: {what}");
        std::thread::sleep(Duration::from_millis(20));
    }
}

fn relay() -> (Node<Hello, Hello>, Multiaddr) {
    let cfg = NodeConfig { relay_server: true, relay_limits: RelayLimits::unlimited(), names_server: Some(Names::memory()), ..mem(true) };
    let r = Node::start(&WEIRDNET, Keypair::generate_ed25519(), cfg, Arc::new(Greeter)).unwrap();
    let a = r.reachable_addrs().into_iter().find(|a| a.starts_with("/memory/")).unwrap().parse().unwrap();
    (r, a)
}

/// A phone with no listener of its own: a reservation on the relay, its record there.
fn phone(u: &User, raddr: &Multiaddr, relay: PeerId) -> (Node<Hello, Hello>, Keypair, Multiaddr) {
    let key = Keypair::generate_ed25519();
    let cfg = NodeConfig { relays: vec![raddr.clone()], ..mem(false) };
    let b = Node::start(&WEIRDNET, key.clone(), cfg, Arc::new(Greeter)).unwrap();
    wait("reservation", || b.status().reservations.contains(&relay.to_string()));
    let circuit: Multiaddr = format!("{raddr}/p2p-circuit/p2p/{}", b.peer_id()).parse().unwrap();
    let _ = u;
    (b, key, circuit)
}

#[test]
fn a_phone_registers_on_its_home_relay_and_is_reached_by_user_id() {
    let (r, raddr) = relay();
    let u = user();
    let (b, bkey, circuit) = phone(&u, &raddr, r.peer_id());
    let rec = WEIRDNET.peer_record(&bkey, &u.key.public(), &cert(&u, &bkey), &[circuit], Some(&raddr), now_ms() as u64, now_ms(), HOUR).unwrap();
    assert_eq!(b.register_everywhere(&Entry::Record(rec.clone())), 1);

    // a stranger who knows only the user id and a names server
    let a = Node::start(&WEIRDNET, Keypair::generate_ed25519(), NodeConfig { names_servers: vec![raddr.clone()], ..mem(false) }, Arc::new(Greeter))
        .unwrap();
    match a.lookup(&u.id) {
        Lookup::Found(found) => assert_eq!(found, rec),
        other => panic!("{other:?}"),
    }
    let (peer, Hello(answer)) = a.request_user(&u.id, Hello("ann".into())).unwrap();
    assert_eq!(peer, b.peer_id());
    assert!(answer.starts_with("hello ann"));

    // withdrawn: the lookup says so
    let w = WEIRDNET.withdrawal(&bkey, &u.key.public(), &cert(&u, &bkey), rec.seq + 1, now_ms(), MIN_WITHDRAWAL_TTL_MS).unwrap();
    assert_eq!(b.register_everywhere(&Entry::Withdrawn(w)), 1);
    assert!(matches!(a.lookup(&u.id), Lookup::Withdrawn(_)));
    assert!(a.request_user(&u.id, Hello("ann".into())).is_err());
    // and the old record can't be registered again
    assert!(b.register(r.peer_id(), std::slice::from_ref(&raddr), Entry::Record(rec)).is_err());
}

#[test]
fn key_only_dialing_reaches_a_peer_through_a_shared_relay() {
    let (r, raddr) = relay();
    let u = user();
    let (b, _, _) = phone(&u, &raddr, r.peer_id());
    let a = Node::start(&WEIRDNET, Keypair::generate_ed25519(), NodeConfig { names_servers: vec![raddr.clone()], ..mem(false) }, Arc::new(Greeter))
        .unwrap();
    let Hello(answer) = a.request_key(b.peer_id(), Hello("by key".into())).unwrap();
    assert!(answer.starts_with("hello by key"));
}

#[test]
fn records_in_the_dht_are_checked_superseded_and_withdrawn() {
    let (r, raddr) = relay();
    let u = user();
    let boot = || NodeConfig { bootstrap: vec![raddr.clone()], ..mem(false) };
    let (bkey, ckey) = (Keypair::generate_ed25519(), Keypair::generate_ed25519());
    let b = Node::start(&WEIRDNET, bkey.clone(), boot(), Arc::new(Greeter)).unwrap();
    let c = Node::start(&WEIRDNET, ckey, boot(), Arc::new(Greeter)).unwrap();
    wait("bootstrap", || b.status().connected.contains(&r.peer_id().to_string()) && c.status().connected.contains(&r.peer_id().to_string()));

    let rec = record(&u, &bkey, 100);
    b.put_entry(Entry::Record(rec.clone())).unwrap();
    match WEIRDNET.newest(&u.id, &c.get_entries(&u.id).unwrap(), now_ms()) {
        Lookup::Found(found) => assert_eq!(found, rec),
        other => panic!("{other:?}"),
    }
    // a forged record (another node's key under this user) is refused by the storing node
    let mut forged = record(&u, &bkey, 200);
    forged.addrs = vec![format!("/ip4/6.6.6.6/tcp/1/p2p/{}", bkey.public().to_peer_id())];
    assert!(c.put_entry(Entry::Record(forged)).is_err(), "checked locally first");

    let w = WEIRDNET.withdrawal(&bkey, &u.key.public(), &cert(&u, &bkey), 101, now_ms(), MIN_WITHDRAWAL_TTL_MS).unwrap();
    b.put_entry(Entry::Withdrawn(w)).unwrap();
    assert!(matches!(WEIRDNET.newest(&u.id, &c.get_entries(&u.id).unwrap(), now_ms()), Lookup::Withdrawn(_)));
    assert!(matches!(c.lookup(&u.id), Lookup::Withdrawn(_)));
    // the relay, a storing node, holds the withdrawal: a stale republish is refused there,
    // so a node that never saw the record finds only the withdrawal
    let _ = c.put_entry(Entry::Record(rec));
    let d = Node::start(&WEIRDNET, Keypair::generate_ed25519(), boot(), Arc::new(Greeter)).unwrap();
    wait("bootstrap", || d.status().connected.contains(&r.peer_id().to_string()));
    let seen = d.get_entries(&u.id).unwrap();
    assert!(!seen.is_empty() && seen.iter().all(|e| e.seq() >= 101), "{seen:?}");
    assert!(matches!(d.lookup(&u.id), Lookup::Withdrawn(_)));
}

#[test]
fn a_node_can_bootstrap_from_and_reserve_on_the_same_relay() {
    let (r, raddr) = relay();
    let cfg = NodeConfig { relays: vec![raddr.clone()], bootstrap: vec![raddr.clone()], ..mem(false) };
    let b = Node::<Hello, Hello>::start(&WEIRDNET, Keypair::generate_ed25519(), cfg, Arc::new(Greeter)).unwrap();
    wait("reservation", || b.status().reservations.contains(&r.peer_id().to_string()));
}

#[test]
fn content_providers_are_found_in_the_dht() {
    let (r, raddr) = relay();
    let boot = || NodeConfig { bootstrap: vec![raddr.clone()], ..mem(false) };
    let b =
        Node::start(&WEIRDNET, Keypair::generate_ed25519(), NodeConfig { listen: vec!["/memory/0".parse().unwrap()], ..boot() }, Arc::new(Greeter))
            .unwrap();
    let c = Node::start(&WEIRDNET, Keypair::generate_ed25519(), boot(), Arc::new(Greeter)).unwrap();
    wait("bootstrap", || b.status().connected.contains(&r.peer_id().to_string()) && c.status().connected.contains(&r.peer_id().to_string()));
    use crate::content::{self, ChunkStore, MemoryStore};
    let store: Arc<dyn ChunkStore> = Arc::new(MemoryStore::default());
    let root = content::add_bytes(&*store, b"a public file").unwrap().root();
    let _srv = content::serve(&b, store, Arc::new(|_, _| true)).unwrap();
    let key = content::provider_key(&root);
    let mut found = vec![];
    wait("provider", || {
        let _ = b.provide(&key);
        found = c.providers(&key).unwrap_or_default();
        found.contains(&b.peer_id())
    });
    assert!(!found.contains(&c.peer_id()));
    assert!(c.providers(&content::provider_key(&[6u8; 32])).unwrap().is_empty());
    // a provider found by key alone is reachable by key alone
    let (_, st) = content::fetch(&c, &[found[0].into()], &root, Arc::new(MemoryStore::default())).unwrap();
    assert_eq!(st.chunks, 2);
}

#[test]
fn locator_records_seal_open_and_refuse_tampering() {
    use crate::locator::{self, LocatorKeys};
    let (u, n) = (user(), Keypair::generate_ed25519());
    let rec = record(&u, &n, 5);
    let now = now_ms();
    let lk = LocatorKeys::generate().unwrap();
    let l = lk.seal("garden-site", &rec, 1, now, now + HOUR).unwrap();
    l.verify(now).unwrap();
    assert_eq!(l.key().unwrap(), locator::dht_key(&lk.key.public(), locator::epoch_of(now)));
    let (site, got) = lk.open(&WEIRDNET, &l, now).unwrap();
    assert_eq!((site.as_str(), &got), ("garden-site", &rec));
    // nothing about the owner shows
    let raw = String::from_utf8(l.encode()).unwrap();
    assert!(!raw.contains(&u.id) && !raw.contains("garden") && !raw.contains("203.0.113.7"));
    // the keys change every day
    assert_ne!(locator::dht_key(&lk.key.public(), 1), locator::dht_key(&lk.key.public(), 2));
    assert_eq!(locator::lookup_keys(&lk.key.public(), now).len(), 2);

    // shared and restored
    let (k, s) = lk.to_bytes().unwrap();
    let again = LocatorKeys::from_bytes(&k, s).unwrap();
    assert!(again.open(&WEIRDNET, &l, now).is_ok());
    // a wrong secret or another locator cannot open it
    let wrong = LocatorKeys::from_bytes(&k, [9u8; 32]).unwrap();
    assert!(wrong.open(&WEIRDNET, &l, now).is_err());
    assert!(LocatorKeys::generate().unwrap().open(&WEIRDNET, &l, now).is_err());
    // tampering breaks the signature
    let mut t = l.clone();
    t.seq = 99;
    assert!(t.verify(now).is_err());
    // expiry is capped at the end of the day (plus grace) and old epochs are refused
    let long = lk.seal("s", &rec, 2, now, now + 10 * HOUR * 24).unwrap();
    assert!(long.expires <= (locator::epoch_of(now) as i64 + 1) * locator::EPOCH_MS + locator::EPOCH_GRACE_MS);
    assert!(l.verify(now + 3 * locator::EPOCH_MS).is_err());
    // storing nodes keep only a higher seq, under the right key
    let key = l.key().unwrap();
    locator::accept_locator(&key, None, &l, now).unwrap();
    assert!(locator::accept_locator(&key, Some(&long), &l, now).is_err());
    assert!(locator::accept_locator(&[0u8; 32], None, &l, now).is_err());
    assert_eq!(locator::newest_open(&lk, &WEIRDNET, &[l.clone(), long.clone()], now).unwrap().0, "s");
}

#[test]
fn locator_records_go_through_the_dht() {
    use crate::locator::LocatorKeys;
    let (r, raddr) = relay();
    let boot = || NodeConfig { bootstrap: vec![raddr.clone()], ..mem(false) };
    let (u, nkey) = (user(), Keypair::generate_ed25519());
    let b = Node::start(&WEIRDNET, nkey.clone(), boot(), Arc::new(Greeter)).unwrap();
    let c = Node::start(&WEIRDNET, Keypair::generate_ed25519(), boot(), Arc::new(Greeter)).unwrap();
    wait("bootstrap", || b.status().connected.contains(&r.peer_id().to_string()) && c.status().connected.contains(&r.peer_id().to_string()));
    let lk = LocatorKeys::generate().unwrap();
    let now = now_ms();
    let l = lk.seal("orchard", &record(&u, &nkey, 1), 1, now, now + HOUR).unwrap();
    b.put_locator(l.clone()).unwrap();
    let mut found = vec![];
    wait("locator", || {
        found = c.get_locators(&lk.key.public()).unwrap_or_default();
        !found.is_empty()
    });
    let (site, rec) = crate::locator::newest_open(&lk, &WEIRDNET, &found, now_ms()).unwrap();
    assert_eq!(site, "orchard");
    assert_eq!(rec.user_id, u.id);
    // an older seq is refused
    let older = lk.seal("orchard", &record(&u, &nkey, 1), 0, now, now + HOUR).unwrap();
    assert!(b.put_locator(older).is_err());
}

#[test]
fn a_trusted_peer_caches_the_newest_pushed_record() {
    use crate::names::{EntryCache, Lookup};
    let (u, n) = (user(), Keypair::generate_ed25519());
    let now = now_ms();
    let mut c = EntryCache::new(2);
    c.offer(&WEIRDNET, Entry::Record(record(&u, &n, 2)), now).unwrap();
    assert!(c.offer(&WEIRDNET, Entry::Record(record(&u, &n, 1)), now).is_err(), "older");
    let mut forged = record(&u, &n, 3);
    forged.addrs.push("/ip4/1.2.3.4/tcp/1".into());
    assert!(c.offer(&WEIRDNET, Entry::Record(forged), now).is_err(), "tampered");
    assert!(matches!(c.lookup(&WEIRDNET, &u.id, now), Lookup::Found(r) if r.seq == 2));
    for _ in 0..3 {
        let (v, m) = (user(), Keypair::generate_ed25519());
        c.offer(&WEIRDNET, Entry::Record(record(&v, &m, 1)), now).unwrap();
    }
    assert_eq!(c.len(), 2);
}