librats 1.0.2 → 2.2.0

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

@@ -1,3 +1,4 @@
+/* SPDX-License-Identifier: MIT */
 /*
  * Copyright (C) 2016 Southern Storm Software, Pty Ltd.
  *
@@ -23,7 +24,7 @@
 /* Essentially the same as D. J. Bernstein's reference implementation
    but with an option to use SIMD instructions for 4-way parallelism. */
 
-#include "chacha.h"
+#include "librats/crypto/chacha.h"
 #include <string.h>
 
 #define fromLittle(ptr)   \
@@ -38,12 +39,12 @@
      (ptr)[2] = (uint8_t)((v) >> 16), \
      (ptr)[3] = (uint8_t)((v) >> 24))
 
-#ifdef CHACHA_USE_VECTOR_MATH
+#ifdef RATS_CHACHA_USE_VECTOR_MATH
 
 /* Assumption: CPU is little-endian and can perform unaligned
    32-bit loads and stores */
 #define fromLittleVec(ptr)  \
-    (ChaChaVectorUInt32){((const uint32_t *)(ptr))[0], \
+    (RatsChaChaVectorUInt32){((const uint32_t *)(ptr))[0], \
                          ((const uint32_t *)(ptr))[1], \
                          ((const uint32_t *)(ptr))[2], \
                          ((const uint32_t *)(ptr))[3]}
@@ -71,13 +72,13 @@
         (b) = leftRotate((b) ^ (c), 7); \
     } while (0)
 
-void chacha_keysetup(chacha_ctx *x, const uint8_t *k, uint32_t kbits)
+void rats_chacha_keysetup(rats_chacha_ctx *x, const uint8_t *k, uint32_t kbits)
 {
     static const char tag128[] = "expand 16-byte k";
     static const char tag256[] = "expand 32-byte k";
     if (kbits == 256) {
         memcpy(x->input, tag256, 16);
-#ifdef CHACHA_USE_VECTOR_MATH
+#ifdef RATS_CHACHA_USE_VECTOR_MATH
         x->input[1] = fromLittleVec(k);
         x->input[2] = fromLittleVec(k + 16);
 #else
@@ -92,7 +93,7 @@ void chacha_keysetup(chacha_ctx *x, const uint8_t *k, uint32_t kbits)
 #endif
     } else {
         memcpy(x->input, tag128, 16);
-#ifdef CHACHA_USE_VECTOR_MATH
+#ifdef RATS_CHACHA_USE_VECTOR_MATH
         x->input[2] = x->input[1] = fromLittleVec(k);
 #else
         x->input[8]  = x->input[4] = fromLittle(k);
@@ -101,23 +102,23 @@ void chacha_keysetup(chacha_ctx *x, const uint8_t *k, uint32_t kbits)
         x->input[11] = x->input[7] = fromLittle(k + 12);
 #endif
     }
-#ifdef CHACHA_USE_VECTOR_MATH
-    x->input[3] = (ChaChaVectorUInt32){0, 0, 0, 0};
+#ifdef RATS_CHACHA_USE_VECTOR_MATH
+    x->input[3] = (RatsChaChaVectorUInt32){0, 0, 0, 0};
 #else
     memset(x->input + 12, 0, 16);
 #endif
 }
 
-void chacha_ivsetup(chacha_ctx *x, const uint8_t *iv, const uint8_t *counter)
+void rats_chacha_ivsetup(rats_chacha_ctx *x, const uint8_t *iv, const uint8_t *counter)
 {
-#ifdef CHACHA_USE_VECTOR_MATH
+#ifdef RATS_CHACHA_USE_VECTOR_MATH
     if (counter) {
-        x->input[3] = (ChaChaVectorUInt32){fromLittle(counter),
+        x->input[3] = (RatsChaChaVectorUInt32){fromLittle(counter),
                                            fromLittle(counter + 4),
                                            fromLittle(iv),
                                            fromLittle(iv + 4)};
     } else {
-        x->input[3] = (ChaChaVectorUInt32){0, 0, fromLittle(iv), fromLittle(iv + 4)};
+        x->input[3] = (RatsChaChaVectorUInt32){0, 0, fromLittle(iv), fromLittle(iv + 4)};
     }
 #else
     if (counter) {
@@ -132,15 +133,15 @@ void chacha_ivsetup(chacha_ctx *x, const uint8_t *iv, const uint8_t *counter)
 #endif
 }
 
-#ifdef CHACHA_USE_VECTOR_MATH
+#ifdef RATS_CHACHA_USE_VECTOR_MATH
 
-#define shuffleLeft1(x) (ChaChaVectorUInt32){(x)[1], (x)[2], (x)[3], (x)[0]}
-#define shuffleLeft2(x) (ChaChaVectorUInt32){(x)[2], (x)[3], (x)[0], (x)[1]}
-#define shuffleLeft3(x) (ChaChaVectorUInt32){(x)[3], (x)[0], (x)[1], (x)[2]}
+#define shuffleLeft1(x) (RatsChaChaVectorUInt32){(x)[1], (x)[2], (x)[3], (x)[0]}
+#define shuffleLeft2(x) (RatsChaChaVectorUInt32){(x)[2], (x)[3], (x)[0], (x)[1]}
+#define shuffleLeft3(x) (RatsChaChaVectorUInt32){(x)[3], (x)[0], (x)[1], (x)[2]}
 
-void chacha_encrypt_bytes(chacha_ctx *x, const uint8_t *m, uint8_t *c, uint32_t bytes)
+void rats_chacha_encrypt_bytes(rats_chacha_ctx *x, const uint8_t *m, uint8_t *c, uint32_t bytes)
 {
-    ChaChaVectorUInt32 out0, out1, out2, out3;
+    RatsChaChaVectorUInt32 out0, out1, out2, out3;
     uint32_t index;
     uint8_t temp[64];
     uint8_t *t;
@@ -204,9 +205,9 @@ void chacha_encrypt_bytes(chacha_ctx *x, const uint8_t *m, uint8_t *c, uint32_t
     }
 }
 
-#else /* !CHACHA_USE_VECTOR_MATH */
+#else /* !RATS_CHACHA_USE_VECTOR_MATH */
 
-void chacha_encrypt_bytes(chacha_ctx *x, const uint8_t *m, uint8_t *c, uint32_t bytes)
+void rats_chacha_encrypt_bytes(rats_chacha_ctx *x, const uint8_t *m, uint8_t *c, uint32_t bytes)
 {
     uint32_t in0, in1, in2, in3, in4, in5, in6, in7;
     uint32_t in8, in9, in10, in11, in12, in13, in14, in15;
@@ -309,4 +310,4 @@ void chacha_encrypt_bytes(chacha_ctx *x, const uint8_t *m, uint8_t *c, uint32_t
     x->input[13] = in13;
 }
 
-#endif /* !CHACHA_USE_VECTOR_MATH */
+#endif /* !RATS_CHACHA_USE_VECTOR_MATH */

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

@@ -1,3 +1,4 @@
+/* SPDX-License-Identifier: MIT */
 /*
  * Copyright (C) 2016 Southern Storm Software, Pty Ltd.
  *
@@ -30,34 +31,34 @@
 extern "C" {
 #endif
 
-#define CHACHA_KEY_SIZE 32
-#define CHACHA_NONCE_SIZE 8
-#define CHACHA_BLOCK_SIZE 64
+#define RATS_CHACHA_KEY_SIZE 32
+#define RATS_CHACHA_NONCE_SIZE 8
+#define RATS_CHACHA_BLOCK_SIZE 64
 
 #if defined(__SSE2__) && defined(__GNUC__) && __GNUC__ >= 4
-#define CHACHA_USE_VECTOR_MATH 1
+#define RATS_CHACHA_USE_VECTOR_MATH 1
 #ifdef __clang__
-typedef uint32_t ChaChaVectorUInt32 __attribute__((ext_vector_type(4)));
+typedef uint32_t RatsChaChaVectorUInt32 __attribute__((ext_vector_type(4)));
 #else
-typedef uint32_t ChaChaVectorUInt32 __attribute__((__vector_size__(16)));
+typedef uint32_t RatsChaChaVectorUInt32 __attribute__((__vector_size__(16)));
 #endif
 #else
-#undef CHACHA_USE_VECTOR_MATH
+#undef RATS_CHACHA_USE_VECTOR_MATH
 #endif
 
 typedef struct
 {
-#ifdef CHACHA_USE_VECTOR_MATH
-    ChaChaVectorUInt32 input[4];
+#ifdef RATS_CHACHA_USE_VECTOR_MATH
+    RatsChaChaVectorUInt32 input[4];
 #else
     uint32_t input[16];
 #endif
 
-} chacha_ctx;
+} rats_chacha_ctx;
 
-void chacha_keysetup(chacha_ctx *x, const uint8_t *k, uint32_t kbits);
-void chacha_ivsetup(chacha_ctx *x, const uint8_t *iv, const uint8_t *counter);
-void chacha_encrypt_bytes(chacha_ctx *x, const uint8_t *m, uint8_t *c, uint32_t bytes);
+void rats_chacha_keysetup(rats_chacha_ctx *x, const uint8_t *k, uint32_t kbits);
+void rats_chacha_ivsetup(rats_chacha_ctx *x, const uint8_t *iv, const uint8_t *counter);
+void rats_chacha_encrypt_bytes(rats_chacha_ctx *x, const uint8_t *m, uint8_t *c, uint32_t bytes);
 
 #ifdef __cplusplus
 }

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

@@ -3,9 +3,9 @@
  * Based on RFC 8439
  */
 
-#include "chachapoly.h"
-#include "chacha.h"
-#include "poly1305.h"
+#include "librats/crypto/chachapoly.h"
+#include "librats/crypto/chacha.h"
+#include "librats/crypto/poly1305.h"
 #include <string.h>
 
 /* Write 64-bit nonce counter to 12-byte Noise nonce format (currently unused, reserved for future use) */
@@ -57,80 +57,80 @@ static void secure_zero(void *ptr, size_t len) {
 }
 
 /* Pad to 16-byte boundary for Poly1305 */
-static void poly1305_pad16(poly1305_context *ctx, size_t data_len) {
+static void rats_poly1305_pad16(rats_poly1305_context *ctx, size_t data_len) {
     static const uint8_t zeros[16] = {0};
     size_t pad = (16 - (data_len % 16)) % 16;
     if (pad > 0) {
-        poly1305_update(ctx, zeros, pad);
+        rats_poly1305_update(ctx, zeros, pad);
     }
 }
 
-size_t chachapoly_encrypt(
-    const uint8_t key[CHACHAPOLY_KEY_SIZE],
-    const uint8_t nonce[CHACHAPOLY_NONCE_SIZE],
+size_t rats_chachapoly_encrypt(
+    const uint8_t key[RATS_CHACHAPOLY_KEY_SIZE],
+    const uint8_t nonce[RATS_CHACHAPOLY_NONCE_SIZE],
     const uint8_t *ad, size_t ad_len,
     const uint8_t *plaintext, size_t pt_len,
     uint8_t *ciphertext
 ) {
-    chacha_ctx chacha;
-    poly1305_context poly;
+    rats_chacha_ctx chacha;
+    rats_poly1305_context poly;
     uint8_t poly_key[64];
     uint8_t block0_counter[8] = {0};
     uint8_t block1_counter[8] = {1, 0, 0, 0, 0, 0, 0, 0};
     uint8_t len_block[16];
     
     /* Generate Poly1305 key from first ChaCha20 block (counter = 0) */
-    chacha_keysetup(&chacha, key, 256);
-    chacha_ivsetup(&chacha, nonce + 4, block0_counter);
+    rats_chacha_keysetup(&chacha, key, 256);
+    rats_chacha_ivsetup(&chacha, nonce + 4, block0_counter);
     memset(poly_key, 0, 64);
-    chacha_encrypt_bytes(&chacha, poly_key, poly_key, 64);
+    rats_chacha_encrypt_bytes(&chacha, poly_key, poly_key, 64);
     
     /* Encrypt plaintext with ChaCha20 (counter = 1) */
-    chacha_keysetup(&chacha, key, 256);
-    chacha_ivsetup(&chacha, nonce + 4, block1_counter);
+    rats_chacha_keysetup(&chacha, key, 256);
+    rats_chacha_ivsetup(&chacha, nonce + 4, block1_counter);
     if (pt_len > 0) {
-        chacha_encrypt_bytes(&chacha, plaintext, ciphertext, (uint32_t)pt_len);
+        rats_chacha_encrypt_bytes(&chacha, plaintext, ciphertext, (uint32_t)pt_len);
     }
     
     /* Compute Poly1305 tag */
-    poly1305_init(&poly, poly_key);
+    rats_poly1305_init(&poly, poly_key);
     
     /* Authenticate AD */
     if (ad_len > 0) {
-        poly1305_update(&poly, ad, ad_len);
-        poly1305_pad16(&poly, ad_len);
+        rats_poly1305_update(&poly, ad, ad_len);
+        rats_poly1305_pad16(&poly, ad_len);
     }
     
     /* Authenticate ciphertext */
     if (pt_len > 0) {
-        poly1305_update(&poly, ciphertext, pt_len);
-        poly1305_pad16(&poly, pt_len);
+        rats_poly1305_update(&poly, ciphertext, pt_len);
+        rats_poly1305_pad16(&poly, pt_len);
     }
     
     /* Authenticate lengths */
     write_le64(len_block, ad_len);
     write_le64(len_block + 8, pt_len);
-    poly1305_update(&poly, len_block, 16);
+    rats_poly1305_update(&poly, len_block, 16);
     
     /* Output tag */
-    poly1305_finish(&poly, ciphertext + pt_len);
+    rats_poly1305_finish(&poly, ciphertext + pt_len);
     
     /* Clean up sensitive data */
     secure_zero(&chacha, sizeof(chacha));
     secure_zero(poly_key, sizeof(poly_key));
     
-    return pt_len + CHACHAPOLY_TAG_SIZE;
+    return pt_len + RATS_CHACHAPOLY_TAG_SIZE;
 }
 
-size_t chachapoly_decrypt(
-    const uint8_t key[CHACHAPOLY_KEY_SIZE],
-    const uint8_t nonce[CHACHAPOLY_NONCE_SIZE],
+size_t rats_chachapoly_decrypt(
+    const uint8_t key[RATS_CHACHAPOLY_KEY_SIZE],
+    const uint8_t nonce[RATS_CHACHAPOLY_NONCE_SIZE],
     const uint8_t *ad, size_t ad_len,
     const uint8_t *ciphertext, size_t ct_len,
     uint8_t *plaintext
 ) {
-    chacha_ctx chacha;
-    poly1305_context poly;
+    rats_chacha_ctx chacha;
+    rats_poly1305_context poly;
     uint8_t poly_key[64];
     uint8_t block0_counter[8] = {0};
     uint8_t block1_counter[8] = {1, 0, 0, 0, 0, 0, 0, 0};
@@ -138,53 +138,53 @@ size_t chachapoly_decrypt(
     uint8_t computed_tag[16];
     size_t pt_len;
     
-    if (ct_len < CHACHAPOLY_TAG_SIZE) {
-        return 0;
+    if (ct_len < RATS_CHACHAPOLY_TAG_SIZE) {
+        return RATS_CHACHAPOLY_DECRYPT_FAILED;
     }
-    
-    pt_len = ct_len - CHACHAPOLY_TAG_SIZE;
+
+    pt_len = ct_len - RATS_CHACHAPOLY_TAG_SIZE;
     
     /* Generate Poly1305 key from first ChaCha20 block (counter = 0) */
-    chacha_keysetup(&chacha, key, 256);
-    chacha_ivsetup(&chacha, nonce + 4, block0_counter);
+    rats_chacha_keysetup(&chacha, key, 256);
+    rats_chacha_ivsetup(&chacha, nonce + 4, block0_counter);
     memset(poly_key, 0, 64);
-    chacha_encrypt_bytes(&chacha, poly_key, poly_key, 64);
+    rats_chacha_encrypt_bytes(&chacha, poly_key, poly_key, 64);
     
     /* Compute Poly1305 tag */
-    poly1305_init(&poly, poly_key);
+    rats_poly1305_init(&poly, poly_key);
     
     /* Authenticate AD */
     if (ad_len > 0) {
-        poly1305_update(&poly, ad, ad_len);
-        poly1305_pad16(&poly, ad_len);
+        rats_poly1305_update(&poly, ad, ad_len);
+        rats_poly1305_pad16(&poly, ad_len);
     }
     
     /* Authenticate ciphertext */
     if (pt_len > 0) {
-        poly1305_update(&poly, ciphertext, pt_len);
-        poly1305_pad16(&poly, pt_len);
+        rats_poly1305_update(&poly, ciphertext, pt_len);
+        rats_poly1305_pad16(&poly, pt_len);
     }
     
     /* Authenticate lengths */
     write_le64(len_block, ad_len);
     write_le64(len_block + 8, pt_len);
-    poly1305_update(&poly, len_block, 16);
+    rats_poly1305_update(&poly, len_block, 16);
     
     /* Compute and verify tag */
-    poly1305_finish(&poly, computed_tag);
+    rats_poly1305_finish(&poly, computed_tag);
     
-    if (!secure_compare(computed_tag, ciphertext + pt_len, CHACHAPOLY_TAG_SIZE)) {
+    if (!secure_compare(computed_tag, ciphertext + pt_len, RATS_CHACHAPOLY_TAG_SIZE)) {
         secure_zero(&chacha, sizeof(chacha));
         secure_zero(poly_key, sizeof(poly_key));
         secure_zero(computed_tag, sizeof(computed_tag));
-        return 0;  /* Authentication failed */
+        return RATS_CHACHAPOLY_DECRYPT_FAILED;  /* Authentication failed */
     }
     
     /* Decrypt ciphertext */
-    chacha_keysetup(&chacha, key, 256);
-    chacha_ivsetup(&chacha, nonce + 4, block1_counter);
+    rats_chacha_keysetup(&chacha, key, 256);
+    rats_chacha_ivsetup(&chacha, nonce + 4, block1_counter);
     if (pt_len > 0) {
-        chacha_encrypt_bytes(&chacha, ciphertext, plaintext, (uint32_t)pt_len);
+        rats_chacha_encrypt_bytes(&chacha, ciphertext, plaintext, (uint32_t)pt_len);
     }
     
     /* Clean up sensitive data */
@@ -195,20 +195,20 @@ size_t chachapoly_decrypt(
     return pt_len;
 }
 
-size_t chachapoly_encrypt_inplace(
-    const uint8_t key[CHACHAPOLY_KEY_SIZE],
-    const uint8_t nonce[CHACHAPOLY_NONCE_SIZE],
+size_t rats_chachapoly_encrypt_inplace(
+    const uint8_t key[RATS_CHACHAPOLY_KEY_SIZE],
+    const uint8_t nonce[RATS_CHACHAPOLY_NONCE_SIZE],
     const uint8_t *ad, size_t ad_len,
     uint8_t *data, size_t data_len
 ) {
-    return chachapoly_encrypt(key, nonce, ad, ad_len, data, data_len, data);
+    return rats_chachapoly_encrypt(key, nonce, ad, ad_len, data, data_len, data);
 }
 
-size_t chachapoly_decrypt_inplace(
-    const uint8_t key[CHACHAPOLY_KEY_SIZE],
-    const uint8_t nonce[CHACHAPOLY_NONCE_SIZE],
+size_t rats_chachapoly_decrypt_inplace(
+    const uint8_t key[RATS_CHACHAPOLY_KEY_SIZE],
+    const uint8_t nonce[RATS_CHACHAPOLY_NONCE_SIZE],
     const uint8_t *ad, size_t ad_len,
     uint8_t *data, size_t data_len
 ) {
-    return chachapoly_decrypt(key, nonce, ad, ad_len, data, data_len, data);
+    return rats_chachapoly_decrypt(key, nonce, ad, ad_len, data, data_len, data);
 }

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

@@ -13,9 +13,14 @@
 extern "C" {
 #endif
 
-#define CHACHAPOLY_KEY_SIZE 32
-#define CHACHAPOLY_NONCE_SIZE 12
-#define CHACHAPOLY_TAG_SIZE 16
+#define RATS_CHACHAPOLY_KEY_SIZE 32
+#define RATS_CHACHAPOLY_NONCE_SIZE 12
+#define RATS_CHACHAPOLY_TAG_SIZE 16
+
+/* Sentinel returned by the decrypt functions on authentication failure.
+ * A successful decryption returns the plaintext length, which may legitimately
+ * be 0 (an empty-but-authenticated message), so failure needs a distinct value. */
+#define RATS_CHACHAPOLY_DECRYPT_FAILED ((size_t)-1)
 
 /**
  * Encrypt plaintext with ChaCha20-Poly1305 AEAD
@@ -29,9 +34,9 @@ extern "C" {
  * @param ciphertext Output buffer (must be at least pt_len + 16 bytes)
  * @return          Length of ciphertext (pt_len + 16) on success, 0 on failure
  */
-size_t chachapoly_encrypt(
-    const uint8_t key[CHACHAPOLY_KEY_SIZE],
-    const uint8_t nonce[CHACHAPOLY_NONCE_SIZE],
+size_t rats_chachapoly_encrypt(
+    const uint8_t key[RATS_CHACHAPOLY_KEY_SIZE],
+    const uint8_t nonce[RATS_CHACHAPOLY_NONCE_SIZE],
     const uint8_t *ad, size_t ad_len,
     const uint8_t *plaintext, size_t pt_len,
     uint8_t *ciphertext
@@ -47,11 +52,12 @@ size_t chachapoly_encrypt(
  * @param ciphertext Input ciphertext (plaintext + 16-byte tag)
  * @param ct_len     Length of ciphertext (must be >= 16)
  * @param plaintext  Output buffer (must be at least ct_len - 16 bytes)
- * @return           Length of plaintext (ct_len - 16) on success, 0 on failure
+ * @return           Length of plaintext (ct_len - 16) on success (may be 0 for an
+ *                   empty authenticated message), RATS_CHACHAPOLY_DECRYPT_FAILED on failure
  */
-size_t chachapoly_decrypt(
-    const uint8_t key[CHACHAPOLY_KEY_SIZE],
-    const uint8_t nonce[CHACHAPOLY_NONCE_SIZE],
+size_t rats_chachapoly_decrypt(
+    const uint8_t key[RATS_CHACHAPOLY_KEY_SIZE],
+    const uint8_t nonce[RATS_CHACHAPOLY_NONCE_SIZE],
     const uint8_t *ad, size_t ad_len,
     const uint8_t *ciphertext, size_t ct_len,
     uint8_t *plaintext
@@ -69,9 +75,9 @@ size_t chachapoly_decrypt(
  * @param data_len  Length of plaintext
  * @return          Length of output (data_len + 16) on success, 0 on failure
  */
-size_t chachapoly_encrypt_inplace(
-    const uint8_t key[CHACHAPOLY_KEY_SIZE],
-    const uint8_t nonce[CHACHAPOLY_NONCE_SIZE],
+size_t rats_chachapoly_encrypt_inplace(
+    const uint8_t key[RATS_CHACHAPOLY_KEY_SIZE],
+    const uint8_t nonce[RATS_CHACHAPOLY_NONCE_SIZE],
     const uint8_t *ad, size_t ad_len,
     uint8_t *data, size_t data_len
 );
@@ -85,11 +91,12 @@ size_t chachapoly_encrypt_inplace(
  * @param ad_len    Length of additional data
  * @param data      Data buffer (ciphertext + tag in, plaintext out)
  * @param data_len  Length of ciphertext including tag (must be >= 16)
- * @return          Length of plaintext (data_len - 16) on success, 0 on failure
+ * @return          Length of plaintext (data_len - 16) on success (may be 0),
+ *                  RATS_CHACHAPOLY_DECRYPT_FAILED on failure
  */
-size_t chachapoly_decrypt_inplace(
-    const uint8_t key[CHACHAPOLY_KEY_SIZE],
-    const uint8_t nonce[CHACHAPOLY_NONCE_SIZE],
+size_t rats_chachapoly_decrypt_inplace(
+    const uint8_t key[RATS_CHACHAPOLY_KEY_SIZE],
+    const uint8_t nonce[RATS_CHACHAPOLY_NONCE_SIZE],
     const uint8_t *ad, size_t ad_len,
     uint8_t *data, size_t data_len
 );

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

@@ -1,4 +1,4 @@
-#include "crc32.h"
+#include "librats/crypto/crc32.h"
 
 namespace librats {
 

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

@@ -1,6 +1,8 @@
 #ifndef LIBRATS_CRC32_H
 #define LIBRATS_CRC32_H
 
+#include "librats/util/rats_export.h"
+
 #include <cstdint>
 #include <cstddef>
 #include <vector>
@@ -25,7 +27,7 @@ namespace librats {
  * uint32_t checksum2 = CRC32::calculate("Hello World", 11);
  * @endcode
  */
-class CRC32 {
+class RATS_API CRC32 {
 public:
     /**
      * @brief Construct a new CRC32 object with initial state

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

@@ -1,3 +1,4 @@
+/* SPDX-License-Identifier: BSD-3-Clause */
 /* Copyright 2008, Google Inc.
  * All rights reserved.
  *
@@ -45,11 +46,12 @@
  * uses many of the tricks described therein. Only the crecip function is taken
  * from the sample implementation. */
 
-#include "curve25519.h"
+#include "librats/crypto/curve25519.h"
 #include <string.h>
 
-/* The Curve25519 basepoint */
-const uint8_t curve25519_basepoint[32] = {9};
+/* The Curve25519 basepoint. RATS_API here is what puts the symbol in the DLL:
+ * unlike functions, exported data needs the attribute on the definition too. */
+RATS_API const uint8_t rats_curve25519_basepoint[32] = {9};
 
 #ifdef _MSC_VER
 #define inline __inline
@@ -844,7 +846,7 @@ crecip(limb *out, const limb *z) {
 }
 
 int
-curve25519_donna(u8 *mypublic, const u8 *secret, const u8 *basepoint) {
+rats_curve25519_donna(u8 *mypublic, const u8 *secret, const u8 *basepoint) {
   limb bp[10], x[10], z[11], zmone[10];
   uint8_t e[32];
   int i;

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

@@ -1,3 +1,4 @@
+/* SPDX-License-Identifier: BSD-3-Clause */
 /* Copyright 2008, Google Inc.
  * All rights reserved.
  *
@@ -37,13 +38,15 @@
 #ifndef LIBRATS_CURVE25519_H
 #define LIBRATS_CURVE25519_H
 
+#include "librats/util/rats_export.h"
+
 #include <stdint.h>
 
 #ifdef __cplusplus
 extern "C" {
 #endif
 
-#define CURVE25519_KEY_SIZE 32
+#define RATS_CURVE25519_KEY_SIZE 32
 
 /**
  * Computes a Curve25519 shared secret or public key.
@@ -53,13 +56,13 @@ extern "C" {
  * @param basepoint Public key of the other party, or the Curve25519 basepoint
  * @return 0 on success
  */
-int curve25519_donna(uint8_t *mypublic, const uint8_t *secret, const uint8_t *basepoint);
+int rats_curve25519_donna(uint8_t *mypublic, const uint8_t *secret, const uint8_t *basepoint);
 
 /**
  * The Curve25519 basepoint (9).
  * Use this as basepoint to derive a public key from a private key.
  */
-extern const uint8_t curve25519_basepoint[32];
+RATS_API extern const uint8_t rats_curve25519_basepoint[32];
 
 #ifdef __cplusplus
 }