librats 1.0.2 → 2.2.0

package/native-src/src/librats/core/types.h

@@ -0,0 +1,103 @@
+#pragma once
+
+/**
+ * @file types.h
+ * @brief Core transport identifiers and enums shared across the reactor layer.
+ */
+
+#include "librats/util/rats_export.h"
+
+#include <cstdint>
+
+namespace librats {
+
+/// Stable-for-lifetime connection handle. Assigned by the owning Reactor and
+/// unique within it; never reused while the connection is alive.
+using ConnId = uint64_t;
+constexpr ConnId kInvalidConnId = 0;
+
+/// Opaque timer handle returned by Reactor::schedule(), usable to cancel().
+using TimerId = uint64_t;
+constexpr TimerId kInvalidTimerId = 0;
+
+/// Who initiated the connection.
+enum class ConnRole {
+    Inbound,   ///< We accepted it from a listener.
+    Outbound,  ///< We dialed out to a remote address.
+};
+
+/// Which wire a connection runs over. Tcp and Udp are first-class equals: they
+/// carry the exact same block/frame protocol and the same secure handshake, and
+/// differ only in how an ordered, reliable byte stream is obtained — the kernel's
+/// TCP stack, or the library's own reliability layer on top of datagrams (see
+/// transport/udp_stream.h). Relay is a third way of obtaining that same stream —
+/// out of another peer's connection rather than out of a socket — and is a last
+/// resort rather than an equal (see below).
+enum class TransportKind {
+    Tcp,    ///< One kernel socket per peer.
+    Udp,    ///< Reliable ordered stream over the shared UDP socket (NAT-friendly).
+    /// Carried inside another peer's connection: the byte stream is chopped into
+    /// messages a third node forwards between the two ends (see subsystems/relay.h).
+    /// Not a wire of its own — it is one of the two above, one hop further away —
+    /// but it behaves differently enough to be worth naming: it costs the relay
+    /// bandwidth, it cannot be dialed, and it must always lose to a direct link
+    /// (see PeerTable::add). Never a value connect() or the Dialer chooses.
+    Relay,
+};
+
+/// How hard an outbound datagram dial tries before it is called failed.
+///
+/// The default is the ordinary dial: three Syns at a doubling 500 ms timeout, so a
+/// path that swallows UDP gives up in about three and a half seconds and the dialer
+/// falls back to TCP promptly.
+///
+/// A hole punch wants the opposite shape. There the FIRST Syn is expected to die on
+/// the peer's NAT — its job is to open our own mapping and filter — and what
+/// actually connects is a later one, sent after the peer's Syn has crossed ours. So
+/// a punch trades the long patient tail for a dense burst: more attempts, closer
+/// together, no backoff. Everything else about the stream is unchanged; this only
+/// governs the Syn, and once a stream is connected its timeout comes from measured
+/// round trips as usual.
+struct DialProfile {
+    int      syn_attempts = 3;      ///< transmissions of the Syn before the dial fails
+    uint32_t syn_rto_ms   = 500;    ///< interval before the first retransmission
+    bool     syn_backoff  = true;   ///< double the interval after each attempt
+
+    /// The punch shape: eight probes 200 ms apart, ~1.6 s of dense punching.
+    static DialProfile punch() noexcept { return DialProfile{8, 200, false}; }
+};
+
+/// Connection lifecycle. A connection moves strictly forward through these.
+enum class ConnState {
+    Connecting,   ///< Outbound transport connect in flight (TCP connect / UDP SYN).
+    Handshaking,  ///< Transport up; secure-channel handshake in progress.
+    Established,  ///< Handshake done; application frames may flow.
+    Closing,      ///< Marked for teardown; no further frames accepted.
+    Closed,       ///< Removed from the reactor.
+};
+
+/// Why a connection was torn down. Surfaced to delegates/observers.
+enum class CloseReason {
+    LocalClose,        ///< Application asked to disconnect.
+    PeerClosed,        ///< Remote sent FIN (clean close).
+    PeerReset,         ///< Connection reset / socket error.
+    ConnectFailed,     ///< Outbound transport connect never completed.
+    HandshakeFailed,   ///< Secure-channel handshake failed or timed out.
+    ProtocolError,     ///< Malformed frame / decryption failure on the wire.
+    SlowConsumer,      ///< Send buffer exceeded its high-water mark.
+    ReactorShutdown,   ///< Reactor is stopping.
+    DuplicateConn,     ///< Redundant connection to a peer we already hold; superseded.
+    PeerLimit,         ///< Inbound rejected: the configured peer limit is reached.
+    IdleTimeout,       ///< Datagram link went silent past its idle deadline.
+    DialSuperseded,    ///< A racing dial over the other transport won; this one is redundant.
+};
+
+const char* to_string(ConnState) noexcept;
+const char* to_string(CloseReason) noexcept;
+/// Exported, unlike its siblings above: TransportKind is part of the public
+/// surface (NodeConfig::preferred_transport, PeerInfo::transport), so a consumer
+/// of the shared build needs to be able to render one. ConnState/CloseReason only
+/// ever appear on Connection, which does not cross the library boundary.
+RATS_API const char* to_string(TransportKind) noexcept;
+
+} // namespace librats

package/native-src/src/librats/core/wakeup_pipe.h

@@ -0,0 +1,83 @@
+#pragma once
+
+/**
+ * @file wakeup_pipe.h
+ * @brief Loopback-UDP self-pipe for interrupting a blocking select()/receive.
+ *
+ * A worker thread that blocks in receive_udp_data() can only react to a stop
+ * request (or newly posted work) after its socket timeout expires. WakeupPipe
+ * provides a second socket to add to that select() set: signal() sends a one-byte
+ * datagram to it, which wakes the select() immediately so the worker can react
+ * without waiting out the timeout.
+ *
+ * Two usage patterns are supported:
+ *   - one-shot (NAT-PMP/UPnP): signal() once on stop(), then tear down. No drain().
+ *   - repeated (DHT runner): signal() on every posted task. The worker MUST call
+ *     drain() once per wake-up, otherwise the unread byte keeps select() readable
+ *     and the loop spins. The socket is non-blocking so drain() never stalls.
+ *
+ * UDP loopback is used (rather than a pipe) because it is selectable on every
+ * platform, including Windows. If socket creation fails the pipe degrades
+ * gracefully: fd() returns an invalid socket (treated as "no interrupt"), signal()
+ * is a no-op and drain() is a no-op, so callers fall back to timeout-based wakeups.
+ */
+
+#include "librats/core/socket.h"
+
+#include <vector>
+
+namespace librats {
+
+class WakeupPipe {
+public:
+    WakeupPipe() {
+        sock_ = create_udp_socket(0, "127.0.0.1", AddressFamily::IPv4);
+        if (is_valid_socket(sock_)) {
+            sockaddr_in addr;
+            socklen_t len = sizeof(addr);
+            if (getsockname(sock_, reinterpret_cast<sockaddr*>(&addr), &len) == 0) {
+                port_ = ntohs(addr.sin_port);
+            }
+            set_socket_nonblocking(sock_);  // so drain() reads until empty without blocking
+        }
+    }
+
+    ~WakeupPipe() {
+        if (is_valid_socket(sock_)) close_socket(sock_);
+    }
+
+    WakeupPipe(const WakeupPipe&) = delete;
+    WakeupPipe& operator=(const WakeupPipe&) = delete;
+
+    /// Socket to add to a select() set (pass as receive_udp_data's interrupt_fd).
+    socket_t fd() const { return sock_; }
+
+    /// Wake any select() watching fd(). Safe to call from any thread (a one-byte UDP
+    /// send), and as often as needed — drain() consumes the accumulated bytes.
+    void signal() {
+        if (is_valid_socket(sock_) && port_ != 0) {
+            send_udp_data(sock_, std::vector<uint8_t>{1}, "127.0.0.1", port_, AddressFamily::IPv4);
+        }
+    }
+
+    /// Discard all pending wakeup bytes so the next select() blocks again. Call once
+    /// after each wake-up, from the waiting thread only. No-op if the pipe is degraded.
+    void drain() {
+        if (!is_valid_socket(sock_)) return;
+        uint8_t buf[64];
+        sockaddr_in from;
+        socklen_t len;
+        for (;;) {
+            len = sizeof(from);
+            const int n = recvfrom(sock_, reinterpret_cast<char*>(buf), sizeof(buf), 0,
+                                   reinterpret_cast<sockaddr*>(&from), &len);
+            if (n <= 0) break;  // EWOULDBLOCK / drained (socket is non-blocking)
+        }
+    }
+
+private:
+    socket_t sock_ = RATS_INVALID_SOCKET;
+    uint16_t port_ = 0;
+};
+
+} // namespace librats

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

@@ -1,3 +1,4 @@
+/* SPDX-License-Identifier: MIT */
 /*
  * Copyright (C) 2016 Southern Storm Software, Pty Ltd.
  *
@@ -23,35 +24,32 @@
 #ifndef LIBRATS_BLAKE2_ENDIAN_H
 #define LIBRATS_BLAKE2_ENDIAN_H
 
-#if defined(__WIN32__) || defined(WIN32) || defined(_WIN32)
-#ifndef __BIG_ENDIAN
-#define __BIG_ENDIAN 4321
-#endif
-#ifndef __LITTLE_ENDIAN
-#define __LITTLE_ENDIAN 1234
-#endif
-#ifndef __BYTE_ORDER
-#define __BYTE_ORDER __LITTLE_ENDIAN
-#endif
+/*
+ * Defines RATS_BLAKE2_LITTLE_ENDIAN when the target is little-endian, and
+ * nothing else. This header is installed, so it must NOT define __BYTE_ORDER /
+ * __LITTLE_ENDIAN / __BIG_ENDIAN: those names are reserved to the platform, and
+ * defining them here leaks into every consumer translation unit that includes
+ * us. Detect the byte order instead of asserting it.
+ */
+
+#if defined(__BYTE_ORDER__) && defined(__ORDER_LITTLE_ENDIAN__)
+/* GCC and Clang predefine these on every target — no system header needed. */
+#if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
+#define RATS_BLAKE2_LITTLE_ENDIAN 1
+#endif
+#elif defined(_WIN32)
+/* MSVC predefines no byte-order macro; every Windows target it ships is LE. */
+#define RATS_BLAKE2_LITTLE_ENDIAN 1
 #elif defined(__APPLE__)
 #include <machine/endian.h>
-#if !defined( __BYTE_ORDER) && defined(__DARWIN_BYTE_ORDER)
-#define __BYTE_ORDER __DARWIN_BYTE_ORDER
+#if __DARWIN_BYTE_ORDER == __DARWIN_LITTLE_ENDIAN
+#define RATS_BLAKE2_LITTLE_ENDIAN 1
 #endif
-#if !defined( __BIG_ENDIAN) && defined(__DARWIN_BIG_ENDIAN)
-#define __BIG_ENDIAN __DARWIN_BIG_ENDIAN
-#endif
-#if !defined( __LITTLE_ENDIAN) && defined(__DARWIN_LITTLE_ENDIAN)
-#define __LITTLE_ENDIAN __DARWIN_LITTLE_ENDIAN
-#endif
-#elif defined(__ANDROID__)
-#include <endian.h>
 #else
 #include <endian.h>
-#endif
-
 #if __BYTE_ORDER == __LITTLE_ENDIAN
-#define BLAKE2_LITTLE_ENDIAN 1
+#define RATS_BLAKE2_LITTLE_ENDIAN 1
+#endif
 #endif
 
 #endif /* LIBRATS_BLAKE2_ENDIAN_H */

package/native-src/src/{crypto → librats/crypto}/blake2b.c

@@ -1,3 +1,4 @@
+/* SPDX-License-Identifier: MIT */
 /*
  * Copyright (C) 2016 Southern Storm Software, Pty Ltd.
  *
@@ -26,30 +27,30 @@
     https://github.com/rweather/arduinolibs
 */
 
-#include "blake2b.h"
-#include "blake2_endian.h"
+#include "librats/crypto/blake2b.h"
+#include "librats/crypto/blake2_endian.h"
 #include <string.h>
 
 /* Initialization vectors for BLAKE2b */
-#define BLAKE2b_IV0 0x6a09e667f3bcc908ULL
-#define BLAKE2b_IV1 0xbb67ae8584caa73bULL
-#define BLAKE2b_IV2 0x3c6ef372fe94f82bULL
-#define BLAKE2b_IV3 0xa54ff53a5f1d36f1ULL
-#define BLAKE2b_IV4 0x510e527fade682d1ULL
-#define BLAKE2b_IV5 0x9b05688c2b3e6c1fULL
-#define BLAKE2b_IV6 0x1f83d9abfb41bd6bULL
-#define BLAKE2b_IV7 0x5be0cd19137e2179ULL
-
-void BLAKE2b_reset(BLAKE2b_context_t *context)
+#define rats_blake2b_IV0 0x6a09e667f3bcc908ULL
+#define rats_blake2b_IV1 0xbb67ae8584caa73bULL
+#define rats_blake2b_IV2 0x3c6ef372fe94f82bULL
+#define rats_blake2b_IV3 0xa54ff53a5f1d36f1ULL
+#define rats_blake2b_IV4 0x510e527fade682d1ULL
+#define rats_blake2b_IV5 0x9b05688c2b3e6c1fULL
+#define rats_blake2b_IV6 0x1f83d9abfb41bd6bULL
+#define rats_blake2b_IV7 0x5be0cd19137e2179ULL
+
+void rats_blake2b_reset(rats_blake2b_context_t *context)
 {
-    context->h[0] = BLAKE2b_IV0 ^ 0x01010040; /* Default output length of 64 */
-    context->h[1] = BLAKE2b_IV1;
-    context->h[2] = BLAKE2b_IV2;
-    context->h[3] = BLAKE2b_IV3;
-    context->h[4] = BLAKE2b_IV4;
-    context->h[5] = BLAKE2b_IV5;
-    context->h[6] = BLAKE2b_IV6;
-    context->h[7] = BLAKE2b_IV7;
+    context->h[0] = rats_blake2b_IV0 ^ 0x01010040; /* Default output length of 64 */
+    context->h[1] = rats_blake2b_IV1;
+    context->h[2] = rats_blake2b_IV2;
+    context->h[3] = rats_blake2b_IV3;
+    context->h[4] = rats_blake2b_IV4;
+    context->h[5] = rats_blake2b_IV5;
+    context->h[6] = rats_blake2b_IV6;
+    context->h[7] = rats_blake2b_IV7;
     context->length = 0;
     context->posn = 0;
 }
@@ -87,7 +88,7 @@ static const uint8_t sigma[12][16] = {
     } while (0)
 
 static void blake2b_transform
-    (BLAKE2b_context_t *context, const uint8_t *data, uint64_t f0)
+    (rats_blake2b_context_t *context, const uint8_t *data, uint64_t f0)
 {
     uint8_t index;
     uint64_t m[16];
@@ -95,7 +96,7 @@ static void blake2b_transform
     const uint8_t *sigma_row;
 
     /* Unpack the input data from little-endian */
-#if BLAKE2_LITTLE_ENDIAN
+#if RATS_BLAKE2_LITTLE_ENDIAN
     memcpy(m, data, sizeof(m));
 #else
     for (index = 0; index < 16; ++index, data += 8) {
@@ -112,14 +113,14 @@ static void blake2b_transform
 
     /* Format the block to be hashed */
     memcpy(v, context->h, sizeof(context->h));
-    v[8]  = BLAKE2b_IV0;
-    v[9]  = BLAKE2b_IV1;
-    v[10] = BLAKE2b_IV2;
-    v[11] = BLAKE2b_IV3;
-    v[12] = BLAKE2b_IV4 ^ context->length;
-    v[13] = BLAKE2b_IV5;
-    v[14] = BLAKE2b_IV6 ^ f0;
-    v[15] = BLAKE2b_IV7;
+    v[8]  = rats_blake2b_IV0;
+    v[9]  = rats_blake2b_IV1;
+    v[10] = rats_blake2b_IV2;
+    v[11] = rats_blake2b_IV3;
+    v[12] = rats_blake2b_IV4 ^ context->length;
+    v[13] = rats_blake2b_IV5;
+    v[14] = rats_blake2b_IV6 ^ f0;
+    v[15] = rats_blake2b_IV7;
 
     /* Perform the 12 BLAKE2b rounds */
     sigma_row = sigma[0];
@@ -142,7 +143,7 @@ static void blake2b_transform
         context->h[index] ^= (v[index] ^ v[index + 8]);
 }
 
-void BLAKE2b_update(BLAKE2b_context_t *context, const void *data, size_t size)
+void rats_blake2b_update(rats_blake2b_context_t *context, const void *data, size_t size)
 {
     /* Break the input up into 1024-bit chunks and process each in turn */
     const uint8_t *d = (const uint8_t *)data;
@@ -174,14 +175,14 @@ void BLAKE2b_update(BLAKE2b_context_t *context, const void *data, size_t size)
     }
 }
 
-void BLAKE2b_finish(BLAKE2b_context_t *context, uint8_t *hash)
+void rats_blake2b_finish(rats_blake2b_context_t *context, uint8_t *hash)
 {
     /* Pad the last chunk and hash it with f0 set to all-ones */
     memset(context->m + context->posn, 0, 128 - context->posn);
     blake2b_transform(context, context->m, 0xFFFFFFFFFFFFFFFFULL);
 
     /* Copy the hash to the caller's return buffer in little-endian */
-#if BLAKE2_LITTLE_ENDIAN
+#if RATS_BLAKE2_LITTLE_ENDIAN
     memcpy(hash, context->h, sizeof(context->h));
 #else
     {

package/native-src/src/{crypto → librats/crypto}/blake2b.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 BLAKE2B_HASH_SIZE 64
-#define BLAKE2B_BLOCK_SIZE 128
+#define RATS_BLAKE2B_HASH_SIZE 64
+#define RATS_BLAKE2B_BLOCK_SIZE 128
 
 typedef struct
 {
@@ -40,11 +41,11 @@ typedef struct
     uint64_t length;    /* Limited to 2^64 - 1 bytes */
     uint8_t  posn;
 
-} BLAKE2b_context_t;
+} rats_blake2b_context_t;
 
-void BLAKE2b_reset(BLAKE2b_context_t *context);
-void BLAKE2b_update(BLAKE2b_context_t *context, const void *data, size_t size);
-void BLAKE2b_finish(BLAKE2b_context_t *context, uint8_t *hash);
+void rats_blake2b_reset(rats_blake2b_context_t *context);
+void rats_blake2b_update(rats_blake2b_context_t *context, const void *data, size_t size);
+void rats_blake2b_finish(rats_blake2b_context_t *context, uint8_t *hash);
 
 #ifdef __cplusplus
 }

package/native-src/src/{crypto → librats/crypto}/blake2s.c

@@ -1,3 +1,4 @@
+/* SPDX-License-Identifier: MIT */
 /*
  * Copyright (C) 2016 Southern Storm Software, Pty Ltd.
  *
@@ -27,36 +28,36 @@
     https://github.com/rweather/arduinolibs
 */
 
-#include "blake2s.h"
-#include "blake2_endian.h"
+#include "librats/crypto/blake2s.h"
+#include "librats/crypto/blake2_endian.h"
 #include <string.h>
 
 /* Initialization vectors for BLAKE2s */
-#define BLAKE2s_IV0 0x6A09E667
-#define BLAKE2s_IV1 0xBB67AE85
-#define BLAKE2s_IV2 0x3C6EF372
-#define BLAKE2s_IV3 0xA54FF53A
-#define BLAKE2s_IV4 0x510E527F
-#define BLAKE2s_IV5 0x9B05688C
-#define BLAKE2s_IV6 0x1F83D9AB
-#define BLAKE2s_IV7 0x5BE0CD19
+#define rats_blake2s_IV0 0x6A09E667
+#define rats_blake2s_IV1 0xBB67AE85
+#define rats_blake2s_IV2 0x3C6EF372
+#define rats_blake2s_IV3 0xA54FF53A
+#define rats_blake2s_IV4 0x510E527F
+#define rats_blake2s_IV5 0x9B05688C
+#define rats_blake2s_IV6 0x1F83D9AB
+#define rats_blake2s_IV7 0x5BE0CD19
 
-void BLAKE2s_reset(BLAKE2s_context_t *context)
+void rats_blake2s_reset(rats_blake2s_context_t *context)
 {
-#if BLAKE2S_USE_VECTOR_MATH
-    context->h[0] = (BlakeVectorUInt32){BLAKE2s_IV0 ^ 0x01010020,
-                                        BLAKE2s_IV1, BLAKE2s_IV2, BLAKE2s_IV3};
-    context->h[1] = (BlakeVectorUInt32){BLAKE2s_IV4, BLAKE2s_IV5,
-                                        BLAKE2s_IV6, BLAKE2s_IV7};
+#if RATS_BLAKE2S_USE_VECTOR_MATH
+    context->h[0] = (RatsBlakeVectorUInt32){rats_blake2s_IV0 ^ 0x01010020,
+                                        rats_blake2s_IV1, rats_blake2s_IV2, rats_blake2s_IV3};
+    context->h[1] = (RatsBlakeVectorUInt32){rats_blake2s_IV4, rats_blake2s_IV5,
+                                        rats_blake2s_IV6, rats_blake2s_IV7};
 #else
-    context->h[0] = BLAKE2s_IV0 ^ 0x01010020; /* Default output length of 32 */
-    context->h[1] = BLAKE2s_IV1;
-    context->h[2] = BLAKE2s_IV2;
-    context->h[3] = BLAKE2s_IV3;
-    context->h[4] = BLAKE2s_IV4;
-    context->h[5] = BLAKE2s_IV5;
-    context->h[6] = BLAKE2s_IV6;
-    context->h[7] = BLAKE2s_IV7;
+    context->h[0] = rats_blake2s_IV0 ^ 0x01010020; /* Default output length of 32 */
+    context->h[1] = rats_blake2s_IV1;
+    context->h[2] = rats_blake2s_IV2;
+    context->h[3] = rats_blake2s_IV3;
+    context->h[4] = rats_blake2s_IV4;
+    context->h[5] = rats_blake2s_IV5;
+    context->h[6] = rats_blake2s_IV6;
+    context->h[7] = rats_blake2s_IV7;
 #endif
     context->length = 0;
     context->posn = 0;
@@ -92,11 +93,11 @@ static const uint8_t sigma[10][16] = {
         (b) = rightRotate((b) ^ (c), 7); \
     } while (0)
 
-#if BLAKE2S_USE_VECTOR_MATH
+#if RATS_BLAKE2S_USE_VECTOR_MATH
 
-#define shuffleLeft1(x) (BlakeVectorUInt32){(x)[1], (x)[2], (x)[3], (x)[0]}
-#define shuffleLeft2(x) (BlakeVectorUInt32){(x)[2], (x)[3], (x)[0], (x)[1]}
-#define shuffleLeft3(x) (BlakeVectorUInt32){(x)[3], (x)[0], (x)[1], (x)[2]}
+#define shuffleLeft1(x) (RatsBlakeVectorUInt32){(x)[1], (x)[2], (x)[3], (x)[0]}
+#define shuffleLeft2(x) (RatsBlakeVectorUInt32){(x)[2], (x)[3], (x)[0], (x)[1]}
+#define shuffleLeft3(x) (RatsBlakeVectorUInt32){(x)[3], (x)[0], (x)[1], (x)[2]}
 
 /* Perform a BLAKE2s quarter round operation with vector math */
 #define quarterRoundVec(a, b, c, d, mv0, mv1) \
@@ -114,31 +115,31 @@ static const uint8_t sigma[10][16] = {
 #endif
 
 static void blake2s_transform
-    (BLAKE2s_context_t *context, const uint8_t *data, uint32_t f0)
+    (rats_blake2s_context_t *context, const uint8_t *data, uint32_t f0)
 {
-#if BLAKE2S_USE_VECTOR_MATH
+#if RATS_BLAKE2S_USE_VECTOR_MATH
     /* Assumption: CPU is little-endian and supports unaligned 32-bit loads */
     uint8_t index;
     const uint32_t *m = (const uint32_t *)data;
-    BlakeVectorUInt32 v0, v1, v2, v3, mv0, mv1;
+    RatsBlakeVectorUInt32 v0, v1, v2, v3, mv0, mv1;
     const uint8_t *sigma_row;
 
     /* Format the block to be hashed */
     v0 = context->h[0];
     v1 = context->h[1];
-    v2 = (BlakeVectorUInt32){BLAKE2s_IV0, BLAKE2s_IV1,
-                             BLAKE2s_IV2, BLAKE2s_IV3};
-    v3 = (BlakeVectorUInt32){BLAKE2s_IV4 ^ (uint32_t)(context->length),
-                             BLAKE2s_IV5 ^ (uint32_t)(context->length >> 32),
-                             BLAKE2s_IV6 ^ f0, BLAKE2s_IV7};
+    v2 = (RatsBlakeVectorUInt32){rats_blake2s_IV0, rats_blake2s_IV1,
+                             rats_blake2s_IV2, rats_blake2s_IV3};
+    v3 = (RatsBlakeVectorUInt32){rats_blake2s_IV4 ^ (uint32_t)(context->length),
+                             rats_blake2s_IV5 ^ (uint32_t)(context->length >> 32),
+                             rats_blake2s_IV6 ^ f0, rats_blake2s_IV7};
 
     /* Perform the 10 BLAKE2s rounds */
     sigma_row = sigma[0];
     for (index = 0; index < 10; ++index, sigma_row += 16) {
         /* Column round */
-        mv0 = (BlakeVectorUInt32){m[sigma_row[0]], m[sigma_row[2]],
+        mv0 = (RatsBlakeVectorUInt32){m[sigma_row[0]], m[sigma_row[2]],
                                   m[sigma_row[4]], m[sigma_row[6]]};
-        mv1 = (BlakeVectorUInt32){m[sigma_row[1]], m[sigma_row[3]],
+        mv1 = (RatsBlakeVectorUInt32){m[sigma_row[1]], m[sigma_row[3]],
                                   m[sigma_row[5]], m[sigma_row[7]]};
         quarterRoundVec(v0, v1, v2, v3, mv0, mv1);
         v1 = shuffleLeft1(v1);
@@ -146,9 +147,9 @@ static void blake2s_transform
         v3 = shuffleLeft3(v3);
 
         /* Diagonal round */
-        mv0 = (BlakeVectorUInt32){m[sigma_row[8]],  m[sigma_row[10]],
+        mv0 = (RatsBlakeVectorUInt32){m[sigma_row[8]],  m[sigma_row[10]],
                                   m[sigma_row[12]], m[sigma_row[14]]};
-        mv1 = (BlakeVectorUInt32){m[sigma_row[9]],  m[sigma_row[11]],
+        mv1 = (RatsBlakeVectorUInt32){m[sigma_row[9]],  m[sigma_row[11]],
                                   m[sigma_row[13]], m[sigma_row[15]]};
         quarterRoundVec(v0, v1, v2, v3, mv0, mv1);
         v1 = shuffleLeft3(v1);
@@ -159,14 +160,14 @@ static void blake2s_transform
     /* Combine the new and old hash values */
     context->h[0] ^= v0 ^ v2;
     context->h[1] ^= v1 ^ v3;
-#else /* !BLAKE2S_USE_VECTOR_MATH */
+#else /* !RATS_BLAKE2S_USE_VECTOR_MATH */
     uint8_t index;
     uint32_t m[16];
     uint32_t v[16];
     const uint8_t *sigma_row;
 
     /* Unpack the input data from little-endian */
-#if BLAKE2_LITTLE_ENDIAN
+#if RATS_BLAKE2_LITTLE_ENDIAN
     memcpy(m, data, sizeof(m));
 #else
     for (index = 0; index < 16; ++index, data += 4) {
@@ -179,14 +180,14 @@ static void blake2s_transform
 
     /* Format the block to be hashed */
     memcpy(v, context->h, sizeof(context->h));
-    v[8]  = BLAKE2s_IV0;
-    v[9]  = BLAKE2s_IV1;
-    v[10] = BLAKE2s_IV2;
-    v[11] = BLAKE2s_IV3;
-    v[12] = BLAKE2s_IV4 ^ (uint32_t)(context->length);
-    v[13] = BLAKE2s_IV5 ^ (uint32_t)(context->length >> 32);
-    v[14] = BLAKE2s_IV6 ^ f0;
-    v[15] = BLAKE2s_IV7;
+    v[8]  = rats_blake2s_IV0;
+    v[9]  = rats_blake2s_IV1;
+    v[10] = rats_blake2s_IV2;
+    v[11] = rats_blake2s_IV3;
+    v[12] = rats_blake2s_IV4 ^ (uint32_t)(context->length);
+    v[13] = rats_blake2s_IV5 ^ (uint32_t)(context->length >> 32);
+    v[14] = rats_blake2s_IV6 ^ f0;
+    v[15] = rats_blake2s_IV7;
 
     /* Perform the 10 BLAKE2s rounds */
     sigma_row = sigma[0];
@@ -207,10 +208,10 @@ static void blake2s_transform
     /* Combine the new and old hash values */
     for (index = 0; index < 8; ++index)
         context->h[index] ^= (v[index] ^ v[index + 8]);
-#endif /* !BLAKE2S_USE_VECTOR_MATH */
+#endif /* !RATS_BLAKE2S_USE_VECTOR_MATH */
 }
 
-void BLAKE2s_update(BLAKE2s_context_t *context, const void *data, size_t size)
+void rats_blake2s_update(rats_blake2s_context_t *context, const void *data, size_t size)
 {
     /* Break the input up into 512-bit chunks and process each in turn */
     const uint8_t *d = (const uint8_t *)data;
@@ -242,14 +243,14 @@ void BLAKE2s_update(BLAKE2s_context_t *context, const void *data, size_t size)
     }
 }
 
-void BLAKE2s_finish(BLAKE2s_context_t *context, uint8_t *hash)
+void rats_blake2s_finish(rats_blake2s_context_t *context, uint8_t *hash)
 {
     /* Pad the last chunk and hash it with f0 set to all-ones */
     memset(context->m + context->posn, 0, 64 - context->posn);
     blake2s_transform(context, context->m, 0xFFFFFFFF);
 
     /* Copy the hash to the caller's return buffer in little-endian */
-#if BLAKE2_LITTLE_ENDIAN
+#if RATS_BLAKE2_LITTLE_ENDIAN
     memcpy(hash, context->h, sizeof(context->h));
 #else
     {

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

@@ -1,3 +1,4 @@
+/* SPDX-License-Identifier: MIT */
 /*
  * Copyright (C) 2016 Southern Storm Software, Pty Ltd.
  *
@@ -30,24 +31,24 @@
 extern "C" {
 #endif
 
-#define BLAKE2S_HASH_SIZE 32
-#define BLAKE2S_BLOCK_SIZE 64
+#define RATS_BLAKE2S_HASH_SIZE 32
+#define RATS_BLAKE2S_BLOCK_SIZE 64
 
 #if defined(__SSE2__) && defined(__GNUC__) && __GNUC__ >= 4
-#define BLAKE2S_USE_VECTOR_MATH 1
+#define RATS_BLAKE2S_USE_VECTOR_MATH 1
 #ifdef __clang__
-typedef uint32_t BlakeVectorUInt32 __attribute__((ext_vector_type(4)));
+typedef uint32_t RatsBlakeVectorUInt32 __attribute__((ext_vector_type(4)));
 #else
-typedef uint32_t BlakeVectorUInt32 __attribute__((__vector_size__(16)));
+typedef uint32_t RatsBlakeVectorUInt32 __attribute__((__vector_size__(16)));
 #endif
 #else
-#undef BLAKE2S_USE_VECTOR_MATH
+#undef RATS_BLAKE2S_USE_VECTOR_MATH
 #endif
 
 typedef struct
 {
-#if BLAKE2S_USE_VECTOR_MATH
-    BlakeVectorUInt32 h[2];
+#if RATS_BLAKE2S_USE_VECTOR_MATH
+    RatsBlakeVectorUInt32 h[2];
 #else
     uint32_t h[8];
 #endif
@@ -55,11 +56,11 @@ typedef struct
     uint64_t length;
     uint8_t  posn;
 
-} BLAKE2s_context_t;
+} rats_blake2s_context_t;
 
-void BLAKE2s_reset(BLAKE2s_context_t *context);
-void BLAKE2s_update(BLAKE2s_context_t *context, const void *data, size_t size);
-void BLAKE2s_finish(BLAKE2s_context_t *context, uint8_t *hash);
+void rats_blake2s_reset(rats_blake2s_context_t *context);
+void rats_blake2s_update(rats_blake2s_context_t *context, const void *data, size_t size);
+void rats_blake2s_finish(rats_blake2s_context_t *context, uint8_t *hash);
 
 #ifdef __cplusplus
 }