librats 1.0.2 → 2.2.0

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

@@ -16,7 +16,7 @@
 #include <memory>
 #include <string>
 
-namespace rats {
+namespace librats {
 
 /* Constants */
 constexpr size_t NOISE_KEY_SIZE = 32;
@@ -25,6 +25,12 @@ constexpr size_t NOISE_DH_SIZE = 32;
 constexpr size_t NOISE_TAG_SIZE = 16;
 constexpr size_t NOISE_MAX_MESSAGE_SIZE = 65535;
 
+/* Returned by decrypt_with_ad / decrypt_and_hash / NoiseSession::decrypt on
+ * authentication failure. A successful decryption returns the plaintext length,
+ * which may be 0 for an empty authenticated message, so failure needs a distinct
+ * sentinel that cannot be confused with a valid (possibly zero) length. */
+constexpr size_t NOISE_DECRYPT_FAILED = static_cast<size_t>(-1);
+
 /* Protocol name for Noise_XX_25519_ChaChaPoly_SHA256 */
 constexpr const char* NOISE_PROTOCOL_NAME = "Noise_XX_25519_ChaChaPoly_SHA256";
 
@@ -61,7 +67,7 @@ public:
     /* Get current nonce value */
     uint64_t get_nonce() const { return nonce_; }
     
-    /* Set nonce (for testing/rekey) */
+    /* Set nonce (for testing) */
     void set_nonce(uint64_t n) { nonce_ = n; }
     
     /**
@@ -94,9 +100,6 @@ public:
         uint8_t* plaintext
     );
     
-    /* Rekey the cipher state */
-    void rekey();
-    
     /* Clear sensitive data */
     void clear();
 
@@ -145,9 +148,12 @@ public:
      * @param ciphertext Input ciphertext
      * @param ct_len Length of ciphertext
      * @param plaintext Output buffer
+     * @param plaintext_cap Capacity of the output buffer in bytes; decryption is
+     *        refused (returns 0) if the resulting plaintext would not fit. This
+     *        guards a fixed-size payload buffer against an oversized message.
      * @return Length of plaintext on success, 0 on failure
      */
-    size_t decrypt_and_hash(const uint8_t* ciphertext, size_t ct_len, uint8_t* plaintext);
+    size_t decrypt_and_hash(const uint8_t* ciphertext, size_t ct_len, uint8_t* plaintext, size_t plaintext_cap);
     
     /**
      * Split into two CipherState objects for transport phase
@@ -323,8 +329,12 @@ public:
      * Start a new session
      * @param is_initiator true if initiating the connection
      * @param static_keypair Optional pre-generated static key pair
+     * @param prologue Optional prologue mixed into the handshake hash; both peers
+     *                 must supply identical prologue bytes or the handshake fails
+     * @param prologue_len Length of prologue
      */
-    NoiseError start(bool is_initiator, const NoiseKeyPair* static_keypair = nullptr);
+    NoiseError start(bool is_initiator, const NoiseKeyPair* static_keypair = nullptr,
+                     const uint8_t* prologue = nullptr, size_t prologue_len = 0);
     
     /**
      * Process handshake - call repeatedly until is_handshake_complete()
@@ -402,6 +412,6 @@ void noise_generate_keypair(NoiseKeyPair& keypair);
 void noise_derive_public_key(const uint8_t private_key[NOISE_DH_SIZE], 
                              uint8_t public_key[NOISE_DH_SIZE]);
 
-} /* namespace rats */
+} /* namespace librats */
 
 #endif /* RATS_NOISE_H */

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

@@ -1,10 +1,11 @@
+/* SPDX-License-Identifier: MIT */
 /*
  * poly1305-donna
  * https://github.com/floodyberry/poly1305-donna
  * MIT license / public domain
  */
 
-#include "poly1305.h"
+#include "librats/crypto/poly1305.h"
 
 /* Auto detect between 32bit / 64bit */
 #if (defined(__SIZEOF_INT128__) && defined(__LP64__)) || \
@@ -29,17 +30,17 @@
     #define POLY1305_NOINLINE
 #endif
 
-#define poly1305_block_size 16
+#define rats_poly1305_block_size 16
 
 /* 17 + sizeof(size_t) + 14*sizeof(unsigned long) */
-typedef struct poly1305_state_internal_t {
+typedef struct rats_poly1305_state_internal_t {
     unsigned long r[5];
     unsigned long h[5];
     unsigned long pad[4];
     size_t leftover;
-    unsigned char buffer[poly1305_block_size];
+    unsigned char buffer[rats_poly1305_block_size];
     unsigned char final;
-} poly1305_state_internal_t;
+} rats_poly1305_state_internal_t;
 
 /* interpret four 8 bit unsigned integers as a 32 bit unsigned integer in little endian */
 static unsigned long
@@ -61,8 +62,8 @@ U32TO8(unsigned char *p, unsigned long v) {
 }
 
 void
-poly1305_init(poly1305_context *ctx, const unsigned char key[32]) {
-    poly1305_state_internal_t *st = (poly1305_state_internal_t *)ctx;
+rats_poly1305_init(rats_poly1305_context *ctx, const unsigned char key[32]) {
+    rats_poly1305_state_internal_t *st = (rats_poly1305_state_internal_t *)ctx;
 
     /* r &= 0xffffffc0ffffffc0ffffffc0fffffff */
     st->r[0] = (U8TO32(&key[ 0])     ) & 0x3ffffff;
@@ -89,7 +90,7 @@ poly1305_init(poly1305_context *ctx, const unsigned char key[32]) {
 }
 
 static void
-poly1305_blocks(poly1305_state_internal_t *st, const unsigned char *m, size_t bytes) {
+rats_poly1305_blocks(rats_poly1305_state_internal_t *st, const unsigned char *m, size_t bytes) {
     const unsigned long hibit = (st->final) ? 0 : (1UL << 24); /* 1 << 128 */
     unsigned long r0,r1,r2,r3,r4;
     unsigned long s1,s2,s3,s4;
@@ -114,7 +115,7 @@ poly1305_blocks(poly1305_state_internal_t *st, const unsigned char *m, size_t by
     h3 = st->h[3];
     h4 = st->h[4];
 
-    while (bytes >= poly1305_block_size) {
+    while (bytes >= rats_poly1305_block_size) {
         /* h += m[i] */
         h0 += (U8TO32(m+ 0)     ) & 0x3ffffff;
         h1 += (U8TO32(m+ 3) >> 2) & 0x3ffffff;
@@ -138,8 +139,8 @@ poly1305_blocks(poly1305_state_internal_t *st, const unsigned char *m, size_t by
         h0 += c * 5;  c =                (h0 >> 26); h0 =                h0 & 0x3ffffff;
         h1 += c;
 
-        m += poly1305_block_size;
-        bytes -= poly1305_block_size;
+        m += rats_poly1305_block_size;
+        bytes -= rats_poly1305_block_size;
     }
 
     st->h[0] = h0;
@@ -150,8 +151,8 @@ poly1305_blocks(poly1305_state_internal_t *st, const unsigned char *m, size_t by
 }
 
 POLY1305_NOINLINE void
-poly1305_finish(poly1305_context *ctx, unsigned char mac[16]) {
-    poly1305_state_internal_t *st = (poly1305_state_internal_t *)ctx;
+rats_poly1305_finish(rats_poly1305_context *ctx, unsigned char mac[16]) {
+    rats_poly1305_state_internal_t *st = (rats_poly1305_state_internal_t *)ctx;
     unsigned long h0,h1,h2,h3,h4,c;
     unsigned long g0,g1,g2,g3,g4;
     unsigned long long f;
@@ -161,10 +162,10 @@ poly1305_finish(poly1305_context *ctx, unsigned char mac[16]) {
     if (st->leftover) {
         size_t i = st->leftover;
         st->buffer[i++] = 1;
-        for (; i < poly1305_block_size; i++)
+        for (; i < rats_poly1305_block_size; i++)
             st->buffer[i] = 0;
         st->final = 1;
-        poly1305_blocks(st, st->buffer, poly1305_block_size);
+        rats_poly1305_blocks(st, st->buffer, rats_poly1305_block_size);
     }
 
     /* fully carry h */
@@ -273,17 +274,17 @@ poly1305_finish(poly1305_context *ctx, unsigned char mac[16]) {
     #define POLY1305_NOINLINE __attribute__((noinline))
 #endif
 
-#define poly1305_block_size 16
+#define rats_poly1305_block_size 16
 
 /* 17 + sizeof(size_t) + 8*sizeof(unsigned long long) */
-typedef struct poly1305_state_internal_t {
+typedef struct rats_poly1305_state_internal_t {
     unsigned long long r[3];
     unsigned long long h[3];
     unsigned long long pad[2];
     size_t leftover;
-    unsigned char buffer[poly1305_block_size];
+    unsigned char buffer[rats_poly1305_block_size];
     unsigned char final;
-} poly1305_state_internal_t;
+} rats_poly1305_state_internal_t;
 
 /* interpret eight 8 bit unsigned integers as a 64 bit unsigned integer in little endian */
 static unsigned long long
@@ -313,8 +314,8 @@ U64TO8(unsigned char *p, unsigned long long v) {
 }
 
 void
-poly1305_init(poly1305_context *ctx, const unsigned char key[32]) {
-    poly1305_state_internal_t *st = (poly1305_state_internal_t *)ctx;
+rats_poly1305_init(rats_poly1305_context *ctx, const unsigned char key[32]) {
+    rats_poly1305_state_internal_t *st = (rats_poly1305_state_internal_t *)ctx;
     unsigned long long t0,t1;
 
     /* r &= 0xffffffc0ffffffc0ffffffc0fffffff */
@@ -339,7 +340,7 @@ poly1305_init(poly1305_context *ctx, const unsigned char key[32]) {
 }
 
 static void
-poly1305_blocks(poly1305_state_internal_t *st, const unsigned char *m, size_t bytes) {
+rats_poly1305_blocks(rats_poly1305_state_internal_t *st, const unsigned char *m, size_t bytes) {
     const unsigned long long hibit = (st->final) ? 0 : ((unsigned long long)1 << 40); /* 1 << 128 */
     unsigned long long r0,r1,r2;
     unsigned long long s1,s2;
@@ -358,7 +359,7 @@ poly1305_blocks(poly1305_state_internal_t *st, const unsigned char *m, size_t by
     s1 = r1 * (5 << 2);
     s2 = r2 * (5 << 2);
 
-    while (bytes >= poly1305_block_size) {
+    while (bytes >= rats_poly1305_block_size) {
         unsigned long long t0,t1;
 
         /* h += m[i] */
@@ -381,8 +382,8 @@ poly1305_blocks(poly1305_state_internal_t *st, const unsigned char *m, size_t by
         h0  += c * 5; c = (h0 >> 44);  h0 =    h0  & 0xfffffffffffULL;
         h1  += c;
 
-        m += poly1305_block_size;
-        bytes -= poly1305_block_size;
+        m += rats_poly1305_block_size;
+        bytes -= rats_poly1305_block_size;
     }
 
     st->h[0] = h0;
@@ -392,8 +393,8 @@ poly1305_blocks(poly1305_state_internal_t *st, const unsigned char *m, size_t by
 
 
 POLY1305_NOINLINE void
-poly1305_finish(poly1305_context *ctx, unsigned char mac[16]) {
-    poly1305_state_internal_t *st = (poly1305_state_internal_t *)ctx;
+rats_poly1305_finish(rats_poly1305_context *ctx, unsigned char mac[16]) {
+    rats_poly1305_state_internal_t *st = (rats_poly1305_state_internal_t *)ctx;
     unsigned long long h0,h1,h2,c;
     unsigned long long g0,g1,g2;
     unsigned long long t0,t1;
@@ -402,10 +403,10 @@ poly1305_finish(poly1305_context *ctx, unsigned char mac[16]) {
     if (st->leftover) {
         size_t i = st->leftover;
         st->buffer[i] = 1;
-        for (i = i + 1; i < poly1305_block_size; i++)
+        for (i = i + 1; i < rats_poly1305_block_size; i++)
             st->buffer[i] = 0;
         st->final = 1;
-        poly1305_blocks(st, st->buffer, poly1305_block_size);
+        rats_poly1305_blocks(st, st->buffer, rats_poly1305_block_size);
     }
 
     /* fully carry h */
@@ -465,13 +466,13 @@ poly1305_finish(poly1305_context *ctx, unsigned char mac[16]) {
 #endif /* POLY1305_64BIT */
 
 void
-poly1305_update(poly1305_context *ctx, const unsigned char *m, size_t bytes) {
-    poly1305_state_internal_t *st = (poly1305_state_internal_t *)ctx;
+rats_poly1305_update(rats_poly1305_context *ctx, const unsigned char *m, size_t bytes) {
+    rats_poly1305_state_internal_t *st = (rats_poly1305_state_internal_t *)ctx;
     size_t i;
 
     /* handle leftover */
     if (st->leftover) {
-        size_t want = (poly1305_block_size - st->leftover);
+        size_t want = (rats_poly1305_block_size - st->leftover);
         if (want > bytes)
             want = bytes;
         for (i = 0; i < want; i++)
@@ -479,16 +480,16 @@ poly1305_update(poly1305_context *ctx, const unsigned char *m, size_t bytes) {
         bytes -= want;
         m += want;
         st->leftover += want;
-        if (st->leftover < poly1305_block_size)
+        if (st->leftover < rats_poly1305_block_size)
             return;
-        poly1305_blocks(st, st->buffer, poly1305_block_size);
+        rats_poly1305_blocks(st, st->buffer, rats_poly1305_block_size);
         st->leftover = 0;
     }
 
     /* process full blocks */
-    if (bytes >= poly1305_block_size) {
-        size_t want = (bytes & ~(poly1305_block_size - 1));
-        poly1305_blocks(st, m, want);
+    if (bytes >= rats_poly1305_block_size) {
+        size_t want = (bytes & ~(rats_poly1305_block_size - 1));
+        rats_poly1305_blocks(st, m, want);
         m += want;
         bytes -= want;
     }
@@ -502,15 +503,15 @@ poly1305_update(poly1305_context *ctx, const unsigned char *m, size_t bytes) {
 }
 
 void
-poly1305_auth(unsigned char mac[16], const unsigned char *m, size_t bytes, const unsigned char key[32]) {
-    poly1305_context ctx;
-    poly1305_init(&ctx, key);
-    poly1305_update(&ctx, m, bytes);
-    poly1305_finish(&ctx, mac);
+rats_poly1305_auth(unsigned char mac[16], const unsigned char *m, size_t bytes, const unsigned char key[32]) {
+    rats_poly1305_context ctx;
+    rats_poly1305_init(&ctx, key);
+    rats_poly1305_update(&ctx, m, bytes);
+    rats_poly1305_finish(&ctx, mac);
 }
 
 int
-poly1305_verify(const unsigned char mac1[16], const unsigned char mac2[16]) {
+rats_poly1305_verify(const unsigned char mac1[16], const unsigned char mac2[16]) {
     size_t i;
     unsigned int dif = 0;
     for (i = 0; i < 16; i++)
@@ -522,7 +523,7 @@ poly1305_verify(const unsigned char mac1[16], const unsigned char mac2[16]) {
 
 /* test a few basic operations */
 int
-poly1305_power_on_self_test(void) {
+rats_poly1305_power_on_self_test(void) {
     /* example from nacl */
     static const unsigned char nacl_key[32] = {
         0xee,0xa6,0xa7,0x25,0x1c,0x1e,0x72,0x91,
@@ -559,8 +560,8 @@ poly1305_power_on_self_test(void) {
     unsigned char mac[16];
     int result = 1;
 
-    poly1305_auth(mac, nacl_msg, sizeof(nacl_msg), nacl_key);
-    result &= poly1305_verify(nacl_mac, mac);
+    rats_poly1305_auth(mac, nacl_msg, sizeof(nacl_msg), nacl_key);
+    result &= rats_poly1305_verify(nacl_mac, mac);
 
     return result;
 }

package/native-src/src/librats/crypto/poly1305.h

@@ -0,0 +1,37 @@
+/* SPDX-License-Identifier: MIT */
+/*
+ * poly1305-donna
+ * https://github.com/floodyberry/poly1305-donna
+ * MIT license / public domain
+ */
+
+#ifndef LIBRATS_POLY1305_H
+#define LIBRATS_POLY1305_H
+
+#include <stddef.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define RATS_POLY1305_KEY_SIZE 32
+#define RATS_POLY1305_TAG_SIZE 16
+
+typedef struct rats_poly1305_context {
+    size_t aligner;
+    unsigned char opaque[136];
+} rats_poly1305_context;
+
+void rats_poly1305_init(rats_poly1305_context *ctx, const unsigned char key[32]);
+void rats_poly1305_update(rats_poly1305_context *ctx, const unsigned char *m, size_t bytes);
+void rats_poly1305_finish(rats_poly1305_context *ctx, unsigned char mac[16]);
+void rats_poly1305_auth(unsigned char mac[16], const unsigned char *m, size_t bytes, const unsigned char key[32]);
+
+int rats_poly1305_verify(const unsigned char mac1[16], const unsigned char mac2[16]);
+int rats_poly1305_power_on_self_test(void);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* LIBRATS_POLY1305_H */

package/native-src/src/{sha1.cpp → librats/crypto/sha1.cpp}

@@ -1,4 +1,4 @@
-#include "sha1.h"
+#include "librats/crypto/sha1.h"
 #include <iomanip>
 #include <sstream>
 #include <cstring>
@@ -148,6 +148,38 @@ std::string SHA1::finalize() {
     return result.str();
 }
 
+std::array<uint8_t, 20> SHA1::finalize_bytes() {
+    if (!finalized) {
+        // Same padding as finalize(): append 0x80, zero-fill to 56 mod 64, then
+        // the 64-bit big-endian bit length.
+        uint64_t bit_length = total_length * 8;
+        update(0x80);
+        while (buffer_length != 56) {
+            update(0x00);
+        }
+        for (int i = 7; i >= 0; i--) {
+            update(static_cast<uint8_t>(bit_length >> (i * 8)));
+        }
+        finalized = true;
+    }
+
+    std::array<uint8_t, 20> out{};
+    const uint32_t h[5] = {h0, h1, h2, h3, h4};
+    for (int i = 0; i < 5; i++) {
+        out[i * 4]     = static_cast<uint8_t>(h[i] >> 24);
+        out[i * 4 + 1] = static_cast<uint8_t>(h[i] >> 16);
+        out[i * 4 + 2] = static_cast<uint8_t>(h[i] >> 8);
+        out[i * 4 + 3] = static_cast<uint8_t>(h[i]);
+    }
+    return out;
+}
+
+std::array<uint8_t, 20> SHA1::hash_raw(const uint8_t* data, size_t length) {
+    SHA1 hasher;
+    hasher.update(data, length);
+    return hasher.finalize_bytes();
+}
+
 std::string SHA1::hash(const std::string& input) {
     SHA1 hasher;
     hasher.update(input);

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

@@ -2,6 +2,7 @@
 
 #include <string>
 #include <vector>
+#include <array>
 #include <cstdint>
 
 namespace librats {
@@ -9,25 +10,32 @@ namespace librats {
 class SHA1 {
 public:
     SHA1();
-    
+
     // Process a single byte
     void update(uint8_t byte);
-    
+
     // Process a buffer
     void update(const uint8_t* data, size_t length);
-    
+
     // Process a string
     void update(const std::string& str);
-    
+
     // Get the final hash as a hex string
     std::string finalize();
-    
+
+    // Get the final hash as the raw 20-byte digest. Idempotent: may be called
+    // after finalize() (and vice versa) — the digest is retained once computed.
+    std::array<uint8_t, 20> finalize_bytes();
+
     // Convenience function to hash a string directly
     static std::string hash(const std::string& input);
-    
+
     // Convenience function to hash a vector of bytes directly
     static std::string hash_bytes(const std::vector<uint8_t>& input);
 
+    // Convenience: hash a buffer to the raw 20-byte digest in one call.
+    static std::array<uint8_t, 20> hash_raw(const uint8_t* data, size_t length);
+
 private:
     void process_block();
     void reset();

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

@@ -1,3 +1,4 @@
+/* SPDX-License-Identifier: MIT */
 /*
  * Copyright (C) 2016 Southern Storm Software, Pty Ltd.
  *
@@ -20,10 +21,10 @@
  * DEALINGS IN THE SOFTWARE.
  */
 
-#include "sha256.h"
+#include "librats/crypto/sha256.h"
 #include <string.h>
 
-void sha256_reset(sha256_context_t *context)
+void rats_sha256_reset(rats_sha256_context_t *context)
 {
     context->h[0] = 0x6a09e667;
     context->h[1] = 0xbb67ae85;
@@ -39,7 +40,7 @@ void sha256_reset(sha256_context_t *context)
 
 #define rightRotate(v, n) (((v) >> (n)) | ((v) << (32 - (n))))
 
-static void sha256_transform(sha256_context_t *context, const uint8_t *m)
+static void rats_sha256_transform(rats_sha256_context_t *context, const uint8_t *m)
 {
     static uint32_t const k[64] = {
         0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5,
@@ -126,12 +127,12 @@ static void sha256_transform(sha256_context_t *context, const uint8_t *m)
     context->h[7] += h;
 }
 
-void sha256_update(sha256_context_t *context, const void *data, size_t size)
+void rats_sha256_update(rats_sha256_context_t *context, const void *data, size_t size)
 {
     const uint8_t *d = (const uint8_t *)data;
     while (size > 0) {
         if (context->posn == 0 && size >= 64) {
-            sha256_transform(context, d);
+            rats_sha256_transform(context, d);
             d += 64;
             size -= 64;
             context->length += 64 * 8;
@@ -142,7 +143,7 @@ void sha256_update(sha256_context_t *context, const void *data, size_t size)
             memcpy(context->m + context->posn, d, temp);
             context->posn += (uint8_t)temp;
             if (context->posn >= 64) {
-                sha256_transform(context, context->m);
+                rats_sha256_transform(context, context->m);
                 context->posn = 0;
             }
             d += temp;
@@ -160,7 +161,7 @@ static void write_be32(uint8_t *out, uint32_t value)
     out[3] = (uint8_t)value;
 }
 
-void sha256_finish(sha256_context_t *context, uint8_t *hash)
+void rats_sha256_finish(rats_sha256_context_t *context, uint8_t *hash)
 {
     uint8_t posn = context->posn;
     if (posn <= (64 - 9)) {
@@ -169,21 +170,21 @@ void sha256_finish(sha256_context_t *context, uint8_t *hash)
     } else {
         context->m[posn] = 0x80;
         memset(context->m + posn + 1, 0, 64 - (posn + 1));
-        sha256_transform(context, context->m);
+        rats_sha256_transform(context, context->m);
         memset(context->m, 0, 64 - 8);
     }
     write_be32(context->m + 64 - 8, (uint32_t)(context->length >> 32));
     write_be32(context->m + 64 - 4, (uint32_t)context->length);
-    sha256_transform(context, context->m);
+    rats_sha256_transform(context, context->m);
     context->posn = 0;
     for (posn = 0; posn < 8; ++posn)
         write_be32(hash + posn * 4, context->h[posn]);
 }
 
-void sha256_hash(uint8_t *hash, const void *data, size_t size)
+void rats_sha256_hash(uint8_t *hash, const void *data, size_t size)
 {
-    sha256_context_t context;
-    sha256_reset(&context);
-    sha256_update(&context, data, size);
-    sha256_finish(&context, hash);
+    rats_sha256_context_t context;
+    rats_sha256_reset(&context);
+    rats_sha256_update(&context, data, size);
+    rats_sha256_finish(&context, hash);
 }

package/native-src/src/{crypto → librats/crypto}/sha256.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 SHA256_HASH_SIZE 32
-#define SHA256_BLOCK_SIZE 64
+#define RATS_SHA256_HASH_SIZE 32
+#define RATS_SHA256_BLOCK_SIZE 64
 
 typedef struct
 {
@@ -40,12 +41,12 @@ typedef struct
     uint64_t length;
     uint8_t  posn;
 
-} sha256_context_t;
+} rats_sha256_context_t;
 
-void sha256_reset(sha256_context_t *context);
-void sha256_update(sha256_context_t *context, const void *data, size_t size);
-void sha256_finish(sha256_context_t *context, uint8_t *hash);
-void sha256_hash(uint8_t *hash, const void *data, size_t size);
+void rats_sha256_reset(rats_sha256_context_t *context);
+void rats_sha256_update(rats_sha256_context_t *context, const void *data, size_t size);
+void rats_sha256_finish(rats_sha256_context_t *context, uint8_t *hash);
+void rats_sha256_hash(uint8_t *hash, const void *data, size_t size);
 
 #ifdef __cplusplus
 }

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

@@ -1,3 +1,4 @@
+/* SPDX-License-Identifier: MIT */
 /*
  * Copyright (C) 2016 Southern Storm Software, Pty Ltd.
  *
@@ -20,10 +21,10 @@
  * DEALINGS IN THE SOFTWARE.
  */
 
-#include "sha512.h"
+#include "librats/crypto/sha512.h"
 #include <string.h>
 
-void sha512_reset(sha512_context_t *context)
+void rats_sha512_reset(rats_sha512_context_t *context)
 {
     static uint64_t const hash_start[8] = {
         0x6A09E667F3BCC908ULL, 0xBB67AE8584CAA73BULL, 0x3C6EF372FE94F82BULL,
@@ -37,7 +38,7 @@ void sha512_reset(sha512_context_t *context)
 
 #define rightRotate(v, n) (((v) >> (n)) | ((v) << (64 - (n))))
 
-static void sha512_transform(sha512_context_t *context, const uint8_t *m)
+static void rats_sha512_transform(rats_sha512_context_t *context, const uint8_t *m)
 {
     static uint64_t const k[80] = {
         0x428A2F98D728AE22ULL, 0x7137449123EF65CDULL, 0xB5C0FBCFEC4D3B2FULL,
@@ -139,12 +140,12 @@ static void sha512_transform(sha512_context_t *context, const uint8_t *m)
     context->h[7] += h;
 }
 
-void sha512_update(sha512_context_t *context, const void *data, size_t size)
+void rats_sha512_update(rats_sha512_context_t *context, const void *data, size_t size)
 {
     const uint8_t *d = (const uint8_t *)data;
     while (size > 0) {
         if (context->posn == 0 && size >= 128) {
-            sha512_transform(context, d);
+            rats_sha512_transform(context, d);
             d += 128;
             size -= 128;
             context->length += 128 * 8;
@@ -155,7 +156,7 @@ void sha512_update(sha512_context_t *context, const void *data, size_t size)
             memcpy(context->m + context->posn, d, temp);
             context->posn += (uint8_t)temp;
             if (context->posn >= 128) {
-                sha512_transform(context, context->m);
+                rats_sha512_transform(context, context->m);
                 context->posn = 0;
             }
             d += temp;
@@ -177,7 +178,7 @@ static void write_be64(uint8_t *out, uint64_t value)
     out[7] = (uint8_t)value;
 }
 
-void sha512_finish(sha512_context_t *context, uint8_t *hash)
+void rats_sha512_finish(rats_sha512_context_t *context, uint8_t *hash)
 {
     uint8_t posn = context->posn;
     if (posn <= (128 - 17)) {
@@ -186,21 +187,21 @@ void sha512_finish(sha512_context_t *context, uint8_t *hash)
     } else {
         context->m[posn] = 0x80;
         memset(context->m + posn + 1, 0, 128 - (posn + 1));
-        sha512_transform(context, context->m);
+        rats_sha512_transform(context, context->m);
         memset(context->m, 0, 128 - 16);
     }
     write_be64(context->m + 128 - 16, 0);
     write_be64(context->m + 128 - 8, context->length);
-    sha512_transform(context, context->m);
+    rats_sha512_transform(context, context->m);
     context->posn = 0;
     for (posn = 0; posn < 8; ++posn)
         write_be64(hash + posn * 8, context->h[posn]);
 }
 
-void sha512_hash(uint8_t *hash, const void *data, size_t size)
+void rats_sha512_hash(uint8_t *hash, const void *data, size_t size)
 {
-    sha512_context_t context;
-    sha512_reset(&context);
-    sha512_update(&context, data, size);
-    sha512_finish(&context, hash);
+    rats_sha512_context_t context;
+    rats_sha512_reset(&context);
+    rats_sha512_update(&context, data, size);
+    rats_sha512_finish(&context, hash);
 }