librats 1.0.0 → 1.0.2

package/native-src/src/dht.cpp

@@ -2,6 +2,7 @@
 #include "network_utils.h"
 #include "logger.h"
 #include "socket.h"
+#include "sha1.h"
 #include "json.hpp"
 #include <random>
 #include <algorithm>
@@ -27,6 +28,16 @@
 
 namespace librats {
 
+// Normalize an IPv6-mapped IPv4 address (::ffff:x.x.x.x -> x.x.x.x) so a node reached over a
+// dual-stack socket compares equal regardless of how its source address was rendered.
+static std::string normalize_ip_for_compare(const std::string& ip) {
+    static const std::string ipv4_mapped_prefix = "::ffff:";
+    if (ip.compare(0, ipv4_mapped_prefix.size(), ipv4_mapped_prefix) == 0) {
+        return ip.substr(ipv4_mapped_prefix.size());
+    }
+    return ip;
+}
+
 
 DhtClient::DhtClient(int port, const std::string& bind_address, const std::string& data_directory,
                      AddressFamily address_family)
@@ -35,6 +46,14 @@ DhtClient::DhtClient(int port, const std::string& bind_address, const std::strin
     node_id_ = generate_node_id();
     routing_table_.resize(NODE_ID_SIZE * 8);  // 160 buckets for 160-bit node IDs
 
+    // Seed the BEP 5 write-token secret with fresh randomness (current and previous generations).
+    {
+        std::random_device rd;
+        for (auto& b : token_secret_)      b = static_cast<uint8_t>(rd());
+        for (auto& b : token_secret_prev_) b = static_cast<uint8_t>(rd());
+        token_secret_rotated_at_ = std::chrono::steady_clock::now();
+    }
+
     if (data_directory_.empty()) {
         data_directory_ = ".";
     }
@@ -449,9 +468,6 @@ void DhtClient::maintenance_loop() {
             // Cleanup stale nodes every 1 minute
             cleanup_stale_nodes();
             
-            // Cleanup stale peer tokens
-            cleanup_stale_peer_tokens();
-            
             // Cleanup stale pending searches
             cleanup_stale_searches();
             
@@ -893,8 +909,8 @@ void DhtClient::handle_krpc_get_peers(const KrpcMessage& message, const Peer& se
         add_node(sender_node, true, false);
     }
     
-    // Generate a token for this peer
-    std::string token = generate_token(sender);
+    // Generate a token for this peer, bound to this info_hash (BEP 5)
+    std::string token = generate_token(sender, message.info_hash);
     
     // Use neighbor_id only for spider-contacted IPs, real node_id for organic DHT traffic
     NodeId response_id = use_neighbor_id ? neighbor_id(message.info_hash) : node_id_;
@@ -930,7 +946,7 @@ void DhtClient::handle_krpc_announce_peer(const KrpcMessage& message, const Peer
     // Note: We still want to collect announces even when ignoring other requests
     
     // In spider mode, skip token verification for maximum collection
-    if (!is_spider && !verify_token(sender, message.token)) {
+    if (!is_spider && !verify_token(sender, message.info_hash, message.token)) {
         LOG_DHT_WARN("Invalid token from " << sender.ip << ":" << sender.port << " for KRPC ANNOUNCE_PEER");
         auto error = KrpcProtocol::create_error(message.transaction_id, KrpcErrorCode::ProtocolError, "Invalid token");
         send_krpc_message(error, sender);
@@ -938,7 +954,7 @@ void DhtClient::handle_krpc_announce_peer(const KrpcMessage& message, const Peer
     }
 #else
     // Verify token
-    if (!verify_token(sender, message.token)) {
+    if (!verify_token(sender, message.info_hash, message.token)) {
         LOG_DHT_WARN("Invalid token from " << sender.ip << ":" << sender.port << " for KRPC ANNOUNCE_PEER");
         auto error = KrpcProtocol::create_error(message.transaction_id, KrpcErrorCode::ProtocolError, "Invalid token");
         send_krpc_message(error, sender);
@@ -1036,6 +1052,24 @@ void DhtClient::handle_krpc_response(const KrpcMessage& message, const Peer& sen
     }
 #endif
 
+    // Anti-spoofing: if this response matches a search transaction we issued, require it to come
+    // from the exact endpoint we queried. Off-path attackers can guess/observe a transaction ID but
+    // cannot send from the queried node's address, so this drops forged responses before they can
+    // inject routing-table entries or poison the lookup. (Responses with an unknown transaction ID
+    // are not tied to any outstanding query and fall through to the existing handling.)
+    {
+        std::lock_guard<std::mutex> lock(pending_searches_mutex_);
+        auto trans_it = transaction_to_search_.find(message.transaction_id);
+        if (trans_it != transaction_to_search_.end()) {
+            if (normalize_ip_for_compare(sender.ip) != normalize_ip_for_compare(trans_it->second.queried_endpoint.ip)) {
+                LOG_DHT_WARN("Dropping search response from unexpected source " << sender.ip << ":" << sender.port
+                             << " (queried " << trans_it->second.queried_endpoint.ip << ":"
+                             << trans_it->second.queried_endpoint.port << ") - possible spoofing");
+                return;
+            }
+        }
+    }
+
     // Normal mode: add nodes to routing table
     KrpcNode krpc_node(message.response_id, sender.ip, sender.port);
     DhtNode sender_node = krpc_node_to_dht_node(krpc_node);
@@ -1400,33 +1434,45 @@ NodeId DhtClient::neighbor_id(const NodeId& target) const {
     return result;
 }
 
-std::string DhtClient::generate_token(const Peer& peer) {
-    // Simple token generation (in real implementation, use proper cryptographic hash)
-    std::string data = peer.ip + ":" + std::to_string(peer.port);
-    std::hash<std::string> hasher;
-    size_t hash = hasher(data);
-    
-    // Convert hash to hex string
-    std::ostringstream oss;
-    oss << std::hex << hash;
-    std::string token = oss.str();
-    
-    // Store token for this peer with timestamp
-    {
-        std::lock_guard<std::mutex> lock(peer_tokens_mutex_);
-        peer_tokens_[peer] = PeerToken(token);
+void DhtClient::maybe_rotate_token_secret_unlocked() {
+    // Caller holds token_secret_mutex_.
+    auto now = std::chrono::steady_clock::now();
+    if (now - token_secret_rotated_at_ >= std::chrono::minutes(TOKEN_SECRET_ROTATION_MINUTES)) {
+        token_secret_prev_ = token_secret_;
+        std::random_device rd;
+        for (auto& b : token_secret_) b = static_cast<uint8_t>(rd());
+        token_secret_rotated_at_ = now;
+        LOG_DHT_DEBUG("Rotated DHT write-token secret");
     }
-    
-    return token;
 }
 
-bool DhtClient::verify_token(const Peer& peer, const std::string& token) {
-    std::lock_guard<std::mutex> lock(peer_tokens_mutex_);
-    auto it = peer_tokens_.find(peer);
-    if (it != peer_tokens_.end()) {
-        return it->second.token == token;
+std::string DhtClient::compute_token_with_secret(const Peer& peer, const InfoHash& info_hash,
+                                                 const std::array<uint8_t, 16>& secret) const {
+    // SHA1(secret || querier_ip || info_hash). Including the secret makes the token unforgeable;
+    // including the info_hash binds it to a single target so one token cannot announce arbitrary hashes.
+    std::vector<uint8_t> data;
+    data.reserve(secret.size() + peer.ip.size() + info_hash.size());
+    data.insert(data.end(), secret.begin(), secret.end());
+    data.insert(data.end(), peer.ip.begin(), peer.ip.end());
+    data.insert(data.end(), info_hash.begin(), info_hash.end());
+    return SHA1::hash_bytes(data);
+}
+
+std::string DhtClient::generate_token(const Peer& peer, const InfoHash& info_hash) {
+    std::lock_guard<std::mutex> lock(token_secret_mutex_);
+    maybe_rotate_token_secret_unlocked();
+    return compute_token_with_secret(peer, info_hash, token_secret_);
+}
+
+bool DhtClient::verify_token(const Peer& peer, const InfoHash& info_hash, const std::string& token) {
+    if (token.empty()) {
+        return false;
     }
-    return false;
+    std::lock_guard<std::mutex> lock(token_secret_mutex_);
+    maybe_rotate_token_secret_unlocked();
+    // Accept tokens minted with either the current or the previous secret (rotation window).
+    return token == compute_token_with_secret(peer, info_hash, token_secret_)
+        || token == compute_token_with_secret(peer, info_hash, token_secret_prev_);
 }
 
 void DhtClient::cleanup_stale_nodes() {
@@ -1468,32 +1514,6 @@ void DhtClient::cleanup_stale_nodes() {
     }
 }
 
-void DhtClient::cleanup_stale_peer_tokens() {
-    std::lock_guard<std::mutex> lock(peer_tokens_mutex_);
-    
-    auto now = std::chrono::steady_clock::now();
-    auto stale_threshold = std::chrono::minutes(10);  // Tokens valid for 10 minutes (BEP 5 recommends tokens expire)
-    
-    size_t total_before = peer_tokens_.size();
-    
-    auto it = peer_tokens_.begin();
-    while (it != peer_tokens_.end()) {
-        if (now - it->second.created_at > stale_threshold) {
-            LOG_DHT_DEBUG("Removing stale token for peer " << it->first.ip << ":" << it->first.port);
-            it = peer_tokens_.erase(it);
-        } else {
-            ++it;
-        }
-    }
-    
-    size_t total_after = peer_tokens_.size();
-    
-    if (total_before > total_after) {
-        LOG_DHT_DEBUG("Cleaned up " << (total_before - total_after) << " stale peer tokens "
-                      << "(from " << total_before << " to " << total_after << ")");
-    }
-}
-
 void DhtClient::print_statistics() {
     auto now = std::chrono::steady_clock::now();
     
@@ -1573,13 +1593,6 @@ void DhtClient::print_statistics() {
         nodes_being_replaced = nodes_being_replaced_.size();
     }
     
-    // Peer tokens statistics
-    size_t peer_tokens_count = 0;
-    {
-        std::lock_guard<std::mutex> tokens_lock(peer_tokens_mutex_);
-        peer_tokens_count = peer_tokens_.size();
-    }
-    
     // Spider mode statistics
 #ifdef RATS_SEARCH_FEATURES
     size_t spider_pool_size = 0;
@@ -1625,9 +1638,8 @@ void DhtClient::print_statistics() {
     LOG_DHT_INFO("  Pending ping verifications: " << pending_pings 
                  << " (nodes being replaced: " << nodes_being_replaced << ")");
     LOG_DHT_INFO("[STORED DATA]");
-    LOG_DHT_INFO("  Announced peers: " << announced_peers_total 
+    LOG_DHT_INFO("  Announced peers: " << announced_peers_total
                  << " across " << announced_peers_infohashes << " infohashes");
-    LOG_DHT_INFO("  Peer tokens: " << peer_tokens_count);
     
     // Best/Worst nodes analysis
     if (!all_nodes.empty()) {
@@ -2449,7 +2461,7 @@ bool DhtClient::add_search_requests(PendingSearch& search, DeferredCallbacks& de
         
         // Send query to this node
         std::string transaction_id = KrpcProtocol::generate_transaction_id();
-        transaction_to_search_[transaction_id] = SearchTransaction(hash_key, node.id);
+        transaction_to_search_[transaction_id] = SearchTransaction(hash_key, node.id, node.peer);
         search.node_states[node.id] |= SearchNodeFlags::QUERIED;
         search.invoke_count++;
         
@@ -2637,18 +2649,10 @@ void DhtClient::handle_ping_verification_response(const std::string& transaction
         const auto& verification = it->second;
         
         // Security check: Verify response comes from the IP we pinged
-        // Normalize IPv6-mapped IPv4 addresses (::ffff:x.x.x.x -> x.x.x.x) for comparison
-        auto normalize_ip = [](const std::string& ip) -> std::string {
-            const std::string ipv4_mapped_prefix = "::ffff:";
-            if (ip.compare(0, ipv4_mapped_prefix.size(), ipv4_mapped_prefix) == 0) {
-                return ip.substr(ipv4_mapped_prefix.size());
-            }
-            return ip;
-        };
-        
-        std::string responder_ip_normalized = normalize_ip(responder.ip);
-        std::string expected_ip_normalized = normalize_ip(verification.old_node.peer.ip);
-        
+        // (normalize IPv6-mapped IPv4 addresses ::ffff:x.x.x.x -> x.x.x.x for comparison)
+        std::string responder_ip_normalized = normalize_ip_for_compare(responder.ip);
+        std::string expected_ip_normalized = normalize_ip_for_compare(verification.old_node.peer.ip);
+
         if (responder_ip_normalized != expected_ip_normalized) {
             LOG_DHT_WARN("Ping verification response from wrong IP " << responder.ip 
                          << " (expected " << verification.old_node.peer.ip << ") - ignoring");
@@ -2894,7 +2898,30 @@ bool DhtClient::load_routing_table() {
             LOG_DHT_WARN("Unsupported routing table version: " << version);
             return false;
         }
-        
+
+        // Restore our own node ID so it stays stable across restarts (matches libtorrent's
+        // calculate_node_id). The external address is not known yet at load time, which is
+        // libtorrent's "external_address.is_unspecified()" case -> reuse the saved ID as long
+        // as it is valid (non-zero). If the external IP is later discovered and the restored
+        // ID is no longer valid for it (BEP 42), set_external_ip() regenerates it then.
+        // Restored before bucketing the loaded nodes below, since get_bucket_index() is
+        // computed relative to node_id_.
+        if (routing_data.contains("node_id")) {
+            try {
+                NodeId saved_id = hex_to_node_id(routing_data["node_id"].get<std::string>());
+                bool all_zeros = std::all_of(saved_id.begin(), saved_id.end(),
+                                             [](uint8_t b) { return b == 0; });
+                if (!all_zeros) {
+                    node_id_ = saved_id;
+                    LOG_DHT_INFO("Restored DHT node ID from disk: " << node_id_to_hex(node_id_));
+                } else {
+                    LOG_DHT_WARN("Saved node ID is invalid (zero/malformed), keeping generated one");
+                }
+            } catch (const std::exception& e) {
+                LOG_DHT_WARN("Failed to restore saved node ID, keeping generated one: " << e.what());
+            }
+        }
+
         // Load nodes
         const auto& nodes_array = routing_data["nodes"];
         size_t loaded_count = 0;

package/native-src/src/dht.h

@@ -443,24 +443,24 @@ private:
     // 3. routing_table_mutex_           (core routing data)
     // 4. spider_nodes_mutex_            (Spider mode: node pool and visited tracking) [RATS_SEARCH_FEATURES]
     // 5. announced_peers_mutex_         (Stored peer data)
-    // 6. peer_tokens_mutex_             (Token validation data)
+    // 6. token_secret_mutex_            (DHT write-token secret)
     // 7. shutdown_mutex_                (Lowest priority - can be locked independently)
     //
     // Routing table (k-buckets)
     std::vector<std::vector<DhtNode>> routing_table_;
     mutable std::mutex routing_table_mutex_;  // Lock order: 3
     
-    // Tokens for peers (use Peer directly as key for efficiency)
-    struct PeerToken {
-        std::string token;
-        std::chrono::steady_clock::time_point created_at;
-        
-        PeerToken() : created_at(std::chrono::steady_clock::now()) {}
-        PeerToken(const std::string& t)
-            : token(t), created_at(std::chrono::steady_clock::now()) {}
-    };
-    std::unordered_map<Peer, PeerToken> peer_tokens_;
-    std::mutex peer_tokens_mutex_;  // Lock order: 6
+    // DHT write-token secret (BEP 5). Announce tokens are SHA1(secret || querier_ip || info_hash),
+    // so they are unforgeable (an attacker does not know the secret) and bound to BOTH the
+    // querier's address and the specific info_hash. The secret rotates periodically; we keep the
+    // previous secret so tokens handed out shortly before a rotation still verify. This replaces the
+    // old, trivially forgeable std::hash("ip:port") scheme. Guarded by token_secret_mutex_, which is
+    // a leaf lock (never held while acquiring any other DHT mutex).
+    static constexpr int TOKEN_SECRET_ROTATION_MINUTES = 5;  // acceptance window ~= 2x this
+    std::array<uint8_t, 16> token_secret_;
+    std::array<uint8_t, 16> token_secret_prev_;
+    std::chrono::steady_clock::time_point token_secret_rotated_at_;
+    std::mutex token_secret_mutex_;  // Lock order: 6
     
 
     
@@ -501,11 +501,12 @@ private:
     struct SearchTransaction {
         std::string info_hash_hex;
         NodeId queried_node_id;
+        Peer queried_endpoint;          // endpoint we actually sent the query to (anti-spoofing)
         std::chrono::steady_clock::time_point sent_at;
-        
+
         SearchTransaction() = default;
-        SearchTransaction(const std::string& hash, const NodeId& id)
-            : info_hash_hex(hash), queried_node_id(id), 
+        SearchTransaction(const std::string& hash, const NodeId& id, const Peer& endpoint)
+            : info_hash_hex(hash), queried_node_id(id), queried_endpoint(endpoint),
               sent_at(std::chrono::steady_clock::now()) {}
     };
     std::unordered_map<std::string, SearchTransaction> transaction_to_search_; // transaction_id -> SearchTransaction
@@ -634,13 +635,20 @@ private:
     NodeId neighbor_id(const NodeId& target) const;
 
     
-    std::string generate_token(const Peer& peer);
-    bool verify_token(const Peer& peer, const std::string& token);
+    // BEP 5 write tokens: bound to the querier address + info_hash and authenticated with a rotating
+    // secret. generate_token is called when answering get_peers; verify_token gates announce_peer.
+    std::string generate_token(const Peer& peer, const InfoHash& info_hash);
+    bool verify_token(const Peer& peer, const InfoHash& info_hash, const std::string& token);
+    // Computes SHA1(secret || peer.ip || info_hash) as a hex digest. Port is intentionally excluded
+    // (a NAT may present a different source port on the subsequent announce).
+    std::string compute_token_with_secret(const Peer& peer, const InfoHash& info_hash,
+                                          const std::array<uint8_t, 16>& secret) const;
+    // Rotates the token secret if older than TOKEN_SECRET_ROTATION_MINUTES. Caller holds token_secret_mutex_.
+    void maybe_rotate_token_secret_unlocked();
     
 
     
     void cleanup_stale_nodes();
-    void cleanup_stale_peer_tokens();
     void refresh_buckets();
     void print_statistics();
     

package/native-src/src/krpc.cpp

@@ -451,7 +451,19 @@ std::unique_ptr<KrpcMessage> KrpcProtocol::decode_error(const BencodeValue& data
 
 // Utility functions
 std::string KrpcProtocol::generate_transaction_id() {
-    return std::to_string(++transaction_counter_);
+    // A predictable transaction ID lets an off-path attacker forge responses to our queries and
+    // poison lookups. We make the ID unpredictable (2 random bytes) while keeping it collision-free
+    // (2 monotonic counter bytes guarantee uniqueness among any 65536 consecutive/outstanding
+    // transactions). The result is a 4-byte opaque binary string echoed back verbatim in KRPC.
+    static thread_local std::mt19937 rng(std::random_device{}());
+    uint32_t counter = transaction_counter_.fetch_add(1, std::memory_order_relaxed);
+    uint16_t rnd = static_cast<uint16_t>(rng() & 0xFFFF);
+    char tid[4];
+    tid[0] = static_cast<char>((rnd >> 8) & 0xFF);
+    tid[1] = static_cast<char>(rnd & 0xFF);
+    tid[2] = static_cast<char>((counter >> 8) & 0xFF);
+    tid[3] = static_cast<char>(counter & 0xFF);
+    return std::string(tid, sizeof(tid));
 }
 
 std::string KrpcProtocol::node_id_to_string(const NodeId& id) {

package/native-src/src/librats.cpp

@@ -658,11 +658,9 @@ void RatsClient::handle_disconnect(socket_t socket) {
         }
     }
     
-    // Remove from poller, peers map, close socket
     poller_remove(socket);
     remove_peer(socket);
-    close_socket(socket);
-    
+
     if (was_validated) {
         if (disconnect_callback_) {
             disconnect_callback_(socket, peer_id);
@@ -682,7 +680,9 @@ void RatsClient::handle_disconnect(socket_t socket) {
             }), "config-save-disconnect");
         }
     }
-    
+
+    close_socket(socket);
+
     LOG_CLIENT_INFO("Peer disconnected: " << peer_id);
 }
 

package/native-src/src/librats_discovery.cpp

@@ -265,22 +265,19 @@ std::chrono::seconds RatsClient::calculate_discovery_interval() const {
 
 void RatsClient::automatic_discovery_loop() {
     LOG_CLIENT_INFO("Automatic peer discovery loop started");
-    
-    // Initial delay to let DHT bootstrap
-    {
-        std::unique_lock<std::mutex> lock(shutdown_mutex_);
-        if (shutdown_cv_.wait_for(lock, std::chrono::seconds(INITIAL_DISCOVERY_DELAY_SECONDS), [this] { return !auto_discovery_running_.load() || !running_.load(); })) {
-            LOG_CLIENT_INFO("Automatic peer discovery loop stopped during initial delay");
-            return;
-        }
-    }
 
-    // Best-effort: discover our public IP via STUN and derive a BEP 42 node ID from it before
-    // we announce, so we announce under the correct ID. This runs on the discovery thread (not
-    // a standalone one) on purpose: stop_dht_discovery() joins this thread via
-    // stop_automatic_peer_discovery() BEFORE resetting the DHT clients, so set_external_ip()
-    // can never touch a destroyed DhtClient. It complements the in-DHT "ip"-field voting, which
-    // keeps the node ID correct if the address changes or STUN is unavailable.
+    // Best-effort: discover our public IP via STUN and derive a BEP 42 node ID from it BEFORE
+    // the initial bootstrap delay below. The DHT starts receiving KRPC responses (each carrying
+    // our address in the "ip" field) immediately on bootstrap, and that in-DHT vote can reach
+    // EXTERNAL_IP_VOTE_THRESHOLD within a few seconds. Probing STUN first lets set_external_ip()
+    // adopt the address and regenerate the node ID up front, so the DHT bootstraps under the
+    // correct ID and the ip-field voting silently confirms the already-adopted address instead
+    // of racing it to consensus. The voting remains the fallback when STUN is unavailable or the
+    // address later changes.
+    //
+    // This runs on the discovery thread (not a standalone one) on purpose: stop_dht_discovery()
+    // joins this thread via stop_automatic_peer_discovery() BEFORE resetting the DHT clients, so
+    // set_external_ip() can never touch a destroyed DhtClient.
     if (auto_discovery_running_.load() && running_.load()) {
         auto mapped = discover_public_address("stun.l.google.com", 19302, 4000);
         if (mapped) {
@@ -296,6 +293,15 @@ void RatsClient::automatic_discovery_loop() {
         }
     }
 
+    // Initial delay to let DHT bootstrap
+    {
+        std::unique_lock<std::mutex> lock(shutdown_mutex_);
+        if (shutdown_cv_.wait_for(lock, std::chrono::seconds(INITIAL_DISCOVERY_DELAY_SECONDS), [this] { return !auto_discovery_running_.load() || !running_.load(); })) {
+            LOG_CLIENT_INFO("Automatic peer discovery loop stopped during initial delay");
+            return;
+        }
+    }
+
     // Announce immediately - this also discovers peers during traversal
     announce_rats_peer();
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "librats",
-  "version": "1.0.0",
+  "version": "1.0.2",
   "description": "Node.js bindings for librats - A high-performance peer-to-peer networking library",
   "main": "lib/index.js",
   "types": "lib/index.d.ts",