nis-ruby 0.0.12 → 0.0.13

data/lib/nis/transaction/multisig_aggregate_modification.rb

@@ -8,7 +8,7 @@ class Nis::Transaction
   # @attr [Integer] version
   # @attr [String] signer
   # @attr [String] signature
-  # @see http://bob.nem.ninja/docs/#multisigAggregateModificationTransaction
+  # @see https://nemproject.github.io/#multisigAggregateModificationTransaction
   class MultisigAggregateModification
     include Nis::Mixin::Struct
 

data/lib/nis/transaction/multisig_signature.rb

@@ -8,7 +8,7 @@ class Nis::Transaction
   # @attr [Integer] version
   # @attr [String] signer
   # @attr [String] signature
-  # @see http://bob.nem.ninja/docs/#multisigSignatureTransaction
+  # @see https://nemproject.github.io/#multisigSignatureTransaction
   class MultisigSignature
     include Nis::Mixin::Struct
 

data/lib/nis/transaction/provision_namespace.rb

@@ -11,7 +11,7 @@ class Nis::Transaction
   # @attr [String] signer
   # @attr [String] signature
   # @attr [Symbol] network
-  # @see http://bob.nem.ninja/docs/#provisionNamespaceTransaction
+  # @see https://nemproject.github.io/#provisionNamespaceTransaction
   class ProvisionNamespace
     include Nis::Mixin::Struct
 

data/lib/nis/transaction/transfer.rb

@@ -10,10 +10,10 @@ class Nis::Transaction
   # @attr [Integer] version
   # @attr [String] signer
   # @attr [Symbol] network
-  # @see http://bob.nem.ninja/docs/#transferTransaction
-  # @see http://bob.nem.ninja/docs/#initiating-a-transfer-transaction
-  # @see http://bob.nem.ninja/docs/#version-1-transfer-transactions
-  # @see http://bob.nem.ninja/docs/#version-2-transfer-transactions
+  # @see https://nemproject.github.io/#transferTransaction
+  # @see https://nemproject.github.io/#initiating-a-transfer-transaction
+  # @see https://nemproject.github.io/#version-1-transfer-transactions
+  # @see https://nemproject.github.io/#version-2-transfer-transactions
   class Transfer
     include Nis::Mixin::Struct
 

data/lib/nis/unit/address.rb

@@ -1,3 +1,7 @@
+require 'openssl'
+require 'base32'
+require 'digest/sha3'
+
 module Nis::Unit
   # @attr [String] value
   class Address
@@ -37,5 +41,20 @@ module Nis::Unit
     def ==(other)
       @value == other.value
     end
+
+    def self.from_public_key(public_key, network = :testnet)
+      bin_public_key = public_key.scan(/../).map(&:hex).pack('C*')
+      public_key_hash = Digest::SHA3.digest(bin_public_key, 256)
+      ripe = OpenSSL::Digest::RIPEMD160.digest(public_key_hash)
+
+      if network == :testnet
+        version = "\x98".force_encoding("ASCII-8BIT") + ripe
+      else
+        version = "\x68" + ripe
+      end
+
+      checksum = Digest::SHA3.digest(version, 256)[0...4]
+      self.new(Base32.encode(version + checksum))
+    end
   end
 end

data/lib/nis/util/convert.rb

@@ -0,0 +1,125 @@
+module Nis::Util
+  module Convert
+    HEX_ENCODE_ARRAY = %w[0 1 2 3 4 5 6 7 8 9 a b c d e f]
+
+    def hexlify(obj)
+      obj.unpack('H*').first
+    end
+
+    def unhexlify(obj)
+      obj.scan(/../).map(&:hex).pack('C*')
+    end
+
+    # Reversed convertion of hex to Uint8Array
+    # @param [String] hex
+    # @return [Array]
+    def self.hex2ua_rev(hex)
+      hex2ua(hex).reverse
+    end
+
+    # Convert hex to Uint8Array
+    # @param [String] hex
+    # @return [Array]
+    def self.hex2ua(hex)
+      hex.scan(/../).map(&:hex)
+    end
+
+    # Convert an Uint8Array to hex
+    # @param [Uint8Array] ua - An Uint8Array
+    # @return [string]
+    def self.ua2hex(ua)
+      ua.map { |el| "#{HEX_ENCODE_ARRAY[el >> 4]}#{HEX_ENCODE_ARRAY[el & 0x0f]}" }.join
+    end
+
+    # Convert hex to string
+    # @param [String] hex
+    # @return [String]
+    def self.hex2a(hex)
+      hex.scan(/../).map { |el| el.to_i(16).chr }.join
+    end
+
+    # Convert UTF-8 to hex
+    # @param [string] str
+    # @return [string]
+    def self.utf8_to_hex(str)
+      rstr2utf8(str).each_byte.map { |b| b.to_s(16) }.join
+    end
+
+    # // Padding helper for above function
+    # let strlpad = function(str, pad, len) {
+    #     while (str.length < len) {
+    #         str = pad + str;
+    #     }
+    #     return str;
+    # }
+
+    # Convert an Uint8Array to WordArray
+    # @param [Uint8Array] ua - An Uint8Array
+    # @param [number] uaLength - The Uint8Array length
+    # @return [WordArray]
+    def self.ua2words(ua, ua_length)
+      ua[0, ua_length].each_slice(4).map do |chunk|
+        x = chunk[0] * 0x1000000 +
+          chunk[1] * 0x10000 +
+          chunk[2] * 0x100 +
+          chunk[3] * 0x1
+        x > 0x7fffffff ? x - 0x100000000 : x
+      end
+    end
+
+    # Convert a wordArray to Uint8Array
+    # @param [Uint8Array] destUa - A destination Uint8Array
+    # @param [WordArray] cryptowords - A wordArray
+    # @return [Uint8Array]
+    def self.words2ua(words)
+      words.map do |v|
+        temp = []
+        v += 0x100000000 if v < 0
+        temp[0] = (v >> 24)
+        temp[1] = (v >> 16) & 0xff
+        temp[2] = (v >>  8) & 0xff
+        temp[3] = (v)       & 0xff
+        temp
+      end.flatten
+    end
+
+    # Converts a raw javascript string into a string of single byte characters using utf8 encoding.
+    # This makes it easier to perform other encoding operations on the string.
+    # @param [String] str
+    # @return [String]
+    def self.rstr2utf8(input)
+      input.unpack('U*').map do |c|
+        case
+        when c < 128
+          c
+        when 128 < c && c < 2048
+          [((c >> 6) | 192), ((c & 63) | 128)]
+        else
+          [((c >> 12) | 224), (((c >> 6) & 63) | 128), ((c & 63) | 128)]
+        end
+      end.flatten.map(&:chr).join
+    end
+
+    # Does the reverse of rstr2utf8.
+    def utf82rstr(input)
+        # let output = "", i = 0, c = 0, c1 = 0, c2 = 0, c3 = 0;
+        # while (i < input.length) {
+        #     c = input.charCodeAt(i);
+        #     if (c < 128) {
+        #         output += String.fromCharCode(c);
+        #         i++;
+        #     } else if ((c > 191) && (c < 224)) {
+        #         c2 = input.charCodeAt(i + 1);
+        #         output += String.fromCharCode(((c & 31) << 6) | (c2 & 63));
+        #         i += 2;
+        #     } else {
+        #         c2 = input.charCodeAt(i + 1);
+        #         c3 = input.charCodeAt(i + 2);
+        #         output += String.fromCharCode(((c & 15) << 12) | ((c2 & 63) << 6) | (c3 & 63));
+        #         i += 3;
+        #     }
+        # }
+        # return output;
+    end
+  end
+end

data/lib/nis/util/ed25519.rb

@@ -0,0 +1,263 @@
+require 'openssl'
+require 'digest/sha3'
+require 'base32'
+
+module Nis::Util
+  module Ed25519
+    class << self
+      def int2byte(i)
+        i.chr
+      end
+
+      def indexbytes(buf, i)
+        buf[i].ord
+      end
+
+      def intlist2bytes(l)
+        l.map {|c| c.chr }.join
+      end
+
+      # standard implement
+      def H(m)
+        OpenSSL::Digest::SHA512.digest(m)
+      end
+
+      def HH(m)
+        Digest::SHA3.digest(m)
+      end
+
+      def pow2(x, p)
+        # """== pow(x, 2**p, q)"""
+        while p > 0 do
+          x = x * x % $q
+          p -= 1
+        end
+        x
+      end
+
+      def inv(z)
+        # """$= z^{-1} \mod q$, for z != 0"""
+        # Adapted from curve25519_athlon.c in djb's Curve25519.
+        z2 = z * z % $q  # 2
+        z9 = pow2(z2, 2) * z % $q  # 9
+        z11 = z9 * z2 % $q  # 11
+        z2_5_0 = (z11 * z11) % $q * z9 % $q  # 31 == 2^5 - 2^0
+        z2_10_0 = pow2(z2_5_0, 5) * z2_5_0 % $q  # 2^10 - 2^0
+        z2_20_0 = pow2(z2_10_0, 10) * z2_10_0 % $q  # ...
+        z2_40_0 = pow2(z2_20_0, 20) * z2_20_0 % $q
+        z2_50_0 = pow2(z2_40_0, 10) * z2_10_0 % $q
+        z2_100_0 = pow2(z2_50_0, 50) * z2_50_0 % $q
+        z2_200_0 = pow2(z2_100_0, 100) * z2_100_0 % $q
+        z2_250_0 = pow2(z2_200_0, 50) * z2_50_0 % $q  # 2^250 - 2^0
+        pow2(z2_250_0, 5) * z11 % $q  # 2^255 - 2^5 + 11 = q - 2
+      end
+
+      def xrecover(y)
+        xx = (y * y - 1) * inv($d * y * y + 1)
+        x = xx.to_bn.mod_exp(($q + 3) / 8, $q)
+        x = (x * $I) % $q if (x * x - xx) % $q != 0
+        x = $q - x if x % 2 != 0
+        x
+      end
+
+      def edwards_add(_P, _Q)
+        # This is formula sequence 'addition-add-2008-hwcd-3' from
+        # http://www.hyperelliptic.org/EFD/g1p/auto-twisted-extended-1.html
+        x1, y1, z1, t1 = _P
+        x2, y2, z2, t2 = _Q
+
+        a = (y1 - x1) * (y2 - x2) % $q
+        b = (y1 + x1) * (y2 + x2) % $q
+        c = t1 * 2 * $d * t2 % $q
+        dd = z1 * 2 * z2 % $q
+        e = b - a
+        f = dd - c
+        g = dd + c
+        h = b + a
+        x3 = e * f
+        y3 = g * h
+        t3 = e * h
+        z3 = f * g
+
+        [x3 % $q, y3 % $q, z3 % $q, t3 % $q]
+      end
+
+      def edwards_double(_P)
+        # This is formula sequence 'dbl-2008-hwcd' from
+        # http://www.hyperelliptic.org/EFD/g1p/auto-twisted-extended-1.html
+        x1, y1, z1, _t1 = _P
+
+        a = x1 * x1 % $q
+        b = y1 * y1 % $q
+        c = 2 * z1 * z1 % $q
+        # dd = -a
+        e = ((x1 + y1) * (x1 + y1) - a - b) % $q
+        g = -a + b  # dd + b
+        f = g - c
+        h = -a - b  # dd - b
+        x3 = e * f
+        y3 = g * h
+        t3 = e * h
+        z3 = f * g
+
+        return x3 % $q, y3 % $q, z3 % $q, t3 % $q
+      end
+
+      def scalarmult(_P, e)
+        return $ident if e == 0
+        _Q = scalarmult(_P, e / 2)
+        _Q = edwards_double(_Q)
+        _Q = edwards_add(_Q, _P) if e & 1
+        _Q
+      end
+
+      def make_Bpow
+        _P = $B
+        (0...253).each do |_|
+          $Bpow << _P
+          _P = edwards_double(_P)
+        end
+      end
+
+      # Implements scalarmult(B, e) more efficiently.
+      def scalarmult_B(e)
+        # scalarmult(B, l) is the identity
+        e = e % $l
+        _P = $ident
+        (0...253).each do |i|
+          _P = edwards_add(_P, $Bpow[i]) if e & 1 == 1
+          e = e / 2
+        end
+        _P
+      end
+
+      def encodeint(y)
+        bits = (0...$b).map {|i| (y >> i) & 1}
+        (0...$b/8).map {|i| int2byte((0...8).inject(0) {|sum, j| sum + (bits[i * 8 + j] << j) }) }.join
+      end
+
+      def encodepoint(_P)
+        x, y, z, _t = _P
+        zi = inv(z)
+        x = (x * zi) % $q
+        y = (y * zi) % $q
+        bits = (0...$b-1).map {|i| (y >> i) & 1} + [x & 1]
+        (0...$b/8).map {|i| int2byte((0...8).inject(0) {|sum, j| sum + (bits[i * 8 + j] << j) }) }.join
+      end
+
+      def bit(h, i)
+        (indexbytes(h, i / 8) >> (i % 8)) & 1
+      end
+
+      def publickey_unsafe(sk)
+        h = H(sk)
+        a = 2 ** ($b-2) + (3...$b-2).inject(0) {|sum, i| sum + 2 ** i * bit(h, i) }
+        _A = scalarmult_B(a)
+        return encodepoint(_A)
+      end
+
+      def publickey_hash_unsafe(sk)
+        h = HH(sk)
+        a = 2 ** ($b-2) + (3...$b-2).inject(0) {|sum, i| sum + 2 ** i * bit(h, i) }
+        _A = scalarmult_B(a)
+        return encodepoint(_A)
+      end
+
+      def Hint(m)
+        h = H(m)
+        (0...2*$b).inject(0) {|sum, i| sum + 2 ** i * bit(h, i) }
+      end
+
+      def Hint_hash(m)
+        h = HH(m)
+        (0...2*$b).inject(0) {|sum, i| sum + 2 ** i * bit(h, i) }
+      end
+
+      def signature_unsafe(m, sk, pk)
+        h = H(sk)
+        a = 2 ** ($b-2) + (3...$b-2).inject(0) {|sum, i| sum + 2 ** i * bit(h, i) }
+        r = Hint(
+          intlist2bytes(($b/8...$b/4).map {|j| indexbytes(h, j) }) + m
+        )
+        _R = scalarmult_B(r)
+        _S = (r + Hint(encodepoint(_R) + pk + m) * a) % $l
+        encodepoint(_R) + encodeint(_S)
+      end
+
+      # Not safe to use with secret keys or secret data.
+      #
+      # See module docstring.  This function should be used for testing only.
+      def signature_hash_unsafe(m, sk, pk)
+        h = HH(sk)
+        a = 2 ** ($b-2) + (3...$b-2).inject(0) {|sum, i| sum + 2 ** i * bit(h, i) }
+        r = Hint_hash(
+          intlist2bytes(($b/8...$b/4).map {|j| indexbytes(h, j) }) + m
+        )
+        _R = scalarmult_B(r)
+        _S = (r + Hint_hash(encodepoint(_R) + pk + m) * a) % $l
+        encodepoint(_R) + encodeint(_S)
+      end
+
+      def isoncurve(_P)
+        x, y, z, t = _P
+        (z % $q != 0 and
+          x * y % $q == z * t % $q and
+          (y * y - x * x - z * z - $d * t * t) % $q == 0)
+      end
+
+      def decodeint(s)
+        (0...$b).inject(0) {|sum, i| sum + 2 ** i * bit(s, i) }
+      end
+
+      def decodepoint(s)
+        y = (0...$b-1).inject(0) {|sum, i| 2 ** i * bit(s, i) }
+        x = xrecover(y)
+        x = $q - x if x & 1 != bit(s, $b - 1)
+        _P = [x, y, 1, (x * y) % $q]
+        raise "decoding point that is not on curve" unless isoncurve(_P)
+        _P
+      end
+
+      class SignatureMismatch < StandardError
+      end
+
+      # Not safe to use when any argument is secret.
+      #
+      # See module docstring.  This function should be used only for
+      # verifying public signatures of public messages.
+      def checkvalid(s, m, pk)
+        raise "signature length is wrong" if s.size != $b / 4
+        raise "public-key length is wrong" if pk.size != $b / 8
+
+        # _R = decodepoint(s[:b // 8])
+        _R = decodepoint(s[0...$b/8])
+        _A = decodepoint(pk)
+        _S = decodeint(s[$b/8...$b/4])
+        h = Hint(encodepoint(_R) + pk + m)
+
+        x1, y1, z1, _t1 = _P = scalarmult_B(_S)
+        x2, y2, z2, _t2 = _Q = edwards_add(_R, scalarmult(_A, h))
+
+        if (!isoncurve(_P) || !isoncurve(_Q) || (x1 * z2 - x2 * z1) % q != 0 || (y1 * z2 - y2 * z1) % q != 0)
+          raise SignatureMismatch("signature does not pass verification")
+        end
+      end
+    end
+
+    $b = 256
+    $q = 2 ** 255 - 19
+    $l = 2 ** 252 + 27742317777372353535851937790883648493
+
+    $d = -121665 * self.inv(121666) % $q
+    $I = 2.to_bn.mod_exp(($q - 1) / 4, $q)
+
+    $By = 4 * self.inv(5)
+    $Bx = self.xrecover($By)
+    $B = [$Bx % $q, $By % $q, 1, ($Bx * $By) % $q]
+    $ident = [0, 1, 1, 0]
+
+    # Bpow[i] == scalarmult(B, 2**i)
+    $Bpow = []
+    self.make_Bpow
+  end
+end