librats 1.0.2 → 2.1.4

package/native-src/src/{crypto → librats/crypto}/sha512.h

@@ -1,3 +1,4 @@
+/* SPDX-License-Identifier: MIT */
 /*
  * Copyright (C) 2016 Southern Storm Software, Pty Ltd.
  *
@@ -30,8 +31,8 @@
 extern "C" {
 #endif
 
-#define SHA512_HASH_SIZE 64
-#define SHA512_BLOCK_SIZE 128
+#define RATS_SHA512_HASH_SIZE 64
+#define RATS_SHA512_BLOCK_SIZE 128
 
 typedef struct
 {
@@ -40,12 +41,12 @@ typedef struct
     uint64_t length; /* Restricted to 2^56 bytes of input */
     uint8_t  posn;
 
-} sha512_context_t;
+} rats_sha512_context_t;
 
-void sha512_reset(sha512_context_t *context);
-void sha512_update(sha512_context_t *context, const void *data, size_t size);
-void sha512_finish(sha512_context_t *context, uint8_t *hash);
-void sha512_hash(uint8_t *hash, const void *data, size_t size);
+void rats_sha512_reset(rats_sha512_context_t *context);
+void rats_sha512_update(rats_sha512_context_t *context, const void *data, size_t size);
+void rats_sha512_finish(rats_sha512_context_t *context, uint8_t *hash);
+void rats_sha512_hash(uint8_t *hash, const void *data, size_t size);
 
 #ifdef __cplusplus
 }

package/native-src/src/librats/dht/announce.cpp

@@ -0,0 +1,37 @@
+#include "librats/dht/announce.h"
+#include "librats/dht/krpc.h"
+
+#include <utility>
+
+namespace librats {
+namespace dht {
+
+Announce::Announce(RoutingTable& table, RpcManager& rpc, const NodeId& self,
+                   const InfoHash& info_hash, uint16_t port, bool implied_port,
+                   PeersCallback on_peers, DoneCallback on_done)
+    : FindPeers(table, rpc, self, info_hash, std::move(on_peers), std::move(on_done)),
+      port_(port),
+      implied_port_(implied_port) {}
+
+void Announce::on_complete() {
+    // Announce to the closest nodes that replied AND gave us a token. results_ is
+    // sorted by distance, so walking it front-to-back yields the closest first.
+    int announced = 0;
+    for (const auto& obs : results_) {
+        if (announced >= static_cast<int>(kBucketSize)) break;
+        if (!obs->has(Observer::kAlive)) continue;
+
+        const auto token = tokens_.find(obs->id());
+        if (token == tokens_.end()) continue;  // no token → we may not announce here
+
+        KrpcMessage msg = KrpcProtocol::create_announce_peer_query(
+            /*txn set by rpc*/ "", self_, target(), port_, token->second, implied_port_);
+        rpc_.send_oneshot(msg, obs->endpoint());  // the ack carries nothing we need
+        ++announced;
+    }
+
+    FindPeers::on_complete();  // still deliver whatever peers we discovered
+}
+
+} // namespace dht
+} // namespace librats

package/native-src/src/librats/dht/announce.h

@@ -0,0 +1,41 @@
+#pragma once
+
+/**
+ * @file announce.h
+ * @brief announce_peer lookup: tell the k closest nodes we're a peer (BEP 5).
+ *
+ * Runs exactly like a FindPeers lookup (it must, to collect write tokens), then on
+ * completion sends announce_peer — with each node's token — to the closest nodes
+ * that answered. Any peers it discovered along the way are still delivered through
+ * the FindPeers callbacks.
+ */
+
+#include "librats/dht/find_peers.h"
+#include "librats/dht/id.h"
+
+#include <cstdint>
+
+namespace librats {
+namespace dht {
+
+class Announce : public FindPeers {
+public:
+    // `port` is the TCP port we're announcing; with implied_port the receiver uses
+    // our UDP source port instead (better behind NAT).
+    Announce(RoutingTable& table, RpcManager& rpc, const NodeId& self, const InfoHash& info_hash,
+             uint16_t port, bool implied_port,
+             PeersCallback on_peers = {}, DoneCallback on_done = {});
+
+    bool is_announce() const noexcept override { return true; }
+
+protected:
+    void on_complete() override;
+    const char* name() const override { return "announce"; }
+
+private:
+    uint16_t port_;
+    bool     implied_port_;
+};
+
+} // namespace dht
+} // namespace librats

package/native-src/src/librats/dht/bep42.cpp

@@ -0,0 +1,109 @@
+#include "librats/dht/bep42.h"
+#include "librats/util/network_utils.h"
+
+#include <algorithm>
+#include <cstddef>
+#include <cstdint>
+
+namespace librats {
+namespace dht {
+
+namespace {
+
+// CRC-32C (Castagnoli), the polynomial mandated by BEP 42: reflected, init
+// 0xFFFFFFFF, final XOR 0xFFFFFFFF, bytes processed in array order. These exact
+// parameters reproduce the BEP 42 reference test vectors.
+uint32_t crc32c(const uint8_t* data, std::size_t len) {
+    uint32_t crc = 0xFFFFFFFFu;
+    for (std::size_t i = 0; i < len; ++i) {
+        crc ^= data[i];
+        for (int k = 0; k < 8; ++k)
+            crc = (crc & 1u) ? (crc >> 1) ^ 0x82F63B78u : (crc >> 1);
+    }
+    return crc ^ 0xFFFFFFFFu;
+}
+
+// Mask the leading octets of `ip` per BEP 42 (4 for IPv4, 8 for IPv6). Returns the
+// number of octets written to `out`, or 0 for the unspecified address. The address
+// bytes are already in network order, so no byte-swapping is needed.
+int masked_octets(const IpAddress& ip, uint8_t out[8]) {
+    static const uint8_t v4_mask[4] = {0x03, 0x0f, 0x3f, 0xff};
+    static const uint8_t v6_mask[8] = {0x01, 0x03, 0x07, 0x0f, 0x1f, 0x3f, 0x7f, 0xff};
+
+    const uint8_t* b = ip.bytes().data();
+    if (ip.is_v6()) {
+        for (int i = 0; i < 8; ++i) out[i] = b[i] & v6_mask[i];
+        return 8;
+    }
+    if (ip.is_v4()) {
+        for (int i = 0; i < 4; ++i) out[i] = b[i] & v4_mask[i];
+        return 4;
+    }
+    return 0;
+}
+
+// Compute the 3 deterministic prefix bytes of the BEP 42 id for (ip, seed). Only
+// the high 5 bits of prefix[2] are deterministic — the low 3 are random in a real
+// id, so they're returned cleared (and masked off again on verify).
+bool bep42_prefix(const IpAddress& ip, uint8_t seed, uint8_t prefix[3]) {
+    uint8_t octets[8];
+    const int num = masked_octets(ip, octets);
+    if (num == 0) return false;
+    octets[0] |= static_cast<uint8_t>((seed & 0x7) << 5);
+    const uint32_t c = crc32c(octets, static_cast<std::size_t>(num));
+    prefix[0] = static_cast<uint8_t>((c >> 24) & 0xff);
+    prefix[1] = static_cast<uint8_t>((c >> 16) & 0xff);
+    prefix[2] = static_cast<uint8_t>((c >> 8) & 0xf8);
+    return true;
+}
+
+} // namespace
+
+bool is_public_address(const IpAddress& ip) {
+    return network_utils::is_public_ip(ip);
+}
+
+bool generate_node_id_from_ip(const IpAddress& ip, NodeId& out, std::mt19937& rng) {
+    std::uniform_int_distribution<int> byte(0, 255);
+    const uint8_t seed = static_cast<uint8_t>(byte(rng));
+
+    uint8_t prefix[3];
+    if (!bep42_prefix(ip, seed, prefix)) return false;
+
+    NodeId id{};
+    id[0] = prefix[0];
+    id[1] = prefix[1];
+    id[2] = static_cast<uint8_t>(prefix[2] | (byte(rng) & 0x7));  // low 3 bits random
+    for (int i = 3; i < 19; ++i) id[i] = static_cast<uint8_t>(byte(rng));
+    id[19] = seed;
+    out = id;
+    return true;
+}
+
+bool verify_node_id_for_ip(const NodeId& id, const IpAddress& ip) {
+    if (!is_public_address(ip)) return true;             // can't verify non-public IPs
+    uint8_t prefix[3];
+    if (!bep42_prefix(ip, id[19], prefix)) return true;  // unspecified -> don't reject
+    return id[0] == prefix[0]
+        && id[1] == prefix[1]
+        && (id[2] & 0xf8) == prefix[2];
+}
+
+bool verify_node_id_for_ip(const NodeId& id, const std::string& ip) {
+    const auto a = IpAddress::parse(ip);
+    if (!a) return true;  // unparseable -> don't reject on uncertainty
+    return verify_node_id_for_ip(id, *a);
+}
+
+bool ip_too_close(const IpAddress& a, const IpAddress& b) noexcept {
+    if (a.family() != b.family()) return false;  // different networks, never "close"
+    // /24 for IPv4, /64 for IPv6: compare the leading network bytes. The address bytes
+    // are in network order, so a plain prefix compare is the CIDR test.
+    const std::size_t network_bytes = a.is_v6() ? 8 : (a.is_v4() ? 3 : 0);
+    if (network_bytes == 0) return false;        // unspecified
+    return std::equal(a.bytes().begin(), a.bytes().begin() + network_bytes,
+                      b.bytes().begin());
+}
+
+} // namespace dht
+} // namespace librats

package/native-src/src/librats/dht/bep42.h

@@ -0,0 +1,48 @@
+#pragma once
+
+/**
+ * @file bep42.h
+ * @brief BEP 42 — deriving a DHT node id from a node's external IP.
+ *
+ * Binding the id to the IP stops a node from freely choosing where it sits in the
+ * keyspace, which is the basis of the DHT's Sybil resistance. The first ~21 bits of
+ * the id are a CRC32C of the masked IP plus a one-byte seed (stored in the last id
+ * byte); the remaining bits are random. Only publicly routable IPs are constrained —
+ * private/loopback/reserved addresses can't be verified and are exempt.
+ */
+
+#include "librats/core/ip_address.h"
+#include "librats/dht/id.h"
+
+#include <random>
+#include <string>
+
+namespace librats {
+namespace dht {
+
+// Is `ip` publicly routable? Only public IPs can be (and must be) verified. Thin
+// wrapper over network_utils::is_public_ip so every subsystem shares one definition.
+bool is_public_address(const IpAddress& ip);
+
+// Build a fresh BEP 42-compliant id for `ip`. Returns false and leaves `out`
+// untouched only if `ip` is unspecified. `rng` supplies the seed and random tail.
+bool generate_node_id_from_ip(const IpAddress& ip, NodeId& out, std::mt19937& rng);
+
+// Does `id` satisfy BEP 42 for a peer observed at `ip`? Always true for non-public
+// or unspecified IPs (they can't be verified), so it never rejects on uncertainty.
+// The IpAddress overload is the hot path (routing-table admission); the string one
+// parses then delegates, and backs the public DhtClient::verify_node_id_for_ip API.
+bool verify_node_id_for_ip(const NodeId& id, const IpAddress& ip);
+bool verify_node_id_for_ip(const NodeId& id, const std::string& ip);
+
+// Are `a` and `b` close enough to be treated as one identity for Sybil/eclipse
+// resistance? Two addresses count as "too close" when they fall in the same /24
+// (IPv4) or /64 (IPv6) block — the granularity at which a single operator typically
+// controls every address. Different families (or an unspecified address) are never
+// too close. The routing table uses this to keep one subnet from filling a bucket,
+// and a lookup to keep it from flooding the candidate set (libtorrent's
+// dht_restrict_routing_ips / dht_restrict_search_ips).
+bool ip_too_close(const IpAddress& a, const IpAddress& b) noexcept;
+
+} // namespace dht
+} // namespace librats