use crate::wire;
use anyhow::{Context, Result, anyhow, bail};
use iroh::{EndpointAddr, EndpointId, SecretKey, Signature};
use serde::{Deserialize, Serialize};
use std::collections::{BTreeMap, BTreeSet};
use std::path::Path;
const FILE: &str = "network.json";
const MAX_PER_SIGNER: usize = 256;
#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub enum Role {
Member,
Admin,
Owner,
}
#[derive(Clone, Debug, PartialEq, Eq)]
pub struct Member {
pub name: String,
pub role: Role,
pub addr: EndpointAddr,
}
#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)]
#[serde(tag = "kind", rename_all = "camelCase")]
pub enum Change {
Owner {
id: EndpointId,
name: String,
},
Admit {
id: EndpointId,
name: String,
},
Promote {
id: EndpointId,
},
Remove {
id: EndpointId,
cascade: bool,
},
Locate {
addr: EndpointAddr,
},
}
#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)]
pub struct Signed {
pub at: u64,
pub by: EndpointId,
pub change: Change,
pub sig: String,
}
impl Signed {
pub fn new(network: &EndpointId, key: &SecretKey, at: u64, change: Change) -> Self {
let by = key.public();
let sig = wire::hex(&key.sign(&body(network, &by, at, &change)).to_bytes());
Self { at, by, change, sig }
}
fn verifies(&self, network: &EndpointId) -> bool {
let Some(Ok(bytes)) = wire::unhex(&self.sig).map(<[u8; Signature::LENGTH]>::try_from) else { return false };
self.by.verify(&body(network, &self.by, self.at, &self.change), &Signature::from_bytes(&bytes)).is_ok()
}
}
fn body(network: &EndpointId, by: &EndpointId, at: u64, change: &Change) -> Vec<u8> {
serde_json::to_vec(&(network, by, at, change)).expect("a change always serializes")
}
#[derive(Clone, Debug, Serialize, Deserialize)]
pub struct Roster {
pub network: EndpointId,
log: BTreeSet<Signed>,
#[serde(skip)]
members: BTreeMap<EndpointId, Member>,
#[serde(skip)]
removed: BTreeSet<EndpointId>,
}
impl PartialEq for Roster {
fn eq(&self, other: &Self) -> bool {
self.network == other.network && self.log == other.log
}
}
impl Roster {
pub fn create(me: &SecretKey, name: String, addr: EndpointAddr, at: u64) -> (Self, SecretKey) {
let root = SecretKey::generate();
let network = root.public();
let mut roster = Self { network, log: BTreeSet::new(), members: BTreeMap::new(), removed: BTreeSet::new() };
roster.log.insert(Signed::new(&network, &root, at, Change::Owner { id: me.public(), name }));
roster.log.insert(Signed::new(&network, me, at, Change::Locate { addr }));
roster.rebuild();
(roster, root)
}
pub fn sign(&mut self, key: &SecretKey, at: u64, change: Change) -> Result<()> {
let entry = Signed::new(&self.network, key, at, change);
let before = self.clone();
self.log.insert(entry);
self.rebuild();
if self.members == before.members && self.removed == before.removed {
*self = before;
bail!("this computer isn't allowed to make that change");
}
Ok(())
}
pub fn members(&self) -> &BTreeMap<EndpointId, Member> {
&self.members
}
pub fn is_member(&self, id: &EndpointId) -> bool {
self.members.contains_key(id)
}
pub fn is_removed(&self, id: &EndpointId) -> bool {
self.removed.contains(id)
}
pub fn role(&self, id: &EndpointId) -> Option<Role> {
self.members.get(id).map(|m| m.role)
}
pub fn find(&self, name: &str) -> Option<EndpointId> {
let name = name.trim();
self.members
.iter()
.find(|(_, m)| m.name.eq_ignore_ascii_case(name))
.or_else(|| self.members.iter().find(|(id, _)| name.len() >= 6 && id.to_string().starts_with(name)))
.map(|(id, _)| *id)
}
pub fn name(&self, id: &EndpointId) -> String {
self.members.get(id).map_or_else(|| id.fmt_short().to_string(), |m| m.name.clone())
}
pub fn free_name(&self, name: &str, for_id: &EndpointId) -> String {
let taken = |n: &str| self.find(n).is_some_and(|id| id != *for_id);
if !taken(name) {
return name.into();
}
(2..=self.members.len() + 2).map(|n| format!("{name}-{n}")).find(|n| !taken(n)).expect("a number is free")
}
pub fn merge(&mut self, other: &Roster) -> bool {
if other.network != self.network {
return false;
}
let new: Vec<Signed> =
other.log.iter().filter(|e| !self.log.contains(e) && e.verifies(&self.network)).cloned().collect();
if new.is_empty() {
return false;
}
let before = self.log.clone();
self.log.extend(new);
self.rebuild();
self.log != before
}
fn rebuild(&mut self) {
let known = self.count();
if self.compact(&known) {
self.count();
}
}
fn compact(&mut self, known: &Known) -> bool {
let newest = newest_locations(&self.log);
let mut share: BTreeMap<EndpointId, usize> = BTreeMap::new();
let kept: BTreeSet<Signed> = self
.log
.iter()
.filter(|s| {
let counts = known.signers.contains(&s.by)
&& match &s.change {
Change::Owner { .. } => s.by == self.network,
Change::Locate { .. } => newest.get(&s.by).is_some_and(|(n, _)| *n == *s),
_ => known.deciders.contains(&s.by),
};
let n = share.entry(s.by).or_default();
*n += usize::from(counts);
counts && *n <= MAX_PER_SIGNER
})
.cloned()
.collect();
let changed = kept.len() != self.log.len();
self.log = kept;
changed
}
fn count(&mut self) -> Known {
let root = self.network;
let log: Vec<&Signed> = self.log.iter().collect();
let mut owners: Vec<(u64, EndpointId, String)> = log
.iter()
.filter(|s| s.by == root)
.filter_map(|s| match &s.change {
Change::Owner { id, name } => Some((s.at, *id, name.clone())),
_ => None,
})
.collect();
owners.sort();
let owner_at = |at: u64| owners.iter().rev().find(|(from, ..)| *from <= at).map(|(_, id, _)| *id);
let top = |by: &EndpointId, at: u64| *by == root || owner_at(at) == Some(*by);
let owner = owners.last().map(|(_, id, _)| *id);
let mut above = vec![root];
for (_, id, _) in owners.iter().rev() {
if !above.contains(id) {
above.push(*id);
}
}
let mut top_removed: BTreeMap<EndpointId, (u64, bool)> = BTreeMap::new();
for by in &above {
if top_removed.get(by).is_some_and(|&(_, cascade)| cascade) {
continue;
}
for s in log.iter().filter(|s| s.by == *by && top(&s.by, s.at)) {
if let Change::Remove { id, cascade } = &s.change
&& (s.by == root || (Some(*id) != owner_at(s.at) && Some(*id) != owner))
{
note_removal(&mut top_removed, *id, s.at, *cascade);
}
}
}
let top_voided = |by: &EndpointId| top_removed.get(by).is_some_and(|&(_, cascade)| cascade);
let mut promoted: BTreeMap<EndpointId, u64> = BTreeMap::new();
for s in &log {
if let Change::Promote { id } = &s.change
&& top(&s.by, s.at)
&& !top_voided(&s.by)
{
let at = promoted.entry(*id).or_insert(s.at);
*at = (*at).min(s.at);
}
}
let admin_at = |id: &EndpointId, at: u64| {
promoted.get(id).is_some_and(|&from| {
from <= at && top_removed.get(id).is_none_or(|&(until, cascade)| !cascade && at < until)
})
};
let mut removed = top_removed.clone();
for s in &log {
if let Change::Remove { id, cascade } = &s.change
&& admin_at(&s.by, s.at)
&& Some(*id) != owner_at(s.at)
&& !promoted.contains_key(id)
&& !top_removed.contains_key(id)
{
note_removal(&mut removed, *id, s.at, *cascade);
}
}
let voided = |by: &EndpointId| removed.get(by).is_some_and(|&(_, cascade)| cascade);
let may_admit = |s: &Signed| !voided(&s.by) && (top(&s.by, s.at) || admin_at(&s.by, s.at));
let mut admitted: BTreeMap<EndpointId, String> = BTreeMap::new();
for (_, id, name) in &owners {
admitted.entry(*id).or_insert_with(|| name.clone());
}
for s in &log {
if let Change::Admit { id, name } = &s.change
&& may_admit(s)
{
admitted.entry(*id).or_insert_with(|| name.clone());
}
}
let addrs = newest_locations(&self.log);
let tops = std::iter::once(root).chain(owners.iter().map(|(_, id, _)| *id));
let known = Known {
signers: tops.clone().chain(admitted.keys().copied()).collect(),
deciders: tops.chain(promoted.keys().copied()).collect(),
};
self.removed = removed.keys().copied().collect();
self.members = admitted
.into_iter()
.filter(|(id, _)| !self.removed.contains(id))
.map(|(id, name)| {
let role = if Some(id) == owner {
Role::Owner
} else if admin_at(&id, u64::MAX) {
Role::Admin
} else {
Role::Member
};
let addr = addrs.get(&id).map_or_else(|| EndpointAddr::new(id), |(_, a)| (*a).clone());
(id, Member { name, role, addr })
})
.collect();
known
}
#[must_use]
pub fn verified(mut self) -> Self {
let network = self.network;
self.log.retain(|s| s.verifies(&network));
self.rebuild();
self
}
pub fn load(dir: &Path) -> Result<Option<Self>> {
match std::fs::read(dir.join(FILE)) {
Ok(bytes) => {
let roster: Self = serde_json::from_slice(&bytes).context("network.json is damaged")?;
Ok(Some(roster.verified()))
}
Err(e) if e.kind() == std::io::ErrorKind::NotFound => Ok(None),
Err(e) => Err(e).context("couldn't read network.json"),
}
}
pub fn save(&self, dir: &Path) -> Result<()> {
let tmp = dir.join(format!("{FILE}.tmp"));
std::fs::write(&tmp, serde_json::to_vec_pretty(self)?)?;
std::fs::rename(&tmp, dir.join(FILE)).context("couldn't save network.json")
}
}
struct Known {
signers: BTreeSet<EndpointId>,
deciders: BTreeSet<EndpointId>,
}
fn newest_locations(log: &BTreeSet<Signed>) -> BTreeMap<EndpointId, (&Signed, &EndpointAddr)> {
let mut newest: BTreeMap<EndpointId, (&Signed, &EndpointAddr)> = BTreeMap::new();
for s in log {
if let Change::Locate { addr } = &s.change
&& addr.id == s.by
&& newest.get(&s.by).is_none_or(|(n, _)| s.at > n.at)
{
newest.insert(s.by, (s, addr));
}
}
newest
}
fn note_removal(removed: &mut BTreeMap<EndpointId, (u64, bool)>, id: EndpointId, at: u64, cascade: bool) {
let e = removed.entry(id).or_insert((at, cascade));
*e = (e.0.min(at), e.1 || cascade);
}
pub fn recovery_code(root: &SecretKey) -> String {
let hex = wire::hex(&root.to_bytes());
hex.as_bytes().chunks(8).map(|c| String::from_utf8_lossy(c).into_owned()).collect::<Vec<_>>().join("-")
}
pub fn root_from_code(code: &str) -> Result<SecretKey> {
let hex: String = code.chars().filter(char::is_ascii_hexdigit).collect();
let bytes: [u8; 32] = wire::unhex(&hex)
.and_then(|b| b.try_into().ok())
.ok_or_else(|| anyhow!("a recovery code is 64 hex characters"))?;
Ok(SecretKey::from_bytes(&bytes))
}
#[cfg(test)]
mod tests;