Provide named VIPs with independent protocol/port listeners and node/port backends so applications can use one DNS endpoint without a separate load balancer. Every authenticated member may create, edit or delete any service. Client agents select the eligible backend with the lowest measured encrypted data-plane RTT, including relayed paths, and pin existing flows. UDP recovers on another backend after failure; established TCP is never replayed or moved. An unanswered empty TCP SYN may retry another backend before establishment. Keep signed multi-writer field registers in state/vip.rs. Independent backend edits merge, same-field conflicts use Lamport/author/canonical ordering, and listener generations prevent old backend entries returning on port recreation. Permanent service tombstones protect replay while allowing obsolete fields to be compacted. Active-service and deletion-history limits are separate. Commit complete snapshots and the author's durable counter atomically before local routing changes or publication. Restore counters from newer genuine author updates learned from replicas after an old backup is restored. Implement bounded client-side address/port NAT at overlay ingress and reverse translation only after authenticated source/destination admission. Reserve OS source ports to avoid direct-flow collisions and quarantine retired ports for late replies. Handle a backend on the client itself, scoped fragment assembly, checksums, re-fragmentation and quoted ICMP/PMTU headers. Plugins and encrypted transit retain their existing contracts. Data-path probes measure RTT; bounded fair TCP connect checks are enabled by default and configurable per listener. Arbitrary UDP application readiness remains unknown; path checks and explicit port errors drive eligibility without protocol-specific probe payloads. Expose the shared draft API through local IPC, simple vip/listener/backend CLI commands, JSON, editor-based atomic updates and watch output. Add a VIP button on each network tile and a separate tray editor. Edits and removals stay local until Save; stale revisions retain the draft, and closing a dirty window offers explicit discard. Report local routing choices, health reasons, RTT age, active and draining bindings, IP counters, rates, drops and UDP failovers. Extend DNS with service names; keep numeric addresses secondary and preserve existing bindings while VIP addresses or listeners change. This changes control wire ALPN/version to tsunagi/ctrl/8 and local IPC to 22; all members and local clients must upgrade together. Data ALPN remains 5. SQLite schema 10 migrates existing mandatory state without changing identity, secrets, network ids, derivation labels, handshake encoding or node records. Crate versions and release tags are unchanged. No installed agent or tray was replaced. Commands, limits and operational semantics are in docs/vip.md. Checks on Linux in nix develop: - cargo fmt --all -- --check - cargo clippy --locked --workspace --all-targets -- -D warnings - cargo test --locked --workspace --all-targets: 559 passed, 3 ignored - git diff --cached --check The full suite includes real encrypted TCP/UDP VIP traffic, backend-stop UDP failover, real loopback TCP check recovery, source admission, signed merges, stale/deleted state, SQLite migration and rollback, restart/author recovery, network isolation, actual CLI/DNS processes, and headless text-entry/Save-button interaction. Discovery and memory TUNs are the existing test substitutions; authentication, transport, encryption and SQLite remain real. Initial checks outside Nix failed for missing GTK pkg-config metadata, and an initial CLI test inherited TSUNAGI_CONTROL_SOCKET. Final checks use the Nix environment with that variable unset so tests address their temporary sockets. Root/internet-dependent tests remain ignored. No live host TUN, native desktop session, macOS or Windows validation was performed.
1468 lines
59 KiB
Rust
1468 lines
59 KiB
Rust
//! The mandatory state store, `state.sqlite`.
|
|
//!
|
|
//! Holds the persistent device identity, configured networks (including their
|
|
//! shared secrets, which are needed to re-derive keys after a restart), the
|
|
//! stored hostname and auto-start flags.
|
|
//!
|
|
//! Corruption is reported, never silently repaired: a damaged state store must
|
|
//! not quietly turn into a brand new identity.
|
|
//!
|
|
//! Future work will add per-author record versions, accepted signed states and
|
|
//! revocations here. When that lands, writing an event and bumping the author's
|
|
//! own counter must happen in one SQLite transaction *before* the change is
|
|
//! published to the network.
|
|
|
|
use std::path::{Path, PathBuf};
|
|
|
|
use rusqlite::{Connection, OptionalExtension, params};
|
|
|
|
use crate::error::{Error, Result};
|
|
use crate::identity::{DeviceIdentity, NetworkId, NetworkName, NetworkSecret};
|
|
use crate::state::{MAX_RETIREMENT_LEN, RecordBody, SignedRecord, SignedRetirement};
|
|
|
|
/// Schema version written by this build.
|
|
pub const SCHEMA_VERSION: i64 = 10;
|
|
|
|
/// Key of the stored hostname setting.
|
|
const SETTING_HOSTNAME: &str = "hostname";
|
|
|
|
/// A network as persisted in the state store.
|
|
///
|
|
/// The secret is held in a [`NetworkSecret`], which redacts itself from `Debug`
|
|
/// and zeroizes on drop.
|
|
#[derive(Debug, Clone)]
|
|
pub struct StoredNetwork {
|
|
/// Ordered local protocol override; absent inherits the agent's defaults.
|
|
pub protocols: Option<Vec<String>>,
|
|
/// Derived public network identifier.
|
|
pub network_id: NetworkId,
|
|
/// Network name.
|
|
pub name: NetworkName,
|
|
/// Shared secret, needed to re-derive keys after restart.
|
|
pub secret: NetworkSecret,
|
|
/// Whether the network is activated automatically at agent startup.
|
|
pub auto_start: bool,
|
|
/// Local broadcast participation, enabled unless explicitly disabled.
|
|
pub broadcast: bool,
|
|
/// This agent offers itself as an exit node here. Off unless turned on.
|
|
pub exit_node: bool,
|
|
/// The member this device sends all its internet traffic through, if any.
|
|
pub exit_via: Option<[u8; 32]>,
|
|
}
|
|
|
|
/// The mandatory state store.
|
|
#[derive(Debug)]
|
|
pub struct StateStore {
|
|
conn: Connection,
|
|
path: PathBuf,
|
|
}
|
|
|
|
impl StateStore {
|
|
/// Opens (creating if absent) the state store at `path`.
|
|
///
|
|
/// Returns [`Error::StateCorrupted`] if the file exists but is not a usable
|
|
/// database. The file is never deleted or recreated by this function.
|
|
pub fn open(path: impl AsRef<Path>) -> Result<Self> {
|
|
let path = path.as_ref().to_path_buf();
|
|
let existed = path.exists();
|
|
// The database file is created on demand, so the directory holding
|
|
// it has to be too — with the same restricted permissions the agent
|
|
// would have given it, never looser.
|
|
if let Some(parent) = path.parent()
|
|
&& !parent.as_os_str().is_empty()
|
|
{
|
|
super::create_dir(parent)?;
|
|
}
|
|
let conn = Connection::open(&path).map_err(|err| Error::StateCorrupted {
|
|
path: path.clone(),
|
|
reason: format!("cannot open database: {err}"),
|
|
})?;
|
|
|
|
super::restrict_path_permissions(&path)?;
|
|
super::apply_common_pragmas(&conn).map_err(|err| Error::StateCorrupted {
|
|
path: path.clone(),
|
|
reason: format!("cannot configure database: {err}"),
|
|
})?;
|
|
|
|
if existed {
|
|
let integrity: String = conn
|
|
.query_row("PRAGMA integrity_check", [], |row| row.get(0))
|
|
.map_err(|err| Error::StateCorrupted {
|
|
path: path.clone(),
|
|
reason: format!("integrity check failed: {err}"),
|
|
})?;
|
|
if integrity != "ok" {
|
|
return Err(Error::StateCorrupted {
|
|
path,
|
|
reason: format!("integrity check reported: {integrity}"),
|
|
});
|
|
}
|
|
}
|
|
|
|
let store = Self { conn, path };
|
|
store.migrate()?;
|
|
Ok(store)
|
|
}
|
|
|
|
/// Path of the underlying file.
|
|
pub fn path(&self) -> &Path {
|
|
&self.path
|
|
}
|
|
|
|
fn corrupt(&self, reason: impl std::fmt::Display) -> Error {
|
|
Error::StateCorrupted {
|
|
path: self.path.clone(),
|
|
reason: reason.to_string(),
|
|
}
|
|
}
|
|
|
|
fn migrate(&self) -> Result<()> {
|
|
let found: i64 = self
|
|
.conn
|
|
.query_row("PRAGMA user_version", [], |row| row.get(0))
|
|
.map_err(|err| self.corrupt(format!("cannot read schema version: {err}")))?;
|
|
|
|
if found > SCHEMA_VERSION {
|
|
return Err(Error::UnsupportedSchema {
|
|
found,
|
|
supported: SCHEMA_VERSION,
|
|
});
|
|
}
|
|
if found == SCHEMA_VERSION {
|
|
return self.verify_shape();
|
|
}
|
|
|
|
// Migration 2 -> 3: the record body gained a hostname, which changed
|
|
// the signing domain, and the version counter gained an author.
|
|
//
|
|
// The stored records are discarded rather than carried over. They
|
|
// were signed under a domain that no longer verifies, so keeping them
|
|
// would mean holding rows that every read has to reject — and one of
|
|
// those rejections could be mistaken for corruption. Each member
|
|
// re-publishes its claim on the next run, which is the one thing here
|
|
// that repairs itself.
|
|
if (2..3).contains(&found) {
|
|
self.conn
|
|
.execute_batch(
|
|
"BEGIN;
|
|
DROP TABLE IF EXISTS signed_records;
|
|
DROP TABLE IF EXISTS own_record_version;
|
|
COMMIT;",
|
|
)
|
|
.map_err(|err| self.corrupt(format!("cannot migrate schema to 3: {err}")))?;
|
|
self.conn
|
|
.execute_batch(SIGNED_RECORDS_SCHEMA)
|
|
.map_err(|err| self.corrupt(format!("cannot migrate schema to 3: {err}")))?;
|
|
}
|
|
|
|
// Migration 1 -> 2: signed records that outlive a session.
|
|
if (1..2).contains(&found) {
|
|
self.conn
|
|
.execute_batch(SIGNED_RECORDS_SCHEMA)
|
|
.map_err(|err| self.corrupt(format!("cannot migrate schema to 2: {err}")))?;
|
|
}
|
|
|
|
// Migration 0 -> 1: initial schema.
|
|
if found < 1 {
|
|
self.conn
|
|
.execute_batch(
|
|
"BEGIN;
|
|
CREATE TABLE device_identity (
|
|
id INTEGER PRIMARY KEY CHECK (id = 1),
|
|
secret_key BLOB NOT NULL,
|
|
created_at INTEGER NOT NULL
|
|
);
|
|
CREATE TABLE networks (
|
|
network_id BLOB PRIMARY KEY,
|
|
name TEXT NOT NULL,
|
|
secret BLOB NOT NULL,
|
|
auto_start INTEGER NOT NULL DEFAULT 1,
|
|
created_at INTEGER NOT NULL
|
|
);
|
|
CREATE TABLE settings (
|
|
key TEXT PRIMARY KEY,
|
|
value TEXT NOT NULL
|
|
);
|
|
PRAGMA user_version = 1;
|
|
COMMIT;",
|
|
)
|
|
.map_err(|err| self.corrupt(format!("cannot create schema: {err}")))?;
|
|
self.conn
|
|
.execute_batch(SIGNED_RECORDS_SCHEMA)
|
|
.map_err(|err| self.corrupt(format!("cannot create schema: {err}")))?;
|
|
}
|
|
if found < 4 {
|
|
self.conn.execute_batch("BEGIN;
|
|
ALTER TABLE networks ADD COLUMN broadcast INTEGER NOT NULL DEFAULT 1 CHECK (broadcast IN (0,1));
|
|
PRAGMA user_version = 4;
|
|
COMMIT;").map_err(|err| self.corrupt(format!("cannot migrate schema to 4: {err}")))?;
|
|
}
|
|
if found < 5 {
|
|
self.conn
|
|
.execute_batch(
|
|
"BEGIN;
|
|
CREATE TABLE IF NOT EXISTS peer_hostnames (
|
|
network_id BLOB NOT NULL,
|
|
endpoint_id BLOB NOT NULL,
|
|
hostname TEXT NOT NULL,
|
|
PRIMARY KEY (network_id, endpoint_id)
|
|
);
|
|
PRAGMA user_version = 5;
|
|
COMMIT;",
|
|
)
|
|
.map_err(|err| self.corrupt(format!("cannot migrate schema to 5: {err}")))?;
|
|
}
|
|
if found < 6 {
|
|
self.conn
|
|
.execute_batch(
|
|
"BEGIN;
|
|
ALTER TABLE networks ADD COLUMN exit_node INTEGER NOT NULL DEFAULT 0 CHECK (exit_node IN (0,1));
|
|
ALTER TABLE networks ADD COLUMN exit_via BLOB;
|
|
PRAGMA user_version = 6;
|
|
COMMIT;",
|
|
)
|
|
.map_err(|err| self.corrupt(format!("cannot migrate schema to 6: {err}")))?;
|
|
}
|
|
// Migration 6 -> 7: a claim gained the time its hostname was first
|
|
// claimed, which changed the signing domain. Records signed before
|
|
// no longer verify, so they are discarded rather than kept as rows
|
|
// every read has to reject; each member re-publishes its own claim on
|
|
// its next run and the others arrive again from their authors. The
|
|
// version counter is kept, so nothing is ever published twice at one
|
|
// version.
|
|
if found < 7 {
|
|
self.conn
|
|
.execute_batch(
|
|
"BEGIN;
|
|
DELETE FROM signed_records;
|
|
PRAGMA user_version = 7;
|
|
COMMIT;",
|
|
)
|
|
.map_err(|err| self.corrupt(format!("cannot migrate schema to 7: {err}")))?;
|
|
}
|
|
if found < 8 {
|
|
self.conn
|
|
.execute_batch(
|
|
"BEGIN;
|
|
ALTER TABLE networks ADD COLUMN protocols TEXT;
|
|
PRAGMA user_version = 8;
|
|
COMMIT;",
|
|
)
|
|
.map_err(|err| self.corrupt(format!("cannot migrate schema to 8: {err}")))?;
|
|
}
|
|
if found < 9 {
|
|
self.conn
|
|
.execute_batch(
|
|
"BEGIN;
|
|
CREATE TABLE IF NOT EXISTS retirements (
|
|
network_id BLOB NOT NULL, target BLOB NOT NULL, data BLOB NOT NULL,
|
|
PRIMARY KEY (network_id, target)
|
|
);
|
|
PRAGMA user_version = 9;
|
|
COMMIT;",
|
|
)
|
|
.map_err(|err| self.corrupt(format!("cannot migrate schema to 9: {err}")))?;
|
|
}
|
|
if found < 10 {
|
|
self.conn.execute_batch("BEGIN; CREATE TABLE IF NOT EXISTS vip_fields (
|
|
network_id BLOB NOT NULL, vip TEXT NOT NULL, field TEXT NOT NULL, data BLOB NOT NULL,
|
|
PRIMARY KEY(network_id, vip, field)); PRAGMA user_version = 10; COMMIT;")
|
|
.map_err(|err| self.corrupt(format!("cannot migrate VIP state: {err}")))?;
|
|
}
|
|
Ok(())
|
|
}
|
|
|
|
/// Confirms the expected tables exist, so that a truncated or foreign
|
|
/// database is reported rather than used.
|
|
fn verify_shape(&self) -> Result<()> {
|
|
for table in [
|
|
"device_identity",
|
|
"networks",
|
|
"settings",
|
|
"signed_records",
|
|
"peer_hostnames",
|
|
"retirements",
|
|
"vip_fields",
|
|
] {
|
|
let present: Option<String> = self
|
|
.conn
|
|
.query_row(
|
|
"SELECT name FROM sqlite_master WHERE type = 'table' AND name = ?1",
|
|
params![table],
|
|
|row| row.get(0),
|
|
)
|
|
.optional()
|
|
.map_err(|err| self.corrupt(format!("cannot inspect schema: {err}")))?;
|
|
if present.is_none() {
|
|
return Err(self.corrupt(format!("table `{table}` is missing")));
|
|
}
|
|
}
|
|
Ok(())
|
|
}
|
|
|
|
/// Loads the stored device identity, if there is one.
|
|
///
|
|
/// Reads and never writes, so asking who this device is does not decide
|
|
/// it. A store that has never run an agent has no identity yet, which is
|
|
/// `None` rather than an error.
|
|
///
|
|
/// A stored key of the wrong length is a corruption error, never a reason
|
|
/// to silently mint a new identity.
|
|
pub fn device_identity(&self) -> Result<Option<DeviceIdentity>> {
|
|
let stored: Option<Vec<u8>> = self
|
|
.conn
|
|
.query_row(
|
|
"SELECT secret_key FROM device_identity WHERE id = 1",
|
|
[],
|
|
|row| row.get(0),
|
|
)
|
|
.optional()
|
|
.map_err(|err| self.corrupt(format!("cannot read device identity: {err}")))?;
|
|
|
|
let Some(bytes) = stored else {
|
|
return Ok(None);
|
|
};
|
|
let bytes: [u8; 32] = bytes.as_slice().try_into().map_err(|_| {
|
|
self.corrupt(format!(
|
|
"stored device key has {} bytes, expected 32; refusing to replace it",
|
|
bytes.len()
|
|
))
|
|
})?;
|
|
Ok(Some(DeviceIdentity::from_secret_bytes(&bytes)))
|
|
}
|
|
|
|
/// Loads the stored device identity, creating one on first use.
|
|
pub fn load_or_create_device_identity(&self) -> Result<DeviceIdentity> {
|
|
if let Some(identity) = self.device_identity()? {
|
|
return Ok(identity);
|
|
}
|
|
|
|
let identity = DeviceIdentity::generate();
|
|
self.conn
|
|
.execute(
|
|
"INSERT INTO device_identity (id, secret_key, created_at) VALUES (1, ?1, ?2)",
|
|
params![identity.secret_bytes().as_slice(), now_unix()],
|
|
)
|
|
.map_err(|err| self.corrupt(format!("cannot store device identity: {err}")))?;
|
|
Ok(identity)
|
|
}
|
|
|
|
/// Replaces the device identity, giving up what the outgoing key held.
|
|
///
|
|
/// A device key is the author of every record this agent has signed, so
|
|
/// replacing it makes this a different member. The addresses and names
|
|
/// the old key claimed would otherwise stay reserved to a key nobody
|
|
/// holds, and nothing could ever free them — there is no way to sign on
|
|
/// another author's behalf, and by design there is no authority that
|
|
/// could overrule one.
|
|
///
|
|
/// So the outgoing key signs a release for every network on its way out.
|
|
/// That is the revocation: a positive statement, merged like any other,
|
|
/// which frees the address and the name for whoever wants them next.
|
|
///
|
|
/// All of it commits together. A crash part way through must not leave an
|
|
/// identity that has already been replaced beside releases that were
|
|
/// never written, because the old key would then be gone and unable to
|
|
/// sign them.
|
|
///
|
|
/// Returns the new identity and the networks a release was signed for.
|
|
pub fn rotate_device_identity(&self) -> Result<(DeviceIdentity, Vec<NetworkId>)> {
|
|
let outgoing = self.device_identity()?;
|
|
let networks = self.list_networks()?;
|
|
let replacement = DeviceIdentity::generate();
|
|
|
|
let transaction = self
|
|
.conn
|
|
.unchecked_transaction()
|
|
.map_err(|err| Error::Storage(format!("cannot begin a transaction: {err}")))?;
|
|
|
|
let mut released = Vec::new();
|
|
if let Some(outgoing) = &outgoing {
|
|
let author = outgoing.endpoint_id();
|
|
let signing = outgoing.signing_key();
|
|
for network in &networks {
|
|
let previous: Option<i64> = transaction
|
|
.query_row(
|
|
"SELECT version FROM own_record_version
|
|
WHERE network_id = ?1 AND author = ?2",
|
|
params![
|
|
network.network_id.as_bytes().as_slice(),
|
|
author.as_bytes().as_slice()
|
|
],
|
|
|row| row.get(0),
|
|
)
|
|
.optional()
|
|
.map_err(|err| Error::Storage(format!("cannot read our version: {err}")))?;
|
|
// A key that never published anything has nothing to give up.
|
|
let Some(previous) = previous else { continue };
|
|
|
|
let version = (previous.max(0) as u64).saturating_add(1);
|
|
let record =
|
|
SignedRecord::sign(&signing, network.network_id, version, RecordBody::Release);
|
|
let body = postcard::to_stdvec(&record.body)
|
|
.map_err(|err| Error::Storage(format!("cannot encode a record body: {err}")))?;
|
|
transaction
|
|
.execute(
|
|
"INSERT INTO signed_records (network_id, author, version, body, signature)
|
|
VALUES (?1, ?2, ?3, ?4, ?5)
|
|
ON CONFLICT(network_id, author) DO UPDATE SET
|
|
version = excluded.version,
|
|
body = excluded.body,
|
|
signature = excluded.signature",
|
|
params![
|
|
record.network.as_slice(),
|
|
record.author.as_slice(),
|
|
record.version as i64,
|
|
body,
|
|
record.signature
|
|
],
|
|
)
|
|
.map_err(|err| Error::Storage(format!("cannot store a release: {err}")))?;
|
|
transaction
|
|
.execute(
|
|
"INSERT INTO own_record_version (network_id, author, version)
|
|
VALUES (?1, ?2, ?3)
|
|
ON CONFLICT(network_id, author) DO UPDATE SET
|
|
version = max(version, excluded.version)",
|
|
params![
|
|
record.network.as_slice(),
|
|
record.author.as_slice(),
|
|
record.version as i64
|
|
],
|
|
)
|
|
.map_err(|err| Error::Storage(format!("cannot store our version: {err}")))?;
|
|
released.push(network.network_id);
|
|
}
|
|
}
|
|
|
|
transaction
|
|
.execute(
|
|
"INSERT INTO device_identity (id, secret_key, created_at) VALUES (1, ?1, ?2)
|
|
ON CONFLICT(id) DO UPDATE SET
|
|
secret_key = excluded.secret_key,
|
|
created_at = excluded.created_at",
|
|
params![replacement.secret_bytes().as_slice(), now_unix()],
|
|
)
|
|
.map_err(|err| Error::Storage(format!("cannot store the new identity: {err}")))?;
|
|
|
|
transaction
|
|
.commit()
|
|
.map_err(|err| Error::Storage(format!("cannot commit the new identity: {err}")))?;
|
|
Ok((replacement, released))
|
|
}
|
|
|
|
/// Inserts or updates a network configuration.
|
|
pub fn upsert_network(
|
|
&self,
|
|
network_id: NetworkId,
|
|
name: &NetworkName,
|
|
secret: &NetworkSecret,
|
|
auto_start: bool,
|
|
) -> Result<()> {
|
|
self.conn
|
|
.execute(
|
|
"INSERT INTO networks (network_id, name, secret, auto_start, created_at)
|
|
VALUES (?1, ?2, ?3, ?4, ?5)
|
|
ON CONFLICT(network_id) DO UPDATE SET
|
|
name = excluded.name,
|
|
secret = excluded.secret,
|
|
auto_start = excluded.auto_start",
|
|
params![
|
|
network_id.as_bytes().as_slice(),
|
|
name.as_str(),
|
|
secret.expose(),
|
|
auto_start as i64,
|
|
now_unix()
|
|
],
|
|
)
|
|
.map_err(|err| Error::Storage(format!("cannot store network: {err}")))?;
|
|
Ok(())
|
|
}
|
|
|
|
/// Sets the auto-start flag of a configured network.
|
|
pub fn set_auto_start(&self, network_id: NetworkId, auto_start: bool) -> Result<()> {
|
|
let changed = self
|
|
.conn
|
|
.execute(
|
|
"UPDATE networks SET auto_start = ?2 WHERE network_id = ?1",
|
|
params![network_id.as_bytes().as_slice(), auto_start as i64],
|
|
)
|
|
.map_err(|err| Error::Storage(format!("cannot update network: {err}")))?;
|
|
if changed == 0 {
|
|
return Err(Error::NetworkUnknown(network_id));
|
|
}
|
|
Ok(())
|
|
}
|
|
|
|
/// Saves local participation without changing identity, membership or auto-start.
|
|
pub fn set_broadcast(&self, network_id: NetworkId, enabled: bool) -> Result<()> {
|
|
let changed = self
|
|
.conn
|
|
.execute(
|
|
"UPDATE networks SET broadcast = ?2 WHERE network_id = ?1",
|
|
params![network_id.as_bytes().as_slice(), enabled as i64],
|
|
)
|
|
.map_err(|err| Error::Storage(format!("cannot update broadcast policy: {err}")))?;
|
|
if changed == 0 {
|
|
return Err(Error::NetworkUnknown(network_id));
|
|
}
|
|
Ok(())
|
|
}
|
|
|
|
/// Saves a local ordered protocol selection without changing membership.
|
|
pub fn set_protocols(&self, network_id: NetworkId, protocols: &[String]) -> Result<()> {
|
|
crate::dataplane::validate_protocols(
|
|
protocols,
|
|
crate::config::Limits::default().max_capabilities,
|
|
)?;
|
|
let changed = self
|
|
.conn
|
|
.execute(
|
|
"UPDATE networks SET protocols = ?2 WHERE network_id = ?1",
|
|
params![network_id.as_bytes().as_slice(), protocols.join(",")],
|
|
)
|
|
.map_err(|err| Error::Storage(format!("cannot update protocols: {err}")))?;
|
|
if changed == 0 {
|
|
return Err(Error::NetworkUnknown(network_id));
|
|
}
|
|
Ok(())
|
|
}
|
|
|
|
/// Removes a network configuration entirely.
|
|
pub fn remove_network(&self, network_id: NetworkId) -> Result<()> {
|
|
self.conn
|
|
.execute(
|
|
"DELETE FROM networks WHERE network_id = ?1",
|
|
params![network_id.as_bytes().as_slice()],
|
|
)
|
|
.map_err(|err| Error::Storage(format!("cannot remove network: {err}")))?;
|
|
Ok(())
|
|
}
|
|
|
|
/// Saves whether this agent offers itself as an exit node in a network.
|
|
pub fn set_exit_node(&self, network_id: NetworkId, enabled: bool) -> Result<()> {
|
|
let changed = self
|
|
.conn
|
|
.execute(
|
|
"UPDATE networks SET exit_node = ?2 WHERE network_id = ?1",
|
|
params![network_id.as_bytes().as_slice(), enabled as i64],
|
|
)
|
|
.map_err(|err| Error::Storage(format!("cannot update exit node offer: {err}")))?;
|
|
if changed == 0 {
|
|
return Err(Error::NetworkUnknown(network_id));
|
|
}
|
|
Ok(())
|
|
}
|
|
|
|
/// Saves which member this device sends its internet traffic through.
|
|
///
|
|
/// One device has one default route, so choosing an exit node in one
|
|
/// network clears the choice in every other.
|
|
pub fn set_exit_via(&self, network_id: NetworkId, via: Option<&[u8; 32]>) -> Result<()> {
|
|
let tx = self
|
|
.conn
|
|
.unchecked_transaction()
|
|
.map_err(|err| Error::Storage(format!("cannot update exit node: {err}")))?;
|
|
let changed = tx
|
|
.execute(
|
|
"UPDATE networks SET exit_via = ?2 WHERE network_id = ?1",
|
|
params![network_id.as_bytes().as_slice(), via.map(|v| v.as_slice())],
|
|
)
|
|
.map_err(|err| Error::Storage(format!("cannot update exit node: {err}")))?;
|
|
if changed == 0 {
|
|
return Err(Error::NetworkUnknown(network_id));
|
|
}
|
|
if via.is_some() {
|
|
tx.execute(
|
|
"UPDATE networks SET exit_via = NULL WHERE network_id != ?1",
|
|
params![network_id.as_bytes().as_slice()],
|
|
)
|
|
.map_err(|err| Error::Storage(format!("cannot update exit node: {err}")))?;
|
|
}
|
|
tx.commit()
|
|
.map_err(|err| Error::Storage(format!("cannot update exit node: {err}")))?;
|
|
Ok(())
|
|
}
|
|
|
|
/// Lists every configured network.
|
|
pub fn list_networks(&self) -> Result<Vec<StoredNetwork>> {
|
|
let mut stmt = self
|
|
.conn
|
|
.prepare("SELECT network_id, name, secret, auto_start, broadcast, exit_node, exit_via, protocols FROM networks ORDER BY name")
|
|
.map_err(|err| Error::Storage(format!("cannot list networks: {err}")))?;
|
|
let rows = stmt
|
|
.query_map([], |row| {
|
|
let id: Vec<u8> = row.get(0)?;
|
|
let name: String = row.get(1)?;
|
|
let secret: Vec<u8> = row.get(2)?;
|
|
let auto_start: i64 = row.get(3)?;
|
|
Ok((
|
|
id,
|
|
name,
|
|
secret,
|
|
auto_start != 0,
|
|
row.get::<_, bool>(4)?,
|
|
row.get::<_, bool>(5)?,
|
|
row.get::<_, Option<Vec<u8>>>(6)?,
|
|
row.get::<_, Option<String>>(7)?,
|
|
))
|
|
})
|
|
.map_err(|err| Error::Storage(format!("cannot list networks: {err}")))?;
|
|
|
|
let mut out = Vec::new();
|
|
for row in rows {
|
|
let (id, name, secret, auto_start, broadcast, exit_node, exit_via, protocols) =
|
|
row.map_err(|err| Error::Storage(format!("cannot read network row: {err}")))?;
|
|
let protocols = protocols
|
|
.map(|text| {
|
|
let max = crate::config::Limits::default().max_capabilities;
|
|
if text.len() > max * (crate::dataplane::MAX_PROTOCOL_ID_LEN + 1) {
|
|
return Err(self.corrupt("stored protocol selection is too long"));
|
|
}
|
|
let names = if text.is_empty() {
|
|
Vec::new()
|
|
} else {
|
|
text.split(',').map(str::to_owned).collect()
|
|
};
|
|
crate::dataplane::validate_protocols(&names, max)
|
|
.map_err(|err| self.corrupt(err))?;
|
|
Ok(names)
|
|
})
|
|
.transpose()?;
|
|
let id: [u8; 32] = id
|
|
.as_slice()
|
|
.try_into()
|
|
.map_err(|_| self.corrupt("stored network id is not 32 bytes"))?;
|
|
out.push(StoredNetwork {
|
|
protocols,
|
|
network_id: NetworkId::from_bytes(id),
|
|
name: NetworkName::new(name)?,
|
|
secret: NetworkSecret::from_bytes(secret)?,
|
|
auto_start,
|
|
broadcast,
|
|
exit_node,
|
|
exit_via: exit_via.and_then(|bytes| <[u8; 32]>::try_from(bytes.as_slice()).ok()),
|
|
});
|
|
}
|
|
Ok(out)
|
|
}
|
|
|
|
/// Reads the stored hostname, if any.
|
|
pub fn hostname(&self) -> Result<Option<String>> {
|
|
self.get_setting(SETTING_HOSTNAME)
|
|
}
|
|
|
|
/// Stores the hostname.
|
|
///
|
|
/// Today this is a local setting. In the future a rename must be a signed
|
|
/// record that revokes the specific old binding and announces the new one,
|
|
/// ideally atomically in one record.
|
|
pub fn set_hostname(&self, hostname: &str) -> Result<()> {
|
|
self.set_setting(SETTING_HOSTNAME, hostname)
|
|
}
|
|
|
|
/// Loads every signed record known for a network.
|
|
///
|
|
/// Records are returned as stored; the caller verifies them, because the
|
|
/// database is not a trust boundary — a restored backup or a copied file
|
|
/// could contain anything.
|
|
pub fn signed_records(&self, network_id: NetworkId) -> Result<Vec<SignedRecord>> {
|
|
let mut stmt = self
|
|
.conn
|
|
.prepare(
|
|
"SELECT author, version, body, signature FROM signed_records
|
|
WHERE network_id = ?1",
|
|
)
|
|
.map_err(|err| Error::Storage(format!("cannot read signed records: {err}")))?;
|
|
let rows = stmt
|
|
.query_map(params![network_id.as_bytes().as_slice()], |row| {
|
|
let author: Vec<u8> = row.get(0)?;
|
|
let version: i64 = row.get(1)?;
|
|
let body: Vec<u8> = row.get(2)?;
|
|
let signature: Vec<u8> = row.get(3)?;
|
|
Ok((author, version, body, signature))
|
|
})
|
|
.map_err(|err| Error::Storage(format!("cannot read signed records: {err}")))?;
|
|
|
|
let mut out = Vec::new();
|
|
for row in rows {
|
|
let (author, version, body, signature) =
|
|
row.map_err(|err| Error::Storage(format!("cannot read a record row: {err}")))?;
|
|
let Ok(author) = <[u8; 32]>::try_from(author.as_slice()) else {
|
|
continue;
|
|
};
|
|
let Ok(body) = postcard::from_bytes(&body) else {
|
|
continue;
|
|
};
|
|
out.push(SignedRecord {
|
|
author,
|
|
network: *network_id.as_bytes(),
|
|
version: version as u64,
|
|
body,
|
|
signature,
|
|
});
|
|
}
|
|
Ok(out)
|
|
}
|
|
|
|
/// Stores a record received from somebody else.
|
|
pub fn put_signed_record(&self, record: &SignedRecord) -> Result<()> {
|
|
let body = postcard::to_stdvec(&record.body)
|
|
.map_err(|err| Error::Storage(format!("cannot encode a record body: {err}")))?;
|
|
self.conn
|
|
.execute(
|
|
"INSERT INTO signed_records (network_id, author, version, body, signature)
|
|
VALUES (?1, ?2, ?3, ?4, ?5)
|
|
ON CONFLICT(network_id, author) DO UPDATE SET
|
|
version = excluded.version,
|
|
body = excluded.body,
|
|
signature = excluded.signature",
|
|
params![
|
|
record.network.as_slice(),
|
|
record.author.as_slice(),
|
|
record.version as i64,
|
|
body,
|
|
record.signature
|
|
],
|
|
)
|
|
.map_err(|err| Error::Storage(format!("cannot store a signed record: {err}")))?;
|
|
Ok(())
|
|
}
|
|
|
|
/// Stores one of **our own** records and bumps our counter, atomically.
|
|
///
|
|
/// The model requires that a record and the author's own version counter
|
|
/// are committed together, and **before** the record is published, so a
|
|
/// crash can never leave us able to reuse a version number we already put
|
|
/// on the wire.
|
|
pub fn publish_own_record(&self, record: &SignedRecord) -> Result<()> {
|
|
let body = postcard::to_stdvec(&record.body)
|
|
.map_err(|err| Error::Storage(format!("cannot encode a record body: {err}")))?;
|
|
let transaction = self
|
|
.conn
|
|
.unchecked_transaction()
|
|
.map_err(|err| Error::Storage(format!("cannot begin a transaction: {err}")))?;
|
|
|
|
transaction
|
|
.execute(
|
|
"INSERT INTO signed_records (network_id, author, version, body, signature)
|
|
VALUES (?1, ?2, ?3, ?4, ?5)
|
|
ON CONFLICT(network_id, author) DO UPDATE SET
|
|
version = excluded.version,
|
|
body = excluded.body,
|
|
signature = excluded.signature",
|
|
params![
|
|
record.network.as_slice(),
|
|
record.author.as_slice(),
|
|
record.version as i64,
|
|
body,
|
|
record.signature
|
|
],
|
|
)
|
|
.map_err(|err| Error::Storage(format!("cannot store our record: {err}")))?;
|
|
transaction
|
|
.execute(
|
|
"INSERT INTO own_record_version (network_id, author, version)
|
|
VALUES (?1, ?2, ?3)
|
|
ON CONFLICT(network_id, author) DO UPDATE SET
|
|
version = max(version, excluded.version)",
|
|
params![
|
|
record.network.as_slice(),
|
|
record.author.as_slice(),
|
|
record.version as i64
|
|
],
|
|
)
|
|
.map_err(|err| Error::Storage(format!("cannot store our version: {err}")))?;
|
|
|
|
transaction
|
|
.commit()
|
|
.map_err(|err| Error::Storage(format!("cannot commit our record: {err}")))
|
|
}
|
|
|
|
/// The highest version an author has ever published for a network.
|
|
///
|
|
/// Monotonic even if the record is later replaced by a conflicting one,
|
|
/// so a number is never reused. Keyed by author as well: a replaced
|
|
/// device key is a different author and starts its own sequence, while
|
|
/// the outgoing one keeps its place so the release it signs on the way
|
|
/// out cannot collide with something it already published.
|
|
pub fn own_record_version(
|
|
&self,
|
|
network_id: NetworkId,
|
|
author: iroh::EndpointId,
|
|
) -> Result<u64> {
|
|
let version: Option<i64> = self
|
|
.conn
|
|
.query_row(
|
|
"SELECT version FROM own_record_version WHERE network_id = ?1 AND author = ?2",
|
|
params![
|
|
network_id.as_bytes().as_slice(),
|
|
author.as_bytes().as_slice()
|
|
],
|
|
|row| row.get(0),
|
|
)
|
|
.optional()
|
|
.map_err(|err| Error::Storage(format!("cannot read our version: {err}")))?;
|
|
Ok(version.unwrap_or(0).max(0) as u64)
|
|
}
|
|
|
|
/// Loads durable cleanup markers without allocating oversized stored blobs.
|
|
pub fn retirements(&self, network: NetworkId, max: usize) -> Result<Vec<SignedRetirement>> {
|
|
let mut stmt = self
|
|
.conn
|
|
.prepare(
|
|
"SELECT CASE WHEN length(data) <= ?2 THEN data ELSE NULL END
|
|
FROM retirements WHERE network_id = ?1 ORDER BY target",
|
|
)
|
|
.map_err(|err| self.corrupt(err))?;
|
|
let rows = stmt
|
|
.query_map(
|
|
params![network.as_bytes().as_slice(), MAX_RETIREMENT_LEN as i64],
|
|
|row| row.get::<_, Option<Vec<u8>>>(0),
|
|
)
|
|
.map_err(|err| self.corrupt(err))?;
|
|
let mut out = Vec::new();
|
|
for row in rows {
|
|
if out.len() >= max {
|
|
return Err(Error::Storage(
|
|
"stored retirements exceed the configured limit".into(),
|
|
));
|
|
}
|
|
let bytes = row
|
|
.map_err(|err| self.corrupt(err))?
|
|
.ok_or_else(|| self.corrupt("oversized retirement"))?;
|
|
let marker: SignedRetirement =
|
|
postcard::from_bytes(&bytes).map_err(|err| self.corrupt(err))?;
|
|
marker.verify(network).map_err(|err| self.corrupt(err))?;
|
|
out.push(marker);
|
|
}
|
|
Ok(out)
|
|
}
|
|
|
|
/// Persists a strongest verified marker received from an authenticated session.
|
|
pub fn put_retirement(&self, marker: &SignedRetirement) -> Result<()> {
|
|
let network = NetworkId::from_bytes(marker.network);
|
|
marker
|
|
.verify(network)
|
|
.map_err(|err| Error::Storage(err.to_string()))?;
|
|
let old: Option<Option<Vec<u8>>> = self.conn.query_row(
|
|
"SELECT CASE WHEN length(data) <= ?3 THEN data ELSE NULL END FROM retirements WHERE network_id = ?1 AND target = ?2",
|
|
params![marker.network.as_slice(), marker.target.author.as_slice(), MAX_RETIREMENT_LEN as i64], |row| row.get(0))
|
|
.optional().map_err(|err| self.corrupt(err))?;
|
|
if let Some(bytes) = old {
|
|
let bytes = bytes.ok_or_else(|| self.corrupt("oversized retirement"))?;
|
|
let old: SignedRetirement =
|
|
postcard::from_bytes(&bytes).map_err(|err| self.corrupt(err))?;
|
|
old.verify(network).map_err(|err| self.corrupt(err))?;
|
|
if !marker.supersedes(&old) {
|
|
return Ok(());
|
|
}
|
|
}
|
|
let bytes = postcard::to_stdvec(marker).map_err(|err| Error::Storage(err.to_string()))?;
|
|
if bytes.len() > MAX_RETIREMENT_LEN {
|
|
return Err(Error::Storage(
|
|
"retirement exceeds its encoded bound".into(),
|
|
));
|
|
}
|
|
self.conn
|
|
.execute(
|
|
"INSERT INTO retirements (network_id, target, data) VALUES (?1, ?2, ?3)
|
|
ON CONFLICT(network_id, target) DO UPDATE SET data = excluded.data",
|
|
params![
|
|
marker.network.as_slice(),
|
|
marker.target.author.as_slice(),
|
|
bytes
|
|
],
|
|
)
|
|
.map_err(|err| Error::Storage(format!("cannot store retirement: {err}")))?;
|
|
Ok(())
|
|
}
|
|
|
|
/// Commits our signed cleanup marker and author counter in one transaction.
|
|
pub fn publish_own_retirement(&self, marker: &SignedRetirement) -> Result<()> {
|
|
let transaction = self
|
|
.conn
|
|
.unchecked_transaction()
|
|
.map_err(|err| Error::Storage(err.to_string()))?;
|
|
self.put_retirement(marker)?;
|
|
transaction
|
|
.execute(
|
|
"INSERT INTO own_record_version (network_id, author, version) VALUES (?1, ?2, ?3)
|
|
ON CONFLICT(network_id, author) DO UPDATE SET version = max(version, excluded.version)",
|
|
params![
|
|
marker.network.as_slice(),
|
|
marker.author.as_slice(),
|
|
marker.version as i64
|
|
],
|
|
)
|
|
.map_err(|err| Error::Storage(format!("cannot store retirement counter: {err}")))?;
|
|
transaction
|
|
.commit()
|
|
.map_err(|err| Error::Storage(format!("cannot commit retirement: {err}")))
|
|
}
|
|
|
|
/// Reads bounded mandatory VIP state; corrupt records fail activation.
|
|
pub fn vip_fields(&self, network: NetworkId, max: usize) -> Result<Vec<crate::vip::VipEntry>> {
|
|
let mut stmt = self.conn.prepare("SELECT CASE WHEN length(data) <= 1024 THEN data ELSE NULL END FROM vip_fields WHERE network_id=?1 ORDER BY vip, field")
|
|
.map_err(|e| self.corrupt(e.to_string()))?;
|
|
let mut rows = stmt
|
|
.query(params![network.as_bytes().as_slice()])
|
|
.map_err(|e| self.corrupt(e.to_string()))?;
|
|
let mut entries = Vec::new();
|
|
while let Some(row) = rows.next().map_err(|e| self.corrupt(e.to_string()))? {
|
|
if entries.len() >= max {
|
|
return Err(self.corrupt("stored VIP state exceeds configured limits"));
|
|
}
|
|
let bytes: Option<Vec<u8>> = row.get(0).map_err(|e| self.corrupt(e.to_string()))?;
|
|
let bytes = bytes.ok_or_else(|| self.corrupt("oversized VIP field"))?;
|
|
let entry: crate::vip::VipEntry =
|
|
postcard::from_bytes(&bytes).map_err(|e| self.corrupt(e.to_string()))?;
|
|
entry
|
|
.verify(network)
|
|
.map_err(|e| self.corrupt(e.to_string()))?;
|
|
entries.push(entry);
|
|
}
|
|
Ok(entries)
|
|
}
|
|
|
|
/// Commits a validated VIP snapshot and optional author counter atomically.
|
|
pub fn put_vip_fields(
|
|
&self,
|
|
network: NetworkId,
|
|
entries: &[crate::vip::VipEntry],
|
|
own: Option<([u8; 32], u64)>,
|
|
) -> Result<()> {
|
|
let tx = self
|
|
.conn
|
|
.unchecked_transaction()
|
|
.map_err(|e| Error::Storage(e.to_string()))?;
|
|
if let Some(first) = entries.first() {
|
|
if entries.iter().any(|e| e.vip != first.vip) {
|
|
return Err(Error::Storage(
|
|
"VIP snapshot mixes service identities".into(),
|
|
));
|
|
}
|
|
tx.execute(
|
|
"DELETE FROM vip_fields WHERE network_id=?1 AND vip=?2",
|
|
params![network.as_bytes().as_slice(), first.vip],
|
|
)
|
|
.map_err(|e| Error::Storage(e.to_string()))?;
|
|
}
|
|
for e in entries {
|
|
e.verify(network)?;
|
|
let bytes = postcard::to_stdvec(e).map_err(|e| Error::Storage(e.to_string()))?;
|
|
if bytes.len() > 1024 {
|
|
return Err(Error::Storage("oversized VIP field".into()));
|
|
}
|
|
tx.execute("INSERT INTO vip_fields(network_id,vip,field,data) VALUES(?1,?2,?3,?4) ON CONFLICT(network_id,vip,field) DO UPDATE SET data=excluded.data",
|
|
params![network.as_bytes().as_slice(),e.vip,e.key,bytes]).map_err(|e|Error::Storage(e.to_string()))?;
|
|
}
|
|
if let Some((author, version)) = own {
|
|
tx.execute("INSERT INTO own_record_version(network_id,author,version) VALUES(?1,?2,?3) ON CONFLICT(network_id,author) DO UPDATE SET version=max(version,excluded.version)",
|
|
params![network.as_bytes().as_slice(),author.as_slice(),version as i64]).map_err(|e|Error::Storage(e.to_string()))?;
|
|
}
|
|
tx.commit().map_err(|e| Error::Storage(e.to_string()))
|
|
}
|
|
|
|
/// Drops a forgotten network's local cleanup proofs.
|
|
pub fn forget_retirements(&self, network: NetworkId) -> Result<()> {
|
|
self.conn
|
|
.execute(
|
|
"DELETE FROM vip_fields WHERE network_id = ?1",
|
|
params![network.as_bytes().as_slice()],
|
|
)
|
|
.map_err(|e| Error::Storage(e.to_string()))?;
|
|
self.conn
|
|
.execute(
|
|
"DELETE FROM retirements WHERE network_id = ?1",
|
|
params![network.as_bytes().as_slice()],
|
|
)
|
|
.map_err(|err| Error::Storage(err.to_string()))?;
|
|
Ok(())
|
|
}
|
|
|
|
/// Forgets every record of a network.
|
|
pub fn forget_signed_records(&self, network_id: NetworkId) -> Result<()> {
|
|
self.conn
|
|
.execute(
|
|
"DELETE FROM signed_records WHERE network_id = ?1",
|
|
params![network_id.as_bytes().as_slice()],
|
|
)
|
|
.map_err(|err| Error::Storage(format!("cannot clear signed records: {err}")))?;
|
|
Ok(())
|
|
}
|
|
|
|
/// Remembers the hostname a member last announced.
|
|
pub fn remember_peer_hostname(
|
|
&self,
|
|
network_id: NetworkId,
|
|
endpoint_id: &[u8; 32],
|
|
hostname: &str,
|
|
) -> Result<()> {
|
|
self.conn
|
|
.execute(
|
|
"INSERT INTO peer_hostnames (network_id, endpoint_id, hostname)
|
|
VALUES (?1, ?2, ?3)
|
|
ON CONFLICT(network_id, endpoint_id) DO UPDATE SET hostname = excluded.hostname",
|
|
params![
|
|
network_id.as_bytes().as_slice(),
|
|
endpoint_id.as_slice(),
|
|
hostname
|
|
],
|
|
)
|
|
.map_err(|err| Error::Storage(format!("cannot remember a hostname: {err}")))?;
|
|
Ok(())
|
|
}
|
|
|
|
/// The last hostname every member of a network announced.
|
|
pub fn peer_hostnames(&self, network_id: NetworkId) -> Result<Vec<([u8; 32], String)>> {
|
|
let mut stmt = self
|
|
.conn
|
|
.prepare("SELECT endpoint_id, hostname FROM peer_hostnames WHERE network_id = ?1")
|
|
.map_err(|err| Error::Storage(format!("cannot read hostnames: {err}")))?;
|
|
let rows = stmt
|
|
.query_map(params![network_id.as_bytes().as_slice()], |row| {
|
|
Ok((row.get::<_, Vec<u8>>(0)?, row.get::<_, String>(1)?))
|
|
})
|
|
.map_err(|err| Error::Storage(format!("cannot read hostnames: {err}")))?;
|
|
let mut out = Vec::new();
|
|
for row in rows {
|
|
let (id, hostname) =
|
|
row.map_err(|err| Error::Storage(format!("cannot read hostnames: {err}")))?;
|
|
if let Ok(id) = <[u8; 32]>::try_from(id.as_slice()) {
|
|
out.push((id, hostname));
|
|
}
|
|
}
|
|
Ok(out)
|
|
}
|
|
|
|
/// Forgets every remembered hostname of a network.
|
|
pub fn forget_peer_hostnames(&self, network_id: NetworkId) -> Result<()> {
|
|
self.conn
|
|
.execute(
|
|
"DELETE FROM peer_hostnames WHERE network_id = ?1",
|
|
params![network_id.as_bytes().as_slice()],
|
|
)
|
|
.map_err(|err| Error::Storage(format!("cannot forget hostnames: {err}")))?;
|
|
Ok(())
|
|
}
|
|
|
|
/// Atomically enables a network and puts it first in the startup order.
|
|
pub fn prefer_network(&self, network: NetworkId) -> Result<()> {
|
|
let configured = self.list_networks()?;
|
|
if !configured.iter().any(|n| n.network_id == network) {
|
|
return Err(Error::NetworkUnknown(network));
|
|
}
|
|
let existing = self.get_setting("network_start_order")?.unwrap_or_default();
|
|
let mut order = vec![network];
|
|
for word in existing.split(',') {
|
|
if let Ok(id) = word.parse::<NetworkId>()
|
|
&& configured.iter().any(|n| n.network_id == id)
|
|
&& !order.contains(&id)
|
|
{
|
|
order.push(id);
|
|
}
|
|
}
|
|
let value = order
|
|
.iter()
|
|
.map(ToString::to_string)
|
|
.collect::<Vec<_>>()
|
|
.join(",");
|
|
let transaction = self
|
|
.conn
|
|
.unchecked_transaction()
|
|
.map_err(|err| Error::Storage(format!("cannot begin network preference: {err}")))?;
|
|
transaction
|
|
.execute(
|
|
"UPDATE networks SET auto_start = 1 WHERE network_id = ?1",
|
|
params![network.as_bytes().as_slice()],
|
|
)
|
|
.map_err(|err| Error::Storage(format!("cannot enable network: {err}")))?;
|
|
transaction.execute("INSERT INTO settings (key, value) VALUES ('network_start_order', ?1) ON CONFLICT(key) DO UPDATE SET value = excluded.value", params![value])
|
|
.map_err(|err| Error::Storage(format!("cannot store network preference: {err}")))?;
|
|
transaction
|
|
.commit()
|
|
.map_err(|err| Error::Storage(format!("cannot commit network preference: {err}")))
|
|
}
|
|
|
|
/// Reads an arbitrary setting.
|
|
pub fn get_setting(&self, key: &str) -> Result<Option<String>> {
|
|
self.conn
|
|
.query_row(
|
|
"SELECT value FROM settings WHERE key = ?1",
|
|
params![key],
|
|
|row| row.get(0),
|
|
)
|
|
.optional()
|
|
.map_err(|err| Error::Storage(format!("cannot read setting `{key}`: {err}")))
|
|
}
|
|
|
|
/// Writes an arbitrary setting.
|
|
pub fn set_setting(&self, key: &str, value: &str) -> Result<()> {
|
|
self.conn
|
|
.execute(
|
|
"INSERT INTO settings (key, value) VALUES (?1, ?2)
|
|
ON CONFLICT(key) DO UPDATE SET value = excluded.value",
|
|
params![key, value],
|
|
)
|
|
.map_err(|err| Error::Storage(format!("cannot write setting `{key}`: {err}")))?;
|
|
Ok(())
|
|
}
|
|
}
|
|
|
|
/// Schema for the signed records described in [`crate::state`].
|
|
///
|
|
/// The version counter is keyed by author as well as network. A device key
|
|
/// can be replaced, and the replacement is a different author: it must start
|
|
/// its own sequence rather than inherit one, and the outgoing author's last
|
|
/// version has to survive so its release record cannot collide with
|
|
/// something it already published.
|
|
const SIGNED_RECORDS_SCHEMA: &str = "BEGIN;
|
|
CREATE TABLE IF NOT EXISTS signed_records (
|
|
network_id BLOB NOT NULL,
|
|
author BLOB NOT NULL,
|
|
version INTEGER NOT NULL,
|
|
body BLOB NOT NULL,
|
|
signature BLOB NOT NULL,
|
|
PRIMARY KEY (network_id, author)
|
|
);
|
|
CREATE TABLE IF NOT EXISTS own_record_version (
|
|
network_id BLOB NOT NULL,
|
|
author BLOB NOT NULL,
|
|
version INTEGER NOT NULL,
|
|
PRIMARY KEY (network_id, author)
|
|
);
|
|
PRAGMA user_version = 3;
|
|
COMMIT;";
|
|
|
|
/// Seconds since the Unix epoch, saturating at 0 before it.
|
|
pub(crate) fn now_unix() -> i64 {
|
|
std::time::SystemTime::now()
|
|
.duration_since(std::time::UNIX_EPOCH)
|
|
.map(|d| d.as_secs() as i64)
|
|
.unwrap_or(0)
|
|
}
|
|
#[cfg(test)]
|
|
mod broadcast_storage_tests {
|
|
#![allow(clippy::unwrap_used, clippy::expect_used, clippy::panic)]
|
|
use super::*;
|
|
use crate::identity::NetworkKeys;
|
|
|
|
#[test]
|
|
fn exit_node_choices_are_off_by_default_and_one_choice_clears_the_others() {
|
|
let dir = tempfile::tempdir().unwrap();
|
|
let store = StateStore::open(dir.path().join("state.sqlite")).unwrap();
|
|
let secret = NetworkSecret::from_bytes([5; 32]).unwrap();
|
|
let make = |name: &str| {
|
|
let name = NetworkName::new(name).unwrap();
|
|
let id = NetworkKeys::derive(&name, &secret).network_id();
|
|
store.upsert_network(id, &name, &secret, true).unwrap();
|
|
id
|
|
};
|
|
let (a, b) = (make("exit-a"), make("exit-b"));
|
|
let listed = || store.list_networks().unwrap();
|
|
assert!(
|
|
listed()
|
|
.iter()
|
|
.all(|n| !n.exit_node && n.exit_via.is_none())
|
|
);
|
|
|
|
store.set_exit_node(a, true).unwrap();
|
|
store.set_exit_via(a, Some(&[7; 32])).unwrap();
|
|
store.set_exit_via(b, Some(&[8; 32])).unwrap();
|
|
let by_id = |id: NetworkId| listed().into_iter().find(|n| n.network_id == id).unwrap();
|
|
assert!(by_id(a).exit_node, "offering is per network and kept");
|
|
assert_eq!(by_id(a).exit_via, None, "one default route: a was cleared");
|
|
assert_eq!(by_id(b).exit_via, Some([8; 32]));
|
|
|
|
store.set_exit_via(b, None).unwrap();
|
|
assert_eq!(by_id(b).exit_via, None);
|
|
}
|
|
|
|
#[test]
|
|
fn a_remembered_hostname_survives_a_restart_and_follows_the_latest_name() {
|
|
let dir = tempfile::tempdir().unwrap();
|
|
let path = dir.path().join("state.sqlite");
|
|
let name = NetworkName::new("hostnames").unwrap();
|
|
let secret = NetworkSecret::from_bytes([9; 32]).unwrap();
|
|
let id = NetworkKeys::derive(&name, &secret).network_id();
|
|
let peer = [3u8; 32];
|
|
|
|
let store = StateStore::open(&path).unwrap();
|
|
store.remember_peer_hostname(id, &peer, "laptop").unwrap();
|
|
store.remember_peer_hostname(id, &peer, "laptop-2").unwrap();
|
|
drop(store);
|
|
|
|
let store = StateStore::open(&path).unwrap();
|
|
assert_eq!(
|
|
store.peer_hostnames(id).unwrap(),
|
|
vec![(peer, "laptop-2".to_string())]
|
|
);
|
|
store.forget_peer_hostnames(id).unwrap();
|
|
assert!(store.peer_hostnames(id).unwrap().is_empty());
|
|
}
|
|
|
|
#[test]
|
|
fn retirement_migration_and_atomic_counter_commit_preserve_existing_state() {
|
|
let dir = tempfile::tempdir().unwrap();
|
|
let path = dir.path().join("state.sqlite");
|
|
let store = StateStore::open(&path).unwrap();
|
|
let identity = store.load_or_create_device_identity().unwrap();
|
|
let name = NetworkName::new("retirement-migration").unwrap();
|
|
let secret = NetworkSecret::from_bytes([6; 32]).unwrap();
|
|
let id = NetworkKeys::derive(&name, &secret).network_id();
|
|
store.upsert_network(id, &name, &secret, true).unwrap();
|
|
store.set_protocols(id, &["awg".into()]).unwrap();
|
|
let own = SignedRecord::sign(&identity.signing_key(), id, 8, RecordBody::Release);
|
|
store.publish_own_record(&own).unwrap();
|
|
store
|
|
.conn
|
|
.execute_batch("DROP TABLE retirements; PRAGMA user_version = 8;")
|
|
.unwrap();
|
|
drop(store);
|
|
let store = StateStore::open(&path).unwrap();
|
|
assert_eq!(
|
|
store.device_identity().unwrap().unwrap().endpoint_id(),
|
|
identity.endpoint_id()
|
|
);
|
|
assert_eq!(
|
|
store.list_networks().unwrap()[0].protocols,
|
|
Some(vec!["awg".into()])
|
|
);
|
|
assert_eq!(store.signed_records(id).unwrap(), vec![own]);
|
|
let target_key = iroh::SecretKey::generate();
|
|
let target = SignedRecord::sign(
|
|
&target_key,
|
|
id,
|
|
3,
|
|
RecordBody::Claim {
|
|
address: Some("10.13.37.2".parse().unwrap()),
|
|
range: Some(crate::state::DEFAULT_IPV4_RANGE),
|
|
hostname: Some("old-device".into()),
|
|
hostname_since: Some(123),
|
|
},
|
|
);
|
|
let marker = SignedRetirement::sign(&identity.signing_key(), id, 9, target);
|
|
store
|
|
.conn
|
|
.execute_batch(
|
|
"CREATE TRIGGER fail_retirement_counter BEFORE INSERT ON own_record_version
|
|
WHEN NEW.version = 9 BEGIN SELECT RAISE(ABORT, 'counter write refused'); END;",
|
|
)
|
|
.unwrap();
|
|
assert!(store.publish_own_retirement(&marker).is_err());
|
|
assert!(
|
|
store.retirements(id, 16).unwrap().is_empty(),
|
|
"marker must roll back with counter failure"
|
|
);
|
|
assert_eq!(
|
|
store
|
|
.own_record_version(id, identity.endpoint_id())
|
|
.unwrap(),
|
|
8
|
|
);
|
|
store
|
|
.conn
|
|
.execute_batch("DROP TRIGGER fail_retirement_counter;")
|
|
.unwrap();
|
|
store.publish_own_retirement(&marker).unwrap();
|
|
drop(store);
|
|
let store = StateStore::open(&path).unwrap();
|
|
assert_eq!(store.retirements(id, 16).unwrap(), vec![marker.clone()]);
|
|
assert_eq!(
|
|
store
|
|
.own_record_version(id, identity.endpoint_id())
|
|
.unwrap(),
|
|
9
|
|
);
|
|
assert!(
|
|
store.retirements(id, 0).is_err(),
|
|
"capacity changes must not silently drop markers"
|
|
);
|
|
store
|
|
.conn
|
|
.execute(
|
|
"UPDATE retirements SET data = ?1",
|
|
params![vec![0u8; MAX_RETIREMENT_LEN + 1]],
|
|
)
|
|
.unwrap();
|
|
assert!(matches!(
|
|
store.retirements(id, 16),
|
|
Err(Error::StateCorrupted { .. })
|
|
));
|
|
}
|
|
|
|
#[test]
|
|
fn v7_migration_keeps_signed_state_and_protocol_overrides_are_local_and_durable() {
|
|
let dir = tempfile::tempdir().unwrap();
|
|
let path = dir.path().join("state.sqlite");
|
|
let store = StateStore::open(&path).unwrap();
|
|
let identity = store.load_or_create_device_identity().unwrap();
|
|
let name = NetworkName::new("protocol-migration").unwrap();
|
|
let secret = NetworkSecret::from_bytes([4; 32]).unwrap();
|
|
let id = NetworkKeys::derive(&name, &secret).network_id();
|
|
store.upsert_network(id, &name, &secret, true).unwrap();
|
|
store.set_broadcast(id, false).unwrap();
|
|
let record = SignedRecord::sign(&identity.signing_key(), id, 17, RecordBody::Release);
|
|
store.publish_own_record(&record).unwrap();
|
|
store
|
|
.conn
|
|
.execute_batch("ALTER TABLE networks DROP COLUMN protocols; PRAGMA user_version=7;")
|
|
.unwrap();
|
|
drop(store);
|
|
let store = StateStore::open(&path).unwrap();
|
|
assert_eq!(
|
|
store
|
|
.load_or_create_device_identity()
|
|
.unwrap()
|
|
.endpoint_id(),
|
|
identity.endpoint_id()
|
|
);
|
|
assert_eq!(store.signed_records(id).unwrap(), vec![record]);
|
|
let saved = store.list_networks().unwrap();
|
|
assert!(saved[0].protocols.is_none());
|
|
assert!(!saved[0].broadcast);
|
|
assert!(saved[0].auto_start);
|
|
assert_eq!(saved[0].secret, secret);
|
|
let chosen = vec!["awg".into(), "wg-quic".into()];
|
|
store.set_protocols(id, &chosen).unwrap();
|
|
assert!(
|
|
store
|
|
.set_protocols(id, &["awg".into(), "awg".into()])
|
|
.is_err()
|
|
);
|
|
assert!(
|
|
store
|
|
.set_protocols(NetworkId::from_bytes([1; 32]), &[])
|
|
.is_err()
|
|
);
|
|
drop(store);
|
|
let store = StateStore::open(&path).unwrap();
|
|
assert_eq!(store.list_networks().unwrap()[0].protocols, Some(chosen));
|
|
store.upsert_network(id, &name, &secret, true).unwrap();
|
|
store.set_protocols(id, &[]).unwrap();
|
|
drop(store);
|
|
let store = StateStore::open(&path).unwrap();
|
|
assert_eq!(store.list_networks().unwrap()[0].protocols, Some(vec![]));
|
|
store
|
|
.conn
|
|
.execute("UPDATE networks SET protocols = 'awg,awg'", [])
|
|
.unwrap();
|
|
assert!(matches!(
|
|
store.list_networks(),
|
|
Err(Error::StateCorrupted { .. })
|
|
));
|
|
}
|
|
|
|
#[test]
|
|
fn v3_migration_preserves_identity_and_networks_and_defaults_broadcast_on() {
|
|
let dir = tempfile::tempdir().unwrap();
|
|
let path = dir.path().join("state.sqlite");
|
|
let name = NetworkName::new("migration-broadcast").unwrap();
|
|
let secret = NetworkSecret::from_bytes([7; 32]).unwrap();
|
|
let id = NetworkKeys::derive(&name, &secret).network_id();
|
|
let store = StateStore::open(&path).unwrap();
|
|
let identity = store
|
|
.load_or_create_device_identity()
|
|
.unwrap()
|
|
.endpoint_id();
|
|
store.upsert_network(id, &name, &secret, false).unwrap();
|
|
store.set_hostname("old-host").unwrap();
|
|
store
|
|
.conn
|
|
.execute_batch(
|
|
"ALTER TABLE networks DROP COLUMN broadcast; \
|
|
ALTER TABLE networks DROP COLUMN exit_node; \
|
|
ALTER TABLE networks DROP COLUMN exit_via; \
|
|
ALTER TABLE networks DROP COLUMN protocols; \
|
|
PRAGMA user_version=3;",
|
|
)
|
|
.unwrap();
|
|
drop(store);
|
|
let store = StateStore::open(&path).unwrap();
|
|
let networks = store.list_networks().unwrap();
|
|
assert_eq!(networks.len(), 1);
|
|
assert_eq!(networks[0].network_id, id);
|
|
assert!(!networks[0].auto_start);
|
|
assert!(networks[0].broadcast);
|
|
assert_eq!(store.hostname().unwrap().as_deref(), Some("old-host"));
|
|
assert_eq!(
|
|
store
|
|
.load_or_create_device_identity()
|
|
.unwrap()
|
|
.endpoint_id(),
|
|
identity
|
|
);
|
|
store.set_broadcast(id, false).unwrap();
|
|
store.upsert_network(id, &name, &secret, true).unwrap();
|
|
drop(store);
|
|
let store = StateStore::open(&path).unwrap();
|
|
assert!(
|
|
!store.list_networks().unwrap()[0].broadcast,
|
|
"rejoin and restart preserve opt-out"
|
|
);
|
|
store.remove_network(id).unwrap();
|
|
store.upsert_network(id, &name, &secret, true).unwrap();
|
|
assert!(
|
|
store.list_networks().unwrap()[0].broadcast,
|
|
"forgotten network gets defaults"
|
|
);
|
|
}
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod vip_tests {
|
|
#![allow(clippy::unwrap_used, clippy::expect_used, clippy::panic)]
|
|
use super::*;
|
|
#[test]
|
|
fn vip_migration_and_counter_failure_preserve_identity_and_rollback_fields() {
|
|
let dir = tempfile::TempDir::new().unwrap();
|
|
let path = dir.path().join("state.sqlite");
|
|
let store = StateStore::open(&path).unwrap();
|
|
let identity = store.load_or_create_device_identity().unwrap();
|
|
store
|
|
.conn
|
|
.execute_batch("DROP TABLE vip_fields; PRAGMA user_version=9;")
|
|
.unwrap();
|
|
drop(store);
|
|
let store = StateStore::open(&path).unwrap();
|
|
assert_eq!(
|
|
store.device_identity().unwrap().unwrap().endpoint_id(),
|
|
identity.endpoint_id()
|
|
);
|
|
let net = NetworkId::from_bytes([7; 32]);
|
|
let key = identity.signing_key();
|
|
let config = crate::vip::VipConfig::new("api");
|
|
let fields = crate::vip::VipSet::default()
|
|
.edit(net, &key, 7, &config, None, &crate::Limits::default())
|
|
.unwrap();
|
|
store.conn.execute_batch("CREATE TRIGGER fail_vip_counter BEFORE INSERT ON own_record_version BEGIN SELECT RAISE(ABORT,'counter unavailable'); END;").unwrap();
|
|
assert!(
|
|
store
|
|
.put_vip_fields(net, &fields, Some((*key.public().as_bytes(), 7)))
|
|
.is_err()
|
|
);
|
|
assert!(store.vip_fields(net, 192).unwrap().is_empty());
|
|
store
|
|
.conn
|
|
.execute_batch("DROP TRIGGER fail_vip_counter;")
|
|
.unwrap();
|
|
store
|
|
.put_vip_fields(net, &fields, Some((*key.public().as_bytes(), 7)))
|
|
.unwrap();
|
|
assert_eq!(store.vip_fields(net, 192).unwrap(), fields);
|
|
assert_eq!(store.own_record_version(net, key.public()).unwrap(), 7);
|
|
drop(store);
|
|
let reopened = StateStore::open(path).unwrap();
|
|
assert_eq!(reopened.vip_fields(net, 192).unwrap(), fields);
|
|
reopened
|
|
.conn
|
|
.execute("UPDATE vip_fields SET data=?1", params![vec![0xffu8; 1025]])
|
|
.unwrap();
|
|
assert!(matches!(
|
|
reopened.vip_fields(net, 192),
|
|
Err(Error::StateCorrupted { .. })
|
|
));
|
|
}
|
|
}
|