ttcrypt 0.0.2

data/ext/ttcrypt/sha256.h

@@ -0,0 +1,67 @@
+//
+//  sha256.h
+//  iGlomp
+//
+//  Created by Sergey Chernov on 28.10.11.
+//  Copyright (c) 2011 Thrift. All rights reserved.
+//
+
+#ifndef iGlomp_sha256_h
+#define iGlomp_sha256_h
+
+/* Declarations of functions and data types used for SHA256 and SHA224 sum
+ library functions.
+ Copyright (C) 2005, 2006, 2008, 2009 Free Software Foundation, Inc.
+ 
+ This program is free software: you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation, either version 3 of the License, or
+ (at your option) any later version.
+ 
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ GNU General Public License for more details.
+ 
+ You should have received a copy of the GNU General Public License
+ along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
+
+typedef unsigned char uint8;
+typedef unsigned int uint32;
+
+#ifndef SHA256_H
+# define SHA256_H 1
+
+# include <stdio.h>
+# include <stdint.h>
+
+# ifdef __cplusplus
+extern "C" {
+# endif
+    
+    /* Structure to save state of computation between the single steps.  */
+    typedef struct sha256_ctx
+    {
+        uint32_t state[8];
+        
+        uint32_t total[2];
+        size_t buflen;
+        uint8 buffer[64];
+    } sha256_context;
+    
+    enum { SHA224_DIGEST_SIZE = 224 / 8 };
+    enum { SHA256_DIGEST_SIZE = 256 / 8 };
+    
+    void sha256_starts( sha256_context *ctx );
+    void sha256_update( sha256_context *ctx, uint8 *input, uint32 length );
+    void sha256_finish( sha256_context *ctx, uint8 digest[32] );
+    
+    
+    
+# ifdef __cplusplus
+}
+# endif
+
+
+#endif
+#endif

data/ext/ttcrypt/text_utils.cpp

@@ -0,0 +1,63 @@
+//
+//  text_utils.cpp
+//
+//  Created by Sergey Chernov on 01.06.14.
+//  Copyright (c) 2014 thrift. All rights reserved.
+//
+
+/*
+ This program is free software: you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation, either version 3 of the License, or
+ (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#include "text_utils.h"
+
+
+std::string sformat(const std::string fmt_str, ...) {
+    int final_n, n = ((int)fmt_str.size()) * 2; /* reserve 2 times as much as the length of the fmt_str */
+    std::string str;
+    std::unique_ptr<char[]> formatted;
+    va_list ap;
+    while(1) {
+        formatted.reset(new char[n]); /* wrap the plain char array into the unique_ptr */
+        //        strcpy(&formatted[0], fmt_str.c_str());
+        va_start(ap, fmt_str);
+        final_n = vsnprintf(&formatted[0], n, fmt_str.c_str(), ap);
+        va_end(ap);
+        if (final_n < 0 || final_n >= n)
+            n += abs(final_n - n + 1);
+        else
+            break;
+    }
+    return std::string(formatted.get());
+}
+
+std::string vsformat(const std::string fmt_str, va_list args) {
+    int final_n, n = ((int)fmt_str.size()) * 2; /* reserve 2 times as much as the length of the fmt_str */
+    std::string str;
+    std::unique_ptr<char[]> formatted;
+    while(1) {
+        formatted.reset(new char[n]); /* wrap the plain char array into the unique_ptr */
+        //        strcpy(&formatted[0], fmt_str.c_str());
+        va_list c;
+        va_copy(c, args);
+        final_n = vsnprintf(&formatted[0], n-1, fmt_str.c_str(), c);
+        va_end(c);
+        if (final_n < 0 || final_n >= n)
+            n += abs(final_n - n + 1);
+        else
+            break;
+    }
+    return std::string(formatted.get());
+}
+

data/ext/ttcrypt/text_utils.h

@@ -0,0 +1,64 @@
+//
+//  text_utils.h
+//  zcoin
+//
+//  Created by Sergey Chernov on 01.06.14.
+//  Copyright (c) 2014 thrift. All rights reserved.
+//
+
+/*
+ This program is free software: you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation, either version 3 of the License, or
+ (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#ifndef __zcoin__text_utils__
+#define __zcoin__text_utils__
+
+#include <iostream>
+
+std::string sformat(const std::string fmt_str, ...);
+std::string vsformat(const std::string fmt_str, va_list args);
+
+#ifdef DEBUG
+
+template <class T> void log_d(const T& object,const std::string& msg) {
+    std::cout << (object.to_string() + ": " + msg) << std::endl;
+}
+
+template <class T> void log_d(T *const object,const std::string& msg) {
+    log_d(*object, msg);
+}
+
+inline void log_d(const std::string format, ...) {
+    va_list ap;
+    va_start(ap, format);
+    std::cout << vsformat(format, ap) << std::endl;
+    va_end(ap);
+}
+
+#else
+
+#define log_d(...)
+
+#endif
+
+template <class T>
+void stopwatch(T text, std::function<void(void)> block) {
+    std::cout << "Starting " << text << "...";
+    std::cout.flush();
+    clock_t start = clock();
+    block();
+    std::cout << " done, " << (clock() - start)/1000.0 << "ms " << std::endl;
+}
+
+#endif /* defined(__zcoin__text_utils__) */

data/ext/ttcrypt/ttcrypt.cpp

@@ -0,0 +1,51 @@
+/*
+  ttcrypt.cpp
+
+  Created by Sergey Chernov on 03.06.14.
+  Copyright (c) 2014 thrift. All rights reserved.
+
+
+ This program is free software: you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation, either version 3 of the License, or
+ (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#include "ttcrypt.h"
+#include "sha1.h"
+#include "sha256.h"
+
+using namespace thrift;
+
+byte_buffer ttcrypt::sha1(const byte_buffer& data) noexcept {
+    byte_buffer res(20);
+    sha1::calc(data.data().get(), (int)data.size(), res.data().get() );
+    return res;
+}
+
+byte_buffer ttcrypt::sha256(const thrift::byte_buffer &data) noexcept {
+    byte_buffer res(32);
+    sha256_ctx ctx;
+    sha256_starts(&ctx);
+    sha256_update(&ctx, data.data().get(), (uint32) data.size());
+    sha256_finish(&ctx, res.data().get());
+    return res;
+}
+
+byte_buffer ttcrypt::i2osp(const big_integer& i, size_t block_size) noexcept {
+    byte_buffer res = i.to_byte_buffer();
+    if( block_size > 0 && res.size() != block_size ) {
+        size_t pad_length = block_size - res.size() % block_size;
+        if( pad_length > 0 )
+            return byte_buffer('\0', pad_length) + res;
+    }
+    return res;
+}

data/ext/ttcrypt/ttcrypt.h

@@ -0,0 +1,45 @@
+/*
+  ttcrypt.h
+  zcoin
+
+  Created by Sergey Chernov on 03.06.14.
+  Copyright (c) 2014 thrift. All rights reserved.
+
+ This program is free software: you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation, either version 3 of the License, or
+ (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#ifndef __zcoin__ttcrypt__
+#define __zcoin__ttcrypt__
+
+#include <iostream>
+#include "byte_buffer.h"
+#include "big_integer.h"
+
+using namespace thrift;
+
+namespace ttcrypt {
+
+    byte_buffer sha1(const byte_buffer& data) noexcept;
+    byte_buffer sha256(const byte_buffer& data) noexcept;
+    
+    byte_buffer i2osp(const big_integer& i, size_t block_size=0) noexcept;
+    
+    inline big_integer os2ip(const byte_buffer& buffer) noexcept {
+        return big_integer(buffer);
+    }
+
+}
+
+
+#endif /* defined(__zcoin__ttcrypt__) */

data/ext/ttcrypt/ttcrypt_ruby.cpp

@@ -0,0 +1,234 @@
+/*
+ * TTCrypt ruby bindings
+ *
+ * Copyright (C) 2014 Thrift, Sergey S. Chernov
+
+ This program is free software: you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation, either version 3 of the License, or
+ (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program.  If not, see <http://www.gnu.org/licenses/>.
+*/
+#include <iostream>
+#include <stdlib.h>
+
+#include "ruby_cpp_tools.h"
+
+#include "byte_buffer.h"
+#include "pollard_rho.h"
+#include "rsa_key.h"
+
+extern "C" {
+#include <ruby.h>
+#include <ruby/thread.h>
+
+void Init_ttcrypt(void);
+}
+
+using namespace thrift;
+using namespace ttcrypt;
+
+using namespace std;
+
+static VALUE rsa_exception;
+static VALUE rsa_class;
+
+VALUE wrap_exceptions(const std::function<VALUE()>& block) {
+	try {
+		return block();
+	} catch (const rsa_key::error& e) {
+		rb_raise(rsa_exception, "%s", e.what());
+	} catch (const std::exception& e) {
+		rb_raise(rb_eStandardError, "%s", e.what());
+	} catch (...) {
+		rb_raise(rsa_exception, "unknown exception");
+	}
+	return Qnil;
+}
+
+rsa_key* rsa_ptr(VALUE self) {
+	rsa_key *pkey;
+	Data_Get_Struct(self, rsa_key, pkey);
+	return pkey;
+}
+
+rsa_key& rsa(VALUE self) {
+	return *rsa_ptr(self);
+}
+
+extern "C" {
+
+static VALUE rsa_generate(VALUE self, VALUE length) {
+	return wrap_exceptions([=] {
+		unsigned l = NUM2UINT(length);
+		rsa_key *pkey = rsa_ptr(self);
+		ruby_unblock([=] {*pkey = rsa_key::generate(l);});
+		return self;
+	});
+}
+
+static VALUE rsa_bits(VALUE self) {
+	return INT2NUM(rsa(self).size_in_bits());
+}
+
+static VALUE rsa_encrypt(VALUE self, VALUE rb_data) {
+	return wrap_exceptions([=] {
+		byte_buffer res;
+		auto data = value_to_byte_buffer(rb_data);
+		ruby_unblock([&] {
+					res = rsa(self).encrypt(data);
+				});
+		return to_rb_string(res);
+	});
+}
+
+static VALUE rsa_decrypt(VALUE self, VALUE rb_data) {
+	return wrap_exceptions([=] {
+		byte_buffer res;
+		rsa_key& key = rsa(self);
+		auto data = value_to_byte_buffer(rb_data);
+		ruby_unblock([&res,&data,&key] {
+					res = key.decrypt(data);
+				});
+		return to_rb_string(res);
+	});
+}
+
+static VALUE factorize(VALUE self, VALUE composite) {
+	return wrap_exceptions([=] {
+		string s = value_to_string(composite);
+
+		vector<big_integer> factors;
+		ruby_unblock([s,&factors] {
+					factors = pollard_rho::factorize(decode_hex(s));
+				});
+
+		VALUE result = rb_ary_new();
+		for (auto factor : factors) {
+			rb_ary_push(result, to_hex_value(factor));
+		}
+		return result;
+	});
+}
+
+typedef byte_buffer (*hash_t)(const byte_buffer &);
+
+static hash_t hash_provider(VALUE name) {
+	string n = value_to_string(name);
+	if (n == "sha256")
+		return sha256;
+	else if (n == "sha1")
+		return sha1;
+	else
+		throw invalid_argument("not supported hash: " + n);
+}
+
+static VALUE rsa_sign(VALUE self, VALUE message, VALUE signature_method) {
+	return wrap_exceptions([=] {
+		byte_buffer m = value_to_byte_buffer(message);
+		byte_buffer res;
+		hash_t hash = hash_provider(signature_method);
+
+		ruby_unblock([&] {
+					res = rsa(self).sign(m, hash);
+				});
+
+		return to_value(res);
+	});
+}
+
+static VALUE rsa_verify(VALUE self, VALUE message, VALUE signature,
+		VALUE signature_method) {
+	return wrap_exceptions([=] {
+		byte_buffer m = value_to_byte_buffer(message);
+		byte_buffer s = value_to_byte_buffer(signature);
+		bool res;
+		hash_t hash = hash_provider(signature_method);
+
+		ruby_unblock([&] {
+					res = rsa(self).verify(m, s, hash);
+				});
+
+		return res ? Qtrue : Qfalse;
+	});
+}
+
+static VALUE rsa_extract_public(VALUE self) {
+	return wrap_exceptions([=] {
+		rsa_key &me = rsa(self);
+		VALUE res = rb_class_new_instance(0,NULL,rsa_class);
+		rsa_key &pub = rsa(res);
+		pub = me.public_key();
+		return res;
+	});
+}
+
+static VALUE rsa_components(VALUE self) {
+	return wrap_exceptions([=] {
+		rsa_key& key = rsa(self);
+		VALUE hash = rb_hash_new();
+		for(auto x: key.get_params()) {
+			rb_hash_aset(hash,to_rb_sym(x.first),to_rb_string(x.second.to_byte_buffer()));
+		}
+		return hash;
+	});
+}
+
+static int do_set_param(VALUE key,VALUE data,VALUE obj) {
+	rsa(obj).set(value_to_string(key), value_to_byte_buffer(data));
+	return ST_CONTINUE;
+}
+
+static VALUE rsa_set_params(VALUE self,VALUE hash) {
+	return wrap_exceptions([=]{
+		rb_hash_foreach(hash, (int (*)(...)) do_set_param, self);
+		rsa(self).normalize_key();
+		return Qnil;
+	});
+}
+
+static VALUE rsa_is_private(VALUE self) {
+	return rsa(self).is_private() ? Qtrue : Qfalse;
+}
+
+static void rsa_free(void* ptr) {
+	delete (ttcrypt::rsa_key*) ptr;
+}
+
+static VALUE rsa_alloc(VALUE klass) {
+	return Data_Wrap_Struct(klass, 0, rsa_free, new ttcrypt::rsa_key);
+}
+
+}
+
+void Init_ttcrypt(void) {
+
+	VALUE ttcrypt_module = rb_define_module("TTCrypt");
+
+	rb_define_method(ttcrypt_module, "_factorize", (ruby_method) factorize, 1);
+
+	rsa_class = rb_define_class_under(ttcrypt_module, "RsaKey", rb_cObject);
+	rb_define_alloc_func(rsa_class, rsa_alloc);
+	rb_define_method(rsa_class, "_generate", (ruby_method) rsa_generate, 1);
+	rb_define_method(rsa_class, "_bits", (ruby_method) rsa_bits, 0);
+	rb_define_method(rsa_class, "_encrypt", (ruby_method) rsa_encrypt, 1);
+	rb_define_method(rsa_class, "_decrypt", (ruby_method) rsa_decrypt, 1);
+	rb_define_method(rsa_class, "_sign", (ruby_method) rsa_sign, 2);
+	rb_define_method(rsa_class, "_verify", (ruby_method) rsa_verify, 3);
+	rb_define_method(rsa_class, "extract_public",
+			(ruby_method) rsa_extract_public, 0);
+	rb_define_method(rsa_class, "_is_private", (ruby_method) rsa_is_private, 0);
+	rb_define_method(rsa_class, "_components", (ruby_method) rsa_components, 0);
+	rb_define_method(rsa_class, "_set_params", (ruby_method) rsa_set_params, 1);
+
+	rsa_exception = rb_define_class_under(rsa_class, "Error",
+			rb_eStandardError);
+}
+

data/lib/ttcrypt/version.rb

@@ -0,0 +1,5 @@
+module TTCrypt
+
+  VERSION = '0.0.2'
+
+end

data/lib/ttcrypt.rb

@@ -0,0 +1,142 @@
+# Thrift cryptographics primitives: fast c++ implementation, only strong schemes,
+# releases GVL on long operations so other threads can be executed in parallel.
+module TTCrypt
+  # Your code goes here...
+
+  # Pollard 'rho' prime factorization. Allows execution of other ruby
+  # threads in parallel (releases GVL)
+  #
+  # @return [int] array of prime factors
+  def factorize composite
+    hex = composite.to_i.to_s(16)
+    hex = '0' + hex if (hex.length & 1) == 1
+    _factorize(hex).map { |x| x.to_i(16) }
+  end
+
+  # Implementation of RSAES-OAEP encryption and RSASSA-PSS signing
+  # accroding to pkcs#1 v2.2 specification. Does NOT implement any previous cryptographically
+  # weak shcemes (like 1.5 signature) - go use openssl for itm but it does compromise private
+  # key.
+  #
+  # All time consuming operations are executed releasing GVL so other threads can run in parallel
+  # in the multicore hardware.
+  #
+  class RsaKey
+
+    # raised when some parameters of RSAES are invalid, e.g.
+    # message/representation is too long, encrypted message or representation
+    # is not properly padded
+    class Error < StandardError
+    end
+
+    ACCEPTED_PARAMS = %i|n e p q d|
+
+    def initialize ** params
+      set_params(params)
+    end
+
+    def set_params ** params
+      res = {}
+      params.each { |k, v|
+        ACCEPTED_PARAMS.include?(k) or raise ArgumentError, "unknown key component"
+        res[k.to_s] = v.to_s.force_encoding(Encoding::BINARY)
+      }
+      _set_params res
+    end
+
+    # Generate private key (that contains public key too) of the desired bit
+    # length (recommended at least 2048).
+    def self.generate bits_strength
+      k = RsaKey.new
+      k._generate(bits_strength)
+    end
+
+    # Get key size in bits
+    def bits
+      _bits
+    end
+
+    # Encrypt message with public key using RSAES-OAEP scheme
+    # (pkcs#1 v.2.2).
+    def encrypt message
+      message.force_encoding Encoding::BINARY
+      _encrypt message
+    end
+
+    # Decrypt message with private key using RSAES-OAEP scheme
+    # (pkcs#1 v.2.2). Requires private key
+    #
+    def decrypt message
+      message.force_encoding Encoding::BINARY
+      _decrypt message
+    end
+
+    # Sign the message using pkcs#1 v2.2 RSASSA-PSS
+    # process. Requires private key.
+    #
+    #@param [String] message to sign
+    #@param [Symbol|String] hash function used (:sha1 or :sha256)
+    #@return [bool] true if the signature is consistent
+    def sign message, hash_name
+      message.force_encoding Encoding::BINARY
+      _sign message, hash_name.to_s.downcase
+    end
+
+    # Check message signature signed with pkcs#1 v2.2 RSASSA-PSS
+    # process
+    #
+    #@param [String] message to verify
+    #@param [String] signature
+    #@param [Symbol|String] hash function used (:sha1 or :sha256)
+    #@return [bool] true if the signature is consistent
+    def verify message, signature, hash_name=:sha1
+      message.force_encoding Encoding::BINARY
+      signature.force_encoding Encoding::BINARY
+      _verify message, signature, hash_name.to_s.downcase
+    end
+
+    # Extract public key from a private (or public) key
+    # @return [RsaKey] public key instance
+    def extract_public
+      # native implementation: this is for indexing only
+    end
+
+    # true if self contains private key
+    def private?
+      _is_private
+    end
+
+    # Get key components as hash. Components are binary strings, indexes are symbols
+    # e.g. :n, :e
+    def components
+      @components ||= _components
+    end
+
+    # @return [String] P component or nil
+    def p
+      components[:p]
+    end
+
+    def q
+      components[:q]
+    end
+
+    def n
+      components[:n]
+    end
+
+    def e
+      components[:e]
+    end
+
+  end
+end
+
+# it should require native lib after module definition above
+# otherwise won't work!
+require 'ttcrypt/ttcrypt'
+
+module TTCrypt
+  module_function :factorize, :_factorize
+end
+

data/spec/spec_helper.rb

@@ -0,0 +1,17 @@
+# This file was generated by the `rspec --init` command. Conventionally, all
+# specs live under a `spec` directory, which RSpec adds to the `$LOAD_PATH`.
+# Require this file using `require "spec_helper"` to ensure that it is only
+# loaded once.
+#
+# See http://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration
+RSpec.configure do |config|
+  config.treat_symbols_as_metadata_keys_with_true_values = true
+  config.run_all_when_everything_filtered = true
+  config.filter_run :focus
+
+  # Run specs in random order to surface order dependencies. If you find an
+  # order dependency and want to debug it, you can fix the order by providing
+  # the seed, which is printed after each run.
+  #     --seed 1234
+  config.order = 'random'
+end