librats 1.0.2 → 2.1.4

package/native-src/src/chained_send_buffer.h

@@ -1,137 +0,0 @@
-#pragma once
-
-/**
- * @file chained_send_buffer.h
- * @brief Zero-copy chained send buffer for efficient network sending
- * 
- * Stores a chain of buffers to be sent. Supports:
- * - Appending without copying (move semantics)
- * - Efficient partial sends via pop_front()
- * - Direct access to front chunk for send()
- * 
- * Zero-copy chained buffer for efficient sending.
- */
-
-#include <vector>
-#include <deque>
-#include <cstdint>
-#include <cstddef>
-
-namespace librats {
-
-/**
- * @brief A chunk of data in the send chain
- */
-struct SendChunk {
-    std::vector<uint8_t> data;  ///< Owned data
-    size_t offset = 0;          ///< Current read offset (for partial sends)
-    
-    SendChunk() = default;
-    explicit SendChunk(std::vector<uint8_t> d) : data(std::move(d)), offset(0) {}
-    
-    /// Bytes remaining to send
-    size_t remaining() const { return data.size() - offset; }
-    
-    /// Pointer to current data position
-    const uint8_t* current() const { return data.data() + offset; }
-};
-
-/**
- * @brief Zero-copy chained send buffer
- * 
- * Stores a chain of buffers to be sent. Supports:
- * - Appending without copying (move semantics)
- * - Efficient partial sends via pop_front()
- * - Direct access to front chunk for send()
- * 
- * Zero-copy chained buffer for efficient sending.
- * 
- * Usage:
- *   1. append(data) - queue data for sending
- *   2. send(socket, front_data(), front_size())
- *   3. pop_front(bytes_sent) - remove sent data
- */
-class ChainedSendBuffer {
-public:
-    ChainedSendBuffer() = default;
-    
-    //=========================================================================
-    // Append interface
-    //=========================================================================
-    
-    /**
-     * @brief Append data by moving (zero-copy)
-     */
-    void append(std::vector<uint8_t> data);
-    
-    /**
-     * @brief Append data by copying
-     */
-    void append(const uint8_t* data, size_t length);
-    
-    //=========================================================================
-    // Send interface
-    //=========================================================================
-    
-    /**
-     * @brief Get pointer to front chunk data (for send())
-     * 
-     * Returns nullptr if buffer is empty.
-     */
-    const uint8_t* front_data() const;
-    
-    /**
-     * @brief Get size of front chunk (for send())
-     * 
-     * Returns 0 if buffer is empty.
-     */
-    size_t front_size() const;
-    
-    /**
-     * @brief Remove bytes from front after successful send
-     */
-    void pop_front(size_t bytes);
-    
-    //=========================================================================
-    // Buffer state
-    //=========================================================================
-    
-    /**
-     * @brief Get total bytes pending across all chunks
-     */
-    size_t size() const { return total_bytes_; }
-    
-    /**
-     * @brief Check if buffer is empty
-     */
-    bool empty() const { return total_bytes_ == 0; }
-    
-    /**
-     * @brief Clear all pending data
-     */
-    void clear();
-    
-    /**
-     * @brief Get number of chunks
-     */
-    size_t chunk_count() const { return chunks_.size(); }
-    
-    //=========================================================================
-    // Advanced: Gather I/O support
-    //=========================================================================
-    
-    /**
-     * @brief Copy data to a contiguous buffer (for legacy APIs)
-     * 
-     * @param buffer Output buffer
-     * @param max_bytes Maximum bytes to copy
-     * @return Actual bytes copied
-     */
-    size_t copy_to(uint8_t* buffer, size_t max_bytes) const;
-
-private:
-    std::deque<SendChunk> chunks_;
-    size_t total_bytes_ = 0;
-};
-
-} // namespace librats

package/native-src/src/crypto/hkdf.c

@@ -1,266 +0,0 @@
-/*
- * HKDF-SHA256 implementation for Noise Protocol
- * Based on RFC 5869
- */
-
-#include "hkdf.h"
-#include "sha256.h"
-#include <string.h>
-
-#define SHA256_BLOCK_SIZE 64
-#define SHA256_HASH_SIZE 32
-
-/* Zero memory securely */
-static void secure_zero(void *ptr, size_t len) {
-    volatile uint8_t *p = (volatile uint8_t *)ptr;
-    while (len--) {
-        *p++ = 0;
-    }
-}
-
-void hmac_sha256(
-    const uint8_t *key, size_t key_len,
-    const uint8_t *data, size_t data_len,
-    uint8_t output[HKDF_SHA256_HASH_LEN]
-) {
-    sha256_context_t ctx;
-    uint8_t k_pad[SHA256_BLOCK_SIZE];
-    uint8_t temp_key[SHA256_HASH_SIZE];
-    const uint8_t *k;
-    size_t k_len;
-    size_t i;
-    
-    /* If key is longer than block size, hash it first */
-    if (key_len > SHA256_BLOCK_SIZE) {
-        sha256_hash(temp_key, key, key_len);
-        k = temp_key;
-        k_len = SHA256_HASH_SIZE;
-    } else {
-        k = key;
-        k_len = key_len;
-    }
-    
-    /* Prepare inner padding (key XOR 0x36) */
-    memset(k_pad, 0x36, SHA256_BLOCK_SIZE);
-    for (i = 0; i < k_len; i++) {
-        k_pad[i] ^= k[i];
-    }
-    
-    /* Inner hash: H(K XOR ipad || data) */
-    sha256_reset(&ctx);
-    sha256_update(&ctx, k_pad, SHA256_BLOCK_SIZE);
-    sha256_update(&ctx, data, data_len);
-    sha256_finish(&ctx, output);
-    
-    /* Prepare outer padding (key XOR 0x5c) */
-    memset(k_pad, 0x5c, SHA256_BLOCK_SIZE);
-    for (i = 0; i < k_len; i++) {
-        k_pad[i] ^= k[i];
-    }
-    
-    /* Outer hash: H(K XOR opad || inner_hash) */
-    sha256_reset(&ctx);
-    sha256_update(&ctx, k_pad, SHA256_BLOCK_SIZE);
-    sha256_update(&ctx, output, SHA256_HASH_SIZE);
-    sha256_finish(&ctx, output);
-    
-    /* Clean up */
-    secure_zero(k_pad, sizeof(k_pad));
-    secure_zero(temp_key, sizeof(temp_key));
-}
-
-void hmac_sha256_2(
-    const uint8_t *key, size_t key_len,
-    const uint8_t *data1, size_t data1_len,
-    const uint8_t *data2, size_t data2_len,
-    uint8_t output[HKDF_SHA256_HASH_LEN]
-) {
-    sha256_context_t ctx;
-    uint8_t k_pad[SHA256_BLOCK_SIZE];
-    uint8_t temp_key[SHA256_HASH_SIZE];
-    const uint8_t *k;
-    size_t k_len;
-    size_t i;
-    
-    /* If key is longer than block size, hash it first */
-    if (key_len > SHA256_BLOCK_SIZE) {
-        sha256_hash(temp_key, key, key_len);
-        k = temp_key;
-        k_len = SHA256_HASH_SIZE;
-    } else {
-        k = key;
-        k_len = key_len;
-    }
-    
-    /* Prepare inner padding (key XOR 0x36) */
-    memset(k_pad, 0x36, SHA256_BLOCK_SIZE);
-    for (i = 0; i < k_len; i++) {
-        k_pad[i] ^= k[i];
-    }
-    
-    /* Inner hash: H(K XOR ipad || data1 || data2) */
-    sha256_reset(&ctx);
-    sha256_update(&ctx, k_pad, SHA256_BLOCK_SIZE);
-    sha256_update(&ctx, data1, data1_len);
-    sha256_update(&ctx, data2, data2_len);
-    sha256_finish(&ctx, output);
-    
-    /* Prepare outer padding (key XOR 0x5c) */
-    memset(k_pad, 0x5c, SHA256_BLOCK_SIZE);
-    for (i = 0; i < k_len; i++) {
-        k_pad[i] ^= k[i];
-    }
-    
-    /* Outer hash: H(K XOR opad || inner_hash) */
-    sha256_reset(&ctx);
-    sha256_update(&ctx, k_pad, SHA256_BLOCK_SIZE);
-    sha256_update(&ctx, output, SHA256_HASH_SIZE);
-    sha256_finish(&ctx, output);
-    
-    /* Clean up */
-    secure_zero(k_pad, sizeof(k_pad));
-    secure_zero(temp_key, sizeof(temp_key));
-}
-
-void hkdf_sha256_extract(
-    const uint8_t *salt, size_t salt_len,
-    const uint8_t *ikm, size_t ikm_len,
-    uint8_t prk[HKDF_SHA256_HASH_LEN]
-) {
-    static const uint8_t default_salt[HKDF_SHA256_HASH_LEN] = {0};
-    
-    if (salt == NULL || salt_len == 0) {
-        salt = default_salt;
-        salt_len = HKDF_SHA256_HASH_LEN;
-    }
-    
-    hmac_sha256(salt, salt_len, ikm, ikm_len, prk);
-}
-
-void hkdf_sha256_expand(
-    const uint8_t prk[HKDF_SHA256_HASH_LEN],
-    const uint8_t *info, size_t info_len,
-    uint8_t *okm, size_t okm_len
-) {
-    sha256_context_t ctx;
-    uint8_t k_pad[SHA256_BLOCK_SIZE];
-    uint8_t T[SHA256_HASH_SIZE];
-    uint8_t counter;
-    size_t t_len = 0;
-    size_t copy_len;
-    size_t i;
-    
-    /* Key is always 32 bytes (hash length) */
-    /* Prepare inner padding template */
-    memset(k_pad, 0x36, SHA256_BLOCK_SIZE);
-    for (i = 0; i < HKDF_SHA256_HASH_LEN; i++) {
-        k_pad[i] ^= prk[i];
-    }
-    
-    counter = 1;
-    while (okm_len > 0) {
-        uint8_t outer_result[SHA256_HASH_SIZE];
-        uint8_t k_pad_outer[SHA256_BLOCK_SIZE];
-        
-        /* Inner hash: H(K XOR ipad || T || info || counter) */
-        sha256_reset(&ctx);
-        sha256_update(&ctx, k_pad, SHA256_BLOCK_SIZE);
-        if (t_len > 0) {
-            sha256_update(&ctx, T, t_len);
-        }
-        if (info_len > 0) {
-            sha256_update(&ctx, info, info_len);
-        }
-        sha256_update(&ctx, &counter, 1);
-        sha256_finish(&ctx, T);
-        
-        /* Prepare outer padding */
-        memset(k_pad_outer, 0x5c, SHA256_BLOCK_SIZE);
-        for (i = 0; i < HKDF_SHA256_HASH_LEN; i++) {
-            k_pad_outer[i] ^= prk[i];
-        }
-        
-        /* Outer hash: H(K XOR opad || inner_hash) */
-        sha256_reset(&ctx);
-        sha256_update(&ctx, k_pad_outer, SHA256_BLOCK_SIZE);
-        sha256_update(&ctx, T, SHA256_HASH_SIZE);
-        sha256_finish(&ctx, T);
-        
-        /* Copy to output */
-        copy_len = okm_len < SHA256_HASH_SIZE ? okm_len : SHA256_HASH_SIZE;
-        memcpy(okm, T, copy_len);
-        okm += copy_len;
-        okm_len -= copy_len;
-        
-        t_len = SHA256_HASH_SIZE;
-        counter++;
-        
-        secure_zero(k_pad_outer, sizeof(k_pad_outer));
-    }
-    
-    secure_zero(k_pad, sizeof(k_pad));
-    secure_zero(T, sizeof(T));
-}
-
-void hkdf_sha256(
-    const uint8_t *salt, size_t salt_len,
-    const uint8_t *ikm, size_t ikm_len,
-    const uint8_t *info, size_t info_len,
-    uint8_t *okm, size_t okm_len
-) {
-    uint8_t prk[HKDF_SHA256_HASH_LEN];
-    
-    hkdf_sha256_extract(salt, salt_len, ikm, ikm_len, prk);
-    hkdf_sha256_expand(prk, info, info_len, okm, okm_len);
-    
-    secure_zero(prk, sizeof(prk));
-}
-
-void noise_hkdf_2(
-    const uint8_t chaining_key[HKDF_SHA256_HASH_LEN],
-    const uint8_t *input_key, size_t input_len,
-    uint8_t output1[HKDF_SHA256_HASH_LEN],
-    uint8_t output2[HKDF_SHA256_HASH_LEN]
-) {
-    uint8_t temp_key[HKDF_SHA256_HASH_LEN];
-    uint8_t counter1 = 0x01;
-    uint8_t counter2 = 0x02;
-    
-    /* temp_key = HMAC(ck, input) */
-    hmac_sha256(chaining_key, HKDF_SHA256_HASH_LEN, input_key, input_len, temp_key);
-    
-    /* output1 = HMAC(temp_key, 0x01) */
-    hmac_sha256(temp_key, HKDF_SHA256_HASH_LEN, &counter1, 1, output1);
-    
-    /* output2 = HMAC(temp_key, output1 || 0x02) */
-    hmac_sha256_2(temp_key, HKDF_SHA256_HASH_LEN, output1, HKDF_SHA256_HASH_LEN, &counter2, 1, output2);
-    
-    secure_zero(temp_key, sizeof(temp_key));
-}
-
-void noise_hkdf_3(
-    const uint8_t chaining_key[HKDF_SHA256_HASH_LEN],
-    const uint8_t *input_key, size_t input_len,
-    uint8_t output1[HKDF_SHA256_HASH_LEN],
-    uint8_t output2[HKDF_SHA256_HASH_LEN],
-    uint8_t output3[HKDF_SHA256_HASH_LEN]
-) {
-    uint8_t temp_key[HKDF_SHA256_HASH_LEN];
-    uint8_t counter1 = 0x01;
-    uint8_t counter2 = 0x02;
-    uint8_t counter3 = 0x03;
-    
-    /* temp_key = HMAC(ck, input) */
-    hmac_sha256(chaining_key, HKDF_SHA256_HASH_LEN, input_key, input_len, temp_key);
-    
-    /* output1 = HMAC(temp_key, 0x01) */
-    hmac_sha256(temp_key, HKDF_SHA256_HASH_LEN, &counter1, 1, output1);
-    
-    /* output2 = HMAC(temp_key, output1 || 0x02) */
-    hmac_sha256_2(temp_key, HKDF_SHA256_HASH_LEN, output1, HKDF_SHA256_HASH_LEN, &counter2, 1, output2);
-    
-    /* output3 = HMAC(temp_key, output2 || 0x03) */
-    hmac_sha256_2(temp_key, HKDF_SHA256_HASH_LEN, output2, HKDF_SHA256_HASH_LEN, &counter3, 1, output3);
-    
-    secure_zero(temp_key, sizeof(temp_key));
-}

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

@@ -1,36 +0,0 @@
-/*
- * 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 POLY1305_KEY_SIZE 32
-#define POLY1305_TAG_SIZE 16
-
-typedef struct poly1305_context {
-    size_t aligner;
-    unsigned char opaque[136];
-} poly1305_context;
-
-void poly1305_init(poly1305_context *ctx, const unsigned char key[32]);
-void poly1305_update(poly1305_context *ctx, const unsigned char *m, size_t bytes);
-void poly1305_finish(poly1305_context *ctx, unsigned char mac[16]);
-void poly1305_auth(unsigned char mac[16], const unsigned char *m, size_t bytes, const unsigned char key[32]);
-
-int poly1305_verify(const unsigned char mac1[16], const unsigned char mac2[16]);
-int poly1305_power_on_self_test(void);
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif /* LIBRATS_POLY1305_H */