crypto-lite 0.2.0 → 0.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8380b7856889a9c184423b31a39b84dff8197bcb34a58687cd8d496bf7ded819
-  data.tar.gz: b91ff4cb4baaa9a7de69224e99585ad5efa6491bb2d8e54adf36841675dfd00c
+  metadata.gz: d361cfd5f45ee36170d5efa9e63194a453dc8401334f8eb9db47d15344c74a9b
+  data.tar.gz: 40de7d4721e87e02b8157b0668814a91a75ef3ebd4d5d202e2b0d4085fd52e59
 SHA512:
-  metadata.gz: 37c7deea2e4badbeb25abd89e4df6ad98f9503c5b8c7fc22f14bd141d2036d97aa33b2fd9c00f538490c9eb6e5eb4fa554199574948b893691c5bf1dfab34fd0
-  data.tar.gz: 8727fbeea1fa393124ff0d302d1e0f11cc88517424cefba0e809c1f7d1685a758cf0e60eff2d978355da158fd4cb55bea4190f0368eae327d43124ef7d6fe7b6
+  metadata.gz: f6543504e262d4ea380e529abd15e6789d1cb19988dec206028ad2f715b4ad556838e00c01dd865378a59dc3da2a602371a00a4e7d32db93d374233525be836a
+  data.tar.gz: f541ff370e6a134d5f84a65cc5381d75d8016f9e0ac16d927695507726809d71532acd4ae0b799ab57febf8ee288ac2fdcecf63b3ee7bb9ac17a0e350ac0c8c5

data/README.md

@@ -28,6 +28,10 @@ sha256hex( '616263' )     #=> "ba7816bf8f01cfea414140de5dae2223b00361a396177a9cb
 sha256hex( '0x616263' )   #=> "ba7816bf8f01cfea414140de5dae2223b00361a396177a9cb410ff61f20015ad"
 sha256hex( '0X616263' )   #=> "ba7816bf8f01cfea414140de5dae2223b00361a396177a9cb410ff61f20015ad"
 
+# "auto-magic" hex string to binary string conversion heuristic
+sha256( '0x616263' )      #=> "ba7816bf8f01cfea414140de5dae2223b00361a396177a9cb410ff61f20015ad"
+sha256( '0X616263' )      #=> "ba7816bf8f01cfea414140de5dae2223b00361a396177a9cb410ff61f20015ad"
+
 
 ## try a
 sha256( "a" )         #=> "ca978112ca1bbdcafac231b39a23dc4da786eff8147c4e72b9807785afee48bb"
@@ -38,6 +42,9 @@ sha256( 0x61 )        #=> "ca978112ca1bbdcafac231b39a23dc4da786eff8147c4e72b9807
 sha256hex( '61' )     #=> "ca978112ca1bbdcafac231b39a23dc4da786eff8147c4e72b9807785afee48bb"
 sha256hex( '0x61' )   #=> "ca978112ca1bbdcafac231b39a23dc4da786eff8147c4e72b9807785afee48bb"
 
+# "auto-magic" hex string to binary string conversion heuristic
+sha256( '0x61' )      #=> "ca978112ca1bbdcafac231b39a23dc4da786eff8147c4e72b9807785afee48bb"
+
 
 ## try some more
 sha256( "Hello, Cryptos!" )  #=> "33eedea60b0662c66c289ceba71863a864cf84b00e10002ca1069bf58f9362d5"
@@ -45,6 +52,76 @@ sha256( "Hello, Cryptos!" )  #=> "33eedea60b0662c66c289ceba71863a864cf84b00e1000
 
 
 
+#### Aside - Hex String `'0x616263'` vs Binary String `'abc' == "\x61\x62\x63"`
+
+Note: All hash functions operate on binary strings ("byte arrays")
+and NOT hex strings.
+
+Note: For hex strings the `0x` or `0X` prefix is optional.
+Examples of hex strings:
+
+``` ruby
+# hex string      binary string ("byte array")
+'61'              'a' == "\x61"
+'0x61'            'a' == "\x61"
+
+'616263'          'abc' == "\x61\x62\x63"
+'0x616263'        'abc' == "\x61\x62\x63"
+'0X616263'        'abc' == "\x61\x62\x63"
+
+# or   160-bit hex string (hash)
+'93ce48570b55c42c2af816aeaba06cfee1224fae'
+'0x93ce48570b55c42c2af816aeaba06cfee1224fae'
+
+# or 256-bit hex string (hash)
+'ba7816bf8f01cfea414140de5dae2223b00361a396177a9cb410ff61f20015ad'
+'0xba7816bf8f01cfea414140de5dae2223b00361a396177a9cb410ff61f20015ad'
+```
+
+You can use `[str].pack( 'H*' )`
+to convert a hex string into a binary string.
+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:
+
+``` ruby
+sha256hex( '61' )     #=> "ca978112ca1bbdcafac231b39a23dc4da786eff8147c4e72b9807785afee48bb"
+sha256hex( '0x61' )   #=> "ca978112ca1bbdcafac231b39a23dc4da786eff8147c4e72b9807785afee48bb"
+
+sha256hex( '616263' )     #=> "ba7816bf8f01cfea414140de5dae2223b00361a396177a9cb410ff61f20015ad"
+sha256hex( '0x616263' )   #=> "ba7816bf8f01cfea414140de5dae2223b00361a396177a9cb410ff61f20015ad"
+sha256hex( '0X616263' )   #=> "ba7816bf8f01cfea414140de5dae2223b00361a396177a9cb410ff61f20015ad"
+```
+
+What about the built-in "auto-magic" hex-to-bin conversion / heuristic?
+
+Yes, if your passed in string starts with the
+the `0x` or `0X` prefix the string gets "auto-magically" converted
+to binary. Or if your passed in string is all hexadecimal characters,
+that is, `0-9` and `a-f` and has a minimum length of ten characters.
+Example:
+
+
+``` ruby
+# "auto-magic" hex string to binary string conversion heuristic
+
+sha256( '0x616263' )      #=> "ba7816bf8f01cfea414140de5dae2223b00361a396177a9cb410ff61f20015ad"
+sha256( '0X616263' )      #=> "ba7816bf8f01cfea414140de5dae2223b00361a396177a9cb410ff61f20015ad"
+
+# or without 0x or 0X BUT with minimum heuristic length
+hash160( '02b4632d08485ff1df2db55b9dafd23347d1c47a457072a1e87be26896549a8737' )
+#=> "93ce48570b55c42c2af816aeaba06cfee1224fae"
+
+hash256( '6fe6b145a3908a4d6616b13c1109717add8672c900' )
+#=> "02335f08b8fe4ddad263a50b7a33c5d38ea1cbd8fd2056a1320a3ddece541711"
+
+# and so on
+```
+
+
+
 **Keccak 256-Bit**
 
 ``` ruby
@@ -71,16 +148,13 @@ All-in-one "best-of-both-worlds" helper - first hash with sha256 and than hash w
 
 
 ``` ruby
-hash160hex( '02b9d1cc0b793b03b9f64d022e9c67d5f32670b03f636abf0b3147b34123d13990' )
+hash160( '02b9d1cc0b793b03b9f64d022e9c67d5f32670b03f636abf0b3147b34123d13990' )
 => "e6b145a3908a4d6616b13c1109717add8672c900"
 
-hash160hex( '02b4632d08485ff1df2db55b9dafd23347d1c47a457072a1e87be26896549a8737' )
+hash160( '02b4632d08485ff1df2db55b9dafd23347d1c47a457072a1e87be26896549a8737' )
 => "93ce48570b55c42c2af816aeaba06cfee1224fae"
 ```
 
-Why hex? The input string is a hex string.
-Note: It's optional to start a hex string with `0x` or `0X`.
-
 
 
 **HASH256 -  SHA256(SHA256())**
@@ -88,15 +162,11 @@ Note: It's optional to start a hex string with `0x` or `0X`.
 All-in-one double sha256 hash helper, that is, first hash with sha256 and than hash with sha256 again. Why?  Arguably higher security.
 
 ``` ruby
-hash256hex( '6fe6b145a3908a4d6616b13c1109717add8672c900' )
+hash256( '6fe6b145a3908a4d6616b13c1109717add8672c900' )
 => "02335f08b8fe4ddad263a50b7a33c5d38ea1cbd8fd2056a1320a3ddece541711"
 ```
 
 
-Why hex? The input string is a hex string.
-Note: It's optional to start a hex string with `0x` or `0X`.
-
-
 
 
 

data/lib/crypto-lite.rb

@@ -10,9 +10,6 @@ require 'digest/sha3'  # e.g. keccak (original submission/proposal NOT official
 
 
 
-
-
-
 ## our own code
 require 'crypto-lite/version'    # note: let version always go first
 
@@ -20,6 +17,11 @@ require 'crypto-lite/version'    # note: let version always go first
 
 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.message( input )  ## convert input to (binary) string
     input_type = if input.is_a?( String )
@@ -56,16 +58,19 @@ module Crypto
   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]
   end
   ## todo/fix: add alias RIPEMD160 - why? why not?
@@ -86,20 +91,16 @@ module Crypto
   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]
   end
 
 
-  def self.sha256hex( input, engine=nil )
-    ## convenience helper - lets you pass in hex string
-
-    ##  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
+  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
 
-    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 )
+    input = strip0x( input )  ##  check if input starts with 0x or 0X if yes - (auto-)cut off!!!!!
+    sha256bin( [input].pack( 'H*' ), engine ).unpack( 'H*' )[0]
   end
 
 
@@ -113,34 +114,75 @@ module Crypto
   #              ripemd160.unpack( "H*" )[0]    # Convert back to hex
   # end
 
-  def self.hash160hex( input )
-    ## convenience helper - lets you pass in hex string
+  def self.hash160bin( input )
+    message = message( input )   ## "normalize" / convert to (binary) string
+
+    rmd160bin(sha256bin( message ))
+  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]
+  end
+
+
+
+  def self.hash256bin( input )
+    message = message( input )   ## "normalize" / convert to (binary) string
+
+    sha256bin(sha256bin( message ))
+  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
+  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
 
-    raise ArgumentError, "expected hex string (0-9a-f) - got >#{input}< - can't pack string; sorry"   if input.downcase =~ /[^0-9a-f]/
-    sha256bin = sha256bin( [input].pack( 'H*' ) )
-    rmd160    = rmd160bin( sha256bin ).unpack( "H*" )[0]
-    rmd160
+    input = strip0x( input )  ##  check if input starts with 0x or 0X if yes - (auto-)cut off!!!!!
+    hash256bin( [input].pack( 'H*' ) ).unpack( "H*" )[0]
   end
 
-  def self.hash256hex( input )
-    ## convenience helper - lets you pass in hex string
 
-    ##  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
+  ########
+  # 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
+        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
+
 
-    raise ArgumentError, "expected hex string (0-9a-f) - got >#{input}< - can't pack string; sorry"   if input.downcase =~ /[^0-9a-f]/
-    sha256bin = sha256bin( [input].pack( 'H*' ) )
-    sha256    = sha256bin( sha256bin ).unpack( "H*" )[0]
-    sha256
+  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
 
+  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"
@@ -148,6 +190,7 @@ module Crypto
 
 
 
+
 module RSA
   def self.generate_keys  ## todo/check: add a generate alias - why? why not?
     key_pair = OpenSSL::PKey::RSA.new( 2048 )
@@ -186,8 +229,11 @@ def keccak256( input )    Crypto.keccak256( input ); end
 
 def rmd160( input )    Crypto.rmd160( input ); end
 
-def hash160hex( input )   Crypto.hash160hex( input ); end
-def hash256hex( input )   Crypto.hash256hex( input ); end
+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
 
 
 RSA = Crypto::RSA

data/lib/crypto-lite/version.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: crypto-lite
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.2.1
 platform: ruby
 authors:
 - Gerald Bauer