Initial commitv0.1.0

NAT-aware Kademlia DHT library for peer-to-peer networks.

Features:
- Distributed key-value storage (iterative FIND_NODE, FIND_VALUE, STORE)
- NAT traversal via DTUN hole-punching and proxy relay
- Reliable Datagram Protocol (RDP) with 7-state connection machine
- Datagram transport with automatic fragmentation/reassembly
- Ed25519 packet authentication
- 256-bit node IDs (Ed25519 public keys)
- Rate limiting, ban list, and eclipse attack mitigation
- Persistence and metrics
- OpenBSD and Linux support

1 files changed, 144 insertions, 0 deletions

diff --git a/benches/bench.rs b/benches/bench.rs
new file mode 100644
index 0000000..0b427ef
--- /dev/null
+++ b/benches/bench.rs
@@ -0,0 +1,144 @@
+//! Benchmarks for core operations.
+//!
+//! Run with: cargo bench
+
+use std::net::SocketAddr;
+use tesseras_dht::crypto::Identity;
+use tesseras_dht::id::NodeId;
+use tesseras_dht::peers::PeerInfo;
+use tesseras_dht::routing::RoutingTable;
+use tesseras_dht::wire::MsgHeader;
+
+fn main() {
+    println!("=== tesseras-dht benchmarks ===\n");
+
+    bench_sha256();
+    bench_ed25519_sign();
+    bench_ed25519_verify();
+    bench_routing_add();
+    bench_routing_closest();
+    bench_header_roundtrip();
+    bench_node_id_xor();
+}
+
+fn bench_sha256() {
+    let data = vec![0xABu8; 1024];
+    let start = std::time::Instant::now();
+    let iters = 100_000;
+    for _ in 0..iters {
+        let _ = NodeId::from_key(&data);
+    }
+    let elapsed = start.elapsed();
+    println!(
+        "SHA-256 (1KB):    {:>8.0} ns/op ({iters} iters)",
+        elapsed.as_nanos() as f64 / iters as f64
+    );
+}
+
+fn bench_ed25519_sign() {
+    let id = Identity::generate();
+    let data = vec![0x42u8; 256];
+    let start = std::time::Instant::now();
+    let iters = 10_000;
+    for _ in 0..iters {
+        let _ = id.sign(&data);
+    }
+    let elapsed = start.elapsed();
+    println!(
+        "Ed25519 sign:     {:>8.0} ns/op ({iters} iters)",
+        elapsed.as_nanos() as f64 / iters as f64
+    );
+}
+
+fn bench_ed25519_verify() {
+    let id = Identity::generate();
+    let data = vec![0x42u8; 256];
+    let sig = id.sign(&data);
+    let start = std::time::Instant::now();
+    let iters = 10_000;
+    for _ in 0..iters {
+        let _ = Identity::verify(id.public_key(), &data, &sig);
+    }
+    let elapsed = start.elapsed();
+    println!(
+        "Ed25519 verify:   {:>8.0} ns/op ({iters} iters)",
+        elapsed.as_nanos() as f64 / iters as f64
+    );
+}
+
+fn bench_routing_add() {
+    let local = NodeId::random();
+    let mut rt = RoutingTable::new(local);
+    let start = std::time::Instant::now();
+    let iters = 10_000;
+    for i in 0..iters {
+        let id = NodeId::random();
+        let addr = SocketAddr::from(([10, 0, (i % 256) as u8, 1], 3000));
+        rt.add(PeerInfo::new(id, addr));
+    }
+    let elapsed = start.elapsed();
+    println!(
+        "Routing add:      {:>8.0} ns/op ({iters} iters, size={})",
+        elapsed.as_nanos() as f64 / iters as f64,
+        rt.size()
+    );
+}
+
+fn bench_routing_closest() {
+    let local = NodeId::random();
+    let mut rt = RoutingTable::new(local);
+    for i in 0..500 {
+        let id = NodeId::random();
+        let addr = SocketAddr::from(([10, 0, (i % 256) as u8, 1], 3000));
+        rt.add(PeerInfo::new(id, addr));
+    }
+
+    let target = NodeId::random();
+    let start = std::time::Instant::now();
+    let iters = 10_000;
+    for _ in 0..iters {
+        let _ = rt.closest(&target, 10);
+    }
+    let elapsed = start.elapsed();
+    println!(
+        "Routing closest:  {:>8.0} ns/op ({iters} iters, size={})",
+        elapsed.as_nanos() as f64 / iters as f64,
+        rt.size()
+    );
+}
+
+fn bench_header_roundtrip() {
+    let hdr = MsgHeader::new(
+        tesseras_dht::wire::MsgType::DhtPing,
+        100,
+        NodeId::random(),
+        NodeId::random(),
+    );
+    let mut buf = vec![0u8; tesseras_dht::wire::HEADER_SIZE];
+    let start = std::time::Instant::now();
+    let iters = 1_000_000;
+    for _ in 0..iters {
+        hdr.write(&mut buf).unwrap();
+        let _ = MsgHeader::parse(&buf).unwrap();
+    }
+    let elapsed = start.elapsed();
+    println!(
+        "Header roundtrip: {:>8.0} ns/op ({iters} iters)",
+        elapsed.as_nanos() as f64 / iters as f64
+    );
+}
+
+fn bench_node_id_xor() {
+    let a = NodeId::random();
+    let b = NodeId::random();
+    let start = std::time::Instant::now();
+    let iters = 10_000_000;
+    for _ in 0..iters {
+        let _ = a.distance(&b);
+    }
+    let elapsed = start.elapsed();
+    println!(
+        "NodeId XOR:       {:>8.0} ns/op ({iters} iters)",
+        elapsed.as_nanos() as f64 / iters as f64
+    );
+}