elliptic 1.0.0 → 1.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b669851bc198139a145ad4e0fcec669c63e5510836322db51787ceb8d09362c5
-  data.tar.gz: 1a125a73561286cf5670085f910e8c37c0ed48c9564400219885a24526dbe0de
+  metadata.gz: ff30ac78fc3b9f3528bec550afdfffc4bdc7c4f7049edf67280ba48150d6ce95
+  data.tar.gz: bb13fa5c43a30149dab2457a7ef78ec3c6478122e80c8fd450b99ed8e6998f31
 SHA512:
-  metadata.gz: 9f1ed708148cf5c8dd47ab00c22dfeee9ce43f3967c1626b7f1ed90947d0fb01512e2dbbd6ce0e43ef49a913a59abec48c80c86ba95854d89d62f9061c0daaa8
-  data.tar.gz: bb86040e5624540f3f66368b0f1c1759fe2d0e1eaf0bc2c882f0c14d0e72b4cb685de6baebd84008262fb5f07cfe9775fa40394bf79fcef0142642113bab26ad
+  metadata.gz: 48c3b6ffda0ee6f94aa43fe31fc963be9228aba19adff661ad63bbfc8737be084d8db2c412cee9fa85e7cb9d8fee97fb6e46eb0d752dfdc2bbf6ba0dcf6d322b
+  data.tar.gz: fb14d75d44756fe762f86b81425d6e13796bca980a3b8a5bbecef824fe363085366d3af51a6fffbd5de28d113af304960de1b6a06289cf3138c89a2e7915dc3c

data/Manifest.txt

@@ -4,7 +4,12 @@ README.md
 Rakefile
 i/secp256k1.png
 lib/elliptic.rb
+lib/elliptic/private_key.rb
+lib/elliptic/public_key.rb
+lib/elliptic/signature.rb
 lib/elliptic/version.rb
 test/helper.rb
+test/test_decode.rb
+test/test_openssl.rb
 test/test_sign.rb
 test/test_version.rb

data/lib/elliptic/private_key.rb

@@ -0,0 +1,82 @@
+module EC
+
+class PrivateKey
+  def self.convert( *args, **kwargs )
+    if args.size==1 && args[0].is_a?( PrivateKey )
+      args[0]   ## pass through as is (already a private key)
+    else
+      new( args[0], group: kwargs[:group] )
+    end
+  end
+
+
+  def self.decode_pem( str ) new( str ); end
+  def self.decode_der( str ) new( str ); end
+
+  ## todo/check: only use (allow) base64 for
+  ##   der (binary)-encoded? why? why not?
+  def self.decode_base64( str ) new( Base64.decode64(str)); end
+
+  class << self
+    alias_method :from_pem,    :decode_pem
+    alias_method :from_der,    :decode_der
+    alias_method :from_base64, :decode_base64
+  end
+
+
+  def self.generate( group: nil ) new( group: group ); end
+
+
+  def initialize( input=nil, group: nil )
+    if input.nil?     ## auto-generate new key
+        ec_group = GROUP[ group || 'secp256k1' ]
+        @pkey = OpenSSL::PKey::EC.new( ec_group )
+        @pkey.generate_key  # note: will generate private/public key pair
+    elsif input.is_a?( Integer )
+        ec_group = GROUP[ group || 'secp256k1' ]
+        @pkey = OpenSSL::PKey::EC.new( ec_group )
+        @pkey.private_key = OpenSSL::BN.new( input )
+        ## auto-calculate public key too
+        @pkey.public_key = @pkey.group.generator.mul( @pkey.private_key )
+    else  ## assume string with possible der/pem/etc. encoding
+        ## todo/check: add hex-string auto-detect too - why? why not?
+        @pkey = OpenSSL::PKey::EC.new( input )
+        ## todo/check: make sure public key gets restored too with pem/der-encoding??
+    end
+  end
+
+
+  def to_i()  @pkey.private_key.to_i;           end
+  ## todo/check/fix: make it always a 32 byte (64 hex chars) string
+  ##                    even with leading zeros !!! - why? why not?
+  def to_s()  @pkey.private_key.to_i.to_s(16);  end
+
+
+  def to_pem()     @pkey.to_pem; end
+  def to_der()     @pkey.to_der; end
+  def to_base64()  Base64.encode64( to_der ); end
+
+
+
+  def public_key
+    ## cache returned public key - why? why not?
+    @pub ||= PublicKey.new( @pkey.public_key )
+    @pub
+  end
+
+
+  def sign( message )
+    signature_der = @pkey.dsa_sign_asn1( message )
+    Signature.decode_der( signature_der )
+  end
+
+
+  ################
+  ## more helpers for debugging / internals
+  def group()    @pkey.group; end
+  def to_text()  @pkey.to_text; end
+  def private?() @pkey.private?; end    ## todo/check: keep - needed? - why? why not?
+  def public?()  @pkey.public?;  end    ## todo/check: keep - needed? - why? why not?
+end # class PrivateKey
+
+end  ## module EC

data/lib/elliptic/public_key.rb

@@ -0,0 +1,85 @@
+module EC
+
+
+class PublicKey
+  def self.convert( *args, **kwargs )
+    if args.size==1 && args[0].is_a?( PublicKey )
+      args[0]   ## pass through as is (already a public key)
+    else
+      new( *args, group: kwargs[:group] )
+    end
+  end
+
+
+
+  def self.decode_pem( str ) new( str ); end
+  def self.decode_der( str ) new( str ); end
+
+  ## todo/check: only use (allow) base64 for
+  ##   der (binary)-encoded? why? why not?
+  def self.decode_base64( str ) new( Base64.decode64(str)); end
+
+  class << self
+    alias_method :from_pem,      :decode_pem
+    alias_method :from_der,      :decode_der
+    alias_method :from_base64,   :decode_base64
+  end
+
+
+  def initialize( *args, group: nil )
+    if args.size == 2   ## assume (x,y) raw integer points
+        @pt = Point.new( *args, group: group )
+        point = @pt.to_ec_point  ## convert point to openssl (native) class
+        @pkey = OpenSSL::PKey::EC.new( point.group )
+        @pkey.public_key = point
+    elsif args[0].is_a?( Point ) ||
+          args[0].is_a?( OpenSSL::PKey::EC::Point )
+       ##  "restore"  public key (only) from point for verify
+       ## - OpenSSL::PKey::EC::Point   ## assume public key only (restore pkey object for verify?)
+       ## - Point
+        point = if args[0].is_a?( Point )
+                  @pt = args[0]
+                  @pt.to_ec_point
+                else
+                  args[0]   ## assume it is already OpenSSL::PKey::EC::Point
+                end
+
+        ## note: (auto)get group from point
+        @pkey = OpenSSL::PKey::EC.new( point.group )
+        @pkey.public_key = point
+    else  ## assume string in pem/der/base64
+      @pkey = OpenSSL::PKey::EC.new( args[0] )
+    end
+  end
+
+
+
+  def point
+    ## cache returned point - why? why not?
+    @pt ||= Point.new( @pkey.public_key )
+    @pt
+  end
+
+
+  def to_pem()  @pkey.to_pem; end
+  def to_der()  @pkey.to_der; end
+  def to_base64()  Base64.encode64( to_der ); end
+
+
+  def verify?( message, signature )
+    signature_der = signature.to_der
+    @pkey.dsa_verify_asn1( message, signature_der )
+  end
+  alias_method :valid_signature?, :verify?
+
+
+  ###
+  ## more helpers for debugging / internals
+  def group() @pkey.group; end
+  def to_text()  @pkey.to_text; end
+  def private?() @pkey.private?; end    ## todo/check: keep - needed? - why? why not?
+  def public?()  @pkey.public?; end     ## todo/check: keep - needed? - why? why not?
+end # class PublicKey
+
+
+end  ## module EC

data/lib/elliptic/signature.rb

@@ -0,0 +1,41 @@
+module EC
+
+class Signature
+
+  def self.decode_der( der )
+    asn1 = OpenSSL::ASN1.decode( der )
+    r = asn1.value[0].value.to_i
+    s = asn1.value[1].value.to_i
+    new(r, s)
+  end
+
+  def self.decode_base64( str )
+    decode_der( Base64.decode64( str ) )
+  end
+
+  class << self
+    alias_method :from_der,      :decode_der
+    alias_method :from_base64,   :decode_base64
+  end
+
+
+
+  attr_reader :r, :s
+  def initialize(r, s)
+    @r, @s = r, s
+  end
+
+  def to_der
+    asn1 = OpenSSL::ASN1::Sequence.new [
+        OpenSSL::ASN1::Integer.new( @r ),
+        OpenSSL::ASN1::Integer.new( @s ),
+      ]
+    asn1.to_der
+  end
+
+  def to_base64
+     Base64.encode64( to_der ).gsub("\n", '' )
+  end
+end ## class Signature
+
+end  ## module EC

data/lib/elliptic/version.rb

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

data/test/test_decode.rb

@@ -0,0 +1,85 @@
+###
+#  to run use
+#     ruby -I ./lib -I ./test test/test_decode.rb
+
+
+require 'helper'
+
+
+class TestDecode < MiniTest::Test
+
+
+def test_import_export
+
+   private_key = EC::PrivateKey.generate
+   puts "PrivateKey#to_i:"
+   puts private_key.to_i
+   puts "PrivateKey#to_s:"
+   puts private_key.to_s
+   puts "PrivateKey#to_pem:"
+   puts private_key.to_pem
+   puts "PrivateKey#to_der (binary / asn1):"
+   puts private_key.to_der
+   pp private_key.to_der
+   puts "PrivateKey#to_base64:"
+   puts private_key.to_base64
+
+   public_key  = private_key.public_key
+   assert_equal false, public_key.private?  ## make sure (derived) public key has no private key included/attached
+
+   puts "PublicKey#point:"
+   pp public_key.point
+   puts "PublicKey#point.to_s:"
+   puts public_key.point.to_s
+   puts "PublicKey#to_pem:"
+   puts public_key.to_pem
+   puts "PublicKey#to_der (binary / asn1):"
+   puts public_key.to_der
+   pp public_key.to_der
+   puts "PublicKey#to_base64:"
+   puts public_key.to_base64
+
+
+
+   [
+     EC::PrivateKey.new( private_key.to_i ),
+
+     EC::PrivateKey.new( private_key.to_pem ),
+     EC::PrivateKey.decode_pem( private_key.to_pem ),
+
+     EC::PrivateKey.new( private_key.to_der ),
+     EC::PrivateKey.decode_der( private_key.to_der ),
+
+     EC::PrivateKey.decode_base64( private_key.to_base64 ),
+   ].each do |private_key_decoded|
+      assert_equal private_key_decoded.to_i, private_key.to_i
+      assert private_key_decoded.private?
+      assert private_key_decoded.public?
+
+      assert_equal false, private_key_decoded.public_key.private?
+      assert_equal private_key_decoded.public_key.point.to_s, public_key.point.to_s
+      assert_equal private_key_decoded.public_key.point.x, public_key.point.x
+      assert_equal private_key_decoded.public_key.point.y, public_key.point.y
+   end
+
+
+   [
+      EC::PublicKey.new( public_key.point ),
+
+      EC::PublicKey.new( public_key.to_pem ),
+      EC::PublicKey.decode_pem( public_key.to_pem ),
+
+      EC::PublicKey.new( public_key.to_der ),
+      EC::PublicKey.decode_der( public_key.to_der ),
+
+      EC::PublicKey.decode_base64( public_key.to_base64 ),
+   ].each do |public_key_decoded|
+      assert_equal public_key_decoded.point.to_s, public_key.point.to_s
+      assert_equal public_key_decoded.point.x, public_key.point.x
+      assert_equal public_key_decoded.point.y, public_key.point.y
+      assert public_key_decoded.public?
+      assert_equal false, public_key_decoded.private?
+   end
+end
+
+end # class TestDecode

data/test/test_openssl.rb

@@ -0,0 +1,40 @@
+###
+#  to run use
+#     ruby -I ./lib -I ./test test/test_openssl.rb
+
+
+require 'helper'
+
+
+## test some "basic" openssl (binding) machinery
+##  for source, see https://github.com/ruby/openssl
+
+class TestOpenssl < MiniTest::Test
+
+def test_version
+  puts "OPENSSL_VERSION: #{OpenSSL::OPENSSL_VERSION}"
+  puts "OPENSSL_LIBRARY_VERSION: #{OpenSSL::OPENSSL_LIBRARY_VERSION}"
+end
+
+
+def test_bn
+  [999,
+   -999,
+   2**107-1,
+  -(2**107-1)].each do |num|
+     assert_equal OpenSSL::BN.new( num ), num.to_bn
+  end
+end
+
+def test_bn_to_hex
+  [
+    [999,  "03E7"],
+    [-999, "-03E7"],
+    [2**107-1, "07FFFFFFFFFFFFFFFFFFFFFFFFFF"],
+    [-(2**107-1), "-07FFFFFFFFFFFFFFFFFFFFFFFFFF"]
+  ].each do |item|
+     assert_equal item[1], item[0].to_bn.to_s(16)
+  end
+end
+
+end # class TestOpenssl

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: elliptic
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 1.0.1
 platform: ruby
 authors:
 - Gerald Bauer
@@ -60,8 +60,13 @@ files:
 - Rakefile
 - i/secp256k1.png
 - lib/elliptic.rb
+- lib/elliptic/private_key.rb
+- lib/elliptic/public_key.rb
+- lib/elliptic/signature.rb
 - lib/elliptic/version.rb
 - test/helper.rb
+- test/test_decode.rb
+- test/test_openssl.rb
 - test/test_sign.rb
 - test/test_version.rb
 homepage: https://github.com/rubycoco/blockchain