starkbank-ecdsa 0.0.5 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 552ac4aee46c31ad3dcc11dac2022b7a458925d718fc22ac31c5349a580e441d
-  data.tar.gz: 94d725e7728047557a4c032d5f27c9174b0ace61e76e54bdff481d28fc55ccf3
+  metadata.gz: 4d4a76bc728ec00f073424e79a9e72d75d39aa863074fff03fd5c35694d221f2
+  data.tar.gz: d8612f17a0eb7b9d7e5d735f7fc164ee288e770ba5d2b4bc62c35fcbda97088e
 SHA512:
-  metadata.gz: 657954155c41471d9ecf3799d705c7183cb0beb888de65f9e609f7bad729e6188cd0fdd9f67ee7193ffb2807b679fa9ee1f3f08687b0a0ba9ff32dede7cd3476
-  data.tar.gz: bb5e12f6c6f9413050f74f7acb6a204a75a0af1710689bca44a3af78783d6dec19315a623923c0c370bf23d4eded548d89e187b937cce1c8c04d63c0623e9d5a
+  metadata.gz: 88d83c16ca1e416998cf5411dd45ca4cd9e62af3841dcea5981a2fa8dedbc86ea74a8ef91ceb44db6e5192e36af65c5877f32d373ccffd154c4472951d379fcf
+  data.tar.gz: 4332d9b28484fe4c09708147494ea33c3caa48f263824a72ef846888a32cd27bad585a98560a8f7883c5be88394da72318e44a144e0b1b4ecfbde148812de058

data/lib/curve.rb

@@ -0,0 +1,94 @@
+module EllipticCurve
+    #
+    # Elliptic Curve Equation
+    #
+    # y^2 = x^3 + A*x + B (mod P)
+    #
+    module Curve
+        class CurveFp
+            attr_accessor :a, :b, :p, :n, :g, :name, :oid, :nistName
+
+            def initialize(a, b, p, n, gx, gy, name, oid, nistName=nil)
+                @a = a
+                @b = b
+                @p = p
+                @n = n
+                @g = Point.new(gx, gy)
+                @name = name
+                @oid = oid
+                @nistName = nistName
+            end
+            
+            def contains(p)
+                # Verify if the point `p` is on the curve
+                # :param p: point p = Point(x, y)
+                # :return: boolean
+                if not (0 <= p.x and p.x <= @p - 1)
+                    return false
+                end
+                if not (0 <= p.y and p.y <= @p - 1)
+                    return false
+                end
+                if (p.y ** 2 - (p.x ** 3 + @a * p.x + @b)) % @p != 0
+                    return false
+                end
+                return true
+            end
+
+            def length
+                return (1 + ("%x" % @n).length).div(2)
+            end
+
+            def y(x, isEven)
+                ySquared = (x.pow(3, @p) + @a * x + @b) % @p
+                y = Math::modularSquareRoot(ySquared, @p)
+                if isEven != (y % 2 == 0)
+                    y = @p - y
+                end
+                return y
+            end
+
+        end
+
+        @_curvesByOid = { }
+
+        def self.add(curve)
+            @_curvesByOid[curve.oid] = curve
+        end
+
+        def self.getbyOid(oid)
+            if not @_curvesByOid.include?(oid)
+                raise Exception.new("Unknown curve oid: #{oid}; The following are registered: #{@_curvesByOid.map{|k,v| v.name}}")
+            end
+            return @_curvesByOid[oid]
+        end
+
+        SECP256K1 = CurveFp.new(
+            0x0000000000000000000000000000000000000000000000000000000000000000,
+            0x0000000000000000000000000000000000000000000000000000000000000007,
+            0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffefffffc2f,
+            0xfffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd0364141,
+            0x79be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798,
+            0x483ada7726a3c4655da4fbfc0e1108a8fd17b448a68554199c47d08ffb10d4b8,
+            "secp256k1",
+            [1, 3, 132, 0, 10]
+        )
+
+        PRIME256V1 = CurveFp.new(
+            0xffffffff00000001000000000000000000000000fffffffffffffffffffffffc,
+            0x5ac635d8aa3a93e7b3ebbd55769886bc651d06b0cc53b0f63bce3c3e27d2604b,
+            0xffffffff00000001000000000000000000000000ffffffffffffffffffffffff,
+            0xffffffff00000000ffffffffffffffffbce6faada7179e84f3b9cac2fc632551,
+            0x6b17d1f2e12c4247f8bce6e563a440f277037d812deb33a0f4a13945d898c296,
+            0x4fe342e2fe1a7f9b8ee7eb4a7c0f9e162bce33576b315ececbb6406837bf51f5,
+            "prime256v1",
+            [1, 2, 840, 10045, 3, 1, 7],
+            "p-256",
+        )
+
+        P256 = PRIME256V1
+
+        self.add(PRIME256V1)
+        self.add(SECP256K1)
+    end
+end

data/lib/ecdsa.rb

@@ -1,32 +1,50 @@
 require 'digest'
-require 'openssl'
-require_relative './signature'
 
 
 module EllipticCurve
-
     module Ecdsa
-
         def self.sign(message, privateKey, hashfunc=nil)
-            if hashfunc.nil?
-                message = Digest::SHA256.digest(message)
-            else
-                message = hashfunc(message)
+            if hashfunc.nil? then hashfunc = lambda{ |x| Digest::SHA256.digest(x) } end            
+            byteMessage = hashfunc.call(message)
+            numberMessage = Utils::Binary.numberFromByteString(byteMessage)
+            curve = privateKey.curve
+
+            r, s, randSignPoint = 0, 0, nil
+            while r == 0 or s == 0
+                randNum = Utils::RandomInteger.between(1, curve.n - 1)
+                randSignPoint = Math.multiply(curve.g, randNum, curve.n, curve.a, curve.p)
+                r = randSignPoint.x % curve.n
+                s = ((numberMessage + r * privateKey.secret) * (Math.inv(randNum, curve.n))) % curve.n
             end
-
-            signature = privateKey.openSslPrivateKey.dsa_sign_asn1(message)
-            return Signature.new(signature)
+            recoveryId = randSignPoint.y & 1
+            if randSignPoint.y > curve.n
+                recoveryId += 2
+            end
+            return Signature.new(r, s, recoveryId)
         end
 
         def self.verify(message, signature, publicKey, hashfunc=nil)
-            if hashfunc.nil?
-                message = Digest::SHA256.digest(message)
-            else
-                message = hashfunc(message)
+            if hashfunc.nil? then hashfunc = lambda{ |x| Digest::SHA256.digest(x) } end            
+            byteMessage = hashfunc.call(message)
+            numberMessage = Utils::Binary.numberFromByteString(byteMessage)
+
+            curve = publicKey.curve
+            r = signature.r
+            s = signature.s
+            if not (1 <= r and r <= curve.n - 1)
+                return false
             end
-            return publicKey.openSslPublicKey.dsa_verify_asn1(message, signature.toDer())
+            if not (1 <= s and s <= curve.n - 1)
+                return false
+            end
+            inv = Math.inv(s, curve.n)
+            u1 = Math.multiply(curve.g, (numberMessage * inv) % curve.n, curve.n, curve.a, curve.p)
+            u2 = Math.multiply(publicKey.point, (r * inv) % curve.n, curve.n, curve.a, curve.p)
+            v = Math.add(u1, u2, curve.a, curve.p)
+            if v.isAtInfinity
+                return false
+            end
+            return v.x % curve.n == r
         end
-
     end
-
-end
+end

data/lib/math.rb

@@ -0,0 +1,167 @@
+module EllipticCurve
+    class Math
+        def self.modularSquareRoot(value, prime)
+            # :param value: Value to calculate the square root
+            # :param prime: Prime number in the module of the equation Y^2 = X^3 + A*X + B (mod p)
+            # :return: Square root of the value
+            return value.pow((prime + 1).div(4), prime)
+        end
+
+        def self.multiply(p, n, order, coeff, prime) 
+            # Fast way to multiply point and scalar in elliptic curves
+
+            # :param p: First Point to mutiply
+            # :param n: Scalar to mutiply
+            # :param N: Order of the elliptic curve
+            # :param A: Coefficient of the first-order term of the equation Y^2 = X^3 + A*X + B (mod p)
+            # :param P: Prime number in the module of the equation Y^2 = X^3 + A*X + B (mod p)
+            # :return: Point that represents the sum of First and Second Point
+            return self._fromJacobian(
+                self._jacobianMultiply(self._toJacobian(p), n, order, coeff, prime), prime
+            )
+        end
+
+        def self.add(p, q, coeff, prime)
+            # Fast way to add two points in elliptic curves
+
+            # :param p: First Point you want to add
+            # :param q: Second Point you want to add
+            # :param P: Prime number in the module of the equation Y^2 = X^3 + A*X + B (mod p)
+            # :param A: Coefficient of the first-order term of the equation Y^2 = X^3 + A*X + B (mod p)
+            # :return: Point that represents the sum of First and Second Point
+            return self._fromJacobian(
+                self._jacobianAdd(self._toJacobian(p), self._toJacobian(q), coeff, prime), prime
+            )
+        end
+
+        def self.inv(x, n)
+            # Extended Euclidean Algorithm. It's the 'division' in elliptic curves
+
+            # :param x: Divisor
+            # :param n: Mod for division
+            # :return: Value representing the division
+            if x == 0 then return 0 end
+            
+            lm = 1
+            hm = 0
+            low = x % n
+            high = n
+
+            while low > 1
+                r = high.div(low)
+                nm = hm - lm * r
+                nw = high - low * r
+                high = low
+                hm = lm
+                low = nw
+                lm = nm
+            end
+            return lm % n 
+        end
+
+        def self._toJacobian(p)
+            # Convert point to Jacobian coordinates
+
+            # :param p: First Point you want to add
+            # :return: Point in Jacobian coordinates
+            return Point.new(p.x, p.y, 1)
+        end
+
+        def self._fromJacobian(p, prime)
+            # Convert point back from Jacobian coordinates
+
+            # :param p: First Point you want to add
+            # :param P: Prime number in the module of the equation Y^2 = X^3 + A*X + B (mod p)
+            # :return: Point in default coordinates
+            z = self.inv(p.z, prime)
+            x = (p.x * z ** 2) % prime
+            y = (p.y * z ** 3) % prime
+
+            return Point.new(x, y, 0)
+        end
+
+        def self._jacobianDouble(p, coeff, prime)
+            # Double a point in elliptic curves
+
+            # :param p: Point you want to double
+            # :param A: Coefficient of the first-order term of the equation Y^2 = X^3 + A*X + B (mod p)
+            # :param P: Prime number in the module of the equation Y^2 = X^3 + A*X + B (mod p)
+            # :return: Point that represents the sum of First and Second Point
+            if p.y == 0 then return Point.new(0, 0, 0) end
+
+            ysq = (p.y ** 2) % prime
+            s = (4 * p.x * ysq) % prime
+            m = (3 * p.x ** 2 + coeff * p.z ** 4) % prime
+            nx = (m ** 2 - 2 * s) % prime
+            ny = (m * (s - nx) - 8 * ysq ** 2) % prime
+            nz = (2 * p.y * p.z) % prime
+
+            return Point.new(nx, ny, nz)
+        end
+
+        def self._jacobianAdd(p, q, coeff, prime)
+            # Add two points in elliptic curves
+
+            # :param p: First Point you want to add
+            # :param q: Second Point you want to add
+            # :param A: Coefficient of the first-order term of the equation Y^2 = X^3 + A*X + B (mod p)
+            # :param P: Prime number in the module of the equation Y^2 = X^3 + A*X + B (mod p)
+            # :return: Point that represents the sum of First and Second Point
+            if p.y == 0 then return q end
+            if q.y == 0 then return p end
+
+            u1 = (p.x * q.z ** 2) % prime
+            u2 = (q.x * p.z ** 2) % prime
+            s1 = (p.y * q.z ** 3) % prime
+            s2 = (q.y * p.z ** 3) % prime
+
+            if u1 == u2
+                if s1 != s2 then return Point.new(0, 0, 1) end
+                return self._jacobianDouble(p, coeff, prime)
+            end
+
+            h = u2 - u1
+            r = s2 - s1
+            h2 = (h * h) % prime
+            h3 = (h * h2) % prime
+            u1h2 = (u1 * h2) % prime
+            nx = (r ** 2 - h3 - 2 * u1h2) % prime
+            ny = (r * (u1h2 - nx) - s1 * h3) % prime
+            nz = (h * p.z * q.z) % prime
+
+            return Point.new(nx, ny, nz)
+        end
+
+        def self._jacobianMultiply(p, n, order, coeff, prime)
+            # Multiply point and scalar in elliptic curves
+
+            # :param p: First Point to mutiply
+            # :param n: Scalar to mutiply
+            # :param N: Order of the elliptic curve
+            # :param P: Prime number in the module of the equation Y^2 = X^3 + A*X + B (mod p)
+            # :param A: Coefficient of the first-order term of the equation Y^2 = X^3 + A*X + B (mod p)
+            # :return: Point that represents the sum of First and Second Point
+            if p.y == 0 or n == 0
+                return Point.new(0, 0, 1)
+            end
+
+            if n == 1
+                return p
+            end
+
+            if n < 0 or n >= order
+                return self._jacobianMultiply(p, n % order, order, coeff, prime)
+            end
+
+            if (n % 2) == 0
+                return self._jacobianDouble(
+                    self._jacobianMultiply(p, n.div(2), order, coeff, prime), coeff, prime
+                )
+            end
+
+            return self._jacobianAdd(
+                self._jacobianDouble(self._jacobianMultiply(p, n.div(2), order, coeff, prime), coeff, prime), p, coeff, prime
+            )
+        end
+    end
+end

data/lib/point.rb

@@ -0,0 +1,19 @@
+module EllipticCurve
+    class Point
+        def initialize(x=0, y=0, z=0)
+            @x = x
+            @y = y
+            @z = z
+        end
+
+        attr_accessor :x, :y, :z
+
+        def to_s
+            return "(#{@x}, #{@y}, #{@z})"
+        end
+
+        def isAtInfinity()
+            return @y == 0
+        end
+    end
+end

data/lib/privatekey.rb

@@ -1,53 +1,68 @@
-require "openssl"
-require "base64"
-require_relative "publickey"
-
-
 module EllipticCurve
-
     class PrivateKey
+        PemTemplate = "-----BEGIN EC PRIVATE KEY-----\n{content}\n-----END EC PRIVATE KEY-----"
+        private_constant :PemTemplate
 
-        def initialize(curve="secp256k1", openSslKey=nil)
-            if openSslKey.nil?
-                @openSslPrivateKey = OpenSSL::PKey::EC.new(curve)
-                @openSslPrivateKey.generate_key
-            else
-                @openSslPrivateKey = openSslKey
-            end
-        end
-
-        attr_reader :openSslPrivateKey
+        attr_accessor :curve, :secret
 
+        def initialize(curve=Curve::SECP256K1, secret=nil)
+            @curve = curve
+            @secret = secret ? secret : Utils::RandomInteger.between(1, @curve.n - 1)
+        end
+        
         def publicKey
-            dupKey = OpenSSL::PKey::EC.new(@openSslPrivateKey.to_der())
-            dupKey.private_key = nil
-            return PublicKey.new(dupKey)
+            curve = @curve
+            publicPoint = Math.multiply(
+                curve.g,
+                @secret,
+                curve.n,
+                curve.a,
+                curve.p
+            )
+            return PublicKey.new(publicPoint, curve)
         end
 
         def toString
-            return Base64.encode64(self.toDer())
+            return Utils::Binary.hexFromInt(@secret)
         end
 
         def toDer
-            return @openSslPrivateKey.to_der()
+            publicKeyString = self.publicKey.toString(true)
+            hexadecimal = Utils::Der.encodeConstructed(
+                Utils::Der.encodePrimitive(Utils::Der::DerFieldType.integer, 1),
+                Utils::Der.encodePrimitive(Utils::Der::DerFieldType.octetString, Utils::Binary.hexFromInt(@secret)),
+                Utils::Der.encodePrimitive(Utils::Der::DerFieldType.oidContainer, Utils::Der.encodePrimitive(Utils::Der::DerFieldType.object, @curve.oid)),
+                Utils::Der.encodePrimitive(Utils::Der::DerFieldType.publicKeyPointContainer, Utils::Der.encodePrimitive(Utils::Der::DerFieldType.bitString, publicKeyString))
+            )
+            return Utils::Binary.byteStringFromHex(hexadecimal)
         end
 
         def toPem
-            return @openSslPrivateKey.to_pem()
+            der = self.toDer()
+            return Utils::Pem.create(Utils::Binary.base64FromByteString(der), PemTemplate)
         end
 
         def self.fromPem(string)
-            return PrivateKey.new(nil, OpenSSL::PKey::EC.new(string))
+            privateKeyPem = Utils::Pem.getContent(string, PemTemplate)
+            return self.fromDer(Utils::Binary.byteStringFromBase64(privateKeyPem))
         end
 
         def self.fromDer(string)
-            return PrivateKey.new(nil, OpenSSL::PKey::EC.new(string))
-        end
-
-        def self.fromString(string)
-            return PrivateKey.new(nil, OpenSSL::PKey::EC.new(Base64.decode64(string)))
+            hexadecimal = Utils::Binary.hexFromByteString(string)
+            privateKeyFlag, secretHex, curveData, publicKeyString = Utils::Der.parse(hexadecimal)[0]
+            if privateKeyFlag != 1
+                raise Exception.new("Private keys should start with a '1' flag, but a '#{privateKeyFlag}' was found instead")
+            end
+            curve = Curve.getbyOid(curveData[0])
+            privateKey = self.fromString(secretHex, curve)
+            if privateKey.publicKey.toString(true) != publicKeyString[0]
+                raise Exception.new("The public key described inside the private key file doesn't match the actual public key of the pair")
+            end
+            return privateKey
         end
 
+        def self.fromString(string, curve=Curve::SECP256K1)
+            return PrivateKey.new(curve, Utils::Binary.intFromHex(string))
+        end      
     end
-
-end
+end

data/lib/publickey.rb

@@ -1,37 +1,108 @@
 module EllipticCurve
-
     class PublicKey
+        PemTemplate = "-----BEGIN PUBLIC KEY-----\n{content}\n-----END PUBLIC KEY-----"
+        EcdsaPublicKeyOid = [1, 2, 840, 10045, 2, 1]
+        EvenTag = "02"
+        OddTag = "03"
+        private_constant :PemTemplate, :EcdsaPublicKeyOid, :EvenTag, :OddTag
+
+        attr_accessor :point, :curve
 
-        def initialize(openSslPublicKey)
-            @openSslPublicKey = openSslPublicKey
+        def initialize(point, curve)
+            @point = point
+            @curve = curve
         end
+        
+        def toString encoded=false
+            baseLength = 2 * @curve.length
 
-        attr_reader :openSslPublicKey
+            xHex = Utils::Binary.hexFromInt(@point.x).rjust(baseLength, "0")
+            yHex = Utils::Binary.hexFromInt(@point.y).rjust(baseLength, "0")
+            string = xHex + yHex
+            if encoded 
+                return "0004" + string
+            end
+            return string
+        end
 
-        def toString
-            return Base64.encode64(self.toDer())
+        def toCompressed
+            baseLength = 2 * @curve.length
+            parityTag = @point.y % 2 == 0 ? EvenTag : OddTag
+            xHex = Utils::Binary.hexFromInt(@point.x).rjust(baseLength, "0")
+            return parityTag + xHex
         end
 
         def toDer
-            @openSslPublicKey.to_der()
+            @hexadecimal = Utils::Der.encodeConstructed(
+                Utils::Der.encodeConstructed(
+                    Utils::Der.encodePrimitive(Utils::Der::DerFieldType.object, EcdsaPublicKeyOid),
+                    Utils::Der.encodePrimitive(Utils::Der::DerFieldType.object, @curve.oid)
+                ),
+                Utils::Der.encodePrimitive(Utils::Der::DerFieldType.bitString, self.toString(true))       
+            )
+            return Utils::Binary.byteStringFromHex(@hexadecimal)
         end
 
         def toPem
-            @openSslPublicKey.to_pem()
+            der = self.toDer()
+            return Utils::Pem.create(Utils::Binary.base64FromByteString(der), PemTemplate)
         end
 
         def self.fromPem(string)
-            return PublicKey.new(OpenSSL::PKey::EC.new(string))
+            publicKeyPem = Utils::Pem.getContent(string, PemTemplate)
+            return self.fromDer(Utils::Binary.byteStringFromBase64(publicKeyPem))
         end
 
         def self.fromDer(string)
-            return PublicKey.new(OpenSSL::PKey::EC.new(string))
+            hexadecimal = Utils::Binary.hexFromByteString(string)
+            curveData, pointString = Utils::Der.parse(hexadecimal)[0]
+            publicKeyOid, curveOid = curveData
+            if publicKeyOid != EcdsaPublicKeyOid
+                raise Exception.new("The Public Key Object Identifier (OID) should be #{EcdsaPublicKeyOid}, but #{publicKeyOid} was found instead")
+            end
+            curve = Curve.getbyOid(curveOid)
+            return self.fromString(pointString, curve)
         end
 
-        def self.fromString(string)
-            return PublicKey.new(OpenSSL::PKey::EC.new(Base64.decode64(string)))
+        def self.fromString(string, curve=Curve::SECP256K1, validatePoint=true)
+            baseLength = 2 * curve.length
+            if string.length > 2 * baseLength and string[0..3] == "0004"
+                string = string[4..-1]
+            end
+
+            xs = string[0..baseLength - 1]
+            ys = string[baseLength..-1]
+
+            p = Point.new(
+                Utils::Binary.intFromHex(xs), 
+                Utils::Binary.intFromHex(ys)
+            )
+
+            publicKey = PublicKey.new(p, curve)
+            if not validatePoint
+                return publicKey
+            end
+            if p.isAtInfinity()
+                raise Exception.new("Public key point at infinity")
+            end
+            if not curve.contains(p)
+                raise Exception.new("Point (#{p.x}, #{p.y}) is not valid for curve #{curve.name}")
+            end
+            if not Math.multiply(p, curve.n, curve.n, curve.a, curve.p).isAtInfinity()
+                raise Exception.new("Point (#{p.x}, #{p.y}) * #{curve.name}.n is not at infinity")
+            end
+            
+            return publicKey
         end
 
+        def self.fromCompressed(string, curve=Curve::SECP256K1)
+            parityTag, xHex = string[0..1], string[2..-1]
+            if not [EvenTag, OddTag].include? parityTag
+                raise Exception.new("Compressed string should start with 02 or 03")
+            end
+            x = Utils::Binary.intFromHex(xHex)
+            y = curve.y(x=x, isEven=parityTag == EvenTag)
+            return PublicKey.new(point=Point.new(x, y), curve=curve)
+        end
     end
-
-end
+end

data/lib/signature.rb

@@ -1,35 +1,51 @@
-require "base64"
-require "openssl"
-
-
 module EllipticCurve
-
     class Signature
-
-        def initialize(der)
-            @der = der
-            decoded = OpenSSL::ASN1.decode(der).value
-            @r = decoded[0].value
-            @s = decoded[1].value
+        attr_reader :r, :s, :recoveryId
+        
+        def initialize(r, s, recoveryId=nil)
+            @r = r
+            @s = s
+            @recoveryId = recoveryId
         end
 
-        attr_reader :r, :s
+        def toDer(withRecoveryId=false)
+            hexadecimal = self._toString
+            encodedSequence = Utils::Binary.byteStringFromHex(hexadecimal)
+            if not withRecoveryId
+                return encodedSequence
+            end
+            return (27 + @recoveryId).chr + encodedSequence
+        end
 
-        def toDer
-            return @der
+        def toBase64(withRecoveryId=false)
+            return Utils::Binary.base64FromByteString(self.toDer(withRecoveryId))
         end
 
-        def toBase64
-            Base64.encode64(self.toDer()).gsub("\n", "")
+        def self.fromDer(string, recoveryByte=false)
+            @recoveryId = nil
+            if recoveryByte
+                @recoveryId = string[0].ord - 27
+                string = string[1..-1]
+            end
+            hexadecimal = Utils::Binary.hexFromByteString(string)
+            return self._fromString(hexadecimal, @recoveryId)
         end
 
-        def self.fromDer(string)
-            return Signature.new(string)
+        def self.fromBase64(string, recoveryByte=false)
+            der = Utils::Binary.byteStringFromBase64(string)
+            return self.fromDer(der, recoveryByte)
         end
 
-        def self.fromBase64(string)
-            self.fromDer(Base64.decode64(string))
+        def _toString
+            return Utils::Der.encodeConstructed(
+                Utils::Der.encodePrimitive(Utils::Der::DerFieldType.integer, @r),
+                Utils::Der.encodePrimitive(Utils::Der::DerFieldType.integer, @s)
+            )
         end
 
+        def self._fromString(string, recoveryId=nil)
+            @r, @s = Utils::Der.parse(string)[0]
+            return Signature.new(@r, @s, recoveryId)
+        end
     end
-end
+end

data/lib/starkbank-ecdsa.rb

@@ -1,5 +1,13 @@
+require_relative "utils/pem"
+require_relative "utils/binary"
+require_relative "utils/oid"
+require_relative "utils/integer"
+require_relative "utils/der"
+require_relative "utils/file"
 require_relative "signature"
 require_relative "publickey"
+require_relative "math"
+require_relative "point"
+require_relative "curve"
 require_relative "privatekey"
 require_relative "ecdsa"
-require_relative "utils/file"

data/lib/utils/binary.rb

@@ -0,0 +1,44 @@
+require "base64"
+
+
+module EllipticCurve
+    module Utils
+        class Binary
+            def self.hexFromInt(number)
+                hexadecimal = number.to_s(16)
+                if hexadecimal.length % 2 == 1
+                    hexadecimal = "0" + hexadecimal
+                end
+                return hexadecimal
+            end
+
+            def self.intFromHex(hexadecimal)
+                return hexadecimal.to_i(16)
+            end
+
+            def self.hexFromByteString(bytes)
+                return bytes.unpack("H*")[0]
+            end
+
+            def self.byteStringFromHex(hexadecimal)
+                return [hexadecimal].pack("H*")
+            end
+
+            def self.numberFromByteString(bytes)
+                return bytes.unpack("C*").reduce(0) { |number, byte| number * 256 + byte }
+            end
+
+            def self.base64FromByteString(byteString)
+                return Base64.encode64(byteString).gsub("\n", "")
+            end
+
+            def self.byteStringFromBase64(base64)
+                return Base64.decode64(base64)
+            end
+
+            def self.bitsFromHex(hexadecimal)
+                return intFromHex(hexadecimal).to_s(2).rjust(hexadecimal.length * 4, "0")
+            end
+        end
+    end
+end

data/lib/utils/der.rb

@@ -0,0 +1,184 @@
+module EllipticCurve
+    module Utils
+        class Der
+            module DerFieldType
+                @integer = "integer"
+                @bitString = "bitString"
+                @octetString = "octetString"
+                @null = "null"
+                @object = "object"
+                @printableString = "printableString"
+                @utcTime = "utcTime"
+                @sequence = "sequence"
+                @set = "set"
+                @oidContainer = "oidContainer"
+                @publicKeyPointContainer = "publicKeyPointContainer"
+
+                class << self; attr_accessor :integer, :bitString, :octetString, :null, :object, :printableString, :utcTime, :sequence, :set, :oidContainer, :publicKeyPointContainer; end
+            end
+
+            @_hexTagToType = {
+                "02" => DerFieldType.integer,
+                "03" => DerFieldType.bitString,
+                "04" => DerFieldType.octetString,
+                "05" => DerFieldType.null,
+                "06" => DerFieldType.object,
+                "13" => DerFieldType.printableString,
+                "17" => DerFieldType.utcTime,
+                "30" => DerFieldType.sequence,
+                "31" => DerFieldType.set,
+                "a0" => DerFieldType.oidContainer,
+                "a1" => DerFieldType.publicKeyPointContainer
+            }
+
+            @_typeToHexTag = {}
+            
+            @_hexTagToType.each { |k, v| @_typeToHexTag[v] = k }
+
+            def self.encodeConstructed(*encodedValues)
+                return self.encodePrimitive(DerFieldType.sequence, encodedValues.join(""))
+            end
+
+            def self.encodePrimitive(tagType, value)
+                if tagType == DerFieldType.integer
+                    value = self._encodeInteger(value)
+                end
+                if tagType == DerFieldType.object
+                    value = Utils::Oid.oidToHex(value)
+                end
+                return "#{@_typeToHexTag[tagType]}#{self._generateLengthBytes(value)}#{value}"
+            end
+
+            def self.parse(hexadecimal)
+                if hexadecimal.class == String && hexadecimal.empty?
+                    return []
+                elsif not hexadecimal then 
+                    return [] 
+                end
+                
+                typeByte, hexadecimal = hexadecimal[0..1], hexadecimal[2..-1]
+                length, lengthBytes = self._readLengthBytes(hexadecimal)
+                content = hexadecimal[lengthBytes..lengthBytes + length - 1] 
+                hexadecimal = hexadecimal[lengthBytes + length..-1]
+
+                if content.length < length
+                    raise Exception.new("missing bytes in DER parsing")
+                end
+
+                tagData = self._getTagData(typeByte)
+                if tagData[:isConstructed]
+                    content = self.parse(content)
+                end
+
+                valueParser = {
+                    DerFieldType.null => lambda { |content| self._parseNull(content) },
+                    DerFieldType.object => lambda { |content| self._parseOid(content) },
+                    DerFieldType.utcTime => lambda { |content| self._parseTime(content) },
+                    DerFieldType.integer => lambda { |content| self._parseInteger(content) },
+                    DerFieldType.printableString => lambda { |content| self._parseString(content) },
+                }.fetch(tagData[:type], lambda { |content| self._parseAny(content) })
+
+                return [valueParser.call(content)] + self.parse(hexadecimal)
+            end
+
+            def self._parseAny(hexadecimal)
+                return hexadecimal
+            end
+
+            def self._parseOid(hexadecimal)
+                return Utils::Oid.oidFromHex(hexadecimal)
+            end
+
+            def self._parseTime(hexadecimal)
+                string = self._parseString(hexadecimal)
+                return DateTime.strptime(string, "%y%m%d%H%M%SZ")
+            end
+
+            def self._parseString(hexadecimal)
+                return Utils::Binary.byteStringFromHex(hexadecimal)
+            end
+
+            def self._parseNull(_content)
+                return nil
+            end
+
+            def self._parseInteger(hexadecimal)
+                integer = Utils::Binary.intFromHex(hexadecimal)
+                bits = Utils::Binary.bitsFromHex(hexadecimal[0])
+                if bits[0] == "0" # negative numbers are encoded using two's complement
+                    return integer
+                end
+                bitCount = 4 * hexadecimal.length
+                return integer - (2 ** bitCount)
+            end
+
+            def self._encodeInteger(number)
+                hexadecimal = Utils::Binary.hexFromInt(number.abs)
+                if number < 0
+                    bitCount = hexadecimal.length * 4
+                    twosComplement = (2 ** bitCount) + number
+                    return Utils::Binary.hexFromInt(twosComplement)
+                end
+                bits = Utils::Binary.bitsFromHex(hexadecimal[0])
+                if bits[0] == "1"
+                    hexadecimal = "00" + hexadecimal
+                end
+                return hexadecimal
+            end
+
+            def self._readLengthBytes(hexadecimal)
+                lengthBytes = 2
+                lengthIndicator = Utils::Binary.intFromHex(hexadecimal[0, lengthBytes])
+                isShortForm = lengthIndicator < 128  # checks if first bit of byte is 1 (a.k.a. short-form)
+                if isShortForm
+                    length = lengthIndicator * 2
+                    return length, lengthBytes
+                end
+
+                lengthLength = lengthIndicator - 128  # nullifies first bit of byte (only used as long-form flag)
+                if lengthLength == 0
+                    raise Exception.new("indefinite length encoding located in DER")
+                end
+                lengthBytes += 2 * lengthLength
+                length = Utils::Binary.intFromHex(hexadecimal[2, lengthBytes]) * 2
+                return length, lengthBytes
+            end
+
+            def self._generateLengthBytes(hexadecimal)
+                size = hexadecimal.length.div(2)
+                length = Utils::Binary.hexFromInt(size)
+                if size < 128
+                    return length.rjust(2, "0")
+                end
+                lengthLength = 128 + length.length.div(2)
+                return Utils::Binary.hexFromInt(lengthLength) + length
+            end
+
+            def self._getTagData(tag)
+                bits = Utils::Binary.bitsFromHex(tag)
+                bit8 = bits[0]
+                bit7 = bits[1]
+                bit6 = bits[2]
+
+                tagClass = {
+                    "0" => {
+                        "0" => "universal",
+                        "1" => "application",
+                    },
+                    "1" => {
+                        "0" => "context-specific",
+                        "1" => "private",
+                    },
+                }[bit8][bit7]
+                
+                isConstructed = bit6 == "1"
+
+                return {
+                    "class": tagClass,
+                    "isConstructed": isConstructed,
+                    "type": @_hexTagToType[tag],
+                }
+            end
+        end
+    end
+end

data/lib/utils/file.rb

@@ -1,18 +1,12 @@
 module EllipticCurve
-
     module Utils
-
         class File
-
             def self.read(path, encoding="ASCII")
                 file = ::File.open(path, :encoding => encoding.upcase)
                 content = file.read
                 file.close
                 content
             end
-
         end
-
     end
-
 end

data/lib/utils/integer.rb

@@ -0,0 +1,23 @@
+require('securerandom')
+
+module EllipticCurve
+    module Utils
+        class RandomInteger
+            # Return integer x in the range: min <= x <= max
+
+            # Parameters (required):
+            # :param min: minimum value of the integer
+            # :param max: maximum value of the integer 
+            # :return: A random number between min and max
+            def self.between(min, max)
+                if (max - min) < 0 then
+                    raise Exception.new("max must be greater than min")
+                end
+                if (max - min) > 0 then
+                    return SecureRandom.random_number((max + 1) - min) + min
+                end
+                return min
+            end
+        end
+    end
+end

data/lib/utils/oid.rb

@@ -0,0 +1,43 @@
+module EllipticCurve
+    module Utils
+        class Oid
+            def self.oidFromHex(hexadecimal)
+                firstByte, remainingBytes = hexadecimal[0..1], hexadecimal[2..-1]
+                firstByteInt = Utils::Binary.intFromHex(firstByte)
+                oid = [firstByteInt.div(40), firstByteInt % 40]
+                oidInt = 0
+                while remainingBytes.to_s.length > 0
+                    byte, remainingBytes = remainingBytes[0..1], remainingBytes[2..-1]
+                    byteInt = Utils::Binary.intFromHex(byte)
+                    if byteInt >= 128
+                        oidInt = (128 * oidInt) + (byteInt - 128)
+                        next
+                    end
+                    oidInt = (128 * oidInt) + byteInt
+                    oid.append(oidInt)
+                    oidInt = 0
+                end
+                return oid
+            end
+
+            def self.oidToHex(oid)
+                hexadecimal = Utils::Binary.hexFromInt(40 * oid[0] + oid[1])
+                for number in oid[2..-1]
+                    hexadecimal += self._oidNumberToHex(number)
+                end
+                return hexadecimal
+            end
+
+            def self._oidNumberToHex(number)
+                hexadecimal = ""
+                endDelta = 0
+                while number > 0
+                    hexadecimal = Utils::Binary.hexFromInt((number % 128) + endDelta) + hexadecimal
+                    number = number.div(128)
+                    endDelta = 128
+                end
+                return hexadecimal == "" ? "00" : hexadecimal
+            end
+        end
+    end
+end

data/lib/utils/pem.rb

@@ -0,0 +1,18 @@
+module EllipticCurve
+    module Utils
+        class Pem
+            def self.getContent(pem, template)
+                pattern = template.sub "{content}", ("(.*)")
+                return pem.split("\n").join("").match(pattern.split("\n").join("")).captures[0]
+            end
+
+            def self.create(content, template)
+                lines = []
+                (0..content.length).step(64) do |start|
+                    lines.append(content[start..start+63])
+                end
+                return template.sub "{content}", lines.join("\n")
+            end
+        end
+    end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: starkbank-ecdsa
 version: !ruby/object:Gem::Version
-  version: 0.0.5
+  version: 2.0.0
 platform: ruby
 authors:
 - starkbank
@@ -44,12 +44,20 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- lib/curve.rb
 - lib/ecdsa.rb
+- lib/math.rb
+- lib/point.rb
 - lib/privatekey.rb
 - lib/publickey.rb
 - lib/signature.rb
 - lib/starkbank-ecdsa.rb
+- lib/utils/binary.rb
+- lib/utils/der.rb
 - lib/utils/file.rb
+- lib/utils/integer.rb
+- lib/utils/oid.rb
+- lib/utils/pem.rb
 homepage: https://github.com/starkbank/ecdsa-ruby
 licenses:
 - MIT
@@ -62,14 +70,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '2.3'
+      version: '2.4'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.6
+rubygems_version: 3.0.3.1
 signing_key: 
 specification_version: 4
 summary: fast openSSL-compatible implementation of the Elliptic Curve Digital Signature