crypto-lite 0.3.0 → 0.3.1

data/Rakefile

@@ -1,34 +1,34 @@
-require 'hoe'
-require './lib/crypto-lite/version.rb'
-
-
-Hoe.spec 'crypto-lite' do
-
-  self.version = CryptoLite::VERSION
-
-  self.summary = "crypto-lite  - cryptographic secure hash functions and public key signature algorithms made easy"
-  self.description = summary
-
-  self.urls    = { home: 'https://github.com/rubycoco/blockchain' }
-
-  self.author  = 'Gerald Bauer'
-  self.email   = 'wwwmake@googlegroups.com'
-
-  # switch extension to .markdown for gihub formatting
-  self.readme_file  = 'README.md'
-  self.history_file = 'CHANGELOG.md'
-
-  self.extra_deps = [
-     ['digest-sha3-patched'],
-     ['base32-alphabets'],
-     ['base58-alphabets'],
-     ['elliptic'],
-  ]
-
-  self.licenses = ['Public Domain']
-
-  self.spec_extras = {
-    required_ruby_version: '>= 2.3'
-  }
-
-end
+require 'hoe'
+require './lib/crypto-lite/version.rb'
+
+
+Hoe.spec 'crypto-lite' do
+
+  self.version = CryptoLite::VERSION
+
+  self.summary = "crypto-lite  - cryptographic secure hash functions and public key signature algorithms made easy"
+  self.description = summary
+
+  self.urls    = { home: 'https://github.com/rubycocos/blockchain' }
+
+  self.author  = 'Gerald Bauer'
+  self.email   = 'wwwmake@googlegroups.com'
+
+  # switch extension to .markdown for gihub formatting
+  self.readme_file  = 'README.md'
+  self.history_file = 'CHANGELOG.md'
+
+  self.extra_deps = [
+     ['digest-lite'],
+     ['base32-alphabets'],
+     ['base58-alphabets'],
+     ['elliptic'],
+  ]
+
+  self.licenses = ['Public Domain']
+
+  self.spec_extras = {
+    required_ruby_version: '>= 2.3'
+  }
+
+end

data/lib/crypto/lite.rb

@@ -1,2 +1,2 @@
-require_relative '../crypto-lite'  ## lets you use require 'crypto/lite' too
-
+require_relative '../crypto-lite'  ## lets you use require 'crypto/lite' too
+

data/lib/crypto-lite/config.rb

@@ -1,32 +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
-
-
-
+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

@@ -1,25 +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
-
-
+
+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

@@ -1,128 +1,135 @@
-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
+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::KeccakLite.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, engine=nil )
+    message = message( input )  ## "normalize" / convert to (binary) string
+
+    if engine && ['openssl'].include?( engine.to_s.downcase )
+      puts "  engine: #{engine}"    if debug?
+      digest = OpenSSL::Digest.new( 'SHA3-256' )
+      digest.update( message )
+      digest.digest
+    else  ## use "built-in" hash function from digest module
+      Digest::SHA3Lite.digest( message, 256 )
+    end
+  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

@@ -1,29 +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
+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

@@ -1,23 +1,23 @@
-
-module CryptoLite
-
-  MAJOR = 0
-  MINOR = 3
-  PATCH = 0
-  VERSION = [MAJOR,MINOR,PATCH].join('.')
-
-  def self.version
-    VERSION
-  end
-
-  def self.banner
-    "crypto-lite/#{VERSION} on Ruby #{RUBY_VERSION} (#{RUBY_RELEASE_DATE}) [#{RUBY_PLATFORM}] in (#{root})"
-  end
-
-  def self.root
-    File.expand_path( File.dirname(File.dirname(File.dirname(__FILE__))) )
-  end
-
-end # module CryptoLite
-
-
+
+module CryptoLite
+
+  MAJOR = 0
+  MINOR = 3
+  PATCH = 1
+  VERSION = [MAJOR,MINOR,PATCH].join('.')
+
+  def self.version
+    VERSION
+  end
+
+  def self.banner
+    "crypto-lite/#{VERSION} on Ruby #{RUBY_VERSION} (#{RUBY_RELEASE_DATE}) [#{RUBY_PLATFORM}] in (#{root})"
+  end
+
+  def self.root
+    File.expand_path( File.dirname(File.dirname(File.dirname(__FILE__))) )
+  end
+
+end # module CryptoLite
+
+