crypto-lite 0.1.0 → 0.3.0

data/Rakefile

@@ -19,6 +19,10 @@ Hoe.spec 'crypto-lite' do
   self.history_file = 'CHANGELOG.md'
 
   self.extra_deps = [
+     ['digest-sha3-patched'],
+     ['base32-alphabets'],
+     ['base58-alphabets'],
+     ['elliptic'],
   ]
 
   self.licenses = ['Public Domain']

data/lib/crypto-lite.rb

@@ -3,112 +3,145 @@ require 'digest'
 require 'base64'
 require 'openssl'
 
+## 3rd party gems
+require 'digest/sha3'  # e.g. keccak (original submission/proposal NOT official sha3)
+## see https://rubygems.org/gems/digest-sha3-patched
+##     https://github.com/teamhedge/digest-sha3-ruby
+
+## our own 3rd party (2nd party?)
+require 'base32-alphabets'
+require 'base58-alphabets'
+require 'elliptic'
+
+
 
 ## our own code
 require 'crypto-lite/version'    # note: let version always go first
+require 'crypto-lite/config'
+require 'crypto-lite/metal'
+
 
 
 
 module Crypto
 
-  def self.sha256bin( input, engine=nil )   ## todo/check: add alias sha256b or such to - why? why not?
-    input_type = if input.is_a?( String )
-                  "#{input.class.name}/#{input.encoding}"
-                 else
-                  input.class.name
-                 end
-    puts "  input: #{input} (#{input_type})"
-
-    message = if input.is_a?( Integer )  ## assume byte if single (unsigned) integer
-                raise ArgumentError, "expected unsigned byte (0-255) - got #{input} (0x#{input.to_s(16)}) - can't pack negative number; sorry"   if input < 0
-                ## note: pack -  H (String) => hex string (high nibble first)
-                ## todo/check: is there a better way to convert integer number to (binary) string!!!
-                [input.to_s(16)].pack('H*')
-              else  ## assume (binary) string
-                input
-              end
-
-
-       bytes = message.bytes
-       bin   = bytes.map {|byte| byte.to_s(2).rjust(8, "0")}.join( ' ' )
-       hex   = bytes.map {|byte| byte.to_s(16).rjust(2, "0")}.join( ' ' )
-       puts "  #{pluralize( bytes.size, 'byte')}:  #{bytes.inspect}"
-       puts "  binary: #{bin}"
-       puts "  hex:    #{hex}"
-
-       if engine && ['openssl'].include?( engine.to_s.downcase )
-         puts "  engine: #{engine}"
-         digest = OpenSSL::Digest::SHA256.new
-         digest.update( message )
-         digest.digest
-       else  ## use "built-in" hash function from digest module
-         Digest::SHA256.digest( message )
-       end
+  def self.base58( *args, **kwargs )
+    input = args_to_input( args, kwargs )
+    Metal.base58bin( input )
   end
 
-  def self.sha256( input, engine=nil )
-    sha256bin( input, engine ).unpack( 'H*' )[0]
+  def self.base58check( *args, **kwargs )
+    input = args_to_input( args, kwargs )
+    Metal.base58bin_check( input )
   end
 
 
-  def self.sha256hex( input, engine=nil )
-    ## convenience helper - lets you pass in hex string
+  ########################
+  # (secure) hash functions
+
+  def self.keccak256( *args, **kwargs )
+    input = args_to_input( args, kwargs )
+    Metal.keccak256bin( input ).unpack( 'H*' )[0]
+  end
 
-    ##  check if input starts with 0x or 0X if yes - (auto-)cut off!!!!!
-    if input.start_with?( '0x') || input.start_with?( '0X' )
-      input = input[2..-1]
-    end
 
-    raise ArgumentError, "expected hex string (0-9a-f) - got >#{input}< - can't pack string; sorry"   if input.downcase =~ /[^0-9a-f]/
-    sha256( [input].pack( 'H*' ), engine )
+  def self.rmd160( *args, **kwargs )
+    input = args_to_input( args, kwargs )
+    Metal.rmd160bin( input ).unpack( 'H*' )[0]
   end
 
+  ## add alias RIPEMD160 - why? why not?
+  class << self
+    alias_method :ripemd160,    :rmd160
+  end
 
 
-  def self.pluralize( count, noun )
-     count == 1 ? "#{count} #{noun}" : "#{count} #{noun}s"
+  def self.sha256( *args, **kwargs )
+    input = args_to_input( args, kwargs )
+    engine = kwargs[:engine]
+    Metal.sha256bin( input, engine ).unpack( 'H*' )[0]
+  end
+
+  def self.sha3_256( *args, **kwargs )
+    input = args_to_input( args, kwargs )
+    Metal.sha3_256bin( input ).unpack( 'H*' )[0]
   end
 
 
 
-module RSA
-  def self.generate_keys  ## todo/check: add a generate alias - why? why not?
-    key_pair = OpenSSL::PKey::RSA.new( 2048 )
-    private_key = key_pair.export
-    public_key  = key_pair.public_key.export
+  def self.hash160( *args, **kwargs )
+    input = args_to_input( args, kwargs )
+    Metal.hash160bin( input ).unpack( 'H*' )[0]
+  end
 
-    [private_key, public_key]
+  def self.hash256( *args, **kwargs )
+    input = args_to_input( args, kwargs )
+    Metal.hash256bin( input ).unpack( 'H*' )[0]
   end
 
 
-  def self.sign( plaintext, private_key )
-    private_key = OpenSSL::PKey::RSA.new( private_key ) ## note: convert/wrap into to obj from exported text format
-    Base64.encode64( private_key.private_encrypt( plaintext ))
+
+  ########
+  # more helpers
+  ## check if it is a hex (string)
+  ##  - allow optiona 0x or 0X  and allow abcdef and ABCDEF
+  HEX_RE = /\A(?:0x)?[0-9a-f]+\z/i
+
+  def self.args_to_input( args, kwargs )
+    if kwargs[:hex]
+      hex = kwargs[:hex]
+      raise ArgumentError, "expected hex string (0-9a-f) - got >#{hex}< - can't pack string; sorry"   unless hex =~ HEX_RE
+
+      hex = strip0x( hex )  ##  check if input starts with 0x or 0X if yes - (auto-)cut off!!!!!
+      [hex].pack( 'H*' )
+    else   ## assume single input arg for now
+      input = args[0]
+      input = hex_to_bin_automagic( input )  ## add automagic hex (string) to bin (string) check - why? why not?
+      input
+    end
   end
 
-  def self.decrypt( ciphertext, public_key )
-    public_key = OpenSSL::PKey::RSA.new( public_key )  ## note: convert/wrap into to obj from exported text format
-    public_key.public_decrypt( Base64.decode64( ciphertext ))
+  def self.hex_to_bin_automagic( input )
+    ## todo/check/fix: add configure setting to turn off automagic - why? why not?
+     if input.is_a?( String ) && input =~ HEX_RE
+        if input[0,2] == '0x' || input[0,2] == '0X'
+          ## starting with 0x or 0X always assume hex string for now - why? why not?
+          input = input[2..-1]
+          [input].pack( 'H*' )
+        elsif input.size >= 10
+          ## note: hex heuristic!!
+          ##   for now assumes string MUST have more than 10 digits to qualify!!!
+          [input].pack( 'H*' )
+        else
+          input ## pass through as is!!! (e.g.   a, abc, etc.)
+        end
+     else
+          input  ## pass through as is
+     end
   end
 
 
-  def self.valid_signature?( plaintext, ciphertext, public_key )
-    plaintext == decrypt( ciphertext, public_key )
+  def self.strip0x( str )    ## todo/check: add alias e.g. strip_hex_prefix or such - why? why not?
+    (str[0,2] == '0x' || str[0,2] == '0X') ?  str[2..-1] : str
   end
-end # module RSA
-end # module Crypto
 
+#  def self.hex_to_bin( str )
+#    str = strip0x( str )  ##  check if input starts with 0x or 0X if yes - (auto-)cut off!!!!!
+#    [str].pack( 'H*' )
+#  end
 
+end # module Crypto
 
 
-## add convenience "top-level" helpers
-def sha256( input, engine=nil )    Crypto.sha256( input, engine ); end
-def sha256hex( input, engine=nil ) Crypto.sha256hex( input, engine ); end
 
-RSA = Crypto::RSA
 
+require 'crypto-lite/helper'
+include CryptoHelper      # add convenience "top-level" / global helpers
 
 
+require 'crypto-lite/sign_rsa'
+RSA = Crypto::RSA
+
 
 
 

data/lib/crypto-lite/config.rb

@@ -0,0 +1,32 @@
+module Crypto
+
+  class Configuration
+
+    def initialize
+      @debug = false
+    end
+
+    def debug?()         @debug || false; end
+    def debug=(value)    @debug = value; end
+  end # class Configuration
+
+  ## lets you use
+  ##   Crypto.configure do |config|
+  ##      config.debug  =  true
+  ##   end
+
+  def self.configuration
+    @configuration ||= Configuration.new
+  end
+
+  def self.configure
+    yield( configuration )
+  end
+
+  ## add convenience helper for format
+  def self.debug?() configuration.debug?; end
+  def self.debug=(value) self.configuration.debug = value; end
+end # module Crypto
+
+
+

data/lib/crypto-lite/helper.rb

@@ -0,0 +1,25 @@
+
+module CryptoHelper
+  ### note: use include CryptoHelper
+  ##          to get "top-level" / global helpers
+
+  ## add convenience "top-level" helpers
+  def sha256( *args, **kwargs )    Crypto.sha256( *args, **kwargs ); end
+  def sha3_256( *args, **kwargs )    Crypto.sha3_256( *args, **kwargs ); end
+
+  def keccak256( *args, **kwargs )    Crypto.keccak256( *args, **kwargs ); end
+
+  def rmd160( *args, **kwargs )    Crypto.rmd160( *args, **kwargs ); end
+  ## def ripemd160( input ) Crypto.rmd160( input ); end
+  alias_method :ripemd160, :rmd160
+
+  def hash160( *args, **kwargs )    Crypto.hash160( *args, **kwargs ); end
+
+  def hash256( *args, **kwargs )    Crypto.hash256( *args, **kwargs ); end
+
+
+  def base58( *args, **kwargs )      Crypto.base58( *args, **kwargs ); end
+  def base58check( *args, **kwargs ) Crypto.base58check( *args, **kwargs ); end
+end
+
+

data/lib/crypto-lite/metal.rb

@@ -0,0 +1,128 @@
+module Crypto
+module Metal
+
+  def self.debug?()  Crypto.debug?; end
+
+  ########################
+  ### to the "metal" crypto primitives
+  ##    work with binary strings (aka byte arrays) / data
+
+  ##
+  ## todo/check: use/keep bin-suffix in name - why? why not?
+
+
+  def self.base58bin( input )
+    ## todo/check: input must be a (binary) string - why? why not?
+    Base58::Bitcoin.encode_bin( input )
+  end
+
+  def self.base58bin_check( input )
+    ## todo/check: input must be a (binary) string - why? why not?
+    hash256 = hash256bin( input )
+    base58bin( input + hash256[0,4] )
+  end
+
+
+  ########################
+  # (secure) hash functions
+
+  def self.keccak256bin( input )
+    message = message( input )   ## "normalize" / convert to (binary) string
+    Digest::SHA3.digest( message, 256 )
+  end
+
+  def self.rmd160bin( input )
+    message = message( input )   ## "normalize" / convert to (binary) string
+    Digest::RMD160.digest( message )
+  end
+
+  ## add alias RIPEMD160 - why? why not?
+  class << self
+    alias_method :ripemd160bin, :rmd160bin
+  end
+
+
+  def self.sha256bin( input, engine=nil )   ## todo/check: add alias sha256b or such to - why? why not?
+    message = message( input )  ## "normalize" / convert to (binary) string
+
+    if engine && ['openssl'].include?( engine.to_s.downcase )
+      puts "  engine: #{engine}"    if debug?
+      digest = OpenSSL::Digest::SHA256.new
+      ## or use OpenSSL::Digest.new( 'SHA256' )
+      digest.update( message )
+      digest.digest
+    else  ## use "built-in" hash function from digest module
+      Digest::SHA256.digest( message )
+    end
+  end
+
+  def self.sha3_256bin( input )
+    message = message( input )  ## "normalize" / convert to (binary) string
+
+    digest = OpenSSL::Digest.new( 'SHA3-256' )
+    digest.update( message )
+    digest.digest
+  end
+
+  ####
+  ## helper
+  # def hash160( pubkey )
+  #  binary    = [pubkey].pack( "H*" )       # Convert to binary first before hashing
+  #  sha256    = Digest::SHA256.digest( binary )
+  #  ripemd160 = Digest::RMD160.digest( sha256 )
+  #              ripemd160.unpack( "H*" )[0]    # Convert back to hex
+  # end
+
+  def self.hash160bin( input )
+    message = message( input )   ## "normalize" / convert to (binary) string
+
+    rmd160bin(sha256bin( message ))
+  end
+
+
+  def self.hash256bin( input )
+    message = message( input )   ## "normalize" / convert to (binary) string
+
+    sha256bin(sha256bin( message ))
+  end
+
+
+  ##############################
+  ## helpers
+  def self.message( input )  ## convert input to (binary) string
+    if debug?
+      input_type = if input.is_a?( String )
+                    "#{input.class.name}/#{input.encoding}"
+                   else
+                    input.class.name
+                   end
+      puts "  input: #{input} (#{input_type})"
+    end
+
+    message = if input.is_a?( Integer )  ## assume byte if single (unsigned) integer
+                raise ArgumentError, "expected unsigned byte (0-255) - got #{input} (0x#{input.to_s(16)}) - can't pack negative number; sorry"   if input < 0
+                ## note: pack -  H (String) => hex string (high nibble first)
+                ## todo/check: is there a better way to convert integer number to (binary) string!!!
+                [input.to_s(16)].pack('H*')
+              else  ## assume (binary) string
+                input
+              end
+
+    if debug?
+      bytes = message.bytes
+      bin   = bytes.map {|byte| byte.to_s(2).rjust(8, "0")}.join( ' ' )
+      hex   = bytes.map {|byte| byte.to_s(16).rjust(2, "0")}.join( ' ' )
+      puts "  #{pluralize( bytes.size, 'byte')}:  #{bytes.inspect}"
+      puts "  binary: #{bin}"
+      puts "  hex:    #{hex}"
+    end
+
+    message
+  end
+
+  def self.pluralize( count, noun )
+    count == 1 ? "#{count} #{noun}" : "#{count} #{noun}s"
+  end
+
+end   # module Metal
+end   # module Crypto

data/lib/crypto-lite/sign_rsa.rb

@@ -0,0 +1,29 @@
+module Crypto
+
+
+  module RSA
+    def self.generate_keys  ## todo/check: add a generate alias - why? why not?
+      key_pair = OpenSSL::PKey::RSA.new( 2048 )
+      private_key = key_pair.export
+      public_key  = key_pair.public_key.export
+
+      [private_key, public_key]
+    end
+
+
+    def self.sign( plaintext, private_key )
+      private_key = OpenSSL::PKey::RSA.new( private_key ) ## note: convert/wrap into to obj from exported text format
+      Base64.encode64( private_key.private_encrypt( plaintext ))
+    end
+
+    def self.decrypt( ciphertext, public_key )
+      public_key = OpenSSL::PKey::RSA.new( public_key )  ## note: convert/wrap into to obj from exported text format
+      public_key.public_decrypt( Base64.decode64( ciphertext ))
+    end
+
+
+    def self.valid_signature?( plaintext, ciphertext, public_key )
+      plaintext == decrypt( ciphertext, public_key )
+    end
+  end # module RSA
+end   # module Crypto

data/lib/crypto-lite/version.rb

@@ -2,7 +2,7 @@
 module CryptoLite
 
   MAJOR = 0
-  MINOR = 1
+  MINOR = 3
   PATCH = 0
   VERSION = [MAJOR,MINOR,PATCH].join('.')