ecdsa_ext 0.2.1 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d034afcff3fe0f7bcdd0a201387242296617c4115c8a5e5c17be9c55727aa7b5
-  data.tar.gz: 94ca9bd31bd199527df5e77d82bfad340d81a869675ecaec0dec2f41c63a4ae7
+  metadata.gz: fa41cad7e597e74cfabf27c0dd026aa60b47f64419d8c17e56653fe68d863e4c
+  data.tar.gz: 35754ec99989184df9f3ceabdf2d6c946ed55d810e0753b34b3a9779aa04eb1b
 SHA512:
-  metadata.gz: 57ce381df7da79e9e4853c1e0f9e7a67157a49c7e6701db9076eec31f41b6e87e6e03350280c833d9b5d91c125ca3619364c96b9e621688b5f5b0ea09456f7d5
-  data.tar.gz: 75ecb95e6e18a751dea27a435555b6ae4dc583c93c5dda206a7a9bfd24fbda045d6a09a715f4d962060165aad0c961366977d4092743f3755e0cc04080731e20
+  metadata.gz: c0f9f06b62b6ca56b4c374d665f600d3750204b9b3a91651069f4416a08869c58148158c53cc9b981c3508703c3451b93541c4dbbe72f43cda4364c03ffbd507
+  data.tar.gz: 26f3e2e7313ff913d4b03b91ac3bcc0daa17ca3d8c2f1b3f43a049140f7fd9ba367ccad84913882decdbacc2a06304e40ae3a3add342b86103e980d5df341257

data/Gemfile

@@ -12,4 +12,6 @@ gem "rspec", "~> 3.0"
 gem 'prettier'
 
 gem 'rubocop-rake'
-gem 'rubocop-rspec'
+gem 'rubocop-rspec'
+
+gem 'benchmark-ips'

data/README.md

@@ -75,4 +75,11 @@ projective_point4_neg = projective_point4.negate
 require 'ecdsa_ext'
 
 affine_point = projective_point4.to_affine
-```
+```
+
+### Use jacobian coordinates
+
+Jacobian coordinates have been supported since 0.3.0.
+
+When using Jacobian coordinates, use `ECDSA::Ext::JacobianPoint` instead of `ECDSA::Ext::ProjectivePoint`.
+In addition, `ECDSA::Point` now has a `to_jacobian` method that convert affine coordinates to jacobian coordinates.

data/ecdsa_ext.gemspec

@@ -22,7 +22,7 @@ Gem::Specification.new do |spec|
   # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
   spec.files = Dir.chdir(File.expand_path(__dir__)) do
     `git ls-files -z`.split("\x0").reject do |f|
-      (f == __FILE__) || f.match(%r{\A(?:(?:test|spec|features)/|\.(?:git|travis|circleci)|appveyor)})
+      (f == __FILE__) || f.match(%r{\A(?:(?:test|spec|features|bench)/|\.(?:git|travis|circleci)|appveyor)})
     end
   end
   spec.bindir = "exe"

data/lib/ecdsa/ext/jacobian_arithmetic.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+module ECDSA
+  module Ext
+    # Point arithmetic implementation
+    module JacobianArithmetic
+      def add_with_z_one(a, b)
+        field = a.field
+        h = field.mod(b.x - a.x)
+        hh = field.square(h)
+        i = field.mod(4 * hh)
+        j = field.mod(h * i)
+        r = field.mod(2 * (b.y - a.y))
+        return double_with_z_one(a) if h.zero? && r.zero?
+        v = field.mod(a.x * i)
+        x3 = field.mod(field.square(r) - j - 2 * v)
+        y3 = field.mod(r * (v - x3) - 2 * a.y * j)
+        z3 = field.mod(2 * h)
+        JacobianPoint.new(a.group, x3, y3, z3)
+      end
+
+      def add_with_z_eq(a, b)
+        field = a.field
+        a = field.square(field.mod(b.x - a.x))
+        b = field.mod(a.x * a)
+        c = field.mod(b.x * a)
+        d = field.square(field.mod(b.y - a.y))
+        return double(a) if a.zero? && d.zero?
+        x3 = field.mod(d - b - c)
+        y3 = field.mod((b.y - a.y) * (b - x3) - a.y * (c - b))
+        z3 = field.mod(a.z * (b.x - a.x))
+        JacobianPoint.new(a.group, x3, y3, z3)
+      end
+
+      def add_with_z2_one(a, b)
+        field = a.field
+        z1z1 = field.square(a.z)
+        u2 = field.mod(b.x * z1z1)
+        s2 = field.mod(b.y * a.z * z1z1)
+        h = field.mod(u2 - a.x)
+        hh = field.square(h)
+        i = field.mod(4 * hh)
+        j = field.mod(h * i)
+        r = field.mod(2 * (s2 - a.y))
+        return double_with_z_one(b) if r.zero? && h.zero?
+        v = field.mod(a.x * i)
+        x3 = field.mod(r * r - j - 2 * v)
+        y3 = field.mod(r * (v - x3) - 2 * a.y * j)
+        z3 = field.mod(field.square(a.z + h) - z1z1 - hh)
+        JacobianPoint.new(a.group, x3, y3, z3)
+      end
+
+      def add_with_z_ne(a, b)
+        field = a.field
+        z1z1 = field.square(a.z)
+        z2z2 = field.square(b.z)
+        u1 = field.mod(a.x * z2z2)
+        u2 = field.mod(b.x * z1z1)
+        s1 = field.mod(a.y * b.z * z2z2)
+        s2 = field.mod(b.y * a.z * z1z1)
+        h = field.mod(u2 - u1)
+        i = field.mod(4 * h * h)
+        j = field.mod(h * i)
+        r = field.mod(2 * (s2 - s1))
+        return double(a) if h.zero? && r.zero?
+        v = field.mod(u1 * i)
+        x3 = field.mod(r * r - j - 2 * v)
+        y3 = field.mod(r * (v - x3) - 2 * s1 * j)
+        z3 = field.mod((field.square(a.z + b.z) - z1z1 - z2z2) * h)
+        JacobianPoint.new(a.group, x3, y3, z3)
+      end
+
+      def double_with_z_one(point)
+        field = point.field
+        xx = field.square(point.x)
+        yy = field.square(point.y)
+        yyyy = field.square(yy)
+        s = field.mod(2 * (field.square(point.x + yy) - xx - yyyy))
+        m = field.mod(3 * xx + point.group.param_a)
+        t = field.mod(m * m - 2 * s)
+        y3 = field.mod(m * (s - t) - 8 * yyyy)
+        z3 = field.mod(2 * point.y)
+        JacobianPoint.new(point.group, t, y3, z3)
+      end
+    end
+  end
+end

data/lib/ecdsa/ext/jacobian_point.rb

@@ -0,0 +1,195 @@
+# frozen_string_literal: true
+
+module ECDSA
+  module Ext
+    # Point of Jacobian coordinates
+    class JacobianPoint
+      include JacobianArithmetic
+
+      attr_reader :group, :x, :y, :z
+
+      # Create new instance of jacobian
+      # @param [ECDSA::Group] group
+      # @param [Array] args [x, y, z]
+      # @return [ECDSA::Ext::ProjectivePoint]
+      def initialize(group, *args)
+        @group = group
+        @x, @y, @z = args
+        raise ArgumentError, "Invalid x: #{x.inspect}" unless x.is_a?(Integer)
+        raise ArgumentError, "Invalid y: #{y.inspect}" unless y.is_a?(Integer)
+        raise ArgumentError, "Invalid z: #{z.inspect}" unless z.is_a?(Integer)
+      end
+
+      # Get filed of this group.
+      # @return [ECDSA::PrimeField]
+      def field
+        group.field
+      end
+
+      # Convert coordinates from affine to projective.
+      # @param [ECDSA::Point] point
+      # @return [ECDSA::Ext::JacobianPoint]
+      def self.from_affine(point)
+        if point.infinity?
+          JacobianPoint.infinity(point.group)
+        else
+          new(point.group, point.x, point.y, 1)
+        end
+      end
+
+      # Create infinity point
+      # @return [ECDSA::Ext::JacobianPoint]
+      def self.infinity(group)
+        # new(group, :infinity)
+        new(group, 0, 1, 0)
+      end
+
+      # Check whether infinity point or not.
+      # @return [Boolean]
+      def infinity?
+        x.zero? && y == 1 && z.zero?
+      end
+
+      # Add this point to another point on the same curve.
+      # @param [ECDSA::Ext::JacobianPoint] other
+      # @return [ECDSA::Ext::JacobianPoint]
+      def add_to_point(other)
+        unless other.is_a?(JacobianPoint)
+          raise ArgumentError, "other point must be instance of JacobianPoint"
+        end
+        unless other.group == group
+          raise ArgumentError, "other group must be same group of this point"
+        end
+
+        return other if infinity?
+        return self if other.infinity?
+
+        if x == other.x && y == field.mod(-other.y) && z == other.z
+          return JacobianPoint.infinity(group)
+        end
+
+        return other if y.zero? || z.zero?
+        return self if other.y.zero? || other.z.zero?
+
+        # unless x == other.x
+        if z == other.z
+          return(
+            z == 1 ? add_with_z_one(self, other) : add_with_z_eq(self, other)
+          )
+        end
+        return add_with_z2_one(other, self) if z == 1
+        return add_with_z2_one(self, other) if other.z == 1
+        add_with_z_ne(self, other)
+        # end
+
+        # return double if self == other
+        # raise "Failed to add #{inspect} to #{other.inspect}: No addition rules matched."
+      end
+      alias + add_to_point
+
+      # Return the point added to itself.
+      # @return [ECDSA::Ext::JacobianPoint]
+      def double
+        return self if infinity?
+
+        return double_with_z_one(self) if z == 1
+
+        xx = field.square(x)
+        yy = field.square(y)
+        yyyy = field.square(yy)
+        zz = field.square(z)
+        s = field.mod(2 * (field.square(x + yy) - xx - yyyy))
+        m = field.mod(3 * xx + group.param_a * zz * zz)
+        t = field.mod(m * m - 2 * s)
+        y3 = field.mod(m * (s - t) - 8 * yyyy)
+        z3 = field.mod(field.square(y + z) - yy - zz)
+        JacobianPoint.new(group, t, y3, z3)
+      end
+
+      # Return the point multiplied by a non-negative integer.
+      # @param [Integer] x
+      # @return [ECDSA::Ext::JacobianPoint]
+      def multiply_by_scalar(x)
+        raise ArgumentError, "Scalar is not an integer." unless x.is_a?(Integer)
+        raise ArgumentError, "Scalar is negative." if x.negative?
+
+        q = JacobianPoint.infinity(group)
+        v = self
+        i = x
+        while i.positive?
+          q = q.add_to_point(v) if i.odd?
+          v = v.double
+          i >>= 1
+        end
+        q
+      end
+      alias * multiply_by_scalar
+
+      # Convert this coordinates to affine coordinates.
+      # @return [ECDSA::Point]
+      def to_affine
+        if infinity?
+          group.infinity
+        else
+          z_inv = field.inverse(z)
+          tmp_z = field.square(z_inv)
+          new_x = field.mod(x * tmp_z) # x = x * (1/z)^2
+          new_y = field.mod(y * tmp_z * z_inv) # y = y * (1/z)^3
+          ECDSA::Point.new(group, new_x, new_y)
+        end
+      end
+
+      # Return additive inverse of the point.
+      # @return [ECDSA::Ext::ProjectivePoint]
+      def negate
+        return self if infinity?
+        ProjectivePoint.new(group, x, field.mod(-y), z)
+      end
+
+      # Return coordinates.
+      # @return [Array] (x, y , z)
+      def coords
+        [x, y, z]
+      end
+
+      # Check whether same jacobian point or not.
+      # @param [ECDSA::Ext::JacobianPoint] other
+      # @return [Boolean]
+      def ==(other)
+        return false unless other.is_a?(JacobianPoint)
+        return true if infinity? && other.infinity?
+
+        zz = field.square(z)
+        other_zz = field.square(other.z)
+        lhs_x = field.mod(x * other_zz)
+        rhs_x = field.mod(other.x * zz)
+        lhs_y = field.mod(y * other_zz * other.z)
+        rhs_y = field.mod(other.y * zz * z)
+
+        lhs_x == rhs_x && lhs_y == rhs_y
+      end
+
+      private
+
+      def double_non_const
+        return self if infinity?
+        z == 1 ? double_z1 : double
+      end
+
+      def double_z1
+        z3 = field.mod(2 * y)
+        a = field.square(x)
+        b = field.square(y)
+        c = field.square(b)
+        b = field.square(x + b)
+        d = field.mod(2 * (b - (a + c)))
+        e = field.mod(a * 3)
+        f = field.square(e)
+        x3 = field.mod(f - (2 * d))
+        f = field.mod(d - x3)
+        y3 = field.mod(e * f - 8 * c)
+        JacobianPoint.new(group, x3, y3, z3)
+      end
+    end
+  end
+end

data/lib/ecdsa/ext/point.rb

@@ -8,5 +8,11 @@ module ECDSA
     def to_projective
       ECDSA::Ext::ProjectivePoint.from_affine(self)
     end
+
+    # Convert coordinates to projective point.
+    # @return [ECDSA::Ext::JacobianPoint]
+    def to_jacobian
+      ECDSA::Ext::JacobianPoint.from_affine(self)
+    end
   end
 end

data/lib/ecdsa/ext/{point_arithmetic.rb → projective_arithmetic.rb}

@@ -2,7 +2,7 @@
 module ECDSA
   module Ext
     # Point arithmetic implementation
-    module PointArithmetic
+    module ProjectiveArithmetic
       def addition_negative3(a, b)
         field = a.field
         xx = field.mod(a.x * b.x)
@@ -76,9 +76,9 @@ module ECDSA
 
       def double_negative3(point)
         field = point.field
-        xx = field.power(point.x, 2)
-        yy = field.power(point.y, 2)
-        zz = field.power(point.z, 2)
+        xx = field.square(point.x)
+        yy = field.square(point.y)
+        zz = field.square(point.z)
         xy2 = field.mod(point.x * point.y * 2)
         xz2 = field.mod(point.x * point.z * 2)
 

data/lib/ecdsa/ext/projective_point.rb

@@ -4,13 +4,13 @@ module ECDSA
   module Ext
     # Representing a point on elliptic curves using projective coordinates.
     class ProjectivePoint
-      include PointArithmetic
+      include ProjectiveArithmetic
 
       attr_reader :group, :x, :y, :z
 
       # Create new instance of projective
       # @param [ECDSA::Group] group
-      # @param [Array] args [:infinity] or [x, y, z]
+      # @param [Array] args [x, y, z]
       # @return [ECDSA::Ext::ProjectivePoint]
       def initialize(group, *args)
         @group = group

data/lib/ecdsa/ext/version.rb

@@ -2,6 +2,6 @@
 
 module ECDSA
   module Ext
-    VERSION = "0.2.1"
+    VERSION = "0.3.0"
   end
 end

data/lib/ecdsa/ext.rb

@@ -4,7 +4,9 @@ require_relative "ext/point"
 module ECDSA
   # Extension for ecdsa gem.
   module Ext
-    autoload :PointArithmetic, "ecdsa/ext/point_arithmetic"
+    autoload :ProjectiveArithmetic, "ecdsa/ext/projective_arithmetic"
     autoload :ProjectivePoint, "ecdsa/ext/projective_point"
+    autoload :JacobianArithmetic, "ecdsa/ext/jacobian_arithmetic"
+    autoload :JacobianPoint, "ecdsa/ext/jacobian_point"
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ecdsa_ext
 version: !ruby/object:Gem::Version
-  version: 0.2.1
+  version: 0.3.0
 platform: ruby
 authors:
 - azuchi
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2023-02-28 00:00:00.000000000 Z
+date: 2023-03-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ecdsa
@@ -46,8 +46,10 @@ files:
 - bin/setup
 - ecdsa_ext.gemspec
 - lib/ecdsa/ext.rb
+- lib/ecdsa/ext/jacobian_arithmetic.rb
+- lib/ecdsa/ext/jacobian_point.rb
 - lib/ecdsa/ext/point.rb
-- lib/ecdsa/ext/point_arithmetic.rb
+- lib/ecdsa/ext/projective_arithmetic.rb
 - lib/ecdsa/ext/projective_point.rb
 - lib/ecdsa/ext/version.rb
 - lib/ecdsa_ext.rb