crypto-lite 0.2.2 → 0.2.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: cb39c213dfc1d3d5f0625fceed1aa57ba57094838d6b4fa792388aa914764ec5
-  data.tar.gz: 9222110e4d2a56e99704ae234213438251cc6259d446ea974bb3dcc6f7195669
+  metadata.gz: 7326c07c1553f4f15d79ddbfa19df2ad5dd04bb18e769ccbf564ee521aa97405
+  data.tar.gz: 9602382da425f288147cc4a1a9e5f0fc373dc9f8838204886c990a9e4b611be6
 SHA512:
-  metadata.gz: f644ce38c52fb2b6bb670616619548752a261147515461558dda726309fed4bba5f1e6f1bdb21eaa9923c8cecfd4bd92dd8d30717487f1dc994d48183848867d
-  data.tar.gz: 594fb0787715b39c9995384f650ed261c4455dd0827d08d65286410d8b9b5f77ce27afae8297f78e558ea0006f592fca6dd52dac55f453528f7b62d90fd43b3e
+  metadata.gz: 8b607671748a9035dce0b505ec757397416f2a70193e8d5890a90815bba03bbeff874ec878462b950427a372657889344f16b04c8349286165a70a61fd48fa86
+  data.tar.gz: bc6ad174e2d5fe8c0b75853bd66e7b69ee963024c33f797b9043a836cbe25fee7b5ada35c2c5c144fc5dad93b80859de4e9b3fb09fe34b5390c0a58b654c7363

data/Manifest.txt

@@ -4,12 +4,15 @@ README.md
 Rakefile
 lib/crypto-lite.rb
 lib/crypto-lite/config.rb
+lib/crypto-lite/helper.rb
+lib/crypto-lite/metal.rb
+lib/crypto-lite/sign_rsa.rb
 lib/crypto-lite/version.rb
 lib/crypto.rb
 lib/crypto/lite.rb
 test/helper.rb
 test/test_base58.rb
 test/test_bitcoin_addr.rb
-test/test_hash_keccak.rb
+test/test_hash.rb
 test/test_hash_sha.rb
 test/test_version.rb

data/README.md

@@ -24,23 +24,33 @@ sha256( "abc".b )         #=> "ba7816bf8f01cfea414140de5dae2223b00361a396177a9cb
 sha256( "\x61\x62\x63" )  #=> "ba7816bf8f01cfea414140de5dae2223b00361a396177a9cb410ff61f20015ad"
 sha256( 0x616263 )        #=> "ba7816bf8f01cfea414140de5dae2223b00361a396177a9cb410ff61f20015ad"
 
-sha256hex( '616263' )     #=> "ba7816bf8f01cfea414140de5dae2223b00361a396177a9cb410ff61f20015ad"
-sha256hex( '0x616263' )   #=> "ba7816bf8f01cfea414140de5dae2223b00361a396177a9cb410ff61f20015ad"
-sha256hex( '0X616263' )   #=> "ba7816bf8f01cfea414140de5dae2223b00361a396177a9cb410ff61f20015ad"
+sha256( hex: '616263' )     #=> "ba7816bf8f01cfea414140de5dae2223b00361a396177a9cb410ff61f20015ad"
+sha256( hex: '0x616263' )   #=> "ba7816bf8f01cfea414140de5dae2223b00361a396177a9cb410ff61f20015ad"
+sha256( hex: '0X616263' )   #=> "ba7816bf8f01cfea414140de5dae2223b00361a396177a9cb410ff61f20015ad"
 
 # "auto-magic" hex string to binary string conversion heuristic
 sha256( '0x616263' )      #=> "ba7816bf8f01cfea414140de5dae2223b00361a396177a9cb410ff61f20015ad"
 sha256( '0X616263' )      #=> "ba7816bf8f01cfea414140de5dae2223b00361a396177a9cb410ff61f20015ad"
+```
+
+
+Bonus Back Stage Tip: How does SHA256 work?
+
+Try this [amazing animation of the SHA256 hash function in your very own terminal](https://github.com/in3rsha/sha256-animation) by Greg Walker.
 
 
+
+Onwards with more sha256 examples:
+
+``` ruby
 ## try a
 sha256( "a" )         #=> "ca978112ca1bbdcafac231b39a23dc4da786eff8147c4e72b9807785afee48bb"
 sha256( "\x61" )      #=> "ca978112ca1bbdcafac231b39a23dc4da786eff8147c4e72b9807785afee48bb"
 sha256( 0b01100001 )  #=> "ca978112ca1bbdcafac231b39a23dc4da786eff8147c4e72b9807785afee48bb"
 sha256( 0x61 )        #=> "ca978112ca1bbdcafac231b39a23dc4da786eff8147c4e72b9807785afee48bb"
 
-sha256hex( '61' )     #=> "ca978112ca1bbdcafac231b39a23dc4da786eff8147c4e72b9807785afee48bb"
-sha256hex( '0x61' )   #=> "ca978112ca1bbdcafac231b39a23dc4da786eff8147c4e72b9807785afee48bb"
+sha256( hex: '61' )     #=> "ca978112ca1bbdcafac231b39a23dc4da786eff8147c4e72b9807785afee48bb"
+sha256( hex: '0x61' )   #=> "ca978112ca1bbdcafac231b39a23dc4da786eff8147c4e72b9807785afee48bb"
 
 # "auto-magic" hex string to binary string conversion heuristic
 sha256( '0x61' )      #=> "ca978112ca1bbdcafac231b39a23dc4da786eff8147c4e72b9807785afee48bb"
@@ -51,6 +61,67 @@ sha256( "Hello, Cryptos!" )  #=> "33eedea60b0662c66c289ceba71863a864cf84b00e1000
 ```
 
 
+**SHA3-256 - Secure Hashing Algorthim (SHA) 3, 256-Bit (32 Bytes)**
+
+``` ruby
+sha3_256( "Hello, Cryptos!" )  #=> "7dddf4bc9b86352b67e8823e5010ddbd2a90a854469e2517992ca7ca89e5bd58"
+```
+
+Note:  Yes, SHA256 vs SHA3-256 / SHA-2 vs SHA-3 the hashing functions are
+different (although the 256-bit hash size output is the same).
+The sha256 hashing function is part of the Secure Hash Algorithm (SHA) 2 family / standards first published in 2001.
+The sha3_256 is part of the (newer) Secure Hash Algorithm (SHA) 3 family / standards first published in 2015
+(and uses the Keccak cryptographic primitive "under the hood").
+
+
+
+**Keccak 256-Bit**
+
+``` ruby
+keccak256( "Hello, Cryptos!" )  #=> "2cf14baa817e931f5cc2dcb63c889619d6b7ae0794fc2223ebadf8e672c776f5"
+```
+
+
+#### Aside - Keccak vs SHA3 / Original vs Official
+
+In 2004 the U.S. National Institute of Standards and Technology (NIST)
+changed the padding to `SHA3-256(M) = KECCAK [512] (M || 01, 256)`.
+This is different from the padding proposed by the Keccak team in
+the original Keccak SHA-3 submission version 3 (the final, winning version).
+The difference is the additional `'01'` bits appended to the message.
+
+To help avoid confusion the "submitted original version 3" SHA-3 Keccak
+hashing is now called "Keccak"
+and the finalized NIST SHA-3 standard "SHA3".
+
+Tip: If you don't know what variant of the hash function you have -
+original or official? - check your hash:
+
+For keccak 256-bit:
+
+``` ruby
+keccak256( '' )   #=> "c5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470"
+```
+
+For sha3 256-bit:
+
+``` ruby
+sha3_256( '' )   #=> "a7ffc6f8bf1ed76651c14756a061d662f580ff4de43b49fa82d80a4b80f8434a"
+```
+
+
+
+**RMD / RIPE-MD  - RACE¹ Integrity Primitives Evaluation Message Digest 160-Bit**
+
+¹: Research and development in Advanced Communications technologies in Europe
+
+
+``` ruby
+rmd160( "Hello, Cryptos!" )     #=>"4d65f7b740bbade4097e1348e15d2a7d52ac5f53"
+# or use the alias / alternate name
+ripemd160( "Hello, Cryptos!" )  #=>"4d65f7b740bbade4097e1348e15d2a7d52ac5f53"
+```
+
 
 #### Aside - Hex String `"0x616263"` vs Binary String `"\x61\x62\x63" == "abc"`
 
@@ -84,15 +155,18 @@ Note: The standard `Array#pack` conversion
 will NOT "auto-magically" cut-off the `0x` or `0X` prefix.
 
 
-If you know you have a hex string use the hex-variant of the hash function that will handle the hex-to-bin conversion for you. Example:
+If you know you have a hex string use the `hex:` keyword to pass
+in the arg(ument)
+to the hash function and that will "automagically"
+handle the hex-to-bin conversion for you. Example:
 
 ``` ruby
-sha256hex( '61' )     #=> "ca978112ca1bbdcafac231b39a23dc4da786eff8147c4e72b9807785afee48bb"
-sha256hex( '0x61' )   #=> "ca978112ca1bbdcafac231b39a23dc4da786eff8147c4e72b9807785afee48bb"
+sha256( hex: '61' )     #=> "ca978112ca1bbdcafac231b39a23dc4da786eff8147c4e72b9807785afee48bb"
+sha256( hex: '0x61' )   #=> "ca978112ca1bbdcafac231b39a23dc4da786eff8147c4e72b9807785afee48bb"
 
-sha256hex( '616263' )     #=> "ba7816bf8f01cfea414140de5dae2223b00361a396177a9cb410ff61f20015ad"
-sha256hex( '0x616263' )   #=> "ba7816bf8f01cfea414140de5dae2223b00361a396177a9cb410ff61f20015ad"
-sha256hex( '0X616263' )   #=> "ba7816bf8f01cfea414140de5dae2223b00361a396177a9cb410ff61f20015ad"
+sha256( hex: '616263' )     #=> "ba7816bf8f01cfea414140de5dae2223b00361a396177a9cb410ff61f20015ad"
+sha256( hex: '0x616263' )   #=> "ba7816bf8f01cfea414140de5dae2223b00361a396177a9cb410ff61f20015ad"
+sha256( hex: '0X616263' )   #=> "ba7816bf8f01cfea414140de5dae2223b00361a396177a9cb410ff61f20015ad"
 ```
 
 What about the built-in "auto-magic" hex-to-bin conversion / heuristic?
@@ -121,59 +195,6 @@ hash256( '6fe6b145a3908a4d6616b13c1109717add8672c900' )
 ```
 
 
-
-**Keccak 256-Bit**
-
-``` ruby
-keccak256( "Hello, Cryptos!" )  #=> "2cf14baa817e931f5cc2dcb63c889619d6b7ae0794fc2223ebadf8e672c776f5"
-keccak256( '' )                 #=> "c5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470"
-```
-
-
-#### Aside - Keccak vs SHA3 / Original vs Official
-
-In 2004 the U.S. National Institute of Standards and Technology (NIST)
-changed the padding to `SHA3-256(M) = KECCAK [512] (M || 01, 256)`.
-This is different from the padding proposed by the Keccak team in
-the original Keccak SHA-3 submission version 3 (the final, winning version).
-The difference is the additional `'01'` bits appended to the message.
-
-To help avoid confusion the "submitted original version 3" SHA-3 Keccak
-hashing is now called "Keccak"
-and the finalized NIST SHA-3 standard "SHA3".
-
-Tip: If you don't know what variant of the hash function you have -
-original or official? - check your hash:
-
-For keccak 256-bit:
-
-``` ruby
-keccak256( '' )                #=> "c5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470"
-keccak256( 'Hello, Cryptos!' ) #=> "2cf14baa817e931f5cc2dcb63c889619d6b7ae0794fc2223ebadf8e672c776f5"
-```
-
-For sha3 256-bit:
-
-``` ruby
-sha3_256( '' )                 #=> "a7ffc6f8bf1ed76651c14756a061d662f580ff4de43b49fa82d80a4b80f8434a"
-sha3_256( 'Hello, Cryptos!' )  #=> "7dddf4bc9b86352b67e8823e5010ddbd2a90a854469e2517992ca7ca89e5bd58"
-```
-
-
-
-**RMD  - RACE¹ Integrity Primitives Evaluation Message Digest 160-Bit**
-
-¹: Research and development in Advanced Communications technologies in Europe
-
-
-``` ruby
-rmd160( "Hello, Cryptos!" )     #=>"4d65f7b740bbade4097e1348e15d2a7d52ac5f53"
-# or use the alias / alternate name
-ripemd160( "Hello, Cryptos!" )  #=>"4d65f7b740bbade4097e1348e15d2a7d52ac5f53"
-```
-
-
-
 #### Hash Function Helpers
 
 **HASH160 -  RMD160(SHA256(X))**
@@ -204,7 +225,7 @@ hash256( '6fe6b145a3908a4d6616b13c1109717add8672c900' )
 #=> "02335f08b8fe4ddad263a50b7a33c5d38ea1cbd8fd2056a1320a3ddece541711"
 ```
 
-##### Base58 Encoding / Decoding Helpers
+#### Base58 Encoding / Decoding Helpers
 
 **BASE58**
 
@@ -443,6 +464,20 @@ References
 - [How to create Bitcoin Address](https://en.bitcoin.it/wiki/Technical_background_of_version_1_Bitcoin_addresses#How_to_create_Bitcoin_Address)
 - [Ruby Quiz #15 - Generate the Bitcoin (Base58) Address from the (Elliptic Curve) Public Key](https://github.com/planetruby/quiz/tree/master/015)
 
+Bonus:  Bitcon Tip - How to Buy Bitcoin (The CO₂-Friendly Way)
+
+> 1. Take one $50 bill, five $10 bills, or ten $5 bills (I wouldn't recommend change - stay with paper money).
+> 2. Go to the bathroom.
+> 3. Lift the lid of the loo.
+> 4. Throw money in.
+> 5. Flush down water.
+>
+> Congrats! You just purchased $50 worth of Bitcoin - without fucking the planet!
+>
+>  -- Trolly McTrollface, Bitcon Greater Fool Court Jester
+
+Read more [Crypto Quotes »](https://github.com/openblockchains/crypto-quotes)
+
 
 
 

data/lib/crypto-lite.rb

@@ -17,199 +17,89 @@ require 'base58-alphabets'
 ## our own code
 require 'crypto-lite/version'    # note: let version always go first
 require 'crypto-lite/config'
+require 'crypto-lite/metal'
 
 
 
 
 module Crypto
 
-  ## 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.base58bin( input )
-    ## todo/check: input must be a (binary) string - why? why not?
-    Base58::Bitcoin.encode_bin( input )
+  def self.base58( *args, **kwargs )
+    input = args_to_input( args, kwargs )
+    Metal.base58bin( input )
   end
 
-  def self.base58( input )
-    input = hex_to_bin_automagic( input )  ## add automagic hex (string) to bin (string) check - why? why not?
-    base58bin( input )
-  end
-
-  def self.base58hex( input )
-    raise ArgumentError, "expected hex string (0-9a-f) - got >#{input}< - can't pack string; sorry"   unless input =~ HEX_RE
-
-    input = strip0x( input )  ##  check if input starts with 0x or 0X if yes - (auto-)cut off!!!!!
-    base58bin( [input].pack( 'H*' ) )
-  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
-
-  def self.base58check( input )
-    input = hex_to_bin_automagic( input )  ## add automagic hex (string) to bin (string) check - why? why not?
-    base58bin_check( input )
-  end
-
-  def self.base58hex_check( input )
-    raise ArgumentError, "expected hex string (0-9a-f) - got >#{input}< - can't pack string; sorry"   unless input =~ HEX_RE
-
-    input = strip0x( input )  ##  check if input starts with 0x or 0X if yes - (auto-)cut off!!!!!
-    base58bin_check( [input].pack( 'H*' ) )
+  def self.base58check( *args, **kwargs )
+    input = args_to_input( args, kwargs )
+    Metal.base58bin_check( input )
   end
 
 
   ########################
   # (secure) hash functions
 
-  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
+  def self.keccak256( *args, **kwargs )
+    input = args_to_input( args, kwargs )
+    Metal.keccak256bin( input ).unpack( 'H*' )[0]
   end
 
 
-
-  def self.keccak256bin( input )
-    message = message( input )   ## "normalize" / convert to (binary) string
-    Digest::SHA3.digest( message, 256 )
-  end
-
-  def self.keccak256( input )
-    input = hex_to_bin_automagic( input )  ## add automagic hex (string) to bin (string) check - why? why not?
-    keccak256bin( input ).unpack( 'H*' )[0]
-  end
-
-
-
-  def self.rmd160bin( input )
-    message = message( input )   ## "normalize" / convert to (binary) string
-    Digest::RMD160.digest( message )
-  end
-
-  def self.rmd160( input )
-    input = hex_to_bin_automagic( input )  ## add automagic hex (string) to bin (string) check - why? why not?
-    rmd160bin( input ).unpack( 'H*' )[0]
+  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
-    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
-         digest.update( message )
-         digest.digest
-       else  ## use "built-in" hash function from digest module
-         Digest::SHA256.digest( message )
-       end
-  end
-
-  def self.sha256( input, engine=nil )
-    input = hex_to_bin_automagic( input )  ## add automagic hex (string) to bin (string) check - why? why not?
-    sha256bin( input, engine ).unpack( 'H*' )[0]
+  def self.sha256( *args, **kwargs )
+    input = args_to_input( args, kwargs )
+    engine = kwargs[:engine]
+    Metal.sha256bin( input, engine ).unpack( 'H*' )[0]
   end
 
-
-  def self.sha256hex( input, engine=nil )  ## convenience helper - lets you pass in hex string
-    raise ArgumentError, "expected hex string (0-9a-f) - got >#{input}< - can't pack string; sorry"   unless input =~ HEX_RE
-
-    input = strip0x( input )  ##  check if input starts with 0x or 0X if yes - (auto-)cut off!!!!!
-    sha256bin( [input].pack( 'H*' ), engine ).unpack( 'H*' )[0]
+  def self.sha3_256( *args, **kwargs )
+    input = args_to_input( args, kwargs )
+    Metal.sha3_256bin( input ).unpack( 'H*' )[0]
   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 ))
+  def self.hash160( *args, **kwargs )
+    input = args_to_input( args, kwargs )
+    Metal.hash160bin( input ).unpack( 'H*' )[0]
   end
 
-  def self.hash160( input )
-    input = hex_to_bin_automagic( input )  ## add automagic hex (string) to bin (string) check - why? why not?
-    hash160bin( input ).unpack( 'H*' )[0]
-  end
-
-  def self.hash160hex( input )  ## convenience helper - lets you pass in hex string
-    raise ArgumentError, "expected hex string (0-9a-f) - got >#{input}< - can't pack string; sorry"   unless input =~ HEX_RE
-
-    input = strip0x( input )  ##  check if input starts with 0x or 0X if yes - (auto-)cut off!!!!!
-    hash160bin( [input].pack( 'H*' ) ).unpack( 'H*' )[0]
+  def self.hash256( *args, **kwargs )
+    input = args_to_input( args, kwargs )
+    Metal.hash256bin( input ).unpack( 'H*' )[0]
   end
 
 
 
-  def self.hash256bin( input )
-    message = message( input )   ## "normalize" / convert to (binary) string
-
-    sha256bin(sha256bin( message ))
-  end
-
-  def self.hash256( input )
-    input = hex_to_bin_automagic( input )  ## add automagic hex (string) to bin (string) check - why? why not?
-    hash256bin( input ).unpack( 'H*' )[0]
-  end
-
-  def self.hash256hex( input )  ## convenience helper - lets you pass in hex string
-    raise ArgumentError, "expected hex string (0-9a-f) - got >#{input}< - can't pack string; sorry"   unless input =~ HEX_RE
+  ########
+  # 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
 
-    input = strip0x( input )  ##  check if input starts with 0x or 0X if yes - (auto-)cut off!!!!!
-    hash256bin( [input].pack( 'H*' ) ).unpack( "H*" )[0]
+  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
 
-
-  ########
-  # more helpers
   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
@@ -234,78 +124,24 @@ module Crypto
     (str[0,2] == '0x' || str[0,2] == '0X') ?  str[2..-1] : str
   end
 
-  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
-
-  def self.pluralize( count, noun )
-     count == 1 ? "#{count} #{noun}" : "#{count} #{noun}s"
-  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.hex_to_bin( str )
+#    str = strip0x( str )  ##  check if input starts with 0x or 0X if yes - (auto-)cut off!!!!!
+#    [str].pack( 'H*' )
+#  end
 
-    [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
 
 
 
 
-## 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
-
-def keccak256( input )    Crypto.keccak256( input ); end
-
-def rmd160( input )    Crypto.rmd160( input ); end
-def ripemd160( input ) Crypto.rmd160( input ); end
-## alias_method :ripemd160, :rmd160
-
-def hash160( input )    Crypto.hash160( input ); end
-def hash160hex( input ) Crypto.hash160hex( input ); end
-
-def hash256( input )    Crypto.hash256( input ); end
-def hash256hex( input ) Crypto.hash256hex( input ); end
-
-
-def base58( input )     Crypto.base58( input ); end
-def base58hex( input )  Crypto.base58hex( input ); end
-
-
-def base58check( input ) Crypto.base58check( input ); end
-
+require 'crypto-lite/helper'
+include CryptoHelper      # add convenience "top-level" / global helpers
 
 
+require 'crypto-lite/sign_rsa'
 RSA = Crypto::RSA
 
 
 
 
-
-
 puts CryptoLite.banner    ## say hello

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

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

data/test/test_base58.rb

@@ -15,7 +15,7 @@ HEX_TESTS = [
 
 def test_hex
    HEX_TESTS.each do |item|
-      assert_equal item[1],  base58hex( item[0] )
+      assert_equal item[1],  base58( hex: item[0] )
       assert_equal item[1],  base58( item[0] )
     end
 end
@@ -27,9 +27,10 @@ def test_bitcoin_addr
    pkh = 'f54a5851e9372b87810a8e60cdd2e7cfd80b6e31'
 
    ## all-in-one
+   assert_equal addr_exp, base58check( hex: '00' + pkh )
    assert_equal addr_exp, base58check( '00' + pkh )
-   assert_equal addr_exp, Crypto.base58hex_check( '00' + pkh )
-   assert_equal addr_exp, Crypto.base58bin_check( "\x00" + [pkh].pack('H*') )
+
+   assert_equal addr_exp, Crypto::Metal.base58bin_check( "\x00" + [pkh].pack('H*') )
 end
 
 end # class TestBase58

data/test/test_hash.rb

@@ -0,0 +1,47 @@
+###
+#  to run use
+#     ruby -I ./lib -I ./test test/test_hash.rb
+
+
+require 'helper'
+
+
+class TestHash < MiniTest::Test
+
+ KECCAK256_TESTS = [
+   ['',                'c5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470'],
+   ['testing',         '5f16f4c7f149ac4f9510d9cf8cf384038ad348b3bcdc01915f95de12df9d1b02'],
+   ['Hello, Cryptos!', '2cf14baa817e931f5cc2dcb63c889619d6b7ae0794fc2223ebadf8e672c776f5'],
+ ]
+
+ SHA3_256_TESTS = [
+   ['',                'a7ffc6f8bf1ed76651c14756a061d662f580ff4de43b49fa82d80a4b80f8434a'],
+   ['Hello, Cryptos!', '7dddf4bc9b86352b67e8823e5010ddbd2a90a854469e2517992ca7ca89e5bd58'],
+ ]
+
+ RIPEMD160_TESTS = [
+   ['Hello, Cryptos!', '4d65f7b740bbade4097e1348e15d2a7d52ac5f53'],
+ ]
+
+
+
+def test_keccak256
+   KECCAK256_TESTS.each do |item|
+     assert_equal item[1], keccak256( item[0].b )
+   end
+end
+
+def test_sha3_256
+  SHA3_256_TESTS.each do |item|
+    assert_equal item[1], sha3_256( item[0].b )
+  end
+end
+
+def test_ripemd160
+  RIPEMD160_TESTS.each do |item|
+    assert_equal item[1], ripemd160( item[0].b )
+  end
+end
+
+
+end # class TestHash

data/test/test_hash_sha.rb

@@ -6,21 +6,35 @@
 require 'helper'
 
 
-class TestHash < MiniTest::Test
+class TestHashSha < MiniTest::Test
 
-  SHA256_EMPTY         = 'e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855'
   SHA256_ABC           = 'ba7816bf8f01cfea414140de5dae2223b00361a396177a9cb410ff61f20015ad'
   SHA256_A             = 'ca978112ca1bbdcafac231b39a23dc4da786eff8147c4e72b9807785afee48bb'
   SHA256_B             = '3e23e8160039594a33894f6564e1b1348bbd7a0088d42c4acb73eeaed59c009d'
   SHA256_C             = '2e7d2c03a9507ae265ecf5b5356885a53393a2029d241394997265a1a25aefc6'
-  SHA256_HELLO_CRYPTOS = '33eedea60b0662c66c289ceba71863a864cf84b00e10002ca1069bf58f9362d5'
 
 
-def test_empty
-   assert_equal SHA256_EMPTY, sha256( '' )
-   assert_equal SHA256_EMPTY, sha256( '', :openssl )
+  BIN_TESTS = [
+    ['',                'e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855'],
+    ['Hello, Cryptos!', '33eedea60b0662c66c289ceba71863a864cf84b00e10002ca1069bf58f9362d5'],
+
+    ['Blockchain 1',    '223aae3830e87aff41db07714983671429a74fb7064646e27ab62adbdc892cd1'],
+    ['Blockchain 2',    '8f4b5a896e78f680de2c141d25533e8c9207c9ee0d9b09c22a5a01d7992e7d1b'],
+    ['Blockchain 3',    'f9f5e7d64f3a93f071900a73d34b2b722867adcb09345a21a25b5cd7f8b41254'],
+    ['Blockchain 4',    '69580cfb9a134395106ac27de53595cc41fb9940dcc298082c87144932a983a9'],
+    ['Blockchain 12',   'f94455d34e7b32dc7dac780fb94a5e958f0d7e2da4cc6500505d5daed719c227'],
+    ['Blockchain 13',   '0cedb5e229c9582a35ec291ccb172b3f7c76a20c7f645e08d24ece8d5692e153'],
+  ]
+
+
+def test_bin
+   BIN_TESTS.each do |item|
+     assert_equal item[1], sha256( item[0].b )
+     assert_equal item[1], sha256( item[0].b, engine: 'openssl' )
+   end
 end
 
+
 def test_abc
   ['abc',
    'abc'.b,
@@ -28,14 +42,14 @@ def test_abc
    0x616263
   ].each do |input|
     assert_equal SHA256_ABC, sha256( input )
-    assert_equal SHA256_ABC, sha256( input, :openssl )
+    assert_equal SHA256_ABC, sha256( input, engine: 'openssl' )
   end
 
   ['616263',
    '0x616263',
    '0X616263'
   ].each do |input|
-    assert_equal SHA256_ABC, sha256hex( input )
+    assert_equal SHA256_ABC, sha256( hex: input )
   end
 ## pp sha256hex( 'hello' )  -- fails - uses non-hex chars
 
@@ -47,14 +61,14 @@ def test_abc
     0x61
   ].each do |input|
     assert_equal SHA256_A, sha256( input )
-    assert_equal SHA256_A, sha256( input, :openssl )
+    assert_equal SHA256_A, sha256( input, engine: 'openssl' )
   end
 
   ['61',
    '0x61',
    '0X61'
   ].each do |input|
-    assert_equal SHA256_A, sha256hex( input )
+    assert_equal SHA256_A, sha256( hex: input )
   end
 
   [ 'b',
@@ -70,9 +84,4 @@ def test_abc
   end
 end
 
-
-def test_misc
-   assert_equal SHA256_HELLO_CRYPTOS, sha256( 'Hello, Cryptos!' )
-end
-
-end # class TestHash
+end # class TestHashSha

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: crypto-lite
 version: !ruby/object:Gem::Version
-  version: 0.2.2
+  version: 0.2.3
 platform: ruby
 authors:
 - Gerald Bauer
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-01-18 00:00:00.000000000 Z
+date: 2021-01-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: digest-sha3-patched
@@ -102,13 +102,16 @@ files:
 - Rakefile
 - lib/crypto-lite.rb
 - lib/crypto-lite/config.rb
+- lib/crypto-lite/helper.rb
+- lib/crypto-lite/metal.rb
+- lib/crypto-lite/sign_rsa.rb
 - lib/crypto-lite/version.rb
 - lib/crypto.rb
 - lib/crypto/lite.rb
 - test/helper.rb
 - test/test_base58.rb
 - test/test_bitcoin_addr.rb
-- test/test_hash_keccak.rb
+- test/test_hash.rb
 - test/test_hash_sha.rb
 - test/test_version.rb
 homepage: https://github.com/rubycoco/blockchain

data/test/test_hash_keccak.rb

@@ -1,25 +0,0 @@
-###
-#  to run use
-#     ruby -I ./lib -I ./test test/test_hash_keccak.rb
-
-
-require 'helper'
-
-
-class TestHashKeccak < MiniTest::Test
-
-  KECCAK256_EMPTY         = 'c5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470'
-  KECCAK256_TESTING       = '5f16f4c7f149ac4f9510d9cf8cf384038ad348b3bcdc01915f95de12df9d1b02'
-  KECCAK256_HELLO_CRYPTOS = '2cf14baa817e931f5cc2dcb63c889619d6b7ae0794fc2223ebadf8e672c776f5'
-
-
-def test_empty
-   assert_equal KECCAK256_EMPTY, keccak256( '' )
-end
-
-def test_misc
-   assert_equal KECCAK256_TESTING,       keccak256( 'testing' )
-   assert_equal KECCAK256_HELLO_CRYPTOS, keccak256( 'Hello, Cryptos!' )
-end
-
-end # class TestHashKeccak