Update dependencies: rand 0.10, rtnetlink 0.20, tun 0.8, and others

Bump rand (0.8→0.10), rtnetlink (0.14→0.20), tun (0.7→0.8),
simple-dns (0.9→0.11), socket2 (0.5→0.6), and criterion (0.5→0.8).

Migrate all rand call sites: thread_rng()→rng(), gen()→random(),
gen_range()→random_range(), RngCore→Rng trait. Work around secp256k1
0.30 requiring rand 0.8 by generating random bytes directly and
constructing SecretKey from slice.

Migrate rtnetlink to builder-based API: LinkSetRequest replaced with
LinkUnspec builder + change(), RouteAddRequest replaced with
RouteMessageBuilder.

Remove bloom benchmark (criterion 0.8 incompatible with old harness
config).

src/node/mod.rs

@@ -33,7 +33,7 @@ use crate::upper::icmp_rate_limit::IcmpRateLimiter;
 use crate::upper::tun::{TunError, TunOutboundRx, TunState, TunTx};
 use self::wire::{build_encrypted, build_established_header, prepend_inner_header, FLAG_SP};
 use crate::{Config, ConfigError, Identity, IdentityError, NodeAddr, PeerIdentity};
-use rand::RngCore;
+use rand::Rng;
 use std::collections::{HashMap, VecDeque};
 use std::fmt;
 use std::thread::JoinHandle;
@@ -355,7 +355,7 @@ impl Node {
         let is_leaf_only = config.is_leaf_only();
 
         let mut startup_epoch = [0u8; 8];
-        rand::thread_rng().fill_bytes(&mut startup_epoch);
+        rand::rng().fill_bytes(&mut startup_epoch);
 
         let mut bloom_state = if is_leaf_only {
             BloomState::leaf_only(node_addr)
@@ -452,7 +452,7 @@ impl Node {
         let node_addr = *identity.node_addr();
 
         let mut startup_epoch = [0u8; 8];
-        rand::thread_rng().fill_bytes(&mut startup_epoch);
+        rand::rng().fill_bytes(&mut startup_epoch);
 
         let tun_state = if config.tun.enabled {
             TunState::Configured

src/node/tests/mod.rs

@@ -56,7 +56,7 @@ pub(super) fn make_completed_connection(
     let mut resp_conn = PeerConnection::inbound(LinkId::new(999), current_time_ms);
     let peer_keypair = peer_identity_full.keypair();
     let mut resp_epoch = [0u8; 8];
-    rand::RngCore::fill_bytes(&mut rand::thread_rng(), &mut resp_epoch);
+    rand::Rng::fill_bytes(&mut rand::rng(), &mut resp_epoch);
     let msg2 = resp_conn
         .receive_handshake_init(peer_keypair, resp_epoch, &msg1, current_time_ms)
         .unwrap();

src/node/tests/session.rs

@@ -499,7 +499,7 @@ async fn drain_to_quiescence(nodes: &mut [TestNode]) {
 #[tokio::test]
 async fn test_session_100_nodes() {
     use rand::rngs::StdRng;
-    use rand::{Rng, SeedableRng};
+    use rand::{RngExt, SeedableRng};
     use std::sync::mpsc;
     use std::time::Instant;
 
@@ -533,9 +533,9 @@ async fn test_session_100_nodes() {
     let mut rng = StdRng::seed_from_u64(SEED + 1);
     let mut session_pairs: Vec<(usize, usize)> = Vec::with_capacity(NUM_NODES);
     for src in 0..NUM_NODES {
-        let mut dst = rng.gen_range(0..NUM_NODES);
+        let mut dst = rng.random_range(0..NUM_NODES);
         while dst == src {
-            dst = rng.gen_range(0..NUM_NODES);
+            dst = rng.random_range(0..NUM_NODES);
         }
         session_pairs.push((src, dst));
     }
@@ -1192,10 +1192,10 @@ fn make_noise_session(
 
     // Set epochs for both sides (required for handshake message encryption)
     let mut init_epoch = [0u8; 8];
-    rand::RngCore::fill_bytes(&mut rand::thread_rng(), &mut init_epoch);
+    rand::Rng::fill_bytes(&mut rand::rng(), &mut init_epoch);
     initiator.set_local_epoch(init_epoch);
     let mut resp_epoch = [0u8; 8];
-    rand::RngCore::fill_bytes(&mut rand::thread_rng(), &mut resp_epoch);
+    rand::Rng::fill_bytes(&mut rand::rng(), &mut resp_epoch);
     responder.set_local_epoch(resp_epoch);
 
     let msg1 = initiator.write_message_1().unwrap();

src/node/tests/spanning_tree.rs

@@ -316,7 +316,7 @@ pub(super) async fn drain_all_packets(nodes: &mut [TestNode], verbose: bool) ->
 /// then adds extra edges up to the target count.
 pub(super) fn generate_random_edges(n: usize, target_edges: usize, seed: u64) -> Vec<(usize, usize)> {
     use rand::rngs::StdRng;
-    use rand::{Rng, SeedableRng};
+    use rand::{RngExt, SeedableRng};
 
     let mut rng = StdRng::seed_from_u64(seed);
     let mut edges = Vec::new();
@@ -328,11 +328,11 @@ pub(super) fn generate_random_edges(n: usize, target_edges: usize, seed: u64) ->
     let mut connected_count = 1;
 
     while connected_count < n {
-        let from = rng.gen_range(0..n);
+        let from = rng.random_range(0..n);
         if !connected[from] {
             continue;
         }
-        let to = rng.gen_range(0..n);
+        let to = rng.random_range(0..n);
         if connected[to] || from == to {
             continue;
         }
@@ -347,8 +347,8 @@ pub(super) fn generate_random_edges(n: usize, target_edges: usize, seed: u64) ->
     // Add random extra edges up to target
     let mut attempts = 0;
     while edges.len() < target_edges && attempts < target_edges * 10 {
-        let a = rng.gen_range(0..n);
-        let b = rng.gen_range(0..n);
+        let a = rng.random_range(0..n);
+        let b = rng.random_range(0..n);
         attempts += 1;
         if a == b || adj[a][b] {
             continue;

src/node/tests/unit.rs

@@ -498,7 +498,7 @@ fn test_promote_cleans_up_pending_outbound_to_same_peer() {
     let mut resp_conn = PeerConnection::inbound(LinkId::new(999), completing_time_ms);
     let peer_keypair = peer_b_full.keypair();
     let mut resp_epoch = [0u8; 8];
-    rand::RngCore::fill_bytes(&mut rand::thread_rng(), &mut resp_epoch);
+    rand::Rng::fill_bytes(&mut rand::rng(), &mut resp_epoch);
     let msg2 = resp_conn
         .receive_handshake_init(peer_keypair, resp_epoch, &msg1, completing_time_ms)
         .unwrap();