elliptic 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ef1dcaf22384ecedc56973cf3e2a75bb5da817bb6d5dcaa65f5559e48d4731d4
-  data.tar.gz: a4b7cf7b207cddae72ddd7a5a2cd848fe41e824d56284f46ffb65e3332f96d50
+  metadata.gz: 50c1f0afa4d55fd9b936ddc1ef0c38ede63054432aae99aa2b717ba21bc819c7
+  data.tar.gz: e9d57e5bfece39941288e66fd9b087d99660dfa25a42e723b69f96f85c690fd0
 SHA512:
-  metadata.gz: f78242b719f4871949419099adde1cb3f209d11f176f761aefba7d7828a597ff30f1e4b75fae8ed1048612a226f9dabc4758f21be01466c486851ee483f00a84
-  data.tar.gz: e4561b2707ec6c5dce8e5e09d7dbc516dc5434dbbce7e03e773f6ef8ff0aff7610c9998da0e9c27b9baec976b71e97dccc853c8e9c548a5904476a5297822475
+  metadata.gz: 56cc6e7d72f921b61701d6ca2d1d25383b91377607752db4f96a7d12c56881fdfda1bcccfe2177ff8695114de81822ea9fbc8b0ccecfa1546f4c678393b2b933
+  data.tar.gz: c8ec4acab2b3495b8937bee4e7488d6d3922b31a6ec13473a877ea30249319e0c8eacc4c89062cd76d3e1a4c078c95d36579b2b420b2a55e931ace6be9b69692

data/README.md

@@ -73,10 +73,10 @@ An ECDSA (Elliptic Curve Digital Signature Algorithm) private key is a random nu
 ``` ruby
 require 'elliptic'
 
-# note: Algo will auto-generate (random) private key if no private key passed in
-algo = EC::Algo.new    # by default uses Secp256k1 curve (used in Bitcoin and Ethereum)
+# Auto-generate (random) private key
+private_key = EC::PrivateKey.generate    # by default uses Secp256k1 curve (used in Bitcoin and Ethereum)
 
-algo.private_key
+private_key.to_i
 #=> 72190737707147846840353520312904745954595478835413056312168022784020322830309
 ```
 
@@ -92,11 +92,10 @@ Let's try:
 
 ``` ruby
 # This private key is just an example. It should be much more secure!
-privatekey = 1234
+private_key = EC::PrivateKey.new( 1234 )   # by default uses Secp256k1 curve (used in Bitcoin and Ethereum)
 
-# Elliptic curve (EC) machinery - pass in our own key
-algo = EC::Algo.new( privatekey )  # by default uses Secp256k1 curve (used in Bitcoin and Ethereum)
-point = algo.public_key    ## the "magic" one-way K=k*G curve multiplication (K=public key,k=private key, G=generator point)
+public_key =  private_key.public_key   ## the "magic" one-way K=k*G curve multiplication (K=public key,k=private key, G=generator point)
+point = public_key.point
 
 point.x
 #=> 102884003323827292915668239759940053105992008087520207150474896054185180420338
@@ -120,10 +119,12 @@ tx = 'from: Alice  to: Bob     cryptos: 43_000_000_000'
 txhash = Digest::SHA256.digest( tx )
 
 # Step 2 - Get the Signer's Private key
-privatekey = 1234     # This private key is just an example. It should be much more secure!
+private_key = EC::PrivateKey.new( 1234 )     # This private key is just an example. It should be much more secure!
 
 # Sign!
-signature = EC.sign( txhash, privatekey )
+signature = private_key.sign( txhash )
+# -or-
+signature = EC.sign( txhash, private_key )
 
 signature.r
 #=> 80563021554295584320113598933963644829902821722081604563031030942154621916407
@@ -145,7 +146,7 @@ tx = 'from: Alice  to: Bob     cryptos: 43_000_000_000'
 txhash = Digest::SHA256.digest( tx )
 
 # Step 2 - Get the Signer's Public Key
-pubkey = EC::Point.new(
+public_key = EC::PublicKey.new(
    102884003323827292915668239759940053105992008087520207150474896054185180420338,
    49384988101491619794462775601349526588349137780292274540231125201115197157452
 )
@@ -157,13 +158,15 @@ signature = EC::Signature.new(
 )
 
 # Don't Trust - Verify
-EC.valid_signature?( txhash, pubkey, signature )
+public_key.verify?( txhash, signature )
+# -or-
+EC.verify?( txhash, signature, public_key )
 #=> true
 
 
 # or using hexadecimal numbers
 
-pubkey = EC::Point.new(
+public_key = EC::PublicKey.new(
   0xe37648435c60dcd181b3d41d50857ba5b5abebe279429aa76558f6653f1658f2,
   0x6d2ee9a82d4158f164ae653e9c6fa7f982ed8c94347fc05c2d068ff1d38b304c
 )
@@ -173,7 +176,9 @@ signature = EC::Signature.new(
   0x4fe202bb0835758f514cd4a0787986f8f6bf303df629dc98c5b1a438a426f49a
 )
 
-EC.valid_signature?( txhash, pubkey, signature )
+public_key.verify?( txhash, signature )
+# -or-
+EC.verify?( txhash, signature, public_key )
 #=> true
 ```
 

data/lib/elliptic.rb

@@ -66,8 +66,7 @@ module EC
 
          ## encoded_point is the octet string representation of the point.
          ## This must be either a String or an OpenSSL::BN
-         prefix = '04'
-         hex = prefix + ("%064x" % @x) + ("%064x" % @y)
+         hex = '04' + ("%064x" % @x) + ("%064x" % @y)
          bin = [hex].pack( 'H*' )
 
          ec_group = GROUP[ group || 'secp256k1' ]
@@ -89,62 +88,54 @@ module EC
     end
 
     ## return OpenSSL::PKey::EC::Point - find a better name? e.g. to_raw/native or such - why? why not?
-    def to_point()  @pt; end
+    def to_ec_point()  @pt; end
   end
 
 
 
 
-  class Algo
-    def initialize( input=nil, group: nil )
-
-     ## case 1) "restore"  public key (only) from point for verify
-     if input.is_a?( OpenSSL::PKey::EC::Point ) ||  ## assume public key only (restore pkey object for verify?)
-        input.is_a?( Point )
-
-       point = input.is_a?( Point ) ? input.to_point : input
-
-       ## note: (auto)get group from point
-       @pkey = OpenSSL::PKey::EC.new( point.group )
-       @pkey.public_key = point
-     else  ## case 2) build a private/public key pair
-
-       ec_group = GROUP[ group || 'secp256k1' ]
-       @pkey = OpenSSL::PKey::EC.new( ec_group )
-
-       if input.nil?     ## auto-generate new key
-         @pkey.generate_key
-       else
-         num = if input.is_a?( String )
-                 input.to_i( 16 )
-               else   ## assume (big) integer
-                 input
-               end
-         @pkey.private_key = OpenSSL::BN.new( num )
-         ## auto-calculate public key too
-         @pkey.public_key = @pkey.group.generator.mul( @pkey.private_key )
-       end
+  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 group() @pkey.group; end
 
-    def public?()   @pkey.public?; end
-    def private?()  @pkey.private?; end
+    def initialize( *args, group: nil )
+      point = if args.size == 2   ## assume (x,y) raw integer points
+                 @pt = Point.new( *args, group: group )
+                 @pt.to_ec_point ## convert point to openssl (native) class
+              else
+                ##  "restore"  public key (only) from point for verify
+                ## - OpenSSL::PKey::EC::Point   ## assume public key only (restore pkey object for verify?)
+                ## - 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
+              end
+
+      ## note: (auto)get group from point
+      @pkey = OpenSSL::PKey::EC.new( point.group )
+      @pkey.public_key = point
+    end
 
+    def group() @pkey.group; end
 
-    ## todo/check/fix: fix case with no private_key if passed in point/public key for verify!!!
-    def private_key() @pkey.private_key.to_i; end
-    alias_method :priv_key, :private_key   ## add signing_key alias too?
 
-    def public_key() @public_key ||= Point.new( @pkey.public_key ); end
+    def point
+      ## cache returned point - why? why not?
+      @pt ||= Point.new( @pkey.public_key )
+      @pt
+    end
 
 
-    def sign( message )
-      signature_der = @pkey.dsa_sign_asn1( message )
-      Signature.decode_der( signature_der )
-    end
 
     def verify?( message, signature )
       signature_der = signature.to_der
@@ -152,20 +143,81 @@ module EC
     end
     alias_method :valid_signature?, :verify?
 
-
+    ## helpers for debugging
     def to_text() @pkey.to_text; end
-  end
+    def public?() @pkey.public?; end   ## todo/check: keep - needed? - why? why not?
+  end # class PublicKey
+
+
+
+
+  class PrivateKey
+    def self.convert( *args, **kwargs )
+      if args.size==1 && args[0].is_a?( PrivateKey )
+        args[0]   ## pass through as is (alread a private key)
+      else
+        new( args[0], group: kwargs[:group] )
+      end
+    end
+
+
+    def self.generate( group: nil ) new( group: group ); end
+
+    def initialize( input=nil, group: nil )
+      ec_group = GROUP[ group || 'secp256k1' ]
+      @pkey = OpenSSL::PKey::EC.new( ec_group )
+
+      if input.nil?     ## auto-generate new key
+        @pkey.generate_key
+      else
+        num = if input.is_a?( String )  ## assume hex string
+                input.to_i( 16 )
+              else                      ## assume integer
+                input
+              end
+        @pkey.private_key = OpenSSL::BN.new( num )
+        ## auto-calculate public key too
+        @pkey.public_key = @pkey.group.generator.mul( @pkey.private_key )
+      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 group() @pkey.group; 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
+
+    ## helpers for debugging
+    def to_text()  @pkey.to_text; end
+    def private?() @pkey.private?; end    ## todo/check: keep - needed? - why? why not?
+ end # class PrivateKey
+
+
 
 
 
   def self.sign( message, priv_key )
-    algo = Algo.new( priv_key )
-    algo.sign( message )
+    signer = PrivateKey.convert( priv_key )
+    signer.sign( message )
   end
 
-  def self.verify?( message, pub_key, signature )
-    algo = Algo.new( pub_key )
-    algo.verify?( message, signature )
+  def self.verify?( message, signature, pub_key )
+    verifier = PublicKey.convert( pub_key )
+    verifier.verify?( message, signature )
   end
 
   class << self

data/lib/elliptic/version.rb

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

data/test/test_sign.rb

@@ -10,76 +10,76 @@ class TestSign < MiniTest::Test
 
 
 def test_keys
-  algo = EC::Algo.new( 1234 )
-  assert_equal 1234,        algo.private_key
-  assert_equal "secp256k1", algo.group.curve_name
+  private_key = EC::PrivateKey.new( 1234 )
+  assert_equal 1234,        private_key.to_i
+  assert_equal "secp256k1", private_key.group.curve_name
 
-  public_key = algo.public_key
+  public_key = private_key.public_key
   assert_equal 102884003323827292915668239759940053105992008087520207150474896054185180420338,
-               public_key.x
+               public_key.point.x
 
   assert_equal 49384988101491619794462775601349526588349137780292274540231125201115197157452,
-              public_key.y
+              public_key.point.y
 
   assert_equal "e37648435c60dcd181b3d41d50857ba5b5abebe279429aa76558f6653f1658f2",
-               public_key.x.to_s(16)
+               public_key.point.x.to_s(16)
   assert_equal "6d2ee9a82d4158f164ae653e9c6fa7f982ed8c94347fc05c2d068ff1d38b304c",
-               public_key.y.to_s(16)
+               public_key.point.y.to_s(16)
 
   assert_equal "02e37648435c60dcd181b3d41d50857ba5b5abebe279429aa76558f6653f1658f2",
-               public_key.to_s( :compressed )
+               public_key.point.to_s( :compressed )
 
   assert_equal "04e37648435c60dcd181b3d41d50857ba5b5abebe279429aa76558f6653f1658f26d2ee9a82d4158f164ae653e9c6fa7f982ed8c94347fc05c2d068ff1d38b304c",
-               public_key.to_s
+               public_key.point.to_s
 end
 
 def test_sign
-  algo = EC::Algo.new( 1234 )
-  priv_key = algo.private_key
+  private_key = EC::PrivateKey.new( 1234 )
 
   message  = Digest::SHA256.digest( "hello" )
 
   ## note: sign uses a secure random generated temp key
   ##           every signature is different!!!
-  signature = EC.sign( message, priv_key )
+  signature = EC.sign( message, private_key )
   pp signature.to_der
 
-  signature = EC.sign( message, priv_key )
+  signature = EC.sign( message, private_key )
   pp signature.to_der
 
-  signature = EC.sign( message, priv_key )
+  signature = private_key.sign( message )
   pp signature.to_der
 
-  pp algo.sign( message )
+  signature = private_key.sign( message )
+  pp signature.to_der
 
 
   ### verify
-  public_key = algo.public_key
+  public_key = private_key.public_key
 
-  assert EC.verify?( message, public_key, signature )
-  assert EC.valid_signature?( message, public_key, signature )
+  assert EC.verify?( message, signature, public_key )
+  assert EC.valid_signature?( message, signature, public_key  )
 
-  assert algo.verify?( message, signature )
-  assert algo.valid_signature?( message, signature )
+  assert public_key.verify?( message, signature )
+  assert public_key.valid_signature?( message, signature )
 
   ## public key from point (x,y)
   point = EC::Point.new(
      102884003323827292915668239759940053105992008087520207150474896054185180420338,
      49384988101491619794462775601349526588349137780292274540231125201115197157452)
-  assert EC.verify?( message, point, signature )
+  assert EC.verify?( message, signature, point )
 
   ## signature from r,s values
   signature = EC::Signature.new(
      17435452009115387225781053203681496505351828576563920844344513414624978140095,
      57357162317582879484266879619863223941116872722080991745355058707843528515381)
-  assert EC.verify?( message, point, signature )
+  assert EC.verify?( message, signature, point )
 
 
 
   ## tamper with message
   message  = Digest::SHA256.digest( "hellox" )
-  assert_equal false,  EC.verify?( message, public_key, signature )
-  assert_equal false,  algo.verify?( message, signature )
+  assert_equal false,  EC.verify?( message, signature, public_key )
+  assert_equal false,  public_key.verify?( message, signature )
 end
 
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: elliptic
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - Gerald Bauer
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-01-22 00:00:00.000000000 Z
+date: 2021-01-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rdoc