elliptic-lite 0.1.0

data/lib/elliptic-lite/signature.rb

@@ -0,0 +1,62 @@
+###########
+#  Elliptic Curve Digital Signature Algorithm (ECDSA)
+
+module ECC
+
+
+class Signature
+  attr_reader :r, :s
+  def initialize( r, s )
+    @r, @s = r, s
+  end
+end # class Signature
+
+
+class PublicKey
+  attr_reader :point
+
+  def initialize( *args, group: SECP256K1 )
+    @group = group
+
+    if args.size == 1     ## assume it's a point already -- todo/fix: check class via group - why? why not?
+      @point = args[0]
+    elsif args.size == 2  ## assume it's an x/y coord pair -- todo/fix: check must be Integer class/type - why? why not?
+      @point = @group.point( *args )
+    else
+      raise ArgumentError, "expected point or x/y coords for point; got: #{args.inspect}"
+    end
+  end
+
+  def verify?( z, sig )
+    s_inv = sig.s.pow( @group.n-2, @group.n )
+    u = z * s_inv % @group.n
+    v = sig.r * s_inv % @group.n
+
+    total = u*@group.g + v*@point
+    total.x == sig.r
+  end
+end # class PublicKey
+
+
+class PrivateKey
+  def initialize( secret, group: SECP256K1 )
+    @secret = secret
+    @group  = group
+  end
+
+  def public_key
+    @pubkey ||= PublicKey.new( @secret * @group.g, group: @group )
+  end
+  alias_method :pubkey, :public_key
+
+  def sign( z )
+    k = 1 + SecureRandom.random_number( @group.n - 1)
+    # k = 1234567890
+    r = (k*@group.g).x
+    k_inv = k.pow( @group.n-2, @group.n )
+    s = (z+r*@secret) * k_inv % @group.n
+    s = @group.n - s   if s > @group.n/2
+    Signature.new( r, s )
+  end
+end # class PrivateKey
+end # module ECC

data/lib/elliptic-lite/version.rb

@@ -0,0 +1,20 @@
+module ECCLite
+
+  MAJOR = 0
+  MINOR = 1
+  PATCH = 0
+  VERSION = [MAJOR,MINOR,PATCH].join('.')
+
+  def self.version
+    VERSION
+  end
+
+  def self.banner
+    "elliptic-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 ECCLite

data/lib/elliptic/lite.rb

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

data/test/helper.rb

@@ -0,0 +1,12 @@
+## $:.unshift(File.dirname(__FILE__))
+
+## minitest setup
+
+require 'minitest/autorun'
+
+
+## our own code
+
+require 'elliptic-lite/base'
+
+

data/test/test_field.rb

@@ -0,0 +1,142 @@
+###
+#  to run use
+#     ruby -I ./lib -I ./test test/test_field.rb
+
+
+require 'helper'
+
+class TestField < MiniTest::Test
+
+## same as F13 = FiniteField.new(13) - use shortcut - why? why not?
+class F₁₃ < ECC::FiniteField::Element
+  def self.prime() 13; end
+end
+
+
+def test_f13
+  pp F₁₃
+  pp F₁₃.prime
+  assert_equal 13, F₁₃.prime
+
+  assert F₁₃.include?( 0 )
+  assert F₁₃.include?( 12 )
+  assert_equal false, F₁₃.include?( 13 )
+
+
+  pp F₁₃.new(7)
+  pp F₁₃.new(6)
+
+  a = F₁₃[7]
+  b = F₁₃[6]
+
+  assert_equal false, a == b
+  assert_equal false, F₁₃[7] == F₁₃[6]
+
+  assert a == a
+  assert F₁₃[7] == F₁₃[7]
+
+
+
+  a = F₁₃[7]
+  b = F₁₃[12]
+  c = F₁₃[6]
+
+  assert_equal c, a+b
+  assert_equal 6, F₁₃.add( 7, 12 )
+
+  c = F₁₃[8]
+  assert_equal c, a-b
+  assert_equal F₁₃[8], a-b
+  assert_equal 8, F₁₃.sub( 7, 12 )
+
+  a = F₁₃[3]
+  b = F₁₃[12]
+  c = F₁₃[10]
+
+  assert_equal c, a*b
+  assert_equal F₁₃[10], F₁₃[3]*F₁₃[12]
+  assert_equal 10, F₁₃.mul( 3, 12 )
+
+
+  a = F₁₃[3]
+  b = F₁₃[1]
+  assert_equal b, a**3
+  assert_equal b, a*a*a
+  assert_equal a**3, a*a*a
+  assert_equal 1, F₁₃.pow( 3, 3 )
+
+  a = F₁₃[7]
+  b = F₁₃[8]
+
+  pp a**-3
+  assert_equal b, a**-3
+  assert_equal 8, F₁₃.pow( 7, -3 )
+end
+
+
+
+class F₁₇ < ECC::FiniteField::Element
+  def self.prime() 17; end
+end
+
+def test_f17
+  pp F₁₇.new(7)
+  assert F₁₇.new(7) == F₁₇[7]
+  assert F₁₇.new(7) == F₁₇.new(7)
+  assert F₁₇[7] == F₁₇[7]
+end
+
+
+F₁₉ = ECC::FiniteField.new(19)
+
+def test_f19
+   a = F₁₉[2]
+   b = F₁₉[7]
+   c = a / b
+
+   assert_equal F₁₉[3], c
+
+   assert_equal F₁₉[9], F₁₉[7] / F₁₉[5]
+   assert_equal 9, F₁₉.div( 7, 5 )
+end
+
+
+def test_examples
+   a = F₁₃[7]
+   b = F₁₃[12]
+   c = F₁₃[6]
+   assert_equal c, a+b
+
+   c = F₁₃[8]
+   assert_equal c, a-b
+
+   a = F₁₃[3]
+   b = F₁₃[12]
+   c = F₁₃[10]
+   assert_equal c, a*b
+
+   a = F₁₃[3]
+   b = F₁₃[1]
+   assert_equal b, a**3
+   assert_equal b, a*a*a
+   assert_equal a**3, a*a*a
+
+   a = F₁₉[2]
+   b = F₁₉[7]
+   c = F₁₉[3]
+   assert_equal c, a/b
+
+
+   assert_equal F₁₃[6],  F₁₃[7] + F₁₃[12]
+   assert_equal F₁₃[8],  F₁₃[7] - F₁₃[12]
+   assert_equal F₁₃[10], F₁₃[3] * F₁₃[12]
+   assert_equal F₁₃[1],  F₁₃[3] ** 3
+   assert_equal F₁₃[1],  F₁₃[3] * F₁₃[3] * F₁₃[3]
+   assert_equal F₁₃[3] * F₁₃[3] * F₁₃[3], F₁₃[3] ** 3
+
+   assert_equal F₁₉[3],  F₁₉[2] / F₁₉[7]
+end
+
+end # class TestField
+
+

data/test/test_point.rb

@@ -0,0 +1,83 @@
+###
+#  to run use
+#     ruby -I ./lib -I ./test test/test_point.rb
+
+
+require 'helper'
+
+class TestPoint < MiniTest::Test
+
+  class Point_5_7 < ECC::Point
+    def self.curve() @curve ||= ECC::Curve.new( a: 5, b: 7 ); end
+  end
+
+  def test_point_5_7
+    p1 = Point_5_7.new( -1, -1 )   # point with x/y coords: -1/-1
+    ## p2 = Point_5_7.new( -1, -2 )   # raise ArgumentError!! point NOT on curve
+
+    assert              Point_5_7.on_curve?( -1, -1 )  #=> true
+    assert_equal false, Point_5_7.on_curve?( -1, -2 )  #=> false
+
+    inf = Point_5_7[ :infinity ]
+    assert              inf.infinity?                 #=> true
+
+    p1  = Point_5_7[-1, -1]
+    p2  = Point_5_7[-1,  1]
+    inf = Point_5_7[ :infinity ]
+
+    assert Point_5_7[-1,-1],     p1  + inf
+    assert Point_5_7[-1,1],      inf + p2
+    assert Point_5_7[:infinity], p1  + p2
+
+    p1 = Point_5_7[ 2, 5]
+    p2 = Point_5_7[-1,-1]
+    assert Point_5_7[3,-7], p1 + p2
+
+    p1 = Point_5_7[-1,-1]
+    assert Point_5_7[18,77], p1 + p1
+  end
+
+
+
+  class F₂₂₃ < ECC::FiniteField::Element
+    def self.prime() 223; end
+  end
+
+  class Point_F₂₂₃0_7 < ECC::Point
+    def self.curve() @curve ||= ECC::Curve.new( a: 0, b: 7, f: F₂₂₃ ); end
+  end
+
+
+  def test_point_f₂₂₃0_7
+    p1 = Point_F₂₂₃0_7[ 192, 105 ]
+    p2 = Point_F₂₂₃0_7[ 17, 56 ]
+    assert Point_F₂₂₃0_7[170,142],  p1 + p2
+
+    p1 = Point_F₂₂₃0_7[ 170, 142 ]
+    p2 = Point_F₂₂₃0_7[ 60, 139 ]
+    assert Point_F₂₂₃0_7[220,181], p1 + p2
+
+    p1 = Point_F₂₂₃0_7[ 47, 71 ]
+    p2 = Point_F₂₂₃0_7[ 17, 56 ]
+    assert Point_F₂₂₃0_7[215,68], p1 + p2
+
+
+    p    = Point_F₂₂₃0_7[ 192, 105 ]
+    assert Point_F₂₂₃0_7[49,71], p+p
+
+    p    = Point_F₂₂₃0_7[ 143, 98 ]
+    assert Point_F₂₂₃0_7[64,168], p+p
+
+    p    = Point_F₂₂₃0_7[ 47, 71 ]
+    assert Point_F₂₂₃0_7[36,111], p+p
+    assert Point_F₂₂₃0_7[194,51], p+p+p+p
+    assert Point_F₂₂₃0_7[116,55], p+p+p+p+p+p+p+p
+    assert Point_F₂₂₃0_7[:infinity], p+p+p+p+p+p+p+p+p+p+p+p+p+p+p+p+p+p+p+p+p
+
+    assert 2*p, p+p
+    assert 4*p, p+p+p+p
+    assert 8*p, p+p+p+p+p+p+p+p
+    assert 21*p, p+p+p+p+p+p+p+p+p+p+p+p+p+p+p+p+p+p+p+p+p
+  end
+end # class TestPoint
+

data/test/test_signature.rb

@@ -0,0 +1,61 @@
+###
+#  to run use
+#     ruby -I ./lib -I ./test test/test_signature.rb
+
+
+require 'helper'
+
+class TestSignature < MiniTest::Test
+
+  def test_verify
+    puts "test_verify:"
+    pubkey = ECC::PublicKey.new(
+               0x887387e452b8eacc4acfde10d9aaf7f6d9a0f975aabb10d006e4da568744d06c,
+               0x61de6d95231cd89026e286df3b6ae4a894a3378e393e93a0f45b666329a0ae34 )
+    pp pubkey
+
+    z = 0xec208baa0fc1c19f708a9ca96fdeff3ac3f230bb4a7ba4aede4942ad003c0f60
+    sig = ECC::Signature.new(
+            0xac8d1c87e51d0d441be8b3dd5b05c8795b48875dffe00b7ffcfac23010d3a395,
+            0x68342ceff8935ededd102dd876ffd6ba72d6a427a3edb13d26eb0781cb423c4)
+
+    assert pubkey.verify?( z, sig )
+
+
+    z = 0x7c076ff316692a3d7eb3c3bb0f8b1488cf72e1afcd929e29307032997a838a3d
+    sig = ECC::Signature.new(
+            0xeff69ef2b1bd93a66ed5219add4fb51e11a840f404876325a1e8ffe0529a2c,
+            0xc7207fee197d27c618aea621406f6bf5ef6fca38681d82b2f06fddbdce6feab6)
+
+    assert pubkey.verify?( z, sig )
+  end
+
+  def test_sign
+    puts "test_sign:"
+    e = 12345
+    key = ECC::PrivateKey.new( e )
+
+    pp z_hex = Digest::SHA256.hexdigest( 'Programming Elliptic Curve Cryptography!' )
+    pp z = z_hex.to_i( 16 )
+
+    sig = key.sign( z )
+    pp sig
+
+
+    pp pubkey = key.pubkey
+
+    assert pubkey.verify?( z, sig )
+
+    # -or-
+    pubkey = ECC::PublicKey.new(
+                   0xf01d6b9018ab421dd410404cb869072065522bf85734008f105cf385a023a80f,
+                   0x0eba29d0f0c5408ed681984dc525982abefccd9f7ff01dd26da4999cf3f6a295 )
+
+    sig = ECC::Signature.new(
+            35839919642726191515862186078164267963984698217861116280002507416364797996230,
+            34481949470477153440646085306694123309931748956488082604284303792820502002529 )
+
+    assert pubkey.verify?( z, sig )
+  end
+end  # class TestSignature
+

metadata

@@ -0,0 +1,103 @@
+--- !ruby/object:Gem::Specification
+name: elliptic-lite
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Gerald Bauer
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2021-06-06 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rdoc
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '4.0'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '7'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '4.0'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '7'
+- !ruby/object:Gem::Dependency
+  name: hoe
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.22'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.22'
+description: elliptic-lite - elliptic curve cryptography from scratch / zero - start
+  with finite fields, add elliptic curve points and point addition and scalar multiplications,
+  add the elliptic curve digital signature algorithm (ECDSA) using the secp256k1 curve
+  / group to sign and verify messages and more
+email: wwwmake@googlegroups.com
+executables: []
+extensions: []
+extra_rdoc_files:
+- CHANGELOG.md
+- Manifest.txt
+- README.md
+files:
+- CHANGELOG.md
+- Manifest.txt
+- README.md
+- Rakefile
+- lib/elliptic-lite.rb
+- lib/elliptic-lite/base.rb
+- lib/elliptic-lite/field.rb
+- lib/elliptic-lite/point.rb
+- lib/elliptic-lite/secp256k1.rb
+- lib/elliptic-lite/signature.rb
+- lib/elliptic-lite/version.rb
+- lib/elliptic/lite.rb
+- test/helper.rb
+- test/test_field.rb
+- test/test_point.rb
+- test/test_signature.rb
+homepage: https://github.com/rubycoco/blockchain
+licenses:
+- Public Domain
+metadata: {}
+post_install_message:
+rdoc_options:
+- "--main"
+- README.md
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '2.3'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.1.4
+signing_key:
+specification_version: 4
+summary: elliptic-lite - elliptic curve cryptography from scratch / zero - start with
+  finite fields, add elliptic curve points and point addition and scalar multiplications,
+  add the elliptic curve digital signature algorithm (ECDSA) using the secp256k1 curve
+  / group to sign and verify messages and more
+test_files: []