SIAR Protocol Documentation & Developer Hub

Self-sovereign Ed25519 & X25519 identities, QR Peer Tickets, and Tree-KEM logarithmic group ratchet with Post-Compromise Security (PCS).

// Cargo.toml: siar-crypto = { git = "https://github.com/irshadali5/siar" }
use siar_crypto::{DeviceIdentity, PublicIdentity, PeerTicket, MlsGroupState, PairwiseChannelEngine};
use rand_core::OsRng;

// 1. Generate Sovereign Identity Keypair (auto-zeroized on drop)
let (alice_dev, alice_pub) = DeviceIdentity::generate(&mut OsRng, "Alice".into(), 1700000000000);
println!("Sovereign Address: {}", alice_pub.address()); // e.g. siar17a4fb918cc3da10e

// 2. Create and verify Out-of-Band Peer Ticket (for QR/NFC handshake)
let ticket = PeerTicket::create(&alice_dev, transport_flags::BLE_5_EXTENDED, node_capability_flags::STORE_CARRY_FORWARD_ROUTER, 0);
let qr_string = ticket.to_qr_string()?; // "siar:ticket:..."

// 3. Encrypt 1-to-1 Asynchronous Direct Message (ChaCha20-Poly1305 + X25519 ECDH)
let envelope = PairwiseChannelEngine::encrypt_message(&mut OsRng, &alice_dev, &bob_pub, b"Secret Payload")?;

Async physical radio driver abstractions, BLE L2CAP MTU slicer, LoRa SX1262 framing, and battery-aware ETX scheduler.

// Cargo.toml: siar-transport = { git = "https://github.com/irshadali5/siar" }
use siar_transport::{TransportOrchestrator, BleTransport, WifiDirectTransport, LoraTransport, LoraConfig};

let mut orchestrator = TransportOrchestrator::new();
orchestrator.register_transport(Box::new(BleTransport::new(local_peer_id)));
orchestrator.register_transport(Box::new(WifiDirectTransport::new(local_peer_id, false)));
orchestrator.register_transport(Box::new(LoraTransport::new(local_peer_id, LoraConfig::sx1262_us915())));

// Dynamically routes over fastest link or lowest ETX based on battery %
orchestrator.set_battery_percent(85.0);
orchestrator.route_and_send(&recipient_peer_id, &payload_bytes).await?;

PRoPHET probabilistic routing, 256-byte Bloom filter anti-entropy sync, and flash storage queue with SOS alert immortality.

// Cargo.toml: siar-dtn = { git = "https://github.com/irshadali5/siar" }
use siar_dtn::{DtnBundle, bundle_flags, ProphetRouter, DtnStorageEngine, InventoryBloomFilter};

// Create a DTN bundle with 72-hour lifetime and SOS priority
let bundle = DtnBundle::new(source_id, dest_id, payload, bundle_flags::PRIORITY_EMERGENCY_SOS, 259_200_000, now_ms);

// Manage persistent storage quota (evicts low-priority bundles, preserves SOS alerts)
let mut storage = DtnStorageEngine::new(500 * 1024 * 1024); // 500 MB quota
storage.store_bundle(bundle, now_ms)?;

Dynamic BLAKE3 Proof-of-Work anti-Sybil puzzle engine, quantized traffic padding (256B/512B/1024B), and multi-pass RAM shredder.

// Cargo.toml: siar-security = { git = "https://github.com/irshadali5/siar" }
use siar_security::{ProofOfWorkEngine, TrafficObfuscator, AntiForensicsEngine};

// 1. Solve Proof-of-Work puzzle to authenticate ephemeral relay request
let token = ProofOfWorkEngine::mine_token(&source_pubkey, epoch_hour, 12);
assert!(ProofOfWorkEngine::verify_token(&source_pubkey, &token, epoch_hour));

// 2. Pad frame to standard bucket boundary with random chaff to defeat traffic analysis
let padded_frame = TrafficObfuscator::pad_to_bucket(&mut OsRng, &plaintext_message);

Zero-PII Prometheus metrics collection, differential privacy Laplace noise mechanism, and multi-hop DTN trace profiler.

// Cargo.toml: siar-telemetry = { git = "https://github.com/irshadali5/siar" }
use siar_telemetry::{MeshMetricsRegistry, DifferentialPrivacyEngine, DtnDiagnosticTrace};

let registry = MeshMetricsRegistry::new();
registry.active_ble_neighbors.fetch_add(1, Ordering::Relaxed);
let prom_text = registry.render_prometheus_text(); // Standard Prometheus /metrics format