konpeito 0.1.0

data/lib/konpeito/stdlib/compression/compression_native.c

@@ -0,0 +1,415 @@
+/*
+ * Konpeito Compression stdlib - zlib wrapper
+ *
+ * Provides compression/decompression using zlib.
+ * Supports gzip, deflate, and raw compression.
+ */
+
+#include <ruby.h>
+#include <zlib.h>
+#include <stdlib.h>
+#include <string.h>
+
+/* Default chunk size for compression */
+#define CHUNK_SIZE 16384
+
+/*
+ * Compress data using gzip format
+ *
+ * @param data [String] Data to compress
+ * @return [String] Gzip-compressed data
+ * @raise [RuntimeError] if compression fails
+ */
+VALUE konpeito_compression_gzip(VALUE self, VALUE data) {
+    Check_Type(data, T_STRING);
+
+    const unsigned char *input = (const unsigned char *)RSTRING_PTR(data);
+    size_t input_len = RSTRING_LEN(data);
+
+    /* Allocate output buffer (worst case: input size + overhead) */
+    uLongf output_len = compressBound(input_len) + 18; /* gzip header/footer */
+    unsigned char *output = malloc(output_len);
+    if (!output) {
+        rb_raise(rb_eNoMemError, "Failed to allocate compression buffer");
+        return Qnil;
+    }
+
+    /* Initialize zlib stream for gzip */
+    z_stream stream;
+    memset(&stream, 0, sizeof(stream));
+
+    /* windowBits 15 + 16 = gzip format */
+    int ret = deflateInit2(&stream, Z_DEFAULT_COMPRESSION, Z_DEFLATED,
+                           15 + 16, 8, Z_DEFAULT_STRATEGY);
+    if (ret != Z_OK) {
+        free(output);
+        rb_raise(rb_eRuntimeError, "Failed to initialize compression: %s",
+                 stream.msg ? stream.msg : "unknown error");
+        return Qnil;
+    }
+
+    stream.next_in = (Bytef *)input;
+    stream.avail_in = (uInt)input_len;
+    stream.next_out = output;
+    stream.avail_out = (uInt)output_len;
+
+    ret = deflate(&stream, Z_FINISH);
+    if (ret != Z_STREAM_END) {
+        deflateEnd(&stream);
+        free(output);
+        rb_raise(rb_eRuntimeError, "Compression failed: %s",
+                 stream.msg ? stream.msg : "unknown error");
+        return Qnil;
+    }
+
+    size_t compressed_len = stream.total_out;
+    deflateEnd(&stream);
+
+    VALUE result = rb_str_new((const char *)output, compressed_len);
+    free(output);
+
+    return result;
+}
+
+/*
+ * Decompress gzip data
+ *
+ * @param data [String] Gzip-compressed data
+ * @return [String] Decompressed data
+ * @raise [RuntimeError] if decompression fails
+ */
+VALUE konpeito_compression_gunzip(VALUE self, VALUE data) {
+    Check_Type(data, T_STRING);
+
+    const unsigned char *input = (const unsigned char *)RSTRING_PTR(data);
+    size_t input_len = RSTRING_LEN(data);
+
+    /* Start with a reasonable output buffer size */
+    size_t output_size = input_len * 4;
+    if (output_size < CHUNK_SIZE) output_size = CHUNK_SIZE;
+    unsigned char *output = malloc(output_size);
+    if (!output) {
+        rb_raise(rb_eNoMemError, "Failed to allocate decompression buffer");
+        return Qnil;
+    }
+
+    /* Initialize zlib stream for gzip */
+    z_stream stream;
+    memset(&stream, 0, sizeof(stream));
+
+    /* windowBits 15 + 32 = auto-detect gzip/zlib */
+    int ret = inflateInit2(&stream, 15 + 32);
+    if (ret != Z_OK) {
+        free(output);
+        rb_raise(rb_eRuntimeError, "Failed to initialize decompression: %s",
+                 stream.msg ? stream.msg : "unknown error");
+        return Qnil;
+    }
+
+    stream.next_in = (Bytef *)input;
+    stream.avail_in = (uInt)input_len;
+
+    size_t total_out = 0;
+
+    do {
+        /* Expand buffer if needed */
+        if (total_out >= output_size) {
+            output_size *= 2;
+            unsigned char *new_output = realloc(output, output_size);
+            if (!new_output) {
+                inflateEnd(&stream);
+                free(output);
+                rb_raise(rb_eNoMemError, "Failed to expand decompression buffer");
+                return Qnil;
+            }
+            output = new_output;
+        }
+
+        stream.next_out = output + total_out;
+        stream.avail_out = (uInt)(output_size - total_out);
+
+        ret = inflate(&stream, Z_NO_FLUSH);
+
+        if (ret == Z_NEED_DICT || ret == Z_DATA_ERROR || ret == Z_MEM_ERROR) {
+            inflateEnd(&stream);
+            free(output);
+            rb_raise(rb_eRuntimeError, "Decompression failed: %s",
+                     stream.msg ? stream.msg : "data error");
+            return Qnil;
+        }
+
+        total_out = stream.total_out;
+
+    } while (ret != Z_STREAM_END);
+
+    inflateEnd(&stream);
+
+    VALUE result = rb_str_new((const char *)output, total_out);
+    free(output);
+
+    return result;
+}
+
+/*
+ * Compress data using deflate (raw zlib format, no header)
+ *
+ * @param data [String] Data to compress
+ * @param level [Integer] Compression level (0-9, default 6)
+ * @return [String] Deflate-compressed data
+ * @raise [RuntimeError] if compression fails
+ */
+VALUE konpeito_compression_deflate(VALUE self, VALUE data, VALUE level) {
+    Check_Type(data, T_STRING);
+
+    const unsigned char *input = (const unsigned char *)RSTRING_PTR(data);
+    size_t input_len = RSTRING_LEN(data);
+    int compression_level = NIL_P(level) ? Z_DEFAULT_COMPRESSION : NUM2INT(level);
+
+    if (compression_level < 0 || compression_level > 9) {
+        if (compression_level != Z_DEFAULT_COMPRESSION) {
+            rb_raise(rb_eArgError, "Compression level must be 0-9");
+            return Qnil;
+        }
+    }
+
+    /* Allocate output buffer */
+    uLongf output_len = compressBound(input_len);
+    unsigned char *output = malloc(output_len);
+    if (!output) {
+        rb_raise(rb_eNoMemError, "Failed to allocate compression buffer");
+        return Qnil;
+    }
+
+    /* Initialize zlib stream for raw deflate */
+    z_stream stream;
+    memset(&stream, 0, sizeof(stream));
+
+    /* windowBits -15 = raw deflate (no zlib header) */
+    int ret = deflateInit2(&stream, compression_level, Z_DEFLATED,
+                           -15, 8, Z_DEFAULT_STRATEGY);
+    if (ret != Z_OK) {
+        free(output);
+        rb_raise(rb_eRuntimeError, "Failed to initialize compression: %s",
+                 stream.msg ? stream.msg : "unknown error");
+        return Qnil;
+    }
+
+    stream.next_in = (Bytef *)input;
+    stream.avail_in = (uInt)input_len;
+    stream.next_out = output;
+    stream.avail_out = (uInt)output_len;
+
+    ret = deflate(&stream, Z_FINISH);
+    if (ret != Z_STREAM_END) {
+        deflateEnd(&stream);
+        free(output);
+        rb_raise(rb_eRuntimeError, "Compression failed: %s",
+                 stream.msg ? stream.msg : "unknown error");
+        return Qnil;
+    }
+
+    size_t compressed_len = stream.total_out;
+    deflateEnd(&stream);
+
+    VALUE result = rb_str_new((const char *)output, compressed_len);
+    free(output);
+
+    return result;
+}
+
+/*
+ * Decompress deflate data (raw zlib format, no header)
+ *
+ * @param data [String] Deflate-compressed data
+ * @return [String] Decompressed data
+ * @raise [RuntimeError] if decompression fails
+ */
+VALUE konpeito_compression_inflate(VALUE self, VALUE data) {
+    Check_Type(data, T_STRING);
+
+    const unsigned char *input = (const unsigned char *)RSTRING_PTR(data);
+    size_t input_len = RSTRING_LEN(data);
+
+    /* Start with a reasonable output buffer size */
+    size_t output_size = input_len * 4;
+    if (output_size < CHUNK_SIZE) output_size = CHUNK_SIZE;
+    unsigned char *output = malloc(output_size);
+    if (!output) {
+        rb_raise(rb_eNoMemError, "Failed to allocate decompression buffer");
+        return Qnil;
+    }
+
+    /* Initialize zlib stream for raw inflate */
+    z_stream stream;
+    memset(&stream, 0, sizeof(stream));
+
+    /* windowBits -15 = raw inflate (no zlib header) */
+    int ret = inflateInit2(&stream, -15);
+    if (ret != Z_OK) {
+        free(output);
+        rb_raise(rb_eRuntimeError, "Failed to initialize decompression: %s",
+                 stream.msg ? stream.msg : "unknown error");
+        return Qnil;
+    }
+
+    stream.next_in = (Bytef *)input;
+    stream.avail_in = (uInt)input_len;
+
+    size_t total_out = 0;
+
+    do {
+        /* Expand buffer if needed */
+        if (total_out >= output_size) {
+            output_size *= 2;
+            unsigned char *new_output = realloc(output, output_size);
+            if (!new_output) {
+                inflateEnd(&stream);
+                free(output);
+                rb_raise(rb_eNoMemError, "Failed to expand decompression buffer");
+                return Qnil;
+            }
+            output = new_output;
+        }
+
+        stream.next_out = output + total_out;
+        stream.avail_out = (uInt)(output_size - total_out);
+
+        ret = inflate(&stream, Z_NO_FLUSH);
+
+        if (ret == Z_NEED_DICT || ret == Z_DATA_ERROR || ret == Z_MEM_ERROR) {
+            inflateEnd(&stream);
+            free(output);
+            rb_raise(rb_eRuntimeError, "Decompression failed: %s",
+                     stream.msg ? stream.msg : "data error");
+            return Qnil;
+        }
+
+        total_out = stream.total_out;
+
+    } while (ret != Z_STREAM_END);
+
+    inflateEnd(&stream);
+
+    VALUE result = rb_str_new((const char *)output, total_out);
+    free(output);
+
+    return result;
+}
+
+/*
+ * Compress data using zlib format (with header)
+ *
+ * @param data [String] Data to compress
+ * @return [String] Zlib-compressed data
+ * @raise [RuntimeError] if compression fails
+ */
+VALUE konpeito_compression_zlib_compress(VALUE self, VALUE data) {
+    Check_Type(data, T_STRING);
+
+    const unsigned char *input = (const unsigned char *)RSTRING_PTR(data);
+    size_t input_len = RSTRING_LEN(data);
+
+    uLongf output_len = compressBound(input_len);
+    unsigned char *output = malloc(output_len);
+    if (!output) {
+        rb_raise(rb_eNoMemError, "Failed to allocate compression buffer");
+        return Qnil;
+    }
+
+    int ret = compress(output, &output_len, input, input_len);
+    if (ret != Z_OK) {
+        free(output);
+        rb_raise(rb_eRuntimeError, "Compression failed with code %d", ret);
+        return Qnil;
+    }
+
+    VALUE result = rb_str_new((const char *)output, output_len);
+    free(output);
+
+    return result;
+}
+
+/*
+ * Decompress zlib data (with header)
+ *
+ * @param data [String] Zlib-compressed data
+ * @param max_size [Integer] Maximum decompressed size (for safety)
+ * @return [String] Decompressed data
+ * @raise [RuntimeError] if decompression fails
+ */
+VALUE konpeito_compression_zlib_decompress(VALUE self, VALUE data, VALUE max_size) {
+    Check_Type(data, T_STRING);
+
+    const unsigned char *input = (const unsigned char *)RSTRING_PTR(data);
+    size_t input_len = RSTRING_LEN(data);
+    size_t max_output = NIL_P(max_size) ? 100 * 1024 * 1024 : (size_t)NUM2LONG(max_size); /* 100MB default */
+
+    /* Start with estimated output size */
+    size_t output_size = input_len * 4;
+    if (output_size < CHUNK_SIZE) output_size = CHUNK_SIZE;
+    if (output_size > max_output) output_size = max_output;
+
+    unsigned char *output = malloc(output_size);
+    if (!output) {
+        rb_raise(rb_eNoMemError, "Failed to allocate decompression buffer");
+        return Qnil;
+    }
+
+    uLongf destLen = (uLongf)output_size;
+    int ret;
+
+    while (1) {
+        ret = uncompress(output, &destLen, input, input_len);
+
+        if (ret == Z_OK) {
+            break;
+        } else if (ret == Z_BUF_ERROR) {
+            /* Need bigger buffer */
+            output_size *= 2;
+            if (output_size > max_output) {
+                free(output);
+                rb_raise(rb_eRuntimeError, "Decompressed data exceeds maximum size");
+                return Qnil;
+            }
+            unsigned char *new_output = realloc(output, output_size);
+            if (!new_output) {
+                free(output);
+                rb_raise(rb_eNoMemError, "Failed to expand decompression buffer");
+                return Qnil;
+            }
+            output = new_output;
+            destLen = (uLongf)output_size;
+        } else {
+            free(output);
+            rb_raise(rb_eRuntimeError, "Decompression failed with code %d", ret);
+            return Qnil;
+        }
+    }
+
+    VALUE result = rb_str_new((const char *)output, destLen);
+    free(output);
+
+    return result;
+}
+
+/* Module initialization */
+void Init_konpeito_compression(void) {
+    VALUE mKonpeitoCompression = rb_define_module("KonpeitoCompression");
+
+    /* Gzip format (RFC 1952) */
+    rb_define_module_function(mKonpeitoCompression, "gzip", konpeito_compression_gzip, 1);
+    rb_define_module_function(mKonpeitoCompression, "gunzip", konpeito_compression_gunzip, 1);
+
+    /* Raw deflate (RFC 1951) - no header */
+    rb_define_module_function(mKonpeitoCompression, "deflate", konpeito_compression_deflate, 2);
+    rb_define_module_function(mKonpeitoCompression, "inflate", konpeito_compression_inflate, 1);
+
+    /* Zlib format (RFC 1950) - with header */
+    rb_define_module_function(mKonpeitoCompression, "zlib_compress", konpeito_compression_zlib_compress, 1);
+    rb_define_module_function(mKonpeitoCompression, "zlib_decompress", konpeito_compression_zlib_decompress, 2);
+
+    /* Constants */
+    rb_define_const(mKonpeitoCompression, "BEST_SPEED", INT2FIX(Z_BEST_SPEED));
+    rb_define_const(mKonpeitoCompression, "BEST_COMPRESSION", INT2FIX(Z_BEST_COMPRESSION));
+    rb_define_const(mKonpeitoCompression, "DEFAULT_COMPRESSION", INT2FIX(Z_DEFAULT_COMPRESSION));
+}

data/lib/konpeito/stdlib/compression/extconf.rb

@@ -0,0 +1,19 @@
+# extconf.rb for konpeito_compression
+require 'mkmf'
+
+# Check for zlib
+unless have_library('z') && have_header('zlib.h')
+  abort <<~MSG
+    zlib is required for KonpeitoCompression.
+
+    Installation:
+      macOS:   Usually pre-installed. If not: brew install zlib
+      Ubuntu:  sudo apt-get install zlib1g-dev
+      Fedora:  sudo dnf install zlib-devel
+  MSG
+end
+
+# Optimization flags
+$CFLAGS << ' -O3'
+
+create_makefile('konpeito_compression')

data/lib/konpeito/stdlib/crypto/crypto.rb

@@ -0,0 +1,85 @@
+# KonpeitoCrypto - Cryptographic operations using OpenSSL
+#
+# This module provides cryptographic functionality using the OpenSSL library.
+# It is implemented as a C extension for maximum performance.
+#
+# Usage:
+#   require 'konpeito/stdlib/crypto'
+#
+#   # Hash functions (hex output)
+#   hash = KonpeitoCrypto.sha256("hello world")
+#   # => "b94d27b9934d3e08a52e52d7da7dabfac484efe37a5380ee9088f7ace2efcde9"
+#
+#   hash = KonpeitoCrypto.sha512("hello world")
+#   # => "309ecc489c12d6eb4cc40f50c902f2b4d0ed77ee511a7c7a9bcd3ca86d4cd86f..."
+#
+#   # HMAC for message authentication
+#   mac = KonpeitoCrypto.hmac_sha256("secret-key", "message to authenticate")
+#
+#   # Secure random bytes
+#   bytes = KonpeitoCrypto.random_bytes(32)  # 32 random bytes
+#   hex = KonpeitoCrypto.random_hex(16)      # 32 character hex string
+#
+#   # Timing-safe comparison (for password/token verification)
+#   if KonpeitoCrypto.secure_compare(user_token, stored_token)
+#     puts "Valid token"
+#   end
+
+# Try to load the native extension
+begin
+  require_relative 'konpeito_crypto'
+rescue LoadError => e
+  # Fallback to OpenSSL gem if native extension is not available
+  require 'openssl'
+  require 'securerandom'
+
+  module KonpeitoCrypto
+    class << self
+      def sha256(data)
+        OpenSSL::Digest::SHA256.hexdigest(data)
+      end
+
+      def sha256_binary(data)
+        OpenSSL::Digest::SHA256.digest(data)
+      end
+
+      def sha512(data)
+        OpenSSL::Digest::SHA512.hexdigest(data)
+      end
+
+      def sha512_binary(data)
+        OpenSSL::Digest::SHA512.digest(data)
+      end
+
+      def hmac_sha256(key, data)
+        OpenSSL::HMAC.hexdigest('SHA256', key, data)
+      end
+
+      def hmac_sha256_binary(key, data)
+        OpenSSL::HMAC.digest('SHA256', key, data)
+      end
+
+      def hmac_sha512(key, data)
+        OpenSSL::HMAC.hexdigest('SHA512', key, data)
+      end
+
+      def random_bytes(count)
+        SecureRandom.random_bytes(count)
+      end
+
+      def random_hex(count)
+        SecureRandom.hex(count)
+      end
+
+      def secure_compare(a, b)
+        return false if a.bytesize != b.bytesize
+
+        result = 0
+        a.bytes.zip(b.bytes) { |x, y| result |= x ^ y }
+        result == 0
+      end
+    end
+  end
+
+  warn "KonpeitoCrypto: Native extension not available, using OpenSSL gem fallback (#{e.message})"
+end

data/lib/konpeito/stdlib/crypto/crypto.rbs

@@ -0,0 +1,74 @@
+# KonpeitoCrypto - Cryptographic operations using OpenSSL
+#
+# Usage:
+#   # Hash functions
+#   hash = KonpeitoCrypto.sha256("hello")  # => "2cf24dba5fb0a30e..."
+#   hash = KonpeitoCrypto.sha512("hello")  # => "9b71d224bd62f378..."
+#
+#   # HMAC
+#   mac = KonpeitoCrypto.hmac_sha256("secret", "message")
+#
+#   # Random bytes
+#   bytes = KonpeitoCrypto.random_bytes(32)   # => 32 random bytes (binary)
+#   hex = KonpeitoCrypto.random_hex(16)       # => 32 char hex string
+#
+#   # Secure comparison (timing-attack safe)
+#   KonpeitoCrypto.secure_compare(hash1, hash2)
+
+module KonpeitoCrypto
+  # Compute SHA256 hash (hex output)
+  # @param data [String] Data to hash
+  # @return [String] Hex-encoded SHA256 hash (64 characters)
+  def self.sha256: (String data) -> String
+
+  # Compute SHA256 hash (binary output)
+  # @param data [String] Data to hash
+  # @return [String] Binary SHA256 hash (32 bytes)
+  def self.sha256_binary: (String data) -> String
+
+  # Compute SHA512 hash (hex output)
+  # @param data [String] Data to hash
+  # @return [String] Hex-encoded SHA512 hash (128 characters)
+  def self.sha512: (String data) -> String
+
+  # Compute SHA512 hash (binary output)
+  # @param data [String] Data to hash
+  # @return [String] Binary SHA512 hash (64 bytes)
+  def self.sha512_binary: (String data) -> String
+
+  # Compute HMAC-SHA256 (hex output)
+  # @param key [String] Secret key
+  # @param data [String] Data to authenticate
+  # @return [String] Hex-encoded HMAC-SHA256 (64 characters)
+  def self.hmac_sha256: (String key, String data) -> String
+
+  # Compute HMAC-SHA256 (binary output)
+  # @param key [String] Secret key
+  # @param data [String] Data to authenticate
+  # @return [String] Binary HMAC-SHA256 (32 bytes)
+  def self.hmac_sha256_binary: (String key, String data) -> String
+
+  # Compute HMAC-SHA512 (hex output)
+  # @param key [String] Secret key
+  # @param data [String] Data to authenticate
+  # @return [String] Hex-encoded HMAC-SHA512 (128 characters)
+  def self.hmac_sha512: (String key, String data) -> String
+
+  # Generate cryptographically secure random bytes
+  # @param count [Integer] Number of bytes to generate
+  # @return [String] Binary string of random bytes
+  # @raise [RuntimeError] if random generation fails
+  def self.random_bytes: (Integer count) -> String
+
+  # Generate cryptographically secure random bytes as hex string
+  # @param count [Integer] Number of bytes to generate (output will be 2x this length)
+  # @return [String] Hex-encoded random bytes
+  # @raise [RuntimeError] if random generation fails
+  def self.random_hex: (Integer count) -> String
+
+  # Constant-time comparison of two strings (prevents timing attacks)
+  # @param a [String] First string
+  # @param b [String] Second string
+  # @return [bool] true if strings are equal, false otherwise
+  def self.secure_compare: (String a, String b) -> bool
+end