iota-ruby 1.0.1

data/lib/iota/crypto/converter.rb

@@ -0,0 +1,241 @@
+module IOTA
+  module Crypto
+    class Converter
+      RADIX = 3
+      RADIX_BYTES = 256
+      MAX_TRIT_VALUE = 1
+      MIN_TRIT_VALUE = -1
+      BYTE_HASH_LENGTH = 48
+      HASH_LENGTH = IOTA::Crypto::Curl::HASH_LENGTH
+
+      # All possible tryte values
+      TRYTES_ALPHABET = "9ABCDEFGHIJKLMNOPQRSTUVWXYZ"
+
+      TRYTE_TRITS = [
+        [ 0,  0,  0],
+        [ 1,  0,  0],
+        [-1,  1,  0],
+        [ 0,  1,  0],
+        [ 1,  1,  0],
+        [-1, -1,  1],
+        [ 0, -1,  1],
+        [ 1, -1,  1],
+        [-1,  0,  1],
+        [ 0,  0,  1],
+        [ 1,  0,  1],
+        [-1,  1,  1],
+        [ 0,  1,  1],
+        [ 1,  1,  1],
+        [-1, -1, -1],
+        [ 0, -1, -1],
+        [ 1, -1, -1],
+        [-1,  0, -1],
+        [ 0,  0, -1],
+        [ 1,  0, -1],
+        [-1,  1, -1],
+        [ 0,  1, -1],
+        [ 1,  1, -1],
+        [-1, -1,  0],
+        [ 0, -1,  0],
+        [ 1, -1,  0],
+        [-1,  0,  0]
+      ]
+
+      class << self
+        def trits(input, state = [])
+          trits = state
+
+          if input.is_a? Integer
+            absoluteValue = input < 0 ? -input : input
+
+            while absoluteValue > 0
+              remainder = absoluteValue % 3
+              absoluteValue = (absoluteValue / 3).floor
+
+              if remainder > 1
+                remainder = -1
+                absoluteValue += 1
+              end
+
+              trits[trits.length] = remainder
+            end
+
+            if input < 0
+              (0... trits.length).step(1) do |i|
+                trits[i] = -trits[i]
+              end
+            end
+          else
+            (0... input.length).step(1) do |i|
+              index = TRYTES_ALPHABET.index(input[i])
+              tmp = i * 3
+              trits[tmp...tmp+3] = TRYTE_TRITS[index]
+            end
+          end
+
+          trits
+        end
+
+        def trytes(trits)
+          trytes = ""
+
+          (0...trits.length).step(3) do |i|
+            chunk = trits[i...i+3]
+            trytes += TRYTES_ALPHABET[TRYTE_TRITS.index(chunk)]
+          end
+
+          trytes
+        end
+
+        def value(trits)
+          returnValue = 0
+
+          range = (trits.length..0)
+
+          range.first.downto(range.last).each do |i|
+            returnValue = returnValue * 3 + trits[i].to_i
+          end
+
+          returnValue
+        end
+
+        def fromValue(value)
+          destination = []
+          absoluteValue = value < 0 ? -value : value
+          i = 0
+
+          while absoluteValue > 0
+            remainder = absoluteValue % RADIX
+            absoluteValue = (absoluteValue / RADIX).floor
+
+            if remainder > MAX_TRIT_VALUE
+              remainder = MIN_TRIT_VALUE
+              absoluteValue += 1
+            end
+            destination[i] = remainder
+            i += 1
+          end
+
+          if value < 0
+            (0...destination.length).step(1) do |j|
+              # switch values
+              destination[j] = destination[j] == 0 ? 0 : -destination[j]
+            end
+          end
+
+          destination
+        end
+
+        ### ADOPTED FROM PYTHON LIBRARY
+        # Word to tryte & trytes to words conversion
+        def convertToBytes(trits)
+          bigInt = convertBaseToBigInt(trits, 3)
+          bytes_k = convertBigIntToBytes(bigInt)
+          bytes_k
+        end
+
+        def convertToTrits(bytes)
+          bigInt = convertBytesToBigInt(bytes)
+          trits = convertBigIntToBase(bigInt, 3, HASH_LENGTH)
+          trits
+        end
+
+        # Convert between signed and unsigned bytes
+        def convertSign(byte)
+          if byte < 0
+            return 256 + byte
+          elsif byte > 127
+            return -256 + byte
+          end
+          byte
+        end
+
+        def convertBaseToBigInt(array, base)
+          bigint = 0
+          (0...array.length).step(1) do |i|
+            bigint += array[i] * (base ** i)
+          end
+          bigint
+        end
+
+        def convertBigIntToBase(bigInt, base, length)
+          result = []
+
+          isNegative = bigInt < 0
+          quotient = bigInt.abs
+
+          max, _ = (isNegative ? base : base-1).divmod(2)
+
+          length.times do
+            quotient, remainder = quotient.divmod(base)
+
+            if remainder > max
+              # Lend 1 to the next place so we can make this digit negative.
+              quotient += 1
+              remainder -= base
+            end
+
+            remainder = -remainder if isNegative
+
+            result << remainder
+          end
+
+          result
+        end
+
+        def convertBigIntToBytes(big)
+          bytesArrayTemp = []
+
+          (0...48).step(1) do |pos|
+            bytesArrayTemp << (big.abs >> pos * 8) % (1 << 8)
+          end
+
+          # big endian and balanced
+          bytesArray = bytesArrayTemp.reverse.map { |x| x <= 0x7F ? x : x - 0x100 }
+
+          if big < 0
+            # 1-compliment
+            bytesArray = bytesArray.map { |x| ~x }
+
+            # add1
+            (0...bytesArray.length).reverse_each do |pos|
+              add = (bytesArray[pos] & 0xFF) + 1
+              bytesArray[pos] = add <= 0x7F ? add : add - 0x100
+              break if bytesArray[pos] != 0
+            end
+          end
+
+          bytesArray
+        end
+
+        def convertBytesToBigInt(array)
+          # copy of array
+          bytesArray = array.map { |x| x }
+
+          # number sign in MSB
+          signum = bytesArray[0] >= 0 ? 1 : -1
+
+          if signum == -1
+            # sub1
+            (0...bytesArray.length).reverse_each do |pos|
+              sub = (bytesArray[pos] & 0xFF) - 1
+              bytesArray[pos] = sub <= 0x7F ? sub : sub - 0x100
+              break if bytesArray[pos] != -1
+            end
+
+            # 1-compliment
+            bytesArray = bytesArray.map { |x| ~x }
+          end
+
+          # sum magnitudes and set sign
+          sum = 0
+          bytesArray.reverse.each_with_index do |v, pos|
+            sum += (v & 0xFF) << pos * 8
+          end
+
+          sum * signum
+        end
+      end
+    end
+  end
+end

data/lib/iota/crypto/curl.rb

@@ -0,0 +1,74 @@
+module IOTA
+  module Crypto
+    class Curl
+      NUMBER_OF_ROUNDS = 81
+      HASH_LENGTH = 243
+      STATE_LENGTH = 3 * HASH_LENGTH
+
+      def initialize(rounds = nil)
+        @rounds = rounds || NUMBER_OF_ROUNDS
+        @truthTable = [1, 0, -1, 2, 1, -1, 0, 2, -1, 1, 0]
+      end
+
+      def setup(state = nil)
+        if state
+          @state = state
+        else
+          @state = []
+          STATE_LENGTH.times {|a| @state << 0}
+        end
+      end
+
+      def reset
+        setup
+      end
+
+      def absorb(trits, offset, length)
+        loop do
+          i = 0
+          limit = length < HASH_LENGTH ? length : HASH_LENGTH
+
+          while i < limit
+            @state[i] = trits[offset]
+            i += 1
+            offset += 1
+          end
+
+          transform
+          length -= HASH_LENGTH
+
+          break if length <= 0
+        end
+      end
+
+      def squeeze(trits, offset, length)
+        loop do
+          i = 0
+          limit = length < HASH_LENGTH ? length : HASH_LENGTH
+          while i < limit
+            trits[offset] = @state[i]
+            i += 1
+            offset += 1
+          end
+
+          transform
+          length -= HASH_LENGTH
+
+          break if length <= 0
+        end
+      end
+
+      def transform
+        stateCopy = []
+        index = 0
+
+        (0...@rounds).step(1) do |_|
+          stateCopy = @state.slice(0, @state.length)
+          (0...STATE_LENGTH).step(1) do |i|
+            @state[i] = @truthTable[stateCopy[index].to_i + (stateCopy[index += (index < 365 ? 364 : -365)].to_i << 2) + 5]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/iota/crypto/hmac.rb

@@ -0,0 +1,27 @@
+module IOTA
+  module Crypto
+    class Hmac
+      ROUNDS = 27
+
+      def initialize(key)
+        @key = Converter.trits(key)
+      end
+
+      def addHMAC(bundle)
+        curl = Curl.new(ROUNDS)
+        (0...bundle.bundle.length).step(1) do |i|
+          if bundle.bundle[i].value > 0
+            bundleHashTrits = Converter.trits(bundle.bundle[i].bundle)
+            hmac = Array.new(243, 0)
+            curl.reset
+            curl.absorb(@key)
+            curl.absorb(bundleHashTrits)
+            curl.squeeze(hmac)
+            hmacTrytes = Converter.trytes(hmac)
+            bundle.bundle[i].signatureMessageFragment = hmacTrytes + bundle.bundle[i].signatureMessageFragment[81...2187]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/iota/crypto/kerl.rb

@@ -0,0 +1,78 @@
+require 'digest/sha3'
+
+module IOTA
+  module Crypto
+    class Kerl
+      BIT_HASH_LENGTH = 384
+      HASH_LENGTH = Curl::HASH_LENGTH
+
+      def initialize
+        reset
+      end
+
+      def reset
+        @hasher = Digest::SHA3.new(BIT_HASH_LENGTH)
+      end
+
+      def absorb(trits, offset = 0, length = nil)
+        pad = trits.length % HASH_LENGTH != 0 ? trits.length % HASH_LENGTH : HASH_LENGTH
+        trits.concat([0] * (HASH_LENGTH - pad))
+
+        length = trits.length if length.nil?
+
+        if length % HASH_LENGTH != 0 || length == 0
+          raise StandardError,  "Illegal length provided"
+        end
+
+        while offset < length
+          limit = [offset + HASH_LENGTH, length].min
+
+          # If we're copying over a full chunk, zero last trit
+          trits[limit - 1] = 0 if limit - offset == HASH_LENGTH
+
+          signed_bytes = Converter.convertToBytes(trits[offset...limit])
+
+          # Convert signed bytes into their equivalent unsigned representation
+          # In order to use Python's built-in bytes type
+          unsigned_bytes = signed_bytes.map{ |b| Converter.convertSign(b) }.pack('c*').force_encoding('UTF-8')
+
+          @hasher.update(unsigned_bytes)
+
+          offset += HASH_LENGTH
+        end
+      end
+
+      def squeeze(trits, offset = 0, length = nil)
+        pad = trits.length % HASH_LENGTH != 0 ? trits.length % HASH_LENGTH : HASH_LENGTH
+        trits.concat([0] * (HASH_LENGTH - pad))
+
+        length = trits.length > 0 ? trits.length : HASH_LENGTH if length.nil?
+
+        if length % HASH_LENGTH != 0 || length == 0
+          raise StandardError,  "Illegal length provided"
+        end
+
+        while offset < length
+          unsigned_hash =  @hasher.digest
+
+          signed_hash = unsigned_hash.bytes.map { |b| Converter.convertSign(b) }
+
+          trits_from_hash = Converter.convertToTrits(signed_hash)
+          trits_from_hash[HASH_LENGTH - 1] = 0
+
+          limit = [HASH_LENGTH, length - offset].min
+
+          trits[offset...offset+limit] = trits_from_hash[0...limit]
+
+          flipped_bytes = unsigned_hash.bytes.map{ |b| Converter.convertSign(~b)}.pack('c*').force_encoding('UTF-8')
+
+          # Reset internal state before feeding back in
+          reset
+          @hasher.update(flipped_bytes)
+
+          offset += HASH_LENGTH
+        end
+      end
+    end
+  end
+end

data/lib/iota/crypto/private_key.rb

@@ -0,0 +1,80 @@
+module IOTA
+  module Crypto
+    class PrivateKey
+      HASH_LENGTH = Kerl::HASH_LENGTH
+
+      attr_reader :key
+
+      def initialize(seed, index, security)
+        key = []
+        offset = 0
+        buffer = []
+
+        (0...index).step(1) do |i|
+          # Treat ``seed`` like a really big number and add ``index``.
+          # Note that addition works a little bit differently in balanced ternary.
+          (0...seed.length).step(1) do |j|
+            seed[j] += 1
+
+            if seed[j] > 1
+              seed[j] = -1
+            else
+              break
+            end
+          end
+        end
+
+        kerl = Kerl.new
+        kerl.absorb(seed, 0, seed.length)
+        kerl.squeeze(seed, 0, seed.length)
+        kerl.reset
+        kerl.absorb(seed, 0, seed.length)
+
+        security.times do
+          (0...27).step(1) do |i|
+            kerl.squeeze(buffer, 0, seed.length)
+            (0...HASH_LENGTH).step(1) do |j|
+              key[offset] = buffer[j]
+              offset += 1
+            end
+          end
+        end
+
+        @key = key
+      end
+
+      def digests
+        digestsArray = []
+        buffer = []
+
+        (0...(@key.length / 6561).floor).step(1) do |i|
+          keyFragment = @key.slice(i * 6561, 6561)
+
+          (0...27).step(1) do |j|
+            buffer = keyFragment.slice(j * HASH_LENGTH, HASH_LENGTH);
+
+            (0...26).step(1) do |k|
+              kKerl = Kerl.new
+              kKerl.absorb(buffer, 0, buffer.length)
+              kKerl.squeeze(buffer, 0, HASH_LENGTH)
+            end
+
+            (0...HASH_LENGTH).step(1) do |k|
+              keyFragment[j * HASH_LENGTH + k] = buffer[k]
+            end
+          end
+
+          kerl = Kerl.new
+          kerl.absorb(keyFragment, 0, keyFragment.length)
+          kerl.squeeze(buffer, 0, HASH_LENGTH)
+
+          (0...HASH_LENGTH).step(1) do |j|
+            digestsArray[i * HASH_LENGTH + j] = buffer[j];
+          end
+        end
+
+        digestsArray
+      end
+    end
+  end
+end

data/lib/iota/crypto/signing.rb

@@ -0,0 +1,97 @@
+module IOTA
+  module Crypto
+    class Signing
+      HASH_LENGTH = Kerl::HASH_LENGTH
+
+      class << self
+        def address(digests)
+          addressTrits = []
+
+          kerl = Kerl.new
+
+          kerl.absorb(digests, 0, digests.length)
+          kerl.squeeze(addressTrits, 0, Kerl::HASH_LENGTH)
+
+          addressTrits
+        end
+
+        def digest(normalizedBundleFragment, signatureFragment)
+          buffer = []
+          kerl = Kerl.new
+
+          (0...27).step(1) do |i|
+            buffer = signatureFragment.slice(i * HASH_LENGTH, HASH_LENGTH)
+
+            j = normalizedBundleFragment[i] + 13
+
+            while j > 0
+              jKerl = Kerl.new
+              jKerl.absorb(buffer, 0, buffer.length)
+              jKerl.squeeze(buffer, 0, HASH_LENGTH)
+              j -= 1
+            end
+
+            kerl.absorb(buffer, 0, buffer.length)
+          end
+
+          kerl.squeeze(buffer, 0, HASH_LENGTH)
+          buffer
+        end
+
+        def signatureFragment(normalizedBundleFragment, keyFragment)
+          signatureFragment = keyFragment.slice(0, keyFragment.length)
+          hash = []
+
+          kerl = Kerl.new
+
+          (0...27).step(1) do |i|
+            hash = signatureFragment.slice(i * HASH_LENGTH, HASH_LENGTH)
+
+            (0...13-normalizedBundleFragment[i]).step(1) do |j|
+              kerl.reset
+              kerl.absorb(hash, 0, hash.length)
+              kerl.squeeze(hash, 0, HASH_LENGTH)
+            end
+
+            (0...HASH_LENGTH).step(1) do |j|
+              signatureFragment[i * HASH_LENGTH + j] = hash[j]
+            end
+          end
+
+          signatureFragment
+        end
+
+        def validateSignatures(expectedAddress, signatureFragments, bundleHash)
+          if !bundleHash
+            raise StandardError, "Invalid bundle hash provided"
+          end
+
+          bundle = Bundle.new
+
+          normalizedBundleFragments = []
+          normalizedBundleHash = bundle.normalizedBundle(bundleHash)
+
+          # Split hash into 3 fragments
+          (0...3).step(1) do |i|
+            normalizedBundleFragments[i] = normalizedBundleHash.slice(i * 27, 27)
+          end
+
+          # Get digests
+          digests = []
+          (0...signatureFragments.length).step(1) do |i|
+            digestBuffer = digest(normalizedBundleFragments[i % 3], Converter.trits(signatureFragments[i]))
+
+            (0...HASH_LENGTH).step(1) do |j|
+              digests[i * 243 + j] = digestBuffer[j]
+            end
+          end
+
+          addressTrits = address(digests)
+          address = Converter.trytes(addressTrits)
+
+          expectedAddress == address
+        end
+      end
+    end
+  end
+end