diff --git a/CHANGELOG.md b/CHANGELOG.md index 86e2ffc..1dbb7b6 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -6,6 +6,15 @@ All notable changes to this project are documented here, following ## [Unreleased] ### Added +- **Peer Aliases and Ergonomic Control Resolution (`bin/yipd`, #197).** + - Added optional `alias: Option` to `PeerConfig`, configuration file parser (`alias = "..."` within `[peer]` blocks), `ControlCmd::AddPeer` RPC, and `PeerStats`. + - Added case-insensitive peer resolution by human-readable alias in `PeerManager` (`find_peer_by_alias`, `peer_pubkey`, and fallback in `find_peer_index_by_id`), allowing CLI commands (`peer remove`, `peer set-transport`, `ping`, `trace`, `crypto`) to accept friendly peer aliases as drop-in alternatives to full 64-hex public keys or IPv6 node addresses. + - Updated `yipctl peers` and `yipctl top` dashboard displays to render peer aliases alongside node overlay addresses when configured. +- **Network Invitation Tickets and Terminal QR Code Rendering (`bin/yipd`, #198).** + - Implemented `NetworkTicket` schema in `bin/yipd/src/ticket.rs` compatible with cross-platform desktop/mobile clients (`yip-client`), supporting Base64 serialization, JSON payloads, and `yip://join?ticket={b64}` invitation URIs. + - Added compact terminal Unicode QR code generation using `qrcode` crate with `Dense1x2` half-block glyph rendering. + - Added `ControlCmd::CreateTicket` RPC command and responses (`ControlResponse::Ticket`) over the UNIX domain control socket `/run/yipd/yip.sock`. + - Added CLI subcommands `yip ticket create [--name ] [--route-mode ] [--endpoint ] [--no-qr] [--json]` and `yip ticket show [--no-qr] [--json]`. - **Control Socket Status RPC Metadata Exposure (`bin/yipd`, #194).** - Exposed local node public key (`public_key`), active UDP listen port (`listen_port`), and mesh network ID (`network_id`) in `ControlResponse::Status`. - Added CLI status printout formatting and JSON serialization for node public keys, listen ports, and network IDs, enabling unprivileged desktop clients and orchestration tools to query local node identity without reading secret configuration files. diff --git a/Cargo.lock b/Cargo.lock index 795984f..71a4679 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -1852,6 +1852,12 @@ dependencies = [ "unicode-ident", ] +[[package]] +name = "qrcode" +version = "0.14.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d68782463e408eb1e668cf6152704bd856c78c5b6417adaee3203d8f4c1fc9ec" + [[package]] name = "quinn-proto" version = "0.11.19" @@ -3285,12 +3291,14 @@ dependencies = [ name = "yipd" version = "0.1.0" dependencies = [ + "base64 0.22.1", "blake3", "boring", "bytes", "ed25519-dalek", "getrandom 0.4.3", "libc", + "qrcode", "quinn-proto", "rcgen", "rustls", diff --git a/bin/yipd/Cargo.toml b/bin/yipd/Cargo.toml index a8225a1..3502a59 100644 --- a/bin/yipd/Cargo.toml +++ b/bin/yipd/Cargo.toml @@ -44,6 +44,8 @@ serde = { version = "1.0", features = ["derive"] } serde_json = "1.0" yip-ca = { workspace = true } ed25519-dalek = { version = "3" } +qrcode = { version = "0.14", default-features = false } +base64 = "0.22" [dev-dependencies] ed25519-dalek = { version = "3", default-features = false } diff --git a/bin/yipd/src/config.rs b/bin/yipd/src/config.rs index 0c46081..fa4e6ca 100644 --- a/bin/yipd/src/config.rs +++ b/bin/yipd/src/config.rs @@ -95,6 +95,28 @@ pub struct PeerConfig { /// only by public key (reachable only via rendezvous/relay once Task 6 /// wires that path in). pub endpoint: Option, + /// Optional human-readable nickname or alias for this peer. + pub alias: Option, +} + +impl PeerConfig { + /// Create a peer configuration without an alias. + pub fn new(public_key: [u8; 32], endpoint: Option) -> Self { + Self { + public_key, + endpoint, + alias: None, + } + } + + /// Attach a human-readable alias to this peer configuration. + pub fn with_alias(mut self, alias: impl Into) -> Self { + let a = alias.into().trim().to_string(); + if !a.is_empty() { + self.alias = Some(a); + } + self + } } /// Configuration for packet length quantization (DAITA) and cover traffic defenses. @@ -503,6 +525,7 @@ fn missing(key: &str) -> io::Error { fn flush_peer_block( cur_pk: Option<[u8; 32]>, cur_ep: Option, + cur_alias: Option, peers: &mut Vec, ) -> io::Result<()> { match cur_pk { @@ -512,11 +535,12 @@ fn flush_peer_block( Some(pk) => peers.push(PeerConfig { public_key: pk, endpoint: cur_ep, + alias: cur_alias, }), - None if cur_ep.is_some() => { + None if cur_ep.is_some() || cur_alias.is_some() => { return Err(io::Error::new( io::ErrorKind::InvalidData, - "peer block has an endpoint but no public_key".to_string(), + "peer block has an endpoint or alias but no public_key".to_string(), )); } None => {} @@ -539,6 +563,7 @@ impl Config { let mut peers: Vec = Vec::new(); let mut cur_pk: Option<[u8; 32]> = None; let mut cur_ep: Option = None; + let mut cur_alias: Option = None; let mut legacy_peer_public: Option<[u8; 32]> = None; let mut legacy_peer_endpoint: Option = None; let mut listen: Option = None; @@ -577,9 +602,10 @@ impl Config { // Check for [peer] block header if line == "[peer]" { - flush_peer_block(cur_pk, cur_ep, &mut peers)?; + flush_peer_block(cur_pk, cur_ep, cur_alias, &mut peers)?; cur_pk = None; cur_ep = None; + cur_alias = None; continue; } @@ -595,6 +621,12 @@ impl Config { "local_private" => local_private = Some(hex_to_32(val)?), "local_public" => local_public = Some(hex_to_32(val)?), "public_key" => cur_pk = Some(hex_to_32(val)?), + "alias" => { + let clean = val.trim_matches('"').trim(); + if !clean.is_empty() { + cur_alias = Some(clean.to_string()); + } + } "endpoint" => { cur_ep = Some(val.parse::().map_err(|e| { @@ -823,7 +855,7 @@ impl Config { } // Flush any trailing peer block - flush_peer_block(cur_pk, cur_ep, &mut peers)?; + flush_peer_block(cur_pk, cur_ep, cur_alias, &mut peers)?; // If no [peer] blocks, try legacy single-peer format if peers.is_empty() { @@ -831,6 +863,7 @@ impl Config { peers.push(PeerConfig { public_key: pk, endpoint: Some(ep), + alias: None, }); } } @@ -1361,6 +1394,41 @@ peer_public=0000000000000000000000000000000000000000000000000000000000000003 assert_eq!(cfg.peers[1].public_key[31], 0xb2); } + #[test] + fn parses_peers_with_optional_aliases() { + let text = "local_private=00000000000000000000000000000000000000000000000000000000000000ff\n\ + local_public=000000000000000000000000000000000000000000000000000000000000aa01\n\ + listen=0.0.0.0:443\ndevice=yip0\n\ + [peer]\npublic_key=00000000000000000000000000000000000000000000000000000000000000b1\nendpoint=10.0.0.2:443\nalias=home-gateway\n\ + [peer]\npublic_key=00000000000000000000000000000000000000000000000000000000000000b2\nalias=\"alice-laptop\"\n\ + [peer]\npublic_key=00000000000000000000000000000000000000000000000000000000000000b3\n"; + let cfg = Config::parse(text).expect("parses"); + assert_eq!(cfg.peers.len(), 3); + assert_eq!(cfg.peers[0].alias.as_deref(), Some("home-gateway")); + assert_eq!(cfg.peers[1].alias.as_deref(), Some("alice-laptop")); + assert_eq!(cfg.peers[2].alias, None); + } + + #[test] + fn test_peer_config_constructors_and_alias() { + let p = PeerConfig::new([1u8; 32], None); + assert_eq!(p.alias, None); + let p2 = p.with_alias(" "); + assert_eq!(p2.alias, None); + let p3 = PeerConfig::new([1u8; 32], None).with_alias("gateway"); + assert_eq!(p3.alias.as_deref(), Some("gateway")); + } + + #[test] + fn test_peer_block_with_alias_no_public_key_is_error() { + let text = + "local_private=00000000000000000000000000000000000000000000000000000000000000ff\n\ + local_public=000000000000000000000000000000000000000000000000000000000000aa01\n\ + listen=0.0.0.0:443\ndevice=yip0\n\ + [peer]\nalias=no-pubkey-peer\n"; + assert!(Config::parse(text).is_err()); + } + #[test] fn legacy_single_peer_becomes_one_entry() { let text = "device=yip0\nlisten=0.0.0.0:443\npeer_endpoint=10.0.0.2:443\n\ diff --git a/bin/yipd/src/control.rs b/bin/yipd/src/control.rs index 1721770..18229c2 100644 --- a/bin/yipd/src/control.rs +++ b/bin/yipd/src/control.rs @@ -29,6 +29,8 @@ pub enum ControlCmd { endpoint: Option, #[serde(default)] transport: Option, + #[serde(default)] + alias: Option, }, #[serde(rename = "remove_peer")] RemovePeer { public_key: String }, @@ -114,6 +116,15 @@ pub enum ControlCmd { GetXdpStatus, #[serde(rename = "set_xdp_mode")] SetXdpMode { mode: String }, + #[serde(rename = "create_ticket")] + CreateTicket { + #[serde(default)] + name: Option, + #[serde(default)] + route_mode: Option, + #[serde(default)] + endpoint: Option, + }, } fn default_ping_count() -> u32 { @@ -891,6 +902,13 @@ pub enum ControlResponse { metrics: crate::metrics::TelemetrySnapshot, prometheus: String, }, + Ticket { + ok: bool, + ticket: crate::ticket::NetworkTicket, + uri: String, + #[serde(default)] + qr_terminal: String, + }, Ack { ok: bool, message: String, @@ -1128,6 +1146,7 @@ pub fn dispatch_cmd( public_key, endpoint, transport, + alias, } => { let pk = match crate::config::hex_to_32(&public_key) { Ok(k) => k, @@ -1150,14 +1169,13 @@ pub fn dispatch_cmd( }, None => None, }; + let cfg = PeerConfig { + public_key: pk, + endpoint: ep, + alias, + }; if let Some(tr) = transport { - match pm.add_peer_with_transport( - PeerConfig { - public_key: pk, - endpoint: ep, - }, - Some(tr), - ) { + match pm.add_peer_with_transport(cfg, Some(tr)) { Ok(()) => ControlResponse::Ack { ok: true, message: "peer added".into(), @@ -1168,10 +1186,7 @@ pub fn dispatch_cmd( }, } } else { - match pm.add_peer(PeerConfig { - public_key: pk, - endpoint: ep, - }) { + match pm.add_peer(cfg) { Ok(()) => ControlResponse::Ack { ok: true, message: "peer added".into(), @@ -1187,10 +1202,14 @@ pub fn dispatch_cmd( let pk = match crate::config::hex_to_32(&public_key) { Ok(k) => k, Err(_) => { - return ControlResponse::Err { - ok: false, - error: "invalid public_key hex (must be 64 hex characters)".into(), - }; + if let Some(idx) = pm.find_peer_by_alias(&public_key) { + pm.peer_pubkey(idx).expect("peer exists") + } else { + return ControlResponse::Err { + ok: false, + error: "invalid public_key hex or unknown peer alias".into(), + }; + } } }; match pm.remove_peer(&pk) { @@ -1211,10 +1230,14 @@ pub fn dispatch_cmd( let pk = match crate::config::hex_to_32(&public_key) { Ok(k) => k, Err(_) => { - return ControlResponse::Err { - ok: false, - error: "invalid public_key hex (must be 64 hex characters)".into(), - }; + if let Some(idx) = pm.find_peer_by_alias(&public_key) { + pm.peer_pubkey(idx).expect("peer exists") + } else { + return ControlResponse::Err { + ok: false, + error: "invalid public_key hex or unknown peer alias".into(), + }; + } } }; pm.set_peer_transport(&pk, transport); @@ -1550,6 +1573,47 @@ pub fn dispatch_cmd( Ok(message) => ControlResponse::Ack { ok: true, message }, Err(error) => ControlResponse::Err { ok: false, error }, }, + ControlCmd::CreateTicket { + name, + route_mode, + endpoint, + } => { + let mut net_id = pm.network_id_hex(); + if net_id.is_empty() { + net_id = "default".to_string(); + } + let net_name = name.unwrap_or_else(|| { + let pubkey = pm.local_pub_hex(); + if pubkey.len() >= 8 { + format!("yip-{}", &pubkey[..8]) + } else { + "yip-mesh".to_string() + } + }); + let mode = route_mode.unwrap_or_else(|| "MeshOnly".to_string()); + let mut ticket = crate::ticket::NetworkTicket::new(net_name, net_id, mode); + if let Some(ep) = endpoint { + ticket = ticket.with_endpoint(ep); + } else if pm.listen_port() > 0 { + ticket = ticket.with_endpoint(format!("0.0.0.0:{}", pm.listen_port())); + } + let uri = match ticket.to_uri() { + Ok(u) => u, + Err(e) => { + return ControlResponse::Err { + ok: false, + error: format!("failed to format ticket URI: {e}"), + }; + } + }; + let qr_terminal = ticket.render_qr_terminal().unwrap_or_default(); + ControlResponse::Ticket { + ok: true, + ticket, + uri, + qr_terminal, + } + } } } @@ -1789,7 +1853,10 @@ pub fn run_cli_peers(socket_path: &Path, json: bool) -> Result<(), String> { _ => format!("\x1b[90m{}\x1b[0m", p.state), }; let cert_colored = format!("\x1b[32m{}\x1b[0m", p.cert_status); - let peer_str = p.node_addr.to_string(); + let peer_str = match &p.alias { + Some(alias) if !alias.is_empty() => format!("{} ({alias})", p.node_addr), + _ => p.node_addr.to_string(), + }; println!( "{:<39} {:<22} {:<8} {:<22} {:<16} {:<19} {:<24} {:<10} {:<12}", peer_str, @@ -1961,11 +2028,13 @@ pub fn run_cli_peer_add( public_key: &str, endpoint: Option<&str>, transport: Option<&str>, + alias: Option<&str>, ) -> Result<(), String> { let cmd = ControlCmd::AddPeer { public_key: public_key.into(), endpoint: endpoint.map(|s| s.into()), transport: transport.map(|s| s.into()), + alias: alias.map(|s| s.into()), }; match client_query(socket_path, cmd)? { ControlResponse::Ack { message, .. } => { @@ -1977,6 +2046,90 @@ pub fn run_cli_peer_add( } } +/// Create an invitation ticket for the running node or specified parameters. +pub fn run_cli_ticket_create( + socket_path: &Path, + name: Option, + route_mode: Option, + endpoint: Option, + no_qr: bool, + json: bool, +) -> Result<(), String> { + let resp = client_query( + socket_path, + ControlCmd::CreateTicket { + name, + route_mode, + endpoint, + }, + )?; + if json { + println!( + "{}", + serde_json::to_string_pretty(&resp).map_err(|e| e.to_string())? + ); + return Ok(()); + } + match resp { + ControlResponse::Ticket { + ok, + ticket, + uri, + qr_terminal, + } => { + if !ok { + return Err("daemon reported error creating ticket".into()); + } + if !no_qr && !qr_terminal.is_empty() { + println!("{qr_terminal}\n"); + } + println!("\x1b[1;38;5;208m●\x1b[0m \x1b[1mYip Network Invitation Ticket\x1b[0m"); + println!(" Network Name: \x1b[1m{}\x1b[0m", ticket.name); + println!(" Network ID: \x1b[1;36m{}\x1b[0m", ticket.network_id); + println!(" Route Mode: \x1b[1;32m{}\x1b[0m", ticket.route_mode); + if let Some(ep) = &ticket.endpoint { + println!(" Endpoint: {ep}"); + } + println!("\n\x1b[1mInvitation URI:\x1b[0m\n \x1b[4;34m{uri}\x1b[0m\n"); + let b64 = ticket.to_base64().unwrap_or_default(); + println!("\x1b[1mBase64 Payload:\x1b[0m\n {b64}"); + Ok(()) + } + ControlResponse::Err { error, .. } => Err(error), + _ => Err("unexpected response format from daemon".into()), + } +} + +/// Inspect and display a ticket or URI. +pub fn run_cli_ticket_show(raw_ticket: &str, no_qr: bool, json: bool) -> Result<(), String> { + let ticket = crate::ticket::NetworkTicket::parse(raw_ticket)?; + if json { + let text = serde_json::to_string_pretty(&ticket).map_err(|e| e.to_string())?; + println!("{text}"); + return Ok(()); + } + let uri = ticket.to_uri()?; + let qr = if !no_qr { + ticket.render_qr_terminal().unwrap_or_default() + } else { + String::new() + }; + if !qr.is_empty() { + println!("{qr}\n"); + } + println!("\x1b[1;38;5;208m●\x1b[0m \x1b[1mYip Network Invitation Ticket\x1b[0m"); + println!(" Network Name: \x1b[1m{}\x1b[0m", ticket.name); + println!(" Network ID: \x1b[1;36m{}\x1b[0m", ticket.network_id); + println!(" Route Mode: \x1b[1;32m{}\x1b[0m", ticket.route_mode); + if let Some(ep) = &ticket.endpoint { + println!(" Endpoint: {ep}"); + } + println!("\n\x1b[1mInvitation URI:\x1b[0m\n \x1b[4;34m{uri}\x1b[0m\n"); + let b64 = ticket.to_base64().unwrap_or_default(); + println!("\x1b[1mBase64 Payload:\x1b[0m\n {b64}"); + Ok(()) +} + /// Query and display Reed-Solomon dynamic FEC status. pub fn run_cli_fec_status(socket_path: &Path, json: bool) -> Result<(), String> { let resp = client_query(socket_path, ControlCmd::GetFecStatus)?; @@ -2889,6 +3042,7 @@ mod tests { public_key: new_pk_hex.clone(), endpoint: Some("198.51.100.2:51820".into()), transport: None, + alias: Some("peer2".into()), }; let resp = dispatch_cmd(&mut pm, add_cmd, "yip0", start); assert_eq!( @@ -2923,6 +3077,111 @@ mod tests { assert_eq!(pm.peer_stats().len(), 1); } + #[test] + fn control_protocol_add_peer_with_alias_and_actions_by_alias() { + let mut pm = crate::peer_manager::testutil::test_peer_manager(); + let start = Instant::now(); + + let new_pk_hex = "05".repeat(32); + let add_cmd = ControlCmd::AddPeer { + public_key: new_pk_hex, + endpoint: Some("198.51.100.5:51820".into()), + transport: None, + alias: Some("office-relay".into()), + }; + let resp = dispatch_cmd(&mut pm, add_cmd, "yip0", start); + assert_eq!( + resp, + ControlResponse::Ack { + ok: true, + message: "peer added".into() + } + ); + + // Verify alias is exposed in PeerStats + let peers = pm.peer_stats(); + assert_eq!(peers.len(), 2); + assert_eq!(peers[1].alias.as_deref(), Some("office-relay")); + + // Set transport using alias instead of hex key + let set_tr_cmd = ControlCmd::SetTransport { + public_key: "office-relay".into(), + transport: "TLS Over Proxy".into(), + }; + let resp = dispatch_cmd(&mut pm, set_tr_cmd, "yip0", start); + assert!(matches!(resp, ControlResponse::Ack { .. })); + assert_eq!(pm.peer_stats()[1].transport, "TLS Over Proxy"); + + // Remove peer using alias instead of hex key + let rm_cmd = ControlCmd::RemovePeer { + public_key: "office-relay".into(), + }; + let resp = dispatch_cmd(&mut pm, rm_cmd, "yip0", start); + assert_eq!( + resp, + ControlResponse::Ack { + ok: true, + message: "peer removed".into() + } + ); + assert_eq!(pm.peer_stats().len(), 1); + } + + #[test] + fn control_protocol_create_ticket_rpc_and_serialization() { + let mut pm = crate::peer_manager::testutil::test_peer_manager(); + pm.set_listen_port(51820); + let start = Instant::now(); + + // 1. Create ticket via dispatch_cmd + let cmd = ControlCmd::CreateTicket { + name: Some("TestCluster".into()), + route_mode: Some("ExitNode".into()), + endpoint: Some("203.0.113.88:51820".into()), + }; + let resp = dispatch_cmd(&mut pm, cmd, "yip0", start); + if let ControlResponse::Ticket { + ok, + ticket, + uri, + qr_terminal, + } = resp + { + assert!(ok); + assert_eq!(ticket.name, "TestCluster"); + assert_eq!(ticket.route_mode, "ExitNode"); + assert_eq!(ticket.endpoint.as_deref(), Some("203.0.113.88:51820")); + assert!(uri.starts_with("yip://join?ticket=")); + assert!(!qr_terminal.is_empty()); + + // Parse URI back and assert equality + let parsed = crate::ticket::NetworkTicket::parse(&uri).expect("parse URI"); + assert_eq!(parsed.name, ticket.name); + assert_eq!(parsed.network_id, ticket.network_id); + assert_eq!(parsed.route_mode, ticket.route_mode); + assert_eq!(parsed.endpoint, ticket.endpoint); + } else { + panic!("expected Ticket response"); + } + + // 2. Test JSON round-trip serialization of CreateTicket and Ticket + let cmd_json = r#"{"cmd":"create_ticket","name":"QuickNet","route_mode":"MeshOnly"}"#; + let deserialized_cmd: ControlCmd = + serde_json::from_str(cmd_json).expect("deserialize CreateTicket"); + if let ControlCmd::CreateTicket { + name, + route_mode, + endpoint, + } = deserialized_cmd + { + assert_eq!(name.as_deref(), Some("QuickNet")); + assert_eq!(route_mode.as_deref(), Some("MeshOnly")); + assert_eq!(endpoint, None); + } else { + panic!("expected CreateTicket cmd variant"); + } + } + #[test] fn control_handle_socket_round_trip() { let socket_path = format!("/tmp/test_control_{}.sock", std::process::id()); @@ -3041,6 +3300,7 @@ mod tests { public_key: "bad_hex".into(), endpoint: None, transport: None, + alias: None, }; assert!(matches!( dispatch_cmd(&mut pm, bad_add, "yip0", start), @@ -3052,6 +3312,7 @@ mod tests { public_key: "03".repeat(32), endpoint: Some("not_an_ip".into()), transport: None, + alias: None, }; assert!(matches!( dispatch_cmd(&mut pm, bad_ep, "yip0", start), @@ -3064,6 +3325,7 @@ mod tests { public_key: pk3.clone(), endpoint: Some("127.0.0.1:51820".into()), transport: Some("Holepunched UDP".into()), + alias: Some("peer3".into()), }; assert_eq!( dispatch_cmd(&mut pm, ok_add, "yip0", start), @@ -3123,6 +3385,7 @@ mod tests { rtt_ms: Some(28), fec_ratio_pct: 3, cert_status: "CA Valid".into(), + alias: None, }; let p2 = PeerStats { @@ -3140,6 +3403,7 @@ mod tests { rtt_ms: None, fec_ratio_pct: 0, cert_status: "CA Valid".into(), + alias: None, }; let peers = vec![p1, p2]; @@ -3221,9 +3485,33 @@ mod tests { assert!(run_cli_trace(path, "10.0.0.1", false).is_ok()); assert!(run_cli_trace(path, "10.0.0.1", true).is_ok()); assert!(run_cli_trace(path, "nonexistent", false).is_ok()); - assert!( - run_cli_peer_add(path, &"04".repeat(32), Some("1.2.3.4:51820"), Some("TLS")).is_ok() - ); + assert!(run_cli_peer_add( + path, + &"04".repeat(32), + Some("1.2.3.4:51820"), + Some("TLS"), + Some("peer4") + ) + .is_ok()); + assert!(run_cli_peer_add(path, "bad_hex", None, None, None).is_err()); + assert!(run_cli_ticket_create( + path, + Some("MyNet".into()), + Some("MeshOnly".into()), + Some("1.2.3.4:51820".into()), + false, + false + ) + .is_ok()); + assert!(run_cli_ticket_create(path, None, None, None, true, true).is_ok()); + assert!(run_cli_ticket_create(path, None, None, None, false, true).is_ok()); + let sample_ticket = "yip://join?ticket=eyJuYW1lIjoiVGVzdE5ldCIsIm5ldHdvcmtfaWQiOiJhYWJiY2NkZCIsInJvdXRlX21vZGUiOiJNZXNoT25seSJ9"; + assert!(run_cli_ticket_show(sample_ticket, false, false).is_ok()); + assert!(run_cli_ticket_show(sample_ticket, false, true).is_ok()); + assert!(run_cli_ticket_show(sample_ticket, true, true).is_ok()); + assert!(run_cli_ticket_show(sample_ticket, true, false).is_ok()); + assert!(run_cli_ticket_show("not-a-ticket@@@", false, false).is_err()); + assert!(run_cli_ticket_show("not-a-ticket@@@", true, false).is_err()); assert!(run_cli_fec_status(path, false).is_ok()); assert!(run_cli_fec_status(path, true).is_ok()); assert!(run_cli_fec_set(path, Some("hostile".into()), Some(30), Some(10), Some(4)).is_ok()); diff --git a/bin/yipd/src/lib.rs b/bin/yipd/src/lib.rs index e9cef0a..caded11 100644 --- a/bin/yipd/src/lib.rs +++ b/bin/yipd/src/lib.rs @@ -20,6 +20,7 @@ mod quic; mod relay_client; mod rendezvous; pub mod sharding; +pub mod ticket; mod tls; mod tunnel; pub mod wire_glue; diff --git a/bin/yipd/src/main.rs b/bin/yipd/src/main.rs index 9ca441d..e94f267 100644 --- a/bin/yipd/src/main.rs +++ b/bin/yipd/src/main.rs @@ -22,6 +22,7 @@ mod quic; mod relay_client; mod rendezvous; pub mod sharding; +pub mod ticket; mod tls; mod tunnel; mod wire_glue; @@ -51,6 +52,7 @@ fn print_daemon_usage() { println!("Commands:"); println!(" status Display daemon status and summary"); println!(" peers List connected peers and statistics"); + println!(" ticket Generate or inspect network invitation tickets and QR codes"); println!(" crypto Inspect active cryptographic session states or trigger rekeying"); println!(" metrics Display runtime metrics and telemetry"); println!(" top Real-time ANSI telemetry dashboard"); @@ -146,8 +148,27 @@ fn print_cli_usage(subcmd: &str) { println!(); println!("Options:"); println!(" -c, --control Path to yipd UNIX control socket"); + println!(" --alias Human-readable nickname/alias for peer"); println!(" -h, --help Print help"); } + "ticket" => { + println!("Usage: yipctl ticket [ARGS] [OPTIONS]"); + println!(); + println!("Generate or inspect network onboarding tickets and terminal QR codes."); + println!(); + println!("Commands:"); + println!(" create [--name ] [--route-mode ] [--endpoint ] Generate new ticket"); + println!(" show Display existing ticket"); + println!(); + println!("Options:"); + println!(" -c, --control Path to yipd UNIX control socket"); + println!(" --name Network human-readable name"); + println!(" -m, --route-mode Routing mode (MeshOnly, ExitNode, SplitTunnel)"); + println!(" -e, --endpoint External endpoint (e.g. 203.0.113.1:51820)"); + println!(" --no-qr Omit rendering terminal QR code"); + println!(" --json Output raw JSON"); + println!(" -h, --help Print help"); + } "fec" => { println!("Usage: yipctl fec [OPTIONS]"); println!(); @@ -280,6 +301,7 @@ fn print_cli_usage(subcmd: &str) { println!(" ping Probe round-trip latency to a peer"); println!(" trace Trace multi-hop path and segment latencies across mesh"); println!(" peer Dynamically add or remove peers"); + println!(" ticket Generate or inspect network onboarding tickets and QR codes"); println!(" fec Query or configure dynamic Reed-Solomon FEC"); println!(" daita Query or configure dynamic DAITA traffic defense"); println!(" cert Display certificate status or trigger manual renewal"); @@ -313,6 +335,10 @@ fn run_client_subcommand( let mut apps: Option> = None; let mut ping_count = 4u32; let mut ping_timeout = 2000u64; + let mut alias: Option = None; + let mut ticket_name: Option = None; + let mut ticket_endpoint: Option = None; + let mut no_qr = false; let mut positional: Vec = Vec::new(); while let Some(arg) = args.next() { @@ -549,6 +575,45 @@ fn run_client_subcommand( })?; ping_timeout = t; } + "--alias" => { + let a = args.next().ok_or_else(|| { + std::io::Error::new( + std::io::ErrorKind::InvalidInput, + "--alias requires a peer nickname/alias", + ) + })?; + alias = Some(a); + } + "--name" => { + let n = args.next().ok_or_else(|| { + std::io::Error::new( + std::io::ErrorKind::InvalidInput, + "--name requires a network name", + ) + })?; + ticket_name = Some(n); + } + "--route-mode" => { + let m = args.next().ok_or_else(|| { + std::io::Error::new( + std::io::ErrorKind::InvalidInput, + "--route-mode requires a mode (MeshOnly, ExitNode, SplitTunnel)", + ) + })?; + mode = Some(m); + } + "--endpoint" | "-e" => { + let ep = args.next().ok_or_else(|| { + std::io::Error::new( + std::io::ErrorKind::InvalidInput, + "--endpoint requires an address (e.g. 203.0.113.1:51820)", + ) + })?; + ticket_endpoint = Some(ep); + } + "--no-qr" => { + no_qr = true; + } "--help" | "-h" => { print_cli_usage(subcmd); return Ok(()); @@ -597,7 +662,8 @@ fn run_client_subcommand( let pk = &positional[1]; let ep = positional.get(2).map(|s| s.as_str()); let tr = positional.get(3).map(|s| s.as_str()); - control::run_cli_peer_add(&socket, pk, ep, tr).map_err(std::io::Error::other) + control::run_cli_peer_add(&socket, pk, ep, tr, alias.as_deref()) + .map_err(std::io::Error::other) } "rm" => { if positional.len() < 2 { @@ -651,6 +717,41 @@ fn run_client_subcommand( } } } + "ticket" => { + if positional.is_empty() { + print_cli_usage("ticket"); + return Ok(()); + } + match positional[0].as_str() { + "create" => control::run_cli_ticket_create( + &socket, + ticket_name, + mode, + ticket_endpoint, + no_qr, + json, + ) + .map_err(std::io::Error::other), + "show" => { + if positional.len() < 2 { + eprintln!("Usage: yipctl ticket show [OPTIONS]"); + return Err(std::io::Error::new( + std::io::ErrorKind::InvalidInput, + "missing ticket or URI payload", + )); + } + let raw = &positional[1]; + control::run_cli_ticket_show(raw, no_qr, json).map_err(std::io::Error::other) + } + other => { + eprintln!("Unknown ticket action: {other}"); + Err(std::io::Error::new( + std::io::ErrorKind::InvalidInput, + "unknown ticket action (expected 'create' or 'show')", + )) + } + } + } "cert" => { if positional.is_empty() { println!("Usage: yipd cert "); diff --git a/bin/yipd/src/metrics.rs b/bin/yipd/src/metrics.rs index eb2d09c..987c1cd 100644 --- a/bin/yipd/src/metrics.rs +++ b/bin/yipd/src/metrics.rs @@ -935,6 +935,7 @@ mod tests { rtt_ms: Some(15), fec_ratio_pct: 5, cert_status: "CA Valid".into(), + alias: None, }; let snap = registry.snapshot(std::slice::from_ref(&peer)); @@ -1114,6 +1115,7 @@ mod tests { rtt_ms: Some(25), fec_ratio_pct: 10, cert_status: "CA Valid".into(), + alias: None, }; let server = MetricsHttpServer::start( diff --git a/bin/yipd/src/peer_manager/gossip.rs b/bin/yipd/src/peer_manager/gossip.rs index 4486747..329763b 100644 --- a/bin/yipd/src/peer_manager/gossip.rs +++ b/bin/yipd/src/peer_manager/gossip.rs @@ -192,6 +192,7 @@ mod tests { let cfg = PeerConfig { public_key: gossip_peer.public, endpoint: Some(src), + alias: None, }; let mut pm = PeerManager::new( local.private, @@ -269,6 +270,7 @@ mod tests { let cfg = PeerConfig { public_key: peer.public, endpoint: Some(peer_ep), + alias: None, }; let mut pm = PeerManager::new( local.private, diff --git a/bin/yipd/src/peer_manager/handshake.rs b/bin/yipd/src/peer_manager/handshake.rs index bb3271f..f7c68e5 100644 --- a/bin/yipd/src/peer_manager/handshake.rs +++ b/bin/yipd/src/peer_manager/handshake.rs @@ -547,6 +547,7 @@ mod tests { let cfg_i = PeerConfig { public_key: kp_i.public, endpoint: Some(ep_i), + alias: None, }; let mut pm_r = PeerManager::new( kp_r.private, @@ -639,6 +640,7 @@ mod tests { let cfg_i = PeerConfig { public_key: kp_i.public, endpoint: Some(ep_i), + alias: None, }; let mut pm_r = PeerManager::new( kp_r.private, @@ -733,10 +735,12 @@ mod tests { let cfg_b = PeerConfig { public_key: kp_b.public, endpoint: Some(ep_b), + alias: None, }; let cfg_a = PeerConfig { public_key: kp_a.public, endpoint: Some(ep_a), + alias: None, }; let mut pm_a = PeerManager::new( kp_a.private, @@ -811,6 +815,7 @@ mod tests { let peer = PeerConfig { public_key: peer_pubkey, endpoint: Some(ep), + alias: None, }; let (mut pm, _sent) = pm_with_mock_rdv(&local, &[peer]); pm.on_tun(&dummy_tun_pkt(), started_ms); @@ -1314,6 +1319,7 @@ mod tests { let cfg_peer = PeerConfig { public_key: peer.public, endpoint: Some(peer_ep), + alias: None, }; let mut pm = PeerManager::new( local.private, @@ -1371,6 +1377,7 @@ mod tests { let cfg = PeerConfig { public_key: peer_kp.public, endpoint: Some(peer_ep), + alias: None, }; // ── absent cert in msg2 → rejected ── @@ -1456,6 +1463,7 @@ mod tests { let cfg = PeerConfig { public_key: root.public, endpoint: Some(root_ep), + alias: None, }; let roots = RootSet { roots: vec![(root.public, root_ep)], @@ -1634,6 +1642,7 @@ mod tests { let peer = PeerConfig { public_key: peer_kp.public, endpoint: None, + alias: None, }; let (mut pm, _sent) = pm_with_mock_rdv(&local, &[peer]); pm.set_obf_psk(Some([0xBBu8; 32])); diff --git a/bin/yipd/src/peer_manager/mod.rs b/bin/yipd/src/peer_manager/mod.rs index 3669c13..cf4444b 100644 --- a/bin/yipd/src/peer_manager/mod.rs +++ b/bin/yipd/src/peer_manager/mod.rs @@ -199,6 +199,8 @@ struct HandshakingState { #[derive(Debug, Clone, PartialEq, Eq, serde::Serialize, serde::Deserialize)] pub struct PeerStats { pub public_key: [u8; 32], + #[serde(default, skip_serializing_if = "Option::is_none")] + pub alias: Option, pub endpoint: Option, pub node_addr: std::net::Ipv6Addr, pub state: String, @@ -232,6 +234,7 @@ enum PeerState { /// One configured remote peer plus its live handshake/session state. struct Peer { pubkey: [u8; 32], + alias: Option, /// This peer's self-certifying inner IPv6 address (`node_addr(pubkey)`). /// Routing itself goes through `by_addr` (kept alongside for tests and /// future logging/debugging use). @@ -587,6 +590,7 @@ impl PeerManager { } peers.push(Peer { pubkey: p.public_key, + alias: p.alias.clone(), addr, endpoint: p.endpoint, state: PeerState::Idle, @@ -710,6 +714,7 @@ impl PeerManager { self.by_node.insert(node, idx); self.peers.push(Peer { pubkey, + alias: None, addr, endpoint: endpoints.first().copied(), state: PeerState::Idle, @@ -1000,6 +1005,15 @@ impl PeerManager { return if self.peers.is_empty() { None } else { Some(0) }; } + // 0. Match human-readable alias (case-insensitive) + for (i, p) in self.peers.iter().enumerate() { + if let Some(alias) = &p.alias { + if alias.eq_ignore_ascii_case(&cleaned) { + return Some(i); + } + } + } + // 1. Match full hex or prefix hex for (i, p) in self.peers.iter().enumerate() { let full_hex: String = p.pubkey.iter().map(|b| format!("{b:02x}")).collect(); @@ -1752,6 +1766,7 @@ impl PeerManager { self.by_addr.insert(addr, idx); self.peers.push(Peer { pubkey: cfg.public_key, + alias: cfg.alias, addr, endpoint: cfg.endpoint, state: PeerState::Idle, @@ -1861,6 +1876,7 @@ impl PeerManager { PeerStats { public_key: p.pubkey, + alias: p.alias.clone(), endpoint: p.endpoint, node_addr: p.addr, state: state_str.to_string(), @@ -1884,6 +1900,25 @@ impl PeerManager { self.peer_stats() } + /// Lookup peer index by human-readable alias (case-insensitive). + pub fn find_peer_by_alias(&self, alias: &str) -> Option { + let clean = alias.trim(); + if clean.is_empty() { + return None; + } + self.peers.iter().position(|p| { + p.alias + .as_deref() + .map(|a| a.eq_ignore_ascii_case(clean)) + .unwrap_or(false) + }) + } + + /// Retrieve public key for peer at index. + pub fn peer_pubkey(&self, idx: usize) -> Option<[u8; 32]> { + self.peers.get(idx).map(|p| p.pubkey) + } + // ── rendezvous / path helpers ───────────────────────────────────────── /// The configured rendezvous server address (only meaningful when a diff --git a/bin/yipd/src/peer_manager/rekey.rs b/bin/yipd/src/peer_manager/rekey.rs index 8adf53a..486c036 100644 --- a/bin/yipd/src/peer_manager/rekey.rs +++ b/bin/yipd/src/peer_manager/rekey.rs @@ -1282,6 +1282,7 @@ mod tests { let cfg_i = PeerConfig { public_key: kp_i.public, endpoint: Some(ep_i), + alias: None, }; let mut pm_r = PeerManager::new( kp_r.private, diff --git a/bin/yipd/src/peer_manager/relay.rs b/bin/yipd/src/peer_manager/relay.rs index ffb2b02..327c6d6 100644 --- a/bin/yipd/src/peer_manager/relay.rs +++ b/bin/yipd/src/peer_manager/relay.rs @@ -613,6 +613,7 @@ mod tests { let cfg_peer = PeerConfig { public_key: peer_kp.public, endpoint: None, + alias: None, }; let (mut pm, _sent) = pm_with_mock_rdv(&local, &[cfg_peer]); @@ -681,6 +682,7 @@ mod tests { let peer = PeerConfig { public_key: peer_kp.public, endpoint: Some(endpoint), + alias: None, }; let (mut pm, _sent) = pm_with_mock_rdv(&local, &[peer]); @@ -746,6 +748,7 @@ mod tests { let peer = PeerConfig { public_key: peer_kp.public, endpoint: Some(endpoint), + alias: None, }; let (mut pm, _sent) = pm_with_mock_rdv(&local, &[peer]); @@ -1191,6 +1194,7 @@ mod tests { let peer = PeerConfig { public_key: peer_kp.public, endpoint: None, + alias: None, }; let mut pm = PeerManager::new( local.private, @@ -1258,6 +1262,7 @@ mod tests { let cfg_peer = PeerConfig { public_key: peer.public, endpoint: None, + alias: None, }; let sent = std::rc::Rc::new(std::cell::RefCell::new(Vec::new())); let rdv: Box = Box::new(MockRdv { @@ -1328,6 +1333,7 @@ mod tests { let peer = PeerConfig { public_key: peer_kp.public, endpoint: None, + alias: None, }; let membership = membership_trusting_ca_via_roots(&ca, local.public); let (mut pm, _sent) = pm_with_mock_rdv_and_membership(&local, &[peer], membership); @@ -1375,6 +1381,7 @@ mod tests { let peer = PeerConfig { public_key: peer_kp.public, endpoint: None, + alias: None, }; let membership = membership_trusting_ca_via_roots(&ca, local.public); let (mut pm, _sent) = pm_with_mock_rdv_and_membership(&local, &[peer], membership); @@ -1539,6 +1546,7 @@ mod tests { let cfg_peer = PeerConfig { public_key: peer_kp.public, endpoint: None, + alias: None, }; let (mut pm, _sent) = pm_with_mock_rdv(&local, &[cfg_peer]); @@ -1573,6 +1581,7 @@ mod tests { let cfg_peer = PeerConfig { public_key: peer_kp.public, endpoint: None, + alias: None, }; let mem = membership_for(&ca, local.public); let (mut pm, _sent) = pm_with_mock_rdv_and_membership(&local, &[cfg_peer], mem); @@ -1649,6 +1658,7 @@ mod tests { let cfg_peer = PeerConfig { public_key: peer_kp.public, endpoint: None, + alias: None, }; let mem = membership_for(&ca, local.public); let (mut pm, _sent) = pm_with_mock_rdv_and_membership(&local, &[cfg_peer], mem); @@ -1670,6 +1680,7 @@ mod tests { let cfg_peer = PeerConfig { public_key: peer_kp.public, endpoint: None, + alias: None, }; let mem = membership_for(&ca, local.public); let (mut pm, _sent) = pm_with_mock_rdv_and_membership(&local, &[cfg_peer], mem); diff --git a/bin/yipd/src/peer_manager/tests.rs b/bin/yipd/src/peer_manager/tests.rs index 2e8b6fb..67c7030 100644 --- a/bin/yipd/src/peer_manager/tests.rs +++ b/bin/yipd/src/peer_manager/tests.rs @@ -103,6 +103,7 @@ fn stale_replayed_init_is_rejected_and_endpoint_unchanged() { let cfg_i = PeerConfig { public_key: kp_i.public, endpoint: Some(ep_i), + alias: None, }; let mut pm_r = PeerManager::new( kp_r.private, @@ -174,6 +175,7 @@ fn retransmit_still_replays_cached_resp_regardless_of_ts() { let cfg_i = PeerConfig { public_key: kp_i.public, endpoint: Some(ep_i), + alias: None, }; let mut pm_r = PeerManager::new( kp_r.private, @@ -228,6 +230,7 @@ fn duplicate_init_after_established_does_not_tear_down_session() { let cfg_i = PeerConfig { public_key: kp_i.public, endpoint: Some(ep_i), + alias: None, }; let mut pm_r = PeerManager::new( kp_r.private, @@ -275,6 +278,7 @@ fn initiator_retransmits_same_init_within_total_window_then_gives_up() { let peer = PeerConfig { public_key: [7u8; 32], endpoint: Some("10.0.0.9:9000".parse().unwrap()), + alias: None, }; let mut pm = PeerManager::new( kp_local.private, @@ -335,6 +339,7 @@ fn pending_tun_is_capped_while_handshaking() { let peer = PeerConfig { public_key: [7u8; 32], endpoint: Some("10.0.0.9:9000".parse().unwrap()), + alias: None, }; let mut pm = PeerManager::new( kp_local.private, @@ -366,6 +371,7 @@ fn rendezvous_only_peer_emits_lookup_on_tun_traffic() { let peer = PeerConfig { public_key: peer_kp.public, endpoint: None, + alias: None, }; let (mut pm, sent) = pm_with_mock_rdv(&local, &[peer]); @@ -399,6 +405,7 @@ fn peer_candidate_then_tick_probes_candidate_with_init() { let peer = PeerConfig { public_key: peer_kp.public, endpoint: None, + alias: None, }; let (mut pm, _sent) = pm_with_mock_rdv(&local, &[peer]); @@ -449,6 +456,7 @@ fn peer_candidate_with_valid_signed_record_is_accepted_and_probed() { let peer = PeerConfig { public_key: peer_kp.public, endpoint: None, + alias: None, }; let membership = membership_trusting_ca_via_roots(&ca, local.public); let (mut pm, _sent) = pm_with_mock_rdv_and_membership(&local, &[peer], membership); @@ -502,6 +510,7 @@ fn peer_candidate_with_invalid_record_is_dropped_no_probe() { let peer = PeerConfig { public_key: peer_kp.public, endpoint: None, + alias: None, }; let membership = membership_trusting_ca_via_roots(&ca, local.public); let (mut pm, _sent) = pm_with_mock_rdv_and_membership(&local, &[peer], membership); @@ -553,6 +562,7 @@ fn peer_candidate_with_valid_record_for_wrong_node_is_dropped() { let peer = PeerConfig { public_key: peer_kp.public, endpoint: None, + alias: None, }; let membership = membership_trusting_ca_via_roots(&ca, local.public); let (mut pm, _sent) = pm_with_mock_rdv_and_membership(&local, &[peer], membership); @@ -596,6 +606,7 @@ fn no_rendezvous_direct_endpoint_is_pure_2a() { let peer = PeerConfig { public_key: [7u8; 32], endpoint: Some(endpoint), + alias: None, }; let mut pm = PeerManager::new( local.private, @@ -632,6 +643,7 @@ fn punch_handshake_escalates_to_relay_at_punch_window_not_90s() { let peer = PeerConfig { public_key: peer_kp.public, endpoint: None, // rendezvous-only: starts in the Punching stage + alias: None, }; let (mut pm, _sent) = pm_with_mock_rdv(&local, &[peer]); @@ -712,6 +724,7 @@ fn punch_relay_retarget_draws_fresh_ephemeral_even_if_relay_flag_preset() { let peer = PeerConfig { public_key: peer_kp.public, endpoint: None, // rendezvous-only: starts in the Punching stage + alias: None, }; let (mut pm, _sent) = pm_with_mock_rdv(&local, &[peer]); @@ -823,6 +836,7 @@ fn late_punch_reply_after_relay_escalation_does_not_poison_relay() { let peer = PeerConfig { public_key: peer_kp.public, endpoint: None, // rendezvous-only: starts in the Punching stage + alias: None, }; let (mut pm, _sent) = pm_with_mock_rdv(&local, &[peer]); @@ -976,6 +990,7 @@ fn endpoint_peer_emits_lookup_and_punches_after_direct_window() { let peer = PeerConfig { public_key: peer_kp.public, endpoint: Some(endpoint), // BOTH a direct endpoint AND (via the mock) a rendezvous + alias: None, }; let (mut pm, sent) = pm_with_mock_rdv(&local, &[peer]); @@ -1254,6 +1269,7 @@ fn anti_hijack_established_peer_unmoved_by_gossip_and_resolve() { let cfg = PeerConfig { public_key: peer.public, endpoint: Some(committed_ep), + alias: None, }; let mut pm = PeerManager::new( local.private, @@ -1442,6 +1458,7 @@ fn obf_on_unknown_src_handshake_init_via_obf_psk() { let cfg_i = PeerConfig { public_key: kp_i.public, endpoint: Some(ep_i), + alias: None, }; let mut pm = PeerManager::new( kp_r.private, @@ -1601,6 +1618,7 @@ fn obf_off_on_udp_is_plaintext_as_today() { let cfg_i = PeerConfig { public_key: kp_i.public, endpoint: Some(ep_i), + alias: None, }; let mut pm = PeerManager::new( kp_r.private, @@ -1640,6 +1658,7 @@ fn obf_on_egress_to_server_is_wrapped_under_rdv_type() { let peer = PeerConfig { public_key: peer_kp.public, endpoint: None, + alias: None, }; let (mut pm, _sent) = pm_with_mock_rdv(&local, &[peer]); let psk = [0x55u8; 32]; @@ -1687,6 +1706,7 @@ fn obf_on_ingress_from_server_is_unwrapped_before_on_rdv() { let peer = PeerConfig { public_key: peer_kp.public, endpoint: None, + alias: None, }; let (mut pm, _sent) = pm_with_mock_rdv(&local, &[peer]); let psk = [0x66u8; 32]; @@ -1744,6 +1764,7 @@ fn obf_off_rendezvous_traffic_stays_plaintext() { let peer = PeerConfig { public_key: peer_kp.public, endpoint: None, + alias: None, }; let (mut pm, _sent) = pm_with_mock_rdv(&local, &[peer]); // No set_obf_psk ⇒ obfuscation disabled. @@ -2030,10 +2051,12 @@ fn pm_mesh_two_established_one_expired( let cfg0 = PeerConfig { public_key: expired_peer_pub, endpoint: Some("10.0.0.2:2000".parse().unwrap()), + alias: None, }; let cfg1 = PeerConfig { public_key: valid_peer_pub, endpoint: Some("10.0.0.3:3000".parse().unwrap()), + alias: None, }; let mut pm = PeerManager::new( local.private, @@ -2246,6 +2269,7 @@ fn dynamic_add_peer_updates_mappings_and_routes() { let new_cfg = PeerConfig { public_key: new_pk, endpoint: Some(new_ep), + alias: None, }; // Add peer @@ -2276,12 +2300,14 @@ fn dynamic_remove_peer_cleans_mappings_and_tears_down() { .add_peer(PeerConfig { public_key: p2_pk, endpoint: Some("10.0.0.2:2000".parse().unwrap()), + alias: None, }) .is_ok()); assert!(pm .add_peer(PeerConfig { public_key: p3_pk, endpoint: Some("10.0.0.3:3000".parse().unwrap()), + alias: None, }) .is_ok()); assert_eq!(pm.peers.len(), 3); @@ -3068,10 +3094,12 @@ fn test_peer_manager_metrics_relayed_traffic() { let cfg_b = PeerConfig { public_key: kp_b.public, endpoint: Some(ep_b), + alias: None, }; let cfg_a = PeerConfig { public_key: kp_a.public, endpoint: Some(ep_a), + alias: None, }; let (mut pm_a, _sent_a) = pm_with_mock_rdv(&kp_a, &[cfg_b]); @@ -3542,3 +3570,24 @@ fn test_peer_manager_tick_daita_timer_actions() { ); } } + +#[test] +fn test_peer_alias_lookup_and_pubkey() { + let mut pm = test_peer_manager(); + assert_eq!(pm.find_peer_by_alias(""), None); + assert_eq!(pm.find_peer_by_alias(" "), None); + assert_eq!(pm.find_peer_by_alias("nonexistent"), None); + + // Add a peer with alias + let cfg = PeerConfig::new([7u8; 32], None).with_alias("Gateway-Alpha"); + pm.add_peer(cfg).expect("add_peer"); + + assert_eq!(pm.find_peer_by_alias("Gateway-Alpha"), Some(1)); + assert_eq!(pm.find_peer_by_alias("gateway-alpha"), Some(1)); + assert_eq!(pm.find_peer_by_alias(" GATEWAY-ALPHA "), Some(1)); + assert_eq!(pm.peer_pubkey(1), Some([7u8; 32])); + assert_eq!(pm.peer_pubkey(999), None); + + // Resolving by ID using alias + assert_eq!(pm.find_peer_index_by_id("gateway-alpha"), Some(1)); +} diff --git a/bin/yipd/src/peer_manager/testutil.rs b/bin/yipd/src/peer_manager/testutil.rs index 77ef361..45d7cf2 100644 --- a/bin/yipd/src/peer_manager/testutil.rs +++ b/bin/yipd/src/peer_manager/testutil.rs @@ -16,6 +16,7 @@ pub(super) fn peer_cfg(tag_byte: u8, endpoint: &str) -> PeerConfig { PeerConfig { public_key: [tag_byte; 32], endpoint: Some(endpoint.parse().unwrap()), + alias: None, } } @@ -186,6 +187,7 @@ pub(super) fn pm_with_established_peer( let cfg = PeerConfig { public_key: peer_pubkey, endpoint: Some(ep), + alias: None, }; let mut pm = PeerManager::new( [7u8; 32], @@ -254,10 +256,12 @@ pub(crate) fn established_pm_pair( let cfg_b = PeerConfig { public_key: kp_b.public, endpoint: Some(ep_b), + alias: None, }; let cfg_a = PeerConfig { public_key: kp_a.public, endpoint: Some(ep_a), + alias: None, }; let mut pm_a = PeerManager::new( kp_a.private, @@ -317,10 +321,12 @@ pub(super) fn established_pm_pair_with_obf( let cfg_b = PeerConfig { public_key: kp_b.public, endpoint: Some(ep_b), + alias: None, }; let cfg_a = PeerConfig { public_key: kp_a.public, endpoint: Some(ep_a), + alias: None, }; let mut pm_a = PeerManager::new( kp_a.private, @@ -622,6 +628,7 @@ pub(super) fn responder_established_for_initiator( let cfg_a = PeerConfig { public_key: kp_a.public, endpoint: None, + alias: None, }; let (mut pm_r, _sent) = pm_with_mock_rdv(&kp_r, &[cfg_a]); @@ -665,6 +672,7 @@ pub(super) fn responder_established_direct_for_initiator( let cfg_a = PeerConfig { public_key: kp_a.public, endpoint: Some(ep_a), + alias: None, }; let (mut pm_r, _sent) = pm_with_mock_rdv(&kp_r, &[cfg_a]); @@ -717,6 +725,7 @@ pub(super) fn established_relay_pm( let peer = PeerConfig { public_key: peer_kp.public, endpoint: None, + alias: None, }; let (mut pm, _sent) = pm_with_mock_rdv(&local, &[peer]); pm.rekey_interval_ms = rekey_interval_ms; @@ -885,6 +894,7 @@ pub(super) fn pm_mesh_established_peer( let cfg_peer = PeerConfig { public_key: peer.public, endpoint: Some(peer_ep), + alias: None, }; let mut pm = PeerManager::new( local.private, diff --git a/bin/yipd/src/ticket.rs b/bin/yipd/src/ticket.rs new file mode 100644 index 0000000..a88172c --- /dev/null +++ b/bin/yipd/src/ticket.rs @@ -0,0 +1,325 @@ +#![forbid(unsafe_code)] + +//! Invitation ticket encoding, decoding, and terminal QR code rendering. +//! +//! Compatible with the cross-platform `yip-client` (desktop and mobile) ticket format. + +use base64::engine::general_purpose::{STANDARD, URL_SAFE, URL_SAFE_NO_PAD}; +use base64::Engine; +use qrcode::render::unicode; +use qrcode::QrCode; +use serde::{Deserialize, Serialize}; + +/// Version identifier for network tickets. +pub const TICKET_VERSION: u32 = 1; + +/// Network invitation ticket for onboarding mesh clients. +#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] +pub struct NetworkTicket { + #[serde(default = "default_ticket_version")] + pub v: u32, + pub name: String, + pub network_id: String, + #[serde(default = "default_ticket_route_mode")] + pub route_mode: String, + #[serde(default, skip_serializing_if = "Option::is_none")] + pub endpoint: Option, + #[serde(default, skip_serializing_if = "Option::is_none")] + pub seeds: Option>, + #[serde(default, skip_serializing_if = "Option::is_none")] + pub created_at: Option, +} + +fn default_ticket_version() -> u32 { + TICKET_VERSION +} + +fn default_ticket_route_mode() -> String { + "MeshOnly".to_string() +} + +impl NetworkTicket { + /// Create a new ticket with required parameters and current UTC timestamp. + pub fn new( + name: impl Into, + network_id: impl Into, + route_mode: impl Into, + ) -> Self { + let mode = route_mode.into(); + let normalized_mode = match mode.as_str() { + "ExitNode" | "FullExitNode" => "ExitNode".to_string(), + "SplitTunnel" => "SplitTunnel".to_string(), + _ => "MeshOnly".to_string(), + }; + + Self { + v: TICKET_VERSION, + name: name.into().trim().to_string(), + network_id: network_id.into().trim().to_string(), + route_mode: normalized_mode, + endpoint: None, + seeds: None, + created_at: None, + } + } + + /// Set an optional public endpoint (e.g. `203.0.113.1:51820`). + pub fn with_endpoint(mut self, endpoint: impl Into) -> Self { + let ep = endpoint.into().trim().to_string(); + if !ep.is_empty() { + self.endpoint = Some(ep); + } + self + } + + /// Set optional seed node addresses. + pub fn with_seeds(mut self, seeds: Vec) -> Self { + let filtered: Vec = seeds + .into_iter() + .map(|s| s.trim().to_string()) + .filter(|s| !s.is_empty()) + .collect(); + if !filtered.is_empty() { + self.seeds = Some(filtered); + } + self + } + + /// Serialize ticket to compact JSON string. + pub fn to_json(&self) -> Result { + serde_json::to_string(self).map_err(|e| format!("Failed to serialize ticket to JSON: {e}")) + } + + /// Serialize ticket to URL-safe base64 string. + pub fn to_base64(&self) -> Result { + let json = self.to_json()?; + Ok(URL_SAFE_NO_PAD.encode(json.as_bytes())) + } + + /// Format ticket as a `yip://join?ticket={b64}` invitation URI. + pub fn to_uri(&self) -> Result { + let b64 = self.to_base64()?; + Ok(format!("yip://join?ticket={b64}")) + } + + /// Parse a ticket from a `yip://` URI, base64 payload, or raw JSON. + pub fn parse(raw: &str) -> Result { + let cleaned = raw.trim(); + if cleaned.is_empty() { + return Err("Invitation ticket is empty".to_string()); + } + + let decode_b64 = |b64: &str| -> Result { + let b64_clean = b64.trim(); + let bytes = URL_SAFE_NO_PAD + .decode(b64_clean) + .or_else(|_| URL_SAFE.decode(b64_clean)) + .or_else(|_| STANDARD.decode(b64_clean)) + .map_err(|e| format!("Invalid Base64 ticket payload: {e}"))?; + String::from_utf8(bytes).map_err(|e| format!("Invalid UTF-8 in decoded ticket: {e}")) + }; + + let json_str = if cleaned.starts_with("yip://") { + // Parse query string manually or via URL parser + let query = cleaned.split_once('?').map(|(_, q)| q).unwrap_or(""); + let mut ticket_param = None; + let mut name_param = None; + let mut net_param = None; + let mut mode_param = None; + let mut endpoint_param = None; + + for pair in query.split('&') { + if pair.is_empty() { + continue; + } + let (k, v) = pair.split_once('=').unwrap_or((pair, "")); + match k { + "ticket" => ticket_param = Some(v.to_string()), + "name" => name_param = Some(v.to_string()), + "net" | "network_id" => net_param = Some(v.to_string()), + "mode" | "route_mode" => mode_param = Some(v.to_string()), + "endpoint" => endpoint_param = Some(v.to_string()), + _ => {} + } + } + + if let Some(t) = ticket_param { + decode_b64(&t)? + } else if let (Some(name), Some(net)) = (name_param, net_param) { + let mode = mode_param.unwrap_or_else(|| "MeshOnly".to_string()); + let ticket = NetworkTicket { + v: TICKET_VERSION, + name, + network_id: net, + route_mode: mode, + endpoint: endpoint_param, + seeds: None, + created_at: None, + }; + return Ok(ticket); + } else { + return Err( + "Missing ticket payload or network parameters in yip:// URI".to_string() + ); + } + } else if cleaned.starts_with('{') { + cleaned.to_string() + } else { + decode_b64(cleaned)? + }; + + let ticket: NetworkTicket = serde_json::from_str(&json_str) + .map_err(|e| format!("Failed to parse ticket JSON payload: {e}"))?; + + if ticket.name.trim().is_empty() { + return Err("Ticket is missing valid network name".to_string()); + } + if ticket.network_id.trim().is_empty() { + return Err("Ticket is missing valid network ID".to_string()); + } + + Ok(ticket) + } + + /// Render a compact terminal Unicode QR code representing this ticket's URI. + pub fn render_qr_terminal(&self) -> Result { + let uri = self.to_uri()?; + render_qr_terminal(&uri) + } +} + +impl std::str::FromStr for NetworkTicket { + type Err = String; + + fn from_str(s: &str) -> Result { + Self::parse(s) + } +} + +/// Render a string into a compact Unicode terminal QR code. +pub fn render_qr_terminal(content: &str) -> Result { + let code = + QrCode::new(content.as_bytes()).map_err(|e| format!("Failed to generate QR code: {e}"))?; + let rendered = code.render::().build(); + Ok(rendered) +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn test_ticket_round_trip_json() { + let ticket = NetworkTicket::new("Office Mesh", "aabbccddeeff0011", "MeshOnly") + .with_endpoint("198.51.100.10:51820") + .with_seeds(vec!["198.51.100.1:51820".into()]); + + let json = ticket.to_json().expect("to_json"); + let parsed = NetworkTicket::parse(&json).expect("parse json"); + assert_eq!(ticket.name, parsed.name); + assert_eq!(ticket.network_id, parsed.network_id); + assert_eq!(ticket.endpoint, parsed.endpoint); + assert_eq!(ticket.seeds, parsed.seeds); + assert_eq!(parsed.route_mode, "MeshOnly"); + } + + #[test] + fn test_ticket_round_trip_uri() { + let ticket = NetworkTicket::new("Homelab", "1234567890abcdef", "ExitNode") + .with_endpoint("203.0.113.5:51820"); + + let uri = ticket.to_uri().expect("to_uri"); + assert!(uri.starts_with("yip://join?ticket=")); + + let parsed = NetworkTicket::parse(&uri).expect("parse URI"); + assert_eq!(ticket.name, parsed.name); + assert_eq!(ticket.network_id, parsed.network_id); + assert_eq!(ticket.endpoint, parsed.endpoint); + assert_eq!(parsed.route_mode, "ExitNode"); + } + + #[test] + fn test_ticket_direct_base64() { + let ticket = NetworkTicket::new("Field Mesh", "deadbeefcafe0001", "SplitTunnel"); + let b64 = ticket.to_base64().expect("to_base64"); + let parsed = NetworkTicket::parse(&b64).expect("parse base64"); + assert_eq!(parsed.name, "Field Mesh"); + assert_eq!(parsed.network_id, "deadbeefcafe0001"); + assert_eq!(parsed.route_mode, "SplitTunnel"); + } + + #[test] + fn test_ticket_validation_failures() { + assert!(NetworkTicket::parse("").is_err()); + assert!(NetworkTicket::parse(" ").is_err()); + assert!(NetworkTicket::parse("not-base64-or-json@@@").is_err()); + assert!(NetworkTicket::parse("yip://join").is_err()); + assert!(NetworkTicket::parse(r#"{"name":"","network_id":"123"}"#).is_err()); + assert!(NetworkTicket::parse(r#"{"name":"test","network_id":""}"#).is_err()); + } + + #[test] + fn test_ticket_terminal_qr_rendering() { + let ticket = NetworkTicket::new("Test Mesh", "0102030405060708", "MeshOnly"); + let qr = ticket.render_qr_terminal().expect("render_qr_terminal"); + assert!(!qr.is_empty()); + assert!(qr.contains('█') || qr.contains('▀') || qr.contains('▄') || qr.contains(' ')); + } + + #[test] + fn test_ticket_methods_and_fallbacks() { + // with_endpoint with empty vs valid + let t = NetworkTicket::new("Net", "1234", "FullExitNode").with_endpoint(" "); + assert_eq!(t.endpoint, None); + assert_eq!(t.route_mode, "ExitNode"); + + let t2 = NetworkTicket::new("Net", "1234", "other") + .with_endpoint("10.0.0.1:443") + .with_seeds(vec![" ".into(), "10.0.0.2:443".into()]); + assert_eq!(t2.route_mode, "MeshOnly"); + assert_eq!(t2.endpoint.as_deref(), Some("10.0.0.1:443")); + assert_eq!(t2.seeds, Some(vec!["10.0.0.2:443".into()])); + + let t3 = NetworkTicket::new("Net", "1234", "SplitTunnel").with_seeds(vec![]); + assert_eq!(t3.seeds, None); + assert_eq!(t3.route_mode, "SplitTunnel"); + + // Parse via FromStr + let b64 = t2.to_base64().unwrap(); + let parsed: NetworkTicket = b64.parse().expect("FromStr parse"); + assert_eq!(parsed.name, "Net"); + + // Fallback URI query parameters + let uri = "yip://join?name=QueryNet&net=55667788&mode=ExitNode&endpoint=1.2.3.4:443"; + let parsed_uri = NetworkTicket::parse(uri).expect("parse query uri"); + assert_eq!(parsed_uri.name, "QueryNet"); + assert_eq!(parsed_uri.network_id, "55667788"); + assert_eq!(parsed_uri.route_mode, "ExitNode"); + assert_eq!(parsed_uri.endpoint.as_deref(), Some("1.2.3.4:443")); + + // Standalone render_qr_terminal + let rendered = render_qr_terminal("test").expect("render_qr_terminal"); + assert!(!rendered.is_empty()); + + // Standard Base64 with padding + let json_payload = t2.to_json().unwrap(); + let standard_b64 = STANDARD.encode(json_payload.as_bytes()); + let from_standard = NetworkTicket::parse(&standard_b64).expect("parse standard base64"); + assert_eq!(from_standard.name, "Net"); + + // Query URI with network_id and route_mode and without mode (defaults to MeshOnly) + let uri2 = "yip://join?name=DefaultNet&network_id=99887766&route_mode=SplitTunnel"; + let parsed_uri2 = NetworkTicket::parse(uri2).expect("parse query uri2"); + assert_eq!(parsed_uri2.name, "DefaultNet"); + assert_eq!(parsed_uri2.network_id, "99887766"); + assert_eq!(parsed_uri2.route_mode, "SplitTunnel"); + + let uri3 = "yip://join?name=DefaultNet&net=11223344"; + let parsed_uri3 = NetworkTicket::parse(uri3).expect("parse query uri3"); + assert_eq!(parsed_uri3.route_mode, "MeshOnly"); + + // Invalid UTF-8 in base64 payload + let invalid_utf8_b64 = STANDARD.encode([0xFF, 0xFE, 0xFD]); + assert!(NetworkTicket::parse(&invalid_utf8_b64).is_err()); + } +} diff --git a/bin/yipd/src/tls.rs b/bin/yipd/src/tls.rs index bb4158b..c5a47e0 100644 --- a/bin/yipd/src/tls.rs +++ b/bin/yipd/src/tls.rs @@ -1427,6 +1427,7 @@ mod tests { let peer_cfg = crate::config::PeerConfig { public_key: peer_pub, endpoint: Some(addr), + alias: None, }; let mut manager = PeerManager::new( local_priv, @@ -1521,6 +1522,7 @@ mod tests { let peer_cfg = crate::config::PeerConfig { public_key: peer_pub, endpoint: Some(addr), + alias: None, }; let mut manager = PeerManager::new( local_priv, diff --git a/bin/yipd/tests/control_socket_test.rs b/bin/yipd/tests/control_socket_test.rs index 7606c02..f90bcec 100644 --- a/bin/yipd/tests/control_socket_test.rs +++ b/bin/yipd/tests/control_socket_test.rs @@ -11,6 +11,7 @@ fn control_socket_tick_integration() { let peer = yipd::config::PeerConfig { public_key: [1u8; 32], endpoint: Some("10.0.0.1:1000".parse().unwrap()), + alias: None, }; let mut pm = yipd::peer_manager::PeerManager::new( kp.private, diff --git a/bin/yipd/tests/daita_integration_test.rs b/bin/yipd/tests/daita_integration_test.rs index b3a95ad..b131e9e 100644 --- a/bin/yipd/tests/daita_integration_test.rs +++ b/bin/yipd/tests/daita_integration_test.rs @@ -28,10 +28,12 @@ fn setup_established_daita_pair( let cfg_b = PeerConfig { public_key: kp_b.public, endpoint: Some(ep_b), + alias: None, }; let cfg_a = PeerConfig { public_key: kp_a.public, endpoint: Some(ep_a), + alias: None, }; let mut pm_a = PeerManager::new( diff --git a/bin/yipd/tests/metrics_endpoint_test.rs b/bin/yipd/tests/metrics_endpoint_test.rs index b65f568..0e96525 100644 --- a/bin/yipd/tests/metrics_endpoint_test.rs +++ b/bin/yipd/tests/metrics_endpoint_test.rs @@ -19,6 +19,7 @@ fn make_test_peer_manager() -> PeerManager { let peer = PeerConfig { public_key: [1u8; 32], endpoint: Some("10.0.0.1:1000".parse().unwrap()), + alias: None, }; PeerManager::new( kp.private, @@ -664,6 +665,7 @@ fn test_metrics_registry_cached_peer_stats_fallback_in_http_scraper() { rtt_ms: Some(15), fec_ratio_pct: 3, cert_status: "CA Valid".to_string(), + alias: None, }; registry.update_peer_stats(vec![peer]); diff --git a/bin/yipd/tests/reorder_dataplane_test.rs b/bin/yipd/tests/reorder_dataplane_test.rs index 68eb5e9..96587f1 100644 --- a/bin/yipd/tests/reorder_dataplane_test.rs +++ b/bin/yipd/tests/reorder_dataplane_test.rs @@ -97,10 +97,12 @@ fn setup_peer_manager_pair() -> (PeerManager, PeerManager, SocketAddr, SocketAdd let peer_b_cfg = PeerConfig { public_key: kp_b.public, endpoint: Some(ep_b), + alias: None, }; let peer_a_cfg = PeerConfig { public_key: kp_a.public, endpoint: Some(ep_a), + alias: None, }; let mut pm_a = PeerManager::new(