eth 0.4.12 → 0.5.0

data/lib/eth/eip712.rb

@@ -0,0 +1,184 @@
+# Copyright (c) 2016-2022 The Ruby-Eth Contributors
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# Provides the `Eth` module.
+module Eth
+
+  # Defines handy tools for encoding typed structured data as per EIP-712.
+  # ref: https://eips.ethereum.org/EIPS/eip-712
+  module Eip712
+    extend self
+
+    # Provides a special typed-data error if data structure fails basic
+    # verification.
+    class TypedDataError < StandardError; end
+
+    # Scans all dependencies of a given type recursively and returns
+    # either all dependencies or none if not found.
+    #
+    # @param primary_type [String] the primary type which we want to scan.
+    # @param types [Array] all existing types in the data structure.
+    # @param result [Array] found results from previous recursions.
+    # @return [Array] all dependent types for the given primary type.
+    def type_dependencies(primary_type, types, result = [])
+      if result.include? primary_type
+
+        # ignore if we already have the give type in results
+        return result
+      elsif types[primary_type.to_sym].nil?
+
+        # ignore if the type is not used, e.g., a string or address.
+        return result
+      else
+
+        # we found something
+        result.push primary_type
+
+        # recursively look for further nested dependencies
+        types[primary_type.to_sym].each do |t|
+          dependency = type_dependencies t[:type], types, result
+        end
+        return result
+      end
+    end
+
+    # Encode types as an EIP-712 confrom string, e.g.,
+    # `MyType(string attribute)`.
+    #
+    # @param primary_type [String] the type which we want to encode.
+    # @param types [Array] all existing types in the data structure.
+    # @return [String] an EIP-712 encoded type-string.
+    # @raise [TypedDataError] if non-primary type found.
+    def encode_type(primary_type, types)
+
+      # get all used types
+      all_dependencies = type_dependencies primary_type, types
+
+      # remove primary types and sort the rest alphabetically
+      filtered_dependencies = all_dependencies.delete_if { |type| type.to_s == primary_type }
+      sorted_dependencies = filtered_dependencies.sort
+      dependencies = [primary_type]
+      sorted_dependencies.each do |sorted|
+        dependencies.push sorted
+      end
+
+      # join them all in a string with types and field names
+      result = ""
+      dependencies.each do |type|
+
+        # dependencies should not have non-primary types (such as string, address)
+        raise TypedDataError, "Non-primary type found: #{type}!" if types[type.to_sym].nil?
+
+        result += "#{type}("
+        result += types[type.to_sym].map { |t| "#{t[:type]} #{t[:name]}" }.join(",")
+        result += ")"
+      end
+      return result
+    end
+
+    # Hashes an EIP-712 confrom type-string.
+    #
+    # @param primary_type [String] the type which we want to hash.
+    # @param types [Array] all existing types in the data structure.
+    # @return [String] a Keccak-256 hash of an EIP-712 encoded type-string.
+    def hash_type(primary_type, types)
+      encoded_type = encode_type primary_type, types
+      return Util.keccak256 encoded_type
+    end
+
+    # Recursively ABI-encodes all data and types according to EIP-712.
+    #
+    # @param primary_type [String] the primary type which we want to encode.
+    # @param data [Array] the data in the data structure we want to encode.
+    # @param types [Array] all existing types in the data structure.
+    # @return [String] an ABI-encoded representation of the data and the types.
+    def encode_data(primary_type, data, types)
+
+      # first data field is the type hash
+      encoded_types = ["bytes32"]
+      encoded_values = [hash_type(primary_type, types)]
+
+      # adds field contents
+      types[primary_type.to_sym].each do |field|
+        value = data[field[:name].to_sym]
+        type = field[:type]
+        raise NotImplementedError, "Arrays currently unimplemented for EIP-712." if type.end_with? "]"
+        if type == "string" or type == "bytes"
+          encoded_types.push "bytes32"
+          encoded_values.push Util.keccak256 value
+        elsif !types[type.to_sym].nil?
+          encoded_types.push "bytes32"
+          value = encode_data type, value, types
+          encoded_values.push Util.keccak256 value
+        else
+          encoded_types.push type
+          encoded_values.push value
+        end
+      end
+
+      # all data is abi-encoded
+      return Abi.encode encoded_types, encoded_values
+    end
+
+    # Recursively ABI-encodes and hashes all data and types.
+    #
+    # @param primary_type [String] the primary type which we want to hash.
+    # @param data [Array] the data in the data structure we want to hash.
+    # @param types [Array] all existing types in the data structure.
+    # @return [String] a Keccak-256 hash of the ABI-encoded data and types.
+    def hash_data(primary_type, data, types)
+      encoded_data = encode_data primary_type, data, types
+      return Util.keccak256 encoded_data
+    end
+
+    # Enforces basic properties to be represented in the EIP-712 typed
+    # data structure: types, domain, message, etc.
+    #
+    # @param data [Array] the data in the data structure we want to hash.
+    # @return [Array] the data in the data structure we want to hash.
+    # @raise [TypedDataError] if the data fails validation.
+    def enforce_typed_data(data)
+      data = JSON.parse data if Util.is_hex? data
+      raise TypedDataError, "Data is missing, try again with data." if data.nil? or data.empty?
+      raise TypedDataError, "Data types are missing." if data[:types].nil? or data[:types].empty?
+      raise TypedDataError, "Data primaryType is missing." if data[:primaryType].nil? or data[:primaryType].empty?
+      raise TypedDataError, "Data domain is missing." if data[:domain].nil?
+      raise TypedDataError, "Data message is missing." if data[:message].nil? or data[:message].empty?
+      raise TypedDataError, "Data EIP712Domain is missing." if data[:types][:EIP712Domain].nil?
+      return data
+    end
+
+    # Hashes a typed data structure with Keccak-256 to prepare a signed
+    # typed data operation respecting EIP-712.
+    #
+    # @param data [Array] all the data in the typed data structure.
+    # @return [String] a Keccak-256 hash of the EIP-712-encoded typed data.
+    def hash(data)
+      data = enforce_typed_data data
+
+      # EIP-191 prefix byte
+      buffer = Signature::EIP191_PREFIX_BYTE
+
+      # EIP-712 version byte
+      buffer += Signature::EIP712_VERSION_BYTE
+
+      # hashed domain data
+      buffer += hash_data "EIP712Domain", data[:domain], data[:types]
+
+      # hashed message data
+      buffer += hash_data data[:primaryType], data[:message], data[:types]
+      return Util.keccak256 buffer
+    end
+  end
+end

data/lib/eth/key/decrypter.rb

@@ -1,113 +1,143 @@
-require 'json'
-require 'scrypt'
-
-class Eth::Key::Decrypter
-  include Eth::Utils
-
-  def self.perform(data, password)
-    new(data, password).perform
-  end
-
-  def initialize(data, password)
-    @data = JSON.parse(data)
-    @password = password
-  end
-
-  def perform
-    derive_key password
-    check_macs
-    bin_to_hex decrypted_data
-  end
-
+# Copyright (c) 2016-2022 The Ruby-Eth Contributors
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# Provides the `Eth` module.
+module Eth
+
+  # The Eth::Key::Decrypter class to handle PBKDF2-SHA-256 decryption.
+  class Key::Decrypter
+
+    # Provides a specific decrypter error if decryption fails.
+    class DecrypterError < StandardError; end
+
+    # Class method `Eth::Key::Decrypter.perform`
+    #
+    # @param data [JSON] encryption data including cypherkey
+    # @param password [String] password to decrypt the key
+    # @return [Eth::Key] decrypted key-pair
+    def self.perform(data, password)
+      new(data, password).perform
+    end
 
-  private
+    # Constructor of the `Eth::Key::Decrypter` class for secret key
+    # encryption.
+    #
+    # @param data [JSON] encryption data including cypherkey
+    # @param password [String] password to decrypt the key
+    def initialize(data, password)
+      @data = JSON.parse(data)
+      @password = password
+    end
 
-  attr_reader :data, :key, :password
+    # Method to decrypt key using password
+    #
+    # @return [String] decrypted key
+    def perform
+      derive_key password
+      check_macs
+      private_key = Util.bin_to_hex decrypted_data
+      Eth::Key.new priv: private_key
+    end
 
-  def derive_key(password)
-    case kdf
-    when 'pbkdf2'
-      @key = OpenSSL::PKCS5.pbkdf2_hmac(password, salt, iterations, key_length, digest)
-    when 'scrypt'
-      # OpenSSL 1.1 inclues OpenSSL::KDF.scrypt, but it is not available usually, otherwise we could do: OpenSSL::KDF.scrypt(password, salt: salt, N: n, r: r, p: p, length: key_length)
-      @key = SCrypt::Engine.scrypt(password, salt, n, r, p, key_length)
-    else
-      raise "Unsupported key derivation function: #{kdf}!"
+    private
+
+    attr_reader :data
+    attr_reader :key
+    attr_reader :password
+
+    def derive_key(password)
+      case kdf
+      when "pbkdf2"
+        @key = OpenSSL::PKCS5.pbkdf2_hmac(password, salt, iterations, key_length, digest)
+      when "scrypt"
+        @key = SCrypt::Engine.scrypt(password, salt, n, r, p, key_length)
+      else
+        raise DecrypterError, "Unsupported key derivation function: #{kdf}!"
+      end
     end
-  end
 
-  def check_macs
-    mac1 = keccak256(key[(key_length/2), key_length] + ciphertext)
-    mac2 = hex_to_bin crypto_data['mac']
+    def check_macs
+      mac1 = Util.keccak256(key[(key_length / 2), key_length] + ciphertext)
+      mac2 = Util.hex_to_bin crypto_data["mac"]
 
-    if mac1 != mac2
-      raise "Message Authentications Codes do not match!"
+      if mac1 != mac2
+        raise DecrypterError, "Message Authentications Codes do not match!"
+      end
     end
-  end
 
-  def decrypted_data
-    @decrypted_data ||= cipher.update(ciphertext) + cipher.final
-  end
+    def decrypted_data
+      @decrypted_data ||= cipher.update(ciphertext) + cipher.final
+    end
 
-  def crypto_data
-    @crypto_data ||= data['crypto'] || data['Crypto']
-  end
+    def crypto_data
+      @crypto_data ||= data["crypto"] || data["Crypto"]
+    end
 
-  def ciphertext
-    hex_to_bin crypto_data['ciphertext']
-  end
+    def ciphertext
+      Util.hex_to_bin crypto_data["ciphertext"]
+    end
 
-  def cipher_name
-    "aes-128-ctr"
-  end
+    def cipher_name
+      "aes-128-ctr"
+    end
 
-  def cipher
-    @cipher ||= OpenSSL::Cipher.new(cipher_name).tap do |cipher|
-      cipher.decrypt
-      cipher.key = key[0, (key_length/2)]
-      cipher.iv = iv
+    def cipher
+      @cipher ||= OpenSSL::Cipher.new(cipher_name).tap do |cipher|
+        cipher.decrypt
+        cipher.key = key[0, (key_length / 2)]
+        cipher.iv = iv
+      end
     end
-  end
 
-  def iv
-    hex_to_bin crypto_data['cipherparams']['iv']
-  end
+    def iv
+      Util.hex_to_bin crypto_data["cipherparams"]["iv"]
+    end
 
-  def salt
-    hex_to_bin crypto_data['kdfparams']['salt']
-  end
+    def salt
+      Util.hex_to_bin crypto_data["kdfparams"]["salt"]
+    end
 
-  def iterations
-    crypto_data['kdfparams']['c'].to_i
-  end
+    def iterations
+      crypto_data["kdfparams"]["c"].to_i
+    end
 
-  def kdf
-    crypto_data['kdf']
-  end
+    def kdf
+      crypto_data["kdf"]
+    end
 
-  def key_length
-    crypto_data['kdfparams']['dklen'].to_i
-  end
+    def key_length
+      crypto_data["kdfparams"]["dklen"].to_i
+    end
 
-  def n
-    crypto_data['kdfparams']['n'].to_i
-  end
+    def n
+      crypto_data["kdfparams"]["n"].to_i
+    end
 
-  def r
-    crypto_data['kdfparams']['r'].to_i
-  end
+    def r
+      crypto_data["kdfparams"]["r"].to_i
+    end
 
-  def p
-    crypto_data['kdfparams']['p'].to_i
-  end
+    def p
+      crypto_data["kdfparams"]["p"].to_i
+    end
 
-  def digest
-    OpenSSL::Digest.new digest_name
-  end
+    def digest
+      OpenSSL::Digest.new digest_name
+    end
 
-  def digest_name
-    "sha256"
+    def digest_name
+      "sha256"
+    end
   end
-  
-
 end