ecdsa_ext 0.4.2 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ffeb5bdada0b817b13c781070e239322058aa645a85440a6ef77bf87e5dea2d2
-  data.tar.gz: 277175edaac373991a84de08987c3ec5d426410664f5e5d57a56f409a39ea8f5
+  metadata.gz: f71a8a1ec3a2e0fef42f9820fd59ba1f7d440ec86e0c85922da554f4d1f9d8f2
+  data.tar.gz: 7c1db1f1c79d783f307f2fac3185ed837882bd68b516770da063a5d08dd04755
 SHA512:
-  metadata.gz: 2b9944ff8eaa893aec952088eb9d5fad70d550f9396eec59c76a5e070aa3e0752bef098e5d13982a0963b0eab2641faa10de665feede18305ac32bdc1ff73c69
-  data.tar.gz: bff44997fbd4154ad6099dadd15661927dba01bdf8fd53182b70c1eca8c77ca6f4d08883b413d014b06f1530b8e43e0fe0a433ac3e9751a4b6cb49efcc73c331
+  metadata.gz: f2472cd8dbf5f124619222e00b55c661dcd74962a92a4decb5a4acaa31d281ed052177949875ae68d9b0ec581df2c602c1bc8e9dd72fa2409efebbdc5f51ae17
+  data.tar.gz: 8c4678914dae19af4f13408547ef95ee86041131541b37b68275a13c3da6f8d02641c134d4984e649d665f7c7eeb8d317e1a06a6a950128661c306bb29f98bb7

data/lib/ecdsa/ext/abstract_point.rb

@@ -46,6 +46,10 @@ module ECDSA
         new(group, :infinity)
       end
 
+      def infinity_point
+        self.class.infinity_point(group)
+      end
+
       # Check whether infinity point or not.
       # @return [Boolean]
       def infinity?

data/lib/ecdsa/ext/jacobian_point.rb

@@ -3,9 +3,8 @@
 module ECDSA
   module Ext
     # Point of Jacobian coordinates
+    # http://point-at-infinity.org/ecc/Prime_Curve_Jacobian_Coordinates.html
     class JacobianPoint < AbstractPoint
-      include JacobianArithmetic
-
       # Add this point to another point on the same curve.
       # @param [ECDSA::Ext::JacobianPoint] other
       # @return [ECDSA::Ext::JacobianPoint]
@@ -20,37 +19,21 @@ module ECDSA
         return other if infinity?
         return self if other.infinity?
 
-        if x == other.x && y == field.mod(-other.y) && z == other.z
-          return JacobianPoint.infinity_point(group)
-        end
-
-        return other if y.zero? || z.zero?
-        return self if other.y.zero? || other.z.zero?
+        u1 = field.mod(x * field.power(other.z, 2))
+        u2 = field.mod(other.x * field.power(z, 2))
+        s1 = field.mod(y * field.power(other.z, 3))
+        s2 = field.mod(other.y * field.power(z, 3))
 
-        unless x == other.x
-          new_point =
-            if z == other.z
-              z == 1 ? add_with_z_one(self, other) : add_with_z_eq(self, other)
-            elsif z == 1
-              add_with_z2_one(other, self)
-            elsif other.z == 1
-              add_with_z2_one(self, other)
-            else
-              add_with_z_ne(self, other)
-            end
-          return(
-            (
-              if new_point.y.zero? || new_point.z.zero?
-                JacobianPoint.infinity_point(group)
-              else
-                new_point
-              end
-            )
-          )
-        end
+        return s1 == s2 ? double : infinity_point if u1 == u2
 
-        return double if self == other
-        raise "Failed to add #{inspect} to #{other.inspect}: No addition rules matched."
+        h = field.mod(u2 - u1)
+        h2 = field.power(h, 2)
+        h3 = field.power(h, 3)
+        r = field.mod(s2 - s1)
+        x3 = field.mod(field.power(r, 2) - h3 - 2 * u1 * h2)
+        y3 = field.mod(r * (u1 * h2 - x3) - s1 * h3)
+        z3 = field.mod(h * z * other.z)
+        JacobianPoint.new(group, x3, y3, z3)
       end
       alias + add_to_point
 
@@ -58,19 +41,14 @@ module ECDSA
       # @return [ECDSA::Ext::JacobianPoint]
       def double
         return self if infinity?
+        return infinity_point if y.zero?
 
-        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)
+        s = field.mod(4 * x * field.power(y, 2))
+        m = field.mod(3 * field.power(x, 2) + group.param_a * field.power(z, 4))
+        x3 = field.mod(field.power(m, 2) - 2 * s)
+        y3 = field.mod(m * (s - x3) - 8 * field.power(y, 4))
+        z3 = field.mod(2 * y * z)
+        JacobianPoint.new(group, x3, y3, z3)
       end
 
       # Convert this coordinates to affine coordinates.
@@ -103,28 +81,6 @@ module ECDSA
 
         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/projective_point.rb

@@ -3,9 +3,8 @@
 module ECDSA
   module Ext
     # Representing a point on elliptic curves using projective coordinates.
+    # http://point-at-infinity.org/ecc/Prime_Curve_Standard_Projective_Coordinates.html
     class ProjectivePoint < AbstractPoint
-      include ProjectiveArithmetic
-
       # Add this point to another point on the same curve.
       # @param [ECDSA::Ext::ProjectivePoint] other
       # @return [ECDSA::Ext::ProjectivePoint]
@@ -20,30 +19,21 @@ module ECDSA
         return other if infinity?
         return self if other.infinity?
 
-        if x == other.x && y == field.mod(-other.y) && z == other.z
-          return ProjectivePoint.infinity_point(group)
-        end
-
-        unless x == other.x
-          new_point =
-            if group.param_a == field.mod(-3)
-              addition_negative3(self, other)
-            else
-              addition_any(self, other)
-            end
-          return(
-            (
-              if new_point.y.zero? || new_point.z.zero?
-                JacobianPoint.infinity_point(group)
-              else
-                new_point
-              end
-            )
-          )
-        end
-
-        return double if self == other
-        raise "Failed to add #{inspect} to #{other.inspect}: No addition rules matched."
+        u1 = field.mod(other.y * z)
+        u2 = field.mod(y * other.z)
+        v1 = field.mod(other.x * z)
+        v2 = field.mod(x * other.z)
+        return u1 == u2 ? double : infinity_point if v1 == v2
+        u = field.mod(u1 - u2)
+        v = field.mod(v1 - v2)
+        vv = field.power(v, 2)
+        vvv = field.power(v, 3)
+        w = field.mod(z * other.z)
+        a = field.mod(field.power(u, 2) * w - vvv - 2 * vv * v2)
+        x3 = field.mod(v * a)
+        y3 = field.mod(u * (vv * v2 - a) - vvv * u2)
+        z3 = field.mod(vvv * w)
+        ProjectivePoint.new(group, x3, y3, z3)
       end
       alias + add_to_point
 
@@ -51,12 +41,17 @@ module ECDSA
       # @return [ECDSA::Ext::ProjectivePoint]
       def double
         return self if infinity?
+        return infinity_point if y.zero?
 
-        if group.param_a == field.mod(-3)
-          double_negative3(self)
-        else
-          double_any(self)
-        end
+        w = field.mod(group.param_a * field.power(z, 2) + 3 * field.power(x, 2))
+        s = field.mod(y * z)
+        b = field.mod(x * y * s)
+        h = field.mod(field.power(w, 2) - 8 * b)
+        x3 = field.mod(2 * h * s)
+        y3 =
+          field.mod(w * (4 * b - h) - 8 * field.power(y, 2) * field.power(s, 2))
+        z3 = field.mod(8 * field.power(s, 3))
+        ProjectivePoint.new(group, x3, y3, z3)
       end
 
       # Convert this coordinates to affine coordinates.

data/lib/ecdsa/ext/version.rb

@@ -2,6 +2,6 @@
 
 module ECDSA
   module Ext
-    VERSION = "0.4.2"
+    VERSION = "0.5.0"
   end
 end

data/lib/ecdsa/ext.rb

@@ -5,9 +5,7 @@ module ECDSA
   # Extension for ecdsa gem.
   module Ext
     autoload :AbstractPoint, "ecdsa/ext/abstract_point"
-    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.4.2
+  version: 0.5.0
 platform: ruby
 authors:
 - azuchi
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2023-03-28 00:00:00.000000000 Z
+date: 2023-03-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ecdsa
@@ -47,10 +47,8 @@ files:
 - ecdsa_ext.gemspec
 - lib/ecdsa/ext.rb
 - lib/ecdsa/ext/abstract_point.rb
-- lib/ecdsa/ext/jacobian_arithmetic.rb
 - lib/ecdsa/ext/jacobian_point.rb
 - lib/ecdsa/ext/point.rb
-- lib/ecdsa/ext/projective_arithmetic.rb
 - lib/ecdsa/ext/projective_point.rb
 - lib/ecdsa/ext/sign_verify.rb
 - lib/ecdsa/ext/version.rb

data/lib/ecdsa/ext/jacobian_arithmetic.rb

@@ -1,86 +0,0 @@
-# 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/projective_arithmetic.rb

@@ -1,143 +0,0 @@
-# frozen_string_literal: true
-module ECDSA
-  module Ext
-    # Point arithmetic implementation
-    module ProjectiveArithmetic
-      def addition_negative3(a, b)
-        field = a.field
-        xx = field.mod(a.x * b.x)
-        yy = field.mod(a.y * b.y)
-        zz = field.mod(a.z * b.z)
-        xy_pairs = field.mod((a.x + a.y) * (b.x + b.y) - (xx + yy))
-        yz_pairs = field.mod((a.y + a.z) * (b.y + b.z) - (yy + zz))
-        xz_pairs = field.mod((a.x + a.z) * (b.x + b.z) - (xx + zz))
-
-        bzz_part = field.mod(xz_pairs - a.group.param_b * zz)
-        bzz3_part = field.mod(bzz_part * 2 + bzz_part)
-        yy_m_bzz3 = field.mod(yy - bzz3_part)
-        yy_p_bzz3 = field.mod(yy + bzz3_part)
-
-        zz3 = field.mod(zz * 3)
-        bxz_part = field.mod(a.group.param_b * xz_pairs - (zz3 + xx))
-        bxz3_part = field.mod(bxz_part * 3)
-        xx3_m_zz3 = field.mod(xx * 3 - zz3)
-
-        x = field.mod(yy_p_bzz3 * xy_pairs - yz_pairs * bxz3_part)
-        y = field.mod(yy_p_bzz3 * yy_m_bzz3 + xx3_m_zz3 * bxz3_part)
-        z = field.mod(yy_m_bzz3 * yz_pairs + xy_pairs * xx3_m_zz3)
-        ProjectivePoint.new(a.group, x, y, z)
-      end
-
-      def addition_any(a, b)
-        field = a.field
-        b3 = field.mod(3 * group.param_b)
-        t0 = field.mod(a.x * b.x)
-        t1 = field.mod(a.y * b.y)
-        t2 = field.mod(a.z * b.z)
-        t3 = field.mod(a.x + a.y)
-        t4 = field.mod(b.x + b.y)
-        t3 = field.mod(t3 * t4)
-        t4 = field.mod(t0 + t1)
-        t3 = field.mod(t3 - t4)
-        t4 = field.mod(a.x + a.z)
-        t5 = field.mod(b.x + b.z)
-        t4 = field.mod(t4 * t5)
-        t5 = field.mod(t0 + t2)
-        t4 = field.mod(t4 - t5)
-        t5 = field.mod(a.y + a.z)
-        x3 = field.mod(b.y + b.z)
-        t5 = field.mod(t5 * x3)
-        x3 = field.mod(t1 + t2)
-        t5 = field.mod(t5 - x3)
-        z3 = field.mod(a.group.param_a * t4)
-        x3 = field.mod(b3 * t2)
-        z3 = field.mod(x3 + z3)
-        x3 = field.mod(t1 - z3)
-        z3 = field.mod(t1 + z3)
-        y3 = field.mod(x3 * z3)
-        t1 = field.mod(t0 + t0)
-        t1 = field.mod(t1 + t0)
-        t2 = field.mod(a.group.param_a * t2)
-        t4 = field.mod(b3 * t4)
-        t1 = field.mod(t1 + t2)
-        t2 = field.mod(t0 - t2)
-        t2 = field.mod(a.group.param_a * t2)
-        t4 = field.mod(t4 + t2)
-        t0 = field.mod(t1 * t4)
-        y3 = field.mod(y3 + t0)
-        t0 = field.mod(t5 * t4)
-        x3 = field.mod(t3 * x3)
-        x3 = field.mod(x3 - t0)
-        t0 = field.mod(t3 * t1)
-        z3 = field.mod(t5 * z3)
-        z3 = field.mod(z3 + t0)
-        ProjectivePoint.new(a.group, x3, y3, z3)
-      end
-
-      def double_negative3(point)
-        field = point.field
-        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)
-
-        bzz_part = field.mod(point.group.param_b * zz - xz2)
-        bzz3_part = field.mod(bzz_part + bzz_part + bzz_part)
-        yy_m_bzz3 = field.mod(yy - bzz3_part)
-        yy_p_bzz3 = field.mod(yy + bzz3_part)
-        y_frag = field.mod(yy_p_bzz3 * yy_m_bzz3)
-        x_frag = field.mod(yy_m_bzz3 * xy2)
-
-        zz3 = field.mod(zz * 3)
-        bxz2_part = field.mod(point.group.param_b * xz2 - (zz3 + xx))
-        bxz6_part = field.mod(bxz2_part * 3)
-        xx3_m_zz3 = field.mod(xx * 3 - zz3)
-
-        y = field.mod(y_frag + xx3_m_zz3 * bxz6_part)
-        yz2 = field.mod(point.y * point.z * 2)
-        x = field.mod(x_frag - bxz6_part * yz2)
-        z = field.mod(yz2 * yy * 4)
-        ProjectivePoint.new(point.group, x, y, z)
-      end
-
-      def double_any(point)
-        field = point.field
-        b3 = field.mod(point.group.param_b * 3)
-
-        t0 = field.mod(point.x * point.x)
-        t1 = field.mod(point.y * point.y)
-        t2 = field.mod(point.z * point.z)
-        t3 = field.mod(point.x * point.y)
-        t3 = field.mod(t3 + t3)
-        z3 = field.mod(point.x * point.z)
-        z3 = field.mod(z3 + z3)
-        x3 = field.mod(point.group.param_a * z3)
-        y3 = field.mod(b3 * t2)
-        y3 = field.mod(x3 + y3)
-        x3 = field.mod(t1 - y3)
-        y3 = field.mod(t1 + y3)
-        y3 = field.mod(x3 * y3)
-        x3 = field.mod(t3 * x3)
-        z3 = field.mod(b3 * z3)
-        t2 = field.mod(point.group.param_a * t2)
-        t3 = field.mod(t0 - t2)
-        t3 = field.mod(point.group.param_a * t3)
-        t3 = field.mod(t3 + z3)
-        z3 = field.mod(t0 + t0)
-        t0 = field.mod(z3 + t0)
-        t0 = field.mod(t0 + t2)
-        t0 = field.mod(t0 * t3)
-        y3 = field.mod(y3 + t0)
-        t2 = field.mod(point.y * point.z)
-        t2 = field.mod(t2 + t2)
-        t0 = field.mod(t2 * t3)
-        x3 = field.mod(x3 - t0)
-        z3 = field.mod(t2 * t1)
-        z3 = field.mod(z3 + z3)
-        z3 = field.mod(z3 + z3)
-        ProjectivePoint.new(point.group, x3, y3, z3)
-      end
-    end
-  end
-end