librats 0.5.0 → 0.5.2

package/native-src/src/noise.h

@@ -0,0 +1,227 @@
+#pragma once
+
+#include <array>
+#include <vector>
+#include <string>
+#include <memory>
+#include <cstdint>
+
+namespace librats {
+
+// Noise Protocol constants
+constexpr size_t NOISE_KEY_SIZE = 32;      // 32 bytes for Curve25519 keys
+constexpr size_t NOISE_HASH_SIZE = 32;     // 32 bytes for SHA256
+constexpr size_t NOISE_TAG_SIZE = 16;      // 16 bytes for ChaCha20-Poly1305 tag
+constexpr size_t NOISE_MAX_MESSAGE_SIZE = 65535; // Maximum noise message size
+
+// Noise key types
+using NoiseKey = std::array<uint8_t, NOISE_KEY_SIZE>;
+using NoiseHash = std::array<uint8_t, NOISE_HASH_SIZE>;
+
+/**
+ * Noise Protocol handshake state enumeration
+ */
+enum class NoiseHandshakeState {
+    UNINITIALIZED,
+    WRITE_MESSAGE_1,    // Initiator sends first message
+    READ_MESSAGE_1,     // Responder receives first message
+    WRITE_MESSAGE_2,    // Responder sends second message
+    READ_MESSAGE_2,     // Initiator receives second message
+    WRITE_MESSAGE_3,    // Initiator sends third message
+    READ_MESSAGE_3,     // Responder receives third message
+    COMPLETED,          // Handshake completed successfully
+    FAILED              // Handshake failed
+};
+
+/**
+ * Noise Protocol role enumeration
+ */
+enum class NoiseRole {
+    INITIATOR,          // The peer that initiates the handshake
+    RESPONDER           // The peer that responds to the handshake
+};
+
+/**
+ * Cryptographic functions interface for Noise Protocol
+ */
+class NoiseCrypto {
+public:
+    // ECDH operations using Curve25519
+    static NoiseKey generate_keypair(NoiseKey& private_key);
+    static NoiseKey dh(const NoiseKey& private_key, const NoiseKey& public_key);
+    
+    // AEAD encryption/decryption using ChaCha20-Poly1305
+    static std::vector<uint8_t> encrypt(const NoiseKey& key, uint64_t nonce, 
+                                       const std::vector<uint8_t>& plaintext,
+                                       const std::vector<uint8_t>& ad = {});
+    static std::vector<uint8_t> decrypt(const NoiseKey& key, uint64_t nonce,
+                                       const std::vector<uint8_t>& ciphertext,
+                                       const std::vector<uint8_t>& ad = {});
+    
+    // Hash functions using SHA256
+    static NoiseHash hash(const std::vector<uint8_t>& data);
+    static void hkdf(const std::vector<uint8_t>& salt, const std::vector<uint8_t>& ikm,
+                     const std::vector<uint8_t>& info, uint8_t* okm, size_t okm_len);
+    
+    // Utility functions
+    static void secure_memzero(void* ptr, size_t size);
+    static void random_bytes(uint8_t* buffer, size_t size);
+};
+
+/**
+ * Noise Protocol cipher state for managing encryption/decryption
+ */
+class NoiseCipherState {
+public:
+    NoiseCipherState();
+    ~NoiseCipherState();
+    
+    void initialize_key(const NoiseKey& key);
+    bool has_key() const { return has_key_; }
+    
+    std::vector<uint8_t> encrypt_with_ad(const std::vector<uint8_t>& plaintext,
+                                        const std::vector<uint8_t>& ad = {});
+    std::vector<uint8_t> decrypt_with_ad(const std::vector<uint8_t>& ciphertext,
+                                        const std::vector<uint8_t>& ad = {});
+    
+    void set_nonce(uint64_t nonce) { nonce_ = nonce; }
+    uint64_t get_nonce() const { return nonce_; }
+    
+private:
+    NoiseKey key_;
+    uint64_t nonce_;
+    bool has_key_;
+};
+
+/**
+ * Noise Protocol symmetric state for managing handshake state
+ */
+class NoiseSymmetricState {
+public:
+    NoiseSymmetricState();
+    ~NoiseSymmetricState();
+    
+    void initialize(const std::string& protocol_name);
+    void mix_key(const std::vector<uint8_t>& input_key_material);
+    void mix_hash(const std::vector<uint8_t>& data);
+    void mix_key_and_hash(const std::vector<uint8_t>& input_key_material);
+    
+    std::vector<uint8_t> encrypt_and_hash(const std::vector<uint8_t>& plaintext);
+    std::vector<uint8_t> decrypt_and_hash(const std::vector<uint8_t>& ciphertext);
+    
+    std::pair<NoiseCipherState, NoiseCipherState> split();
+    
+    const NoiseHash& get_handshake_hash() const { return h_; }
+    
+private:
+    NoiseCipherState cipher_state_;
+    NoiseKey ck_;  // Chaining key
+    NoiseHash h_;  // Handshake hash
+};
+
+/**
+ * Noise Protocol handshake state for Noise_XX pattern
+ */
+class NoiseHandshake {
+public:
+    NoiseHandshake();
+    ~NoiseHandshake();
+    
+    // Initialize for either initiator or responder role
+    bool initialize(NoiseRole role, const NoiseKey& static_private_key);
+    
+    // Handshake message processing
+    std::vector<uint8_t> write_message(const std::vector<uint8_t>& payload = {});
+    std::vector<uint8_t> read_message(const std::vector<uint8_t>& message);
+    
+    // State queries
+    NoiseHandshakeState get_state() const { return state_; }
+    NoiseRole get_role() const { return role_; }
+    bool is_completed() const { return state_ == NoiseHandshakeState::COMPLETED; }
+    bool has_failed() const { return state_ == NoiseHandshakeState::FAILED; }
+    
+    // Get cipher states after handshake completion
+    std::pair<NoiseCipherState, NoiseCipherState> get_cipher_states();
+    
+    // Get remote static public key (available after handshake)
+    const NoiseKey& get_remote_static_public_key() const { return rs_; }
+    
+private:
+    NoiseRole role_;
+    NoiseHandshakeState state_;
+    NoiseSymmetricState symmetric_state_;
+    
+    // Local keys
+    NoiseKey s_;   // Local static private key
+    NoiseKey e_;   // Local ephemeral private key
+    
+    // Remote keys
+    NoiseKey rs_;  // Remote static public key
+    NoiseKey re_;  // Remote ephemeral public key
+    
+    void advance_state();
+    void fail_handshake();
+};
+
+/**
+ * High-level Noise Protocol session manager
+ */
+class NoiseSession {
+public:
+    NoiseSession();
+    ~NoiseSession();
+    
+    // Initialize session for client (initiator) or server (responder)
+    bool initialize_as_initiator(const NoiseKey& static_private_key);
+    bool initialize_as_responder(const NoiseKey& static_private_key);
+    
+    // Handshake operations
+    bool is_handshake_completed() const;
+    bool has_handshake_failed() const;
+    
+    std::vector<uint8_t> create_handshake_message(const std::vector<uint8_t>& payload = {});
+    std::vector<uint8_t> process_handshake_message(const std::vector<uint8_t>& message);
+    
+    // Transport operations (available after handshake completion)
+    std::vector<uint8_t> encrypt_transport_message(const std::vector<uint8_t>& plaintext);
+    std::vector<uint8_t> decrypt_transport_message(const std::vector<uint8_t>& ciphertext);
+    
+    // Utility functions
+    NoiseRole get_role() const;
+    NoiseHandshakeState get_handshake_state() const;
+    const NoiseKey& get_remote_static_public_key() const;
+    
+private:
+    std::unique_ptr<NoiseHandshake> handshake_state_;
+    std::unique_ptr<NoiseCipherState> send_cipher_;
+    std::unique_ptr<NoiseCipherState> receive_cipher_;
+    bool handshake_completed_;
+};
+
+/**
+ * Utility functions for Noise Protocol
+ */
+namespace noise_utils {
+    // Key management
+    NoiseKey generate_static_keypair();
+    std::string key_to_hex(const NoiseKey& key);
+    NoiseKey hex_to_key(const std::string& hex);
+    
+    // Protocol utilities
+    std::string get_protocol_name();
+    bool validate_message_size(size_t size);
+    
+    // Error handling
+    enum class NoiseError {
+        SUCCESS,
+        INVALID_STATE,
+        HANDSHAKE_FAILED,
+        DECRYPTION_FAILED,
+        INVALID_MESSAGE_SIZE,
+        CRYPTO_ERROR
+    };
+    
+    std::string noise_error_to_string(NoiseError error);
+}
+
+} // namespace librats 

package/native-src/src/os.cpp

@@ -0,0 +1,371 @@
+#include "os.h"
+#include "logger.h"
+#include <iostream>
+#include <sstream>
+#include <fstream>
+#include <thread>
+#include <cstdlib>
+
+#ifdef _WIN32
+    #include <windows.h>
+    #include <sysinfoapi.h>
+    #include <versionhelpers.h>
+    #include <intrin.h>
+    #pragma comment(lib, "version.lib")
+#elif __APPLE__
+    #include <sys/utsname.h>
+    #include <sys/sysctl.h>
+    #include <unistd.h>
+    #include <mach/mach.h>
+    #include <mach/vm_statistics.h>
+    #include <mach/mach_types.h>
+    #include <mach/mach_init.h>
+    #include <mach/mach_host.h>
+#else
+    #include <sys/utsname.h>
+    #include <sys/sysinfo.h>
+    #include <unistd.h>
+    #include <fstream>
+    #include <regex>
+#endif
+
+namespace librats {
+
+#ifdef _WIN32
+
+std::string get_os_name() {
+    return "Windows";
+}
+
+std::string get_os_version() {
+    std::string version = "Unknown";
+    
+    OSVERSIONINFOEX osvi;
+    ZeroMemory(&osvi, sizeof(OSVERSIONINFOEX));
+    osvi.dwOSVersionInfoSize = sizeof(OSVERSIONINFOEX);
+    
+    if (GetVersionEx((OSVERSIONINFO*)&osvi)) {
+        std::ostringstream oss;
+        oss << osvi.dwMajorVersion << "." << osvi.dwMinorVersion;
+        if (osvi.dwBuildNumber > 0) {
+            oss << "." << osvi.dwBuildNumber;
+        }
+        version = oss.str();
+    }
+    
+    return version;
+}
+
+std::string get_architecture() {
+    SYSTEM_INFO si;
+    GetSystemInfo(&si);
+    
+    switch (si.wProcessorArchitecture) {
+        case PROCESSOR_ARCHITECTURE_AMD64:
+            return "x64";
+        case PROCESSOR_ARCHITECTURE_INTEL:
+            return "x86";
+        case PROCESSOR_ARCHITECTURE_ARM:
+            return "ARM";
+        case PROCESSOR_ARCHITECTURE_ARM64:
+            return "ARM64";
+        default:
+            return "Unknown";
+    }
+}
+
+std::string get_hostname() {
+    char hostname[256];
+    DWORD hostname_len = sizeof(hostname);
+    if (GetComputerNameA(hostname, &hostname_len)) {
+        return std::string(hostname);
+    }
+    return "Unknown";
+}
+
+std::string get_cpu_model() {
+    int CPUInfo[4] = {-1};
+    unsigned nExIds, i = 0;
+    char CPUBrandString[0x40];
+    
+    __cpuid(CPUInfo, 0x80000000);
+    nExIds = CPUInfo[0];
+    
+    for (i = 0x80000000; i <= nExIds; ++i) {
+        __cpuid(CPUInfo, i);
+        
+        if (i == 0x80000002)
+            memcpy(CPUBrandString, CPUInfo, sizeof(CPUInfo));
+        else if (i == 0x80000003)
+            memcpy(CPUBrandString + 16, CPUInfo, sizeof(CPUInfo));
+        else if (i == 0x80000004)
+            memcpy(CPUBrandString + 32, CPUInfo, sizeof(CPUInfo));
+    }
+    
+    return std::string(CPUBrandString);
+}
+
+int get_cpu_cores() {
+    SYSTEM_INFO si;
+    GetSystemInfo(&si);
+    return static_cast<int>(si.dwNumberOfProcessors);
+}
+
+int get_cpu_logical_cores() {
+    return get_cpu_cores(); // Same as cores on Windows with this method
+}
+
+uint64_t get_total_memory_mb() {
+    MEMORYSTATUSEX memInfo;
+    memInfo.dwLength = sizeof(MEMORYSTATUSEX);
+    GlobalMemoryStatusEx(&memInfo);
+    return memInfo.ullTotalPhys / (1024 * 1024);
+}
+
+uint64_t get_available_memory_mb() {
+    MEMORYSTATUSEX memInfo;
+    memInfo.dwLength = sizeof(MEMORYSTATUSEX);
+    GlobalMemoryStatusEx(&memInfo);
+    return memInfo.ullAvailPhys / (1024 * 1024);
+}
+
+#elif __APPLE__
+
+std::string get_os_name() {
+    return "macOS";
+}
+
+std::string get_os_version() {
+    struct utsname unameData;
+    uname(&unameData);
+    return std::string(unameData.release);
+}
+
+std::string get_architecture() {
+    struct utsname unameData;
+    uname(&unameData);
+    return std::string(unameData.machine);
+}
+
+std::string get_hostname() {
+    struct utsname unameData;
+    uname(&unameData);
+    return std::string(unameData.nodename);
+}
+
+std::string get_cpu_model() {
+    char buffer[256];
+    size_t size = sizeof(buffer);
+    if (sysctlbyname("machdep.cpu.brand_string", buffer, &size, NULL, 0) == 0) {
+        return std::string(buffer);
+    }
+    return "Unknown";
+}
+
+int get_cpu_cores() {
+    int cores = 0;
+    size_t size = sizeof(cores);
+    if (sysctlbyname("hw.physicalcpu", &cores, &size, NULL, 0) == 0) {
+        return cores;
+    }
+    return std::thread::hardware_concurrency();
+}
+
+int get_cpu_logical_cores() {
+    int cores = 0;
+    size_t size = sizeof(cores);
+    if (sysctlbyname("hw.logicalcpu", &cores, &size, NULL, 0) == 0) {
+        return cores;
+    }
+    return std::thread::hardware_concurrency();
+}
+
+uint64_t get_total_memory_mb() {
+    uint64_t memsize = 0;
+    size_t size = sizeof(memsize);
+    if (sysctlbyname("hw.memsize", &memsize, &size, NULL, 0) == 0) {
+        return memsize / (1024 * 1024);
+    }
+    return 0;
+}
+
+uint64_t get_available_memory_mb() {
+    vm_size_t page_size;
+    mach_port_t mach_port = mach_host_self();
+    vm_statistics64_data_t vm_stat;
+    mach_msg_type_number_t host_size = sizeof(vm_statistics64_data_t) / sizeof(natural_t);
+    
+    host_page_size(mach_port, &page_size);
+    host_statistics64(mach_port, HOST_VM_INFO, (host_info64_t)&vm_stat, &host_size);
+    
+    uint64_t free_memory = (uint64_t)vm_stat.free_count * (uint64_t)page_size;
+    return free_memory / (1024 * 1024);
+}
+
+#else // Linux
+
+std::string get_os_name() {
+    std::ifstream file("/etc/os-release");
+    std::string line;
+    while (std::getline(file, line)) {
+        if (line.find("PRETTY_NAME=") == 0) {
+            std::string name = line.substr(12);
+            // Remove quotes if present
+            if (name.front() == '"' && name.back() == '"') {
+                name = name.substr(1, name.length() - 2);
+            }
+            return name;
+        }
+    }
+    
+    struct utsname unameData;
+    uname(&unameData);
+    return std::string(unameData.sysname);
+}
+
+std::string get_os_version() {
+    struct utsname unameData;
+    uname(&unameData);
+    return std::string(unameData.release);
+}
+
+std::string get_architecture() {
+    struct utsname unameData;
+    uname(&unameData);
+    return std::string(unameData.machine);
+}
+
+std::string get_hostname() {
+    struct utsname unameData;
+    uname(&unameData);
+    return std::string(unameData.nodename);
+}
+
+std::string get_cpu_model() {
+    std::ifstream file("/proc/cpuinfo");
+    std::string line;
+    while (std::getline(file, line)) {
+        if (line.find("model name") != std::string::npos) {
+            size_t pos = line.find(':');
+            if (pos != std::string::npos) {
+                std::string model = line.substr(pos + 1);
+                // Trim whitespace
+                model.erase(0, model.find_first_not_of(" \t"));
+                model.erase(model.find_last_not_of(" \t") + 1);
+                return model;
+            }
+        }
+    }
+    return "Unknown";
+}
+
+int get_cpu_cores() {
+    std::ifstream file("/proc/cpuinfo");
+    std::string line;
+    int cores = 0;
+    
+    while (std::getline(file, line)) {
+        if (line.find("cpu cores") != std::string::npos) {
+            size_t pos = line.find(':');
+            if (pos != std::string::npos) {
+                cores = std::stoi(line.substr(pos + 1));
+                break;
+            }
+        }
+    }
+    
+    if (cores == 0) {
+        cores = std::thread::hardware_concurrency();
+    }
+    
+    return cores;
+}
+
+int get_cpu_logical_cores() {
+    return std::thread::hardware_concurrency();
+}
+
+uint64_t get_total_memory_mb() {
+    std::ifstream file("/proc/meminfo");
+    std::string line;
+    while (std::getline(file, line)) {
+        if (line.find("MemTotal:") == 0) {
+            std::regex regex(R"(MemTotal:\s+(\d+)\s+kB)");
+            std::smatch match;
+            if (std::regex_search(line, match, regex)) {
+                return std::stoull(match[1]) / 1024; // Convert kB to MB
+            }
+        }
+    }
+    return 0;
+}
+
+uint64_t get_available_memory_mb() {
+    std::ifstream file("/proc/meminfo");
+    std::string line;
+    while (std::getline(file, line)) {
+        if (line.find("MemAvailable:") == 0) {
+            std::regex regex(R"(MemAvailable:\s+(\d+)\s+kB)");
+            std::smatch match;
+            if (std::regex_search(line, match, regex)) {
+                return std::stoull(match[1]) / 1024; // Convert kB to MB
+            }
+        }
+    }
+    return 0;
+}
+
+#endif
+
+SystemInfo get_system_info() {
+    SystemInfo info;
+    info.os_name = get_os_name();
+    info.os_version = get_os_version();
+    info.architecture = get_architecture();
+    info.hostname = get_hostname();
+    info.cpu_model = get_cpu_model();
+    info.cpu_cores = get_cpu_cores();
+    info.cpu_logical_cores = get_cpu_logical_cores();
+    info.total_memory_mb = get_total_memory_mb();
+    info.available_memory_mb = get_available_memory_mb();
+    return info;
+}
+
+void print_system_info() {
+    SystemInfo info = get_system_info();
+    
+    std::cout << "=== System Information ===" << std::endl;
+    std::cout << "OS: " << info.os_name << " " << info.os_version << std::endl;
+    std::cout << "Architecture: " << info.architecture << std::endl;
+    std::cout << "Hostname: " << info.hostname << std::endl;
+    std::cout << "CPU: " << info.cpu_model << std::endl;
+    std::cout << "CPU Cores: " << info.cpu_cores << " physical, " << info.cpu_logical_cores << " logical" << std::endl;
+    std::cout << "Memory: " << info.total_memory_mb << " MB total, " << info.available_memory_mb << " MB available" << std::endl;
+    std::cout << "=========================" << std::endl;
+}
+
+bool supports_unicode() {
+    static bool checked = false;
+    static bool unicode_supported = false;
+    
+    if (!checked) {
+        std::string os = get_os_name();
+        // Check if we're on Windows, which often has console encoding issues
+        if (os.find("Windows") != std::string::npos) {
+            // Try to detect if we're in a proper Unicode-enabled terminal
+            // For simplicity, we'll assume Windows console doesn't support Unicode well
+            // unless specific environment variables are set
+            const char* term = std::getenv("TERM");
+            const char* wt = std::getenv("WT_SESSION"); // Windows Terminal
+            unicode_supported = (term && std::string(term) != "dumb") || wt;
+        } else {
+            // On Unix-like systems, assume Unicode is supported
+            unicode_supported = true;
+        }
+        checked = true;
+    }
+    
+    return unicode_supported;
+}
+
+} // namespace librats 

package/native-src/src/os.h

@@ -0,0 +1,40 @@
+#pragma once
+
+#include <string>
+#include <cstdint>
+
+namespace librats {
+
+struct SystemInfo {
+    std::string os_name;
+    std::string os_version;
+    std::string architecture;
+    std::string hostname;
+    std::string cpu_model;
+    int cpu_cores;
+    int cpu_logical_cores;
+    uint64_t total_memory_mb;
+    uint64_t available_memory_mb;
+};
+
+// Get comprehensive system information
+SystemInfo get_system_info();
+
+// Individual functions for specific info
+std::string get_os_name();
+std::string get_os_version();
+std::string get_architecture();
+std::string get_hostname();
+std::string get_cpu_model();
+int get_cpu_cores();
+int get_cpu_logical_cores();
+uint64_t get_total_memory_mb();
+uint64_t get_available_memory_mb();
+
+// Unicode support detection
+bool supports_unicode();
+
+// Utility function to print system info
+void print_system_info();
+
+} // namespace librats 

package/native-src/src/rats_export.h

@@ -0,0 +1,17 @@
+#pragma once
+
+#ifdef _WIN32
+  #if defined(RATS_EXPORT_DLL)
+    #define RATS_API __declspec(dllexport)
+  #elif defined(RATS_IMPORT_DLL)
+    #define RATS_API __declspec(dllimport)
+  #else
+    #define RATS_API
+  #endif
+#else
+  #if __GNUC__ >= 4
+    #define RATS_API __attribute__((visibility("default")))
+  #else
+    #define RATS_API
+  #endif
+#endif