nem-ruby 0.0.1

data/lib/nem/util/assignable.rb

@@ -0,0 +1,51 @@
+module Nem
+  module Util
+    module Assignable
+      def initialize(attributes = {})
+        attributes.each do |k, v|
+          send("#{k.to_s}=", v) if respond_to?("#{k.to_s}=")
+        end if attributes
+        yield self if block_given?
+      end
+
+      # @param [Symbol, String] attr Attribute name
+      # @return [Any] Attribute value
+      def [](attr)
+        send(attr)
+      end
+
+      # @return [Hash] Attribute and value pairs
+      def to_hash
+        hashed_properties = instance_variables.each_with_object({}) do |var, hash|
+          hash[var.to_s.delete('@').to_sym] = instance_variable_get(var)
+        end
+        hashnize(hashed_properties)
+      end
+
+      # @return [String] JSON formatted structure
+      def to_json(state = nil)
+        to_hash.to_json(state)
+      end
+
+      private
+
+      def hashnize(obj)
+        case true
+        when obj.class.to_s.start_with?('Nem::Unit')
+          obj.to_s
+        when obj.class.to_s.start_with?('Nem::Struct')
+          obj.to_hash
+        when obj.is_a?(Array)
+          obj.map { |el| hashnize(el) }
+        when obj.is_a?(Hash)
+          obj.inject({}) do |hash, (k, v)|
+            hash[k] = hashnize(v)
+            hash
+          end
+        else
+          obj
+        end
+      end
+    end
+  end
+end

data/lib/nem/util/convert.rb

@@ -0,0 +1,112 @@
+module Nem
+  module Util
+    module Convert
+      HEX_ENCODE_ARRAY = %w[0 1 2 3 4 5 6 7 8 9 a b c d e f]
+
+      # 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 hex to string
+      # @param [String] hex
+      # @return [String]
+      def self.hex2a(hex)
+        hex.scan(/../).inject('') { |memo, el| memo << el.hex.chr }
+      end
+
+      # @param [Array] bin
+      # @return [String]
+      def self.hex2bin(hex)
+        hex2ua(hex).pack('C*')
+      end
+
+      # @param [Array] bin
+      # @return [String]
+      def self.hex2bin_rev(hex)
+        hex2ua_rev(hex).pack('C*')
+      end
+
+      # @param [Array] bin
+      # @return [String]
+      def self.bin2hex(bin)
+        bin.map { |v| '%02x' % v }.join
+      end
+
+      # Convert UTF-8 to hex
+      # @param [string] str
+      # @return [string]
+      def self.utf8_to_hex(str)
+        rstr2utf8(str).bytes.inject('') { |memo, b| memo << b.to_s(16) }
+      end
+
+      # Convert an Array to hex
+      # @param [Array] ua - An Uint8Array
+      # @return [string]
+      def self.ua2hex(ua)
+        ua.inject('') { |memo, el| memo << "#{HEX_ENCODE_ARRAY[el >> 4]}#{HEX_ENCODE_ARRAY[el & 0x0f]}" }
+      end
+
+      # Convert an Uint8Array to WordArray
+      # @param [Array] 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 [Array] destUa - A destination Uint8Array
+      # @param [Array] cryptowords - A wordArray
+      # @return [Array]
+      def self.words2ua(words)
+        words.inject([]) do |memo, 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
+          memo + temp
+        end
+      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(str)
+        str.unpack('U*').inject('') do |memo, c|
+          memo << case
+                  when c < 128
+                    c.chr
+                  when 128 < c && c < 2048
+                    (c >> 6 | 192).chr + (c & 63 | 128).chr
+            else
+                    (c >> 12 | 224).chr + (c >> 6 & 63 | 128).chr + (c & 63 | 128).chr
+          end
+        end
+      end
+
+      # Does the reverse of rstr2utf8.
+      def utf82rstr(input)
+        raise 'Not implemented.'
+      end
+    end
+  end
+end

data/lib/nem/util/deserializer.rb

@@ -0,0 +1,158 @@
+module Nem
+  module Util
+    module Deserializer
+      # Deserialize a transaction object
+      # @param [String] serialized
+      # @return [Hash]
+      def self.deserialize_transaction(serialized)
+        s = Nem::Util::Convert.hex2ua(serialized)
+        common = s[0, 60]
+        specific = s[60, s.size]
+        type = deserialize_int(common[0, 4])
+        method = case type
+                 when 0x0101 then method(:deserialize_transfer)
+                 when 0x0801 then method(:deserialize_importance_transfer)
+                 when 0x1001 then method(:deserialize_multisig_aggregate_modification)
+                 when 0x1002 then method(:deserialize_multisig_signature)
+                 when 0x1004 then method(:deserialize_multisig)
+                 when 0x2001 then method(:deserialize_provision_namespace)
+                 when 0x4001 then method(:deserialize_mosaic_definition_creation)
+                 when 0x4002 then method(:deserialize_mosaic_supply_change)
+          else raise "Not implemented entity type: #{type}"
+        end
+        deserialize_common(common).merge(method.call(specific))
+      end
+
+      private
+
+      # Deserialize a transfer transaction object
+      # @param [String] serialized
+      # @return [Hash]
+      def self.deserialize_transfer(s)
+        tx = {}
+        tx[:recipient] = deserialize_a(s[4, 40])
+        tx[:amount] = deserialize_int(s[44, 8])
+        tx[:message] = {}
+        message_len = deserialize_int(s[52, 4])
+        if message_len > 0
+          # s[60, 4] # length of payload
+          tx[:message] = {
+            type: deserialize_int(s[56, 4]),
+            payload: deserialize_hex(s[64, s.size])
+          }
+        else
+          tx[:message] = { type: 1, payload: '' }
+        end
+        tx
+      end
+
+      # Deserialize a importance transaction object
+      # @param [String] serialized
+      # @return [Hash]
+      def self.deserialize_importance_transfer(s)
+        {
+          mode: deserialize_int(s[0, 4]),
+          remoteAccount: deserialize_hex(s[8, 32])
+        }
+      end
+
+      # Deserialize a multisig aggregate modification transaction object
+      # @param [String] serialized
+      # @return [Hash]
+      def self.deserialize_multisig_aggregate_modification(s)
+        raise 'Not yet implimented.'
+        # TODO: deserializing
+        tx = {}
+        tx
+      end
+
+      # Deserialize a multisig signature transaction object
+      # @param [String] serialized
+      # @return [Hash]
+      def self.deserialize_multisig_signature(s)
+        {
+          otherHash: { data: deserialize_hex(s[8, 32]) },
+          otherAccount: deserialize_a(s[44, 40])
+        }
+      end
+
+      # Deserialize a multisig transfer transaction object
+      # @param [String] serialized
+      # @return [Hash]
+      def self.deserialize_multisig(s)
+        raise 'Not yet implimented.'
+        # TODO: deserializing
+        tx = {}
+        tx
+      end
+
+      # Deserialize a provision namespace transaction object
+      # @param [String] serialized
+      # @return [Hash]
+      def self.deserialize_provision_namespace(s)
+        tx = {}
+        tx[:rentalFeeSink] = deserialize_a(s[4, 40])
+        tx[:rentalFee] = deserialize_int(s[44, 8])
+        newpart_len = deserialize_int(s[52, 4])
+        tx[:newPart] = deserialize_a(s[56, newpart_len])
+        parent_len = deserialize_int(s[56 + newpart_len, 4])
+        parent = s[56 + newpart_len, parent_len]
+        unless parent.all? { |val| val == 0xff }
+          tx[:parent] = deserialize_a(parent)
+        end
+        tx
+      end
+
+      # Deserialize a mosaic definition creation transaction object
+      # @param [String] serialized
+      # @return [Hash]
+      def self.deserialize_mosaic_definition_creation(s)
+        raise 'Not yet implimented.'
+        # TODO: deserializing
+        tx = {}
+        tx
+      end
+
+      # Deserialize a mosaic supply change transaction object
+      # @param [String] serialized
+      # @return [Hash]
+      def self.deserialize_mosaic_supply_change(s)
+        tx = {}
+        # s[0, 4] # Length of mosaic id structure
+        ns_len = deserialize_int(s[4, 4])
+        mo_len = deserialize_int(s[8 + ns_len, 4])
+        tx[:mosaicId] = {
+          namespaceId: deserialize_a(s[8, ns_len]),
+          name: deserialize_a(s[8 + ns_len + mo_len, mo_len])
+        }
+        tx[:supplyType] = deserialize_int(s[8 + ns_len + 4 + mo_len, 4])
+        tx[:delta] = deserialize_int(s[8 + ns_len + 4 + mo_len + 4, 8])
+        tx
+      end
+
+      def self.deserialize_common(s)
+        {
+          type: deserialize_int(s[0, 4]),
+          version: deserialize_int(s[4, 4]),
+          timeStamp: deserialize_int(s[8, 4]),
+          # s[12,4] # length of public key,
+          signer: deserialize_hex(s[16, 32]),
+          fee: deserialize_int(s[48, 8]),
+          deadline: deserialize_int(s[56, 4])
+        }
+      end
+
+      def self.deserialize_int(ua)
+        Nem::Util::Convert.ua2hex(ua.reverse).to_i(16)
+      end
+
+      def self.deserialize_hex(ua)
+        Nem::Util::Convert.ua2hex(ua)
+      end
+
+      def self.deserialize_a(ua)
+        Nem::Util::Convert.hex2a(deserialize_hex(ua))
+      end
+    end
+  end
+end

data/lib/nem/util/ed25519.rb

@@ -0,0 +1,316 @@
+require 'securerandom'
+require 'base32'
+require 'openssl'
+require 'digest/sha3'
+
+module Nem
+  module Util
+    module Ed25519
+      class << self
+        def int2byte(i)
+          i.chr
+        end
+
+        def indexbytes(buf, i)
+          buf[i].ord
+        end
+
+        def intlist2bytes(l)
+          l.inject('') { |memo, c| memo << c.chr }
+        end
+
+        # standard implement
+        def H(m)
+          OpenSSL::Digest::SHA512.digest(m)
+        end
+
+        def HH(m)
+          Digest::SHA3.digest(m)
+        end
+
+        def pow2(x, p)
+          while p > 0 do
+            x = x.to_bn.mod_exp(2, @@q).to_i
+            p -= 1
+          end
+          x
+        end
+
+        def inv(z)
+          # 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).to_i
+          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
+
+          [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) == 1
+          _Q
+        end
+
+        def make_Bpow
+          _P = @@B
+          253.times 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
+          253.times 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).inject('') { |memo, i| memo << int2byte((0...8).inject(0) { |sum, j| sum + (bits[i * 8 + j] << j) }) }
+        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).inject('') { |memo, i| memo << int2byte((0...8).inject(0) { |sum, j| sum + (bits[i * 8 + j] << j) }) }
+        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)
+          codepoint(_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)
+          encodepoint(_A)
+        end
+
+        def encrypt(sk, pk, data)
+          h = HH(sk)
+          a = 2**(@@b - 2) + (3...@@b - 2).inject(0) { |sum, i| sum + 2**i * bit(h, i) }
+          _A = decodepoint(pk)
+          bin_g = encodepoint(scalarmult(_A, a))
+
+          bin_iv = SecureRandom.random_bytes(16)
+          hex_iv = bin_iv.unpack('H*').first
+
+          bin_salt = SecureRandom.random_bytes(32)
+          hex_salt = bin_salt.unpack('H*').first
+
+          ua_salt = Nem::Util::Convert.hex2ua(hex_salt)
+          ua_g = Nem::Util::Convert.hex2ua(bin_g.unpack('H*').first)
+
+          c = []
+          ua_salt.each_with_index { |el, idx| c << (el ^ ua_g[idx]) }
+          bin_key = Digest::SHA3.digest(c.pack('C*'), 256)
+
+          cipher = OpenSSL::Cipher.new('AES-256-CBC')
+          cipher.encrypt
+          cipher.key = bin_key
+          cipher.iv = bin_iv
+          encrypted_data = cipher.update(data.bytes.pack('C*')) + cipher.final
+          hex_salt + hex_iv + encrypted_data.unpack('H*').first
+        end
+
+        def decrypt(sk, pk, data)
+          h = HH(sk)
+          a = 2**(@@b - 2) + (3...@@b - 2).inject(0) { |sum, i| sum + 2**i * bit(h, i) }
+          _A = decodepoint(pk)
+          bin_g = encodepoint(scalarmult(_A, a))
+
+          hex_salt = data[0, 64]
+          hex_iv = data[64, 32]
+          hex_encrypted = data[96, data.size]
+
+          ua_iv = Nem::Util::Convert.hex2ua(hex_iv)
+          bin_iv = ua_iv.pack('C*')
+
+          ua_salt = Nem::Util::Convert.hex2ua(hex_salt)
+          ua_g = Nem::Util::Convert.hex2ua(bin_g.unpack('H*').first)
+
+          c = []
+          ua_salt.each_with_index { |el, idx| c << (el ^ ua_g[idx]) }
+          bin_key = Digest::SHA3.digest(c.pack('C*'), 256)
+
+          bin_encrypted = Nem::Util::Convert.hex2ua(hex_encrypted).pack('C*')
+
+          cipher = OpenSSL::Cipher.new('AES-256-CBC')
+          cipher.decrypt
+          cipher.key = bin_key
+          cipher.iv = bin_iv
+          cipher.update(bin_encrypted) + cipher.final
+        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.
+        # 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) &&
+            x * y % @@q == (z * t % @@q) &&
+            (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| sum + 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.
+        # 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[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 = []
+      self.make_Bpow
+    end
+  end
+end