ciri 0.0.0

data/lib/ciri/key.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+# Copyright (c) 2018, by Jiang Jinyang. <https://justjjy.com>
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+# THE SOFTWARE.
+
+
+require 'openssl'
+require_relative 'crypto'
+
+module Ciri
+
+  # Ciri::Key represent private/public key pair, it support several encryption methods used in Ethereum
+  #
+  # Examples:
+  #
+  #   key = Ciri::Key.random
+  #   key.ecdsa_signature(data)
+  #
+  class Key
+
+    class << self
+      def ecdsa_recover(msg, signature)
+        raw_public_key = Crypto.ecdsa_recover(msg, signature, return_raw_key: true)
+        Ciri::Key.new(raw_public_key: raw_public_key)
+      end
+
+      def random
+        ec_key = OpenSSL::PKey::EC.new('secp256k1')
+        ec_key.generate_key
+        Ciri::Key.new(ec_key: ec_key)
+      end
+    end
+
+    attr_reader :ec_key
+
+    # initialized from ec_key or raw keys
+    # ec_key is a OpenSSL::PKey::EC object, raw keys is bytes presented keys
+    def initialize(ec_key: nil, raw_public_key: nil, raw_private_key: nil)
+      @ec_key = ec_key || Ciri::Utils.create_ec_pk(raw_privkey: raw_private_key, raw_pubkey: raw_public_key)
+    end
+
+    # raw public key
+    def raw_public_key
+      @raw_public_key ||= ec_key.public_key.to_bn.to_s(2)
+    end
+
+    def ecdsa_signature(data)
+      Crypto.ecdsa_signature(secp256k1_key, data)
+    end
+
+    def ecies_encrypt(message, shared_mac_data = '')
+      Crypto.ecies_encrypt(message, ec_key, shared_mac_data)
+    end
+
+    def ecies_decrypt(data, shared_mac_data = '')
+      Crypto.ecies_decrypt(data, ec_key, shared_mac_data)
+    end
+
+    private
+    def secp256k1_key
+      @secp256k1_key ||= Crypto.ensure_secp256k1_key(privkey: ec_key.private_key.to_s(2))
+    end
+  end
+end

data/lib/ciri/rlp.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+# Copyright (c) 2018, by Jiang Jinyang. <https://justjjy.com>
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+# THE SOFTWARE.
+
+
+require_relative 'rlp/decode'
+require_relative 'rlp/encode'
+require_relative 'rlp/serializable'
+
+module Ciri
+  module RLP
+    class InvalidValueError < StandardError
+    end
+
+    class << self
+
+      # Decode input from rlp encoding, only produce string or array
+      #
+      # Examples:
+      #
+      #   Ciri::RLP.decode(input)
+      #
+      def decode(input, type = nil)
+        output = Decode.decode(input)
+        if type
+          output = decode_with_type(output, type)
+        end
+        output
+      end
+
+      # Encode input to rlp encoding, only allow string or array
+      #
+      # Examples:
+      #
+      #   Ciri::RLP.encode("hello world")
+      #
+      def encode(input, type = nil)
+        if type
+          input = encode_with_type(input, type)
+        end
+        Encode.encode(input)
+      end
+
+      # Use this method before RLP.encode, this method encode ruby objects to rlp friendly format, string or array.
+      # see Ciri::RLP::Serializable::TYPES for supported types
+      #
+      # Examples:
+      #
+      #   item = Ciri::RLP.encode_with_type(number, :int, zero: "\x00".b)
+      #   encoded_text = Ciri::RLP.encode(item)
+      #
+      def encode_with_type(item, type, zero: '')
+        Serializable.encode_with_type(item, type, zero: zero)
+      end
+
+      # Use this method after RLP.decode, decode values from string or array to specific types
+      # see Ciri::RLP::Serializable::TYPES for supported types
+      #
+      # Examples:
+      #
+      #   item = Ciri::RLP.decode(encoded_text)
+      #   number = Ciri::RLP.decode_with_type(item, :int)
+      #
+      def decode_with_type(item, type)
+        Serializable.decode_with_type(item, type)
+      end
+
+    end
+  end
+end

data/lib/ciri/rlp/decode.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+# Copyright (c) 2018, by Jiang Jinyang. <https://justjjy.com>
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+# THE SOFTWARE.
+
+
+require 'stringio'
+
+module Ciri
+  module RLP
+    module Decode
+
+      class InvalidInput < StandardError
+      end
+
+      class << self
+        def decode(input)
+          s = StringIO.new(input).binmode
+          decode_stream(s)
+        end
+
+        private
+        def decode_stream(s)
+          c = s.read(1)
+          case c.ord
+            when 0x00..0x7f
+              c
+            when 0x80..0xb7
+              length = c.ord - 0x80
+              s.read(length)
+            when 0xb8..0xbf
+              length_binary = s.read(c.ord - 0xb7)
+              length = int_from_binary(length_binary)
+              s.read(length)
+            when 0xc0..0xf7
+              length = c.ord - 0xc0
+              s2 = StringIO.new s.read(length)
+              list = []
+              until s2.eof?
+                list << decode_stream(s2)
+              end
+              list
+            when 0xf8..0xff
+              length_binary = s.read(c.ord - 0xf7)
+              length = int_from_binary(length_binary)
+              s2 = StringIO.new s.read(length)
+              list = []
+              until s2.eof?
+                list << decode_stream(s2)
+              end
+              list
+            else
+              raise InvalidInput.new("invalid char #{c}")
+          end
+        end
+
+        def int_from_binary(input)
+          Ciri::Utils.big_endian_decode(input)
+        end
+
+      end
+    end
+  end
+end

data/lib/ciri/rlp/encode.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+# Copyright (c) 2018, by Jiang Jinyang. <https://justjjy.com>
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+# THE SOFTWARE.
+
+
+module Ciri
+  module RLP
+    module Encode
+
+      class InputOverflow < StandardError
+      end
+
+      class << self
+
+        def encode(input)
+          result = if input.is_a?(String)
+                     encode_string(input)
+                   elsif input.is_a?(Array)
+                     encode_list(input)
+                   else
+                     raise ArgumentError.new('input must be a String or Array')
+                   end
+          result.b
+        end
+
+        private
+        def encode_string(input)
+          length = input.length
+          if length == 1 && input.ord < 0x80
+            input
+          elsif length < 56
+            to_binary(0x80 + length) + input
+          elsif length < 256 ** 8
+            binary_length = to_binary(length)
+            to_binary(0xb7 + binary_length.size) + binary_length + input
+          else
+            raise InputOverflow.new("input length #{input.size} is too long")
+          end
+        end
+
+        def encode_list(input)
+          output = input.map {|item| encode(item)}.join
+          length = output.length
+          if length < 56
+            to_binary(0xc0 + length) + output
+          elsif length < 256 ** 8
+            binary_length = to_binary(length)
+            to_binary(0xf7 + binary_length.size) + binary_length + output
+          else
+            raise InputOverflow.new("input length #{input.size} is too long")
+          end
+        end
+
+        def to_binary(n)
+          Ciri::Utils.big_endian_encode(n)
+        end
+
+      end
+    end
+  end
+end

data/lib/ciri/rlp/serializable.rb

@@ -0,0 +1,268 @@
+# frozen_string_literal: true
+
+# Copyright (c) 2018, by Jiang Jinyang. <https://justjjy.com>
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+# THE SOFTWARE.
+
+
+require 'ciri/utils'
+
+module Ciri
+  module RLP
+
+    # represent bool types: true | false
+    class Bool
+      ENCODED_TRUE = Ciri::Utils.big_endian_encode(0x01)
+      ENCODED_FALSE = Ciri::Utils.big_endian_encode(0x00)
+    end
+
+    # Serializable module allow ruby objects serialize/deserialize to or from RLP encoding.
+    # See Ciri::RLP::Serializable::TYPES for supported type.
+    #
+    # schema method define ordered data structure for class, and determine how to encoding objects.
+    #
+    # schema follow `{attr_name: type}` format,
+    # if attr is raw type(string or array of string), you can just use `:attr_name` to define it
+    # schema simple types include Integer, Bool, String, Array...
+    #
+    # schema also support complex types: array and serializable.
+    #
+    # array types represented as `{attr_name: [type]}`, for example: `{bills: [Integer]}` means value of bill attr is an array of integer
+    # serializable type represent value of attr is a RLP serializable object
+    #
+    #
+    # Examples:
+    #
+    #   class AuthMsgV4
+    #     include Ciri::RLP::Serializable
+    #
+    #     # define schema
+    #     schema [
+    #              :signature, # raw type: string
+    #              {initiator_pubkey: MySerializableKey}, # this attr is a RLP serializable object
+    #              {nonce: [Integer]},
+    #              {version: Integer}
+    #            ]
+    #
+    #     # default values
+    #     default_data(got_plain: false)
+    #   end
+    #
+    #   msg = AuthMsgV4.new(signature: "\x00", initiator_pubkey: my_pubkey, nonce: [1, 2, 3], version: 4)
+    #   encoded = msg.rlp_encode!
+    #   msg2 = AuthMsgV4.rlp_decode!(encoded)
+    #   msg == msg2 # true
+    #
+    module Serializable
+      # nil represent RLP raw value(string or array of string)
+      TYPES = [nil, Integer, Bool].map {|key| [key, true]}.to_h.freeze
+
+      # Schema specific columns types of classes, normally you should not use Serializable::Schema directly
+      #
+      class Schema
+        class InvalidSchemaError < StandardError
+        end
+
+        # keys return data columns array
+        attr_reader :keys
+
+        def initialize(schema)
+          keys = []
+          @_schema = {}
+
+          schema.each do |key|
+            key, type = key.is_a?(Hash) ? key.to_a[0] : [key, nil]
+            raise InvalidSchemaError.new("missing type #{type} for key #{key}") unless check_key_type(type)
+            keys << key
+            @_schema[key] = type
+          end
+
+          @_schema.freeze
+          @keys = keys.freeze
+        end
+
+        # Get column type, see Serializable::TYPES for supported type
+        def [](key)
+          @_schema[key]
+        end
+
+        # Validate data, data is a Hash
+        def validate!(data)
+          keys.each do |key|
+            raise InvalidSchemaError.new("missing key #{key}") unless data.key?(key)
+          end
+        end
+
+        def rlp_encode!(data, raw: true)
+          # pre-encode, encode data to rlp compatible format(only string or array)
+          data_list = keys.map do |key|
+            Serializable.encode_with_type(data[key], self[key])
+          end
+          raw ? RLP.encode(data_list) : data_list
+        end
+
+        def rlp_decode!(input, raw: true)
+          data = raw ? RLP.decode(input) : input
+          keys.each_with_index.map do |key, i|
+            # decode data by type
+            decoded_item = Serializable.decode_with_type(data[i], self[key])
+            [key, decoded_item]
+          end.to_h
+        end
+
+
+        private
+        def check_key_type(type)
+          return true if TYPES.key?(type)
+          return true if type.is_a?(Class) && type < Serializable
+
+          if type.is_a?(Array) && type.size == 1
+            check_key_type(type[0])
+          else
+            false
+          end
+        end
+      end
+
+      module ClassMethods
+        # Decode object from input
+        def rlp_decode(input, raw: true)
+          data = schema.rlp_decode!(input, raw: raw)
+          self.new(data)
+        end
+
+        alias rlp_decode! rlp_decode
+
+        def schema(data_schema = nil)
+          @data_schema ||= Schema.new(data_schema).tap do |schema|
+            # define attributes methods
+            define_attributes(schema)
+          end
+        end
+
+        def default_data(data = nil)
+          @default_data ||= data
+        end
+
+        private
+        def define_attributes(schema)
+          schema.keys.each do |attribute|
+            module_eval <<-ATTR_METHODS
+            def #{attribute}
+              data[:"#{attribute}"]
+            end
+
+            def #{attribute}=(value)
+              data[:"#{attribute}"] = value 
+            end
+            ATTR_METHODS
+          end
+        end
+      end
+
+      class << self
+        def included(base)
+          base.send :extend, ClassMethods
+        end
+
+        # use this method before RLP.encode
+        # encode item to string or array
+        def encode_with_type(item, type, zero: '')
+          if type == Integer
+            if item == 0
+              "\x80".b
+            elsif item < 128
+              Ciri::Utils.big_endian_encode(item, zero)
+            else
+              buf = Ciri::Utils.big_endian_encode(item, zero)
+              [0x80 + buf.size].pack("c*") + buf
+            end
+          elsif type == Bool
+            item ? Bool::ENCODED_TRUE : Bool::ENCODED_FALSE
+          elsif type.is_a?(Class) && type < Serializable
+            item.rlp_encode!(raw: false)
+          elsif type.is_a?(Array)
+            if type.size == 1 # array type
+              item.map {|i| encode_with_type(i, type[0])}
+            else # unknown
+              raise InvalidValueError.new "type size should be 1, got #{type}"
+            end
+          else
+            raise InvalidValueError.new "unknown type #{type}" unless TYPES.key?(type)
+            item
+          end
+        end
+
+        # Use this method after RLP.decode, decode values from string or array to specific types
+        # see Ciri::RLP::Serializable::TYPES for supported types
+        #
+        # Examples:
+        #
+        #   item = Ciri::RLP.decode(encoded_text)
+        #   decode_with_type(item, Integer)
+        #
+        def decode_with_type(item, type)
+          if type == Integer
+            if item == "\x80".b || item.empty?
+              0
+            elsif item[0].ord < 0x80
+              Ciri::Utils.big_endian_decode(item)
+            else
+              size = item[0].ord - 0x80
+              Ciri::Utils.big_endian_decode(item[1..size])
+            end
+          elsif type == Bool
+            if item == Bool::ENCODED_TRUE
+              true
+            elsif item == Bool::ENCODED_FALSE
+              false
+            else
+              raise InvalidValueError.new "invalid bool value #{item}"
+            end
+          elsif type.is_a?(Class) && type < Serializable
+            # already decoded from RLP encoding
+            type.rlp_decode!(item, raw: false)
+          elsif type.is_a?(Array)
+            item.map {|i| decode_with_type(i, type[0])}
+          else
+            raise InvalidValueError.new "unknown type #{type}" unless TYPES.key?(type)
+            item
+          end
+        end
+      end
+
+      attr_reader :data
+
+      def initialize(**data)
+        @data = (self.class.default_data || {}).merge(data)
+        self.class.schema.validate!(@data)
+      end
+
+      # Encode object to rlp encoding string
+      def rlp_encode!(raw: true)
+        self.class.schema.rlp_encode!(data, raw: raw)
+      end
+
+      def ==(other)
+        self.class == other.class && data == other.data
+      end
+
+    end
+  end
+end