ciri-p2p 0.1.0

data/lib/ciri/p2p/peer_store.rb

@@ -0,0 +1,183 @@
+# frozen_string_literal: true
+
+
+# Copyright (c) 2018 by Jiang Jinyang <jjyruby@gmail.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/logger'
+
+module Ciri
+  module P2P
+
+    # PeerStore store information of all peers we have seen
+    #TODO rewrite with a database(sqlite)
+    # Support score peers
+    class PeerStore
+      PEER_LAST_SEEN_VALID = 12 * 3600 # consider peer is valid if we seen it within 12 hours
+      PING_EXPIRATION_IN = 10 * 60 # allow ping within 10 minutes
+
+      # report peer behaviours
+      module Behaviours
+        INVALID_DATA = :invalid_data
+        CONNECT = :connect
+        PING = :ping
+        FAILED_TO_CONNECT = :failed_to_connect
+        FAILED_TO_PING = :failed_to_ping
+        UNEXPECT_DISCONNECT = :unexpect_disconnect
+      end
+
+      include Behaviours
+
+      # peer status
+      module Status
+        CONNECTED = :connected
+        DISCONNECTED = :disconnected
+        UNKNOWN = :unknown
+      end
+
+      include Status
+
+      PEER_INITIAL_SCORE = 100
+      DEFAULT_SCORE_SCHEMA = {
+        INVALID_DATA => -50,
+        CONNECT => 10,
+        PING => 5,
+        FAILED_TO_PING => -10,
+        FAILED_TO_CONNECT => -10,
+        UNEXPECT_DISCONNECT => -20,
+      }
+
+      def initialize(score_schema:{})
+        @peers_ping_records = {}
+        @peers_seen_records = {}
+        @peers = {}
+        @bootnodes = []
+        @ban_peers = {}
+        @score_schema = DEFAULT_SCORE_SCHEMA.merge(score_schema)
+      end
+
+      def has_ping?(raw_node_id, ping_hash, expires_in: PING_EXPIRATION_IN)
+        return false if has_ban?(raw_node_id)
+        record = @peers_ping_records[raw_node_id]
+        if record && record[:ping_hash] == ping_hash && (record[:ping_at] + expires_in) > Time.now.to_i
+          return true
+        elsif record
+          @peers_ping_records.delete(raw_node_id)
+        end
+        false
+      end
+
+      # record ping message
+      def update_ping(raw_node_id, ping_hash, ping_at: Time.now.to_i)
+        @peers_ping_records[raw_node_id] = {ping_hash: ping_hash, ping_at: ping_at}
+      end
+
+      def update_last_seen(raw_node_id, at: Time.now.to_i)
+        @peers_seen_records[raw_node_id] = at
+      end
+
+      def has_seen?(raw_node_id, expires_in: PEER_LAST_SEEN_VALID)
+        return false if has_ban?(raw_node_id)
+        seen = (last_seen_at = @peers_seen_records[raw_node_id]) && (last_seen_at + expires_in > Time.now.to_i)
+        # convert to bool
+        !!seen
+      end
+
+      def add_bootnode(node)
+        @bootnodes << node
+        add_node(node)
+      end
+
+      def has_ban?(raw_node_id, now: Time.now)
+        record = @ban_peers[raw_node_id]
+        if record && (record[:ban_at].to_i + record[:timeout_secs]) > now.to_i
+          true
+        else
+          @ban_peers.delete(raw_node_id)
+          false
+        end
+      end
+
+      def ban_peer(raw_node_id, now: Time.now, timeout_secs:600)
+        @ban_peers[raw_node_id] = {ban_at: now, timeout_secs: timeout_secs}
+      end
+
+      def report_peer(raw_node_id, behaviour)
+        score = @score_schema[behaviour]
+        raise ValueError.new("unsupport report behaviour: #{behaviour}") if score.nil?
+        if (node_info = @peers[raw_node_id])
+          node_info[:score] += score
+        end
+      end
+
+      # TODO find high scoring peers, use bootnodes as fallback
+      def find_bootnodes(count)
+        nodes = @bootnodes.sample(count)
+        nodes + find_attempt_peers(count - nodes.size)
+      end
+
+      # TODO find high scoring peers
+      def find_attempt_peers(count)
+        @peers.values.reject do |peer_info|
+          # reject already connected peers and bootnodes
+          @bootnodes.include?(peer_info[:node]) || peer_status(peer_info[:node].raw_node_id) == Status::CONNECTED
+        end.sort_by do |peer_info|
+          -peer_info[:score]
+        end.map do |peer_info|
+          peer_info[:node]
+        end.take(count)
+      end
+
+      def add_node_addresses(raw_node_id, addresses)
+        node_info = @peers[raw_node_id]
+        node = node_info && node_info[:node]
+        if node
+          node.addresses = (node.addresses + addresses).uniq
+        end
+      end
+
+      def get_node_addresses(raw_node_id)
+        peer_info = @peers[raw_node_id]
+        peer_info && peer_info[:node].addresses
+      end
+
+      def add_node(node)
+        @peers[node.raw_node_id] = {node: node, score: PEER_INITIAL_SCORE, status: Status::UNKNOWN}
+      end
+
+      def peer_status(raw_node_id)
+        if (peer_info = @peers[raw_node_id])
+          peer_info[:status]
+        else
+          Status::UNKNOWN
+        end
+      end
+
+      def update_peer_status(raw_node_id, status)
+        if (peer_info = @peers[raw_node_id])
+          peer_info[:status] = status
+        end
+      end
+    end
+
+  end
+end
+

data/lib/ciri/p2p/protocol.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+
+# Copyright (c) 2018 by Jiang Jinyang <jjyruby@gmail.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/logger'
+
+module Ciri
+  module P2P
+
+    # protocol represent P2P sub protocols
+    class Protocol
+
+      include Utils::Logger
+
+      attr_reader :name, :version, :length
+
+      def initialize(name:, version:, length:)
+        @name = name
+        @version = version
+        @length = length
+      end
+
+      def initialized(context)
+        debug("not implemented Protocol#initialized callback")
+      end
+
+      def received(context, data)
+        debug("not implemented Protocol#received callback")
+      end
+
+      def connected(context)
+        debug("not implemented Protocol#connected callback")
+      end
+
+      def disconnected(context)
+        debug("not implemented Protocol#disconnected callback")
+      end
+    end
+
+  end
+end
+

data/lib/ciri/p2p/protocol_context.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+
+# Copyright (c) 2018 by Jiang Jinyang <jjyruby@gmail.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 'forwardable'
+
+module Ciri
+  module P2P
+
+    # ProtocolContext is used to manuaplate
+    class ProtocolContext
+
+      extend Forwardable
+
+      attr_reader :peer, :protocol, :protocol_io
+
+      def_delegators :protocol_io, :send_data
+      def_delegators :@network_state, :local_node_id
+
+      def initialize(network_state, peer: nil, protocol: nil, protocol_io: nil)
+        @network_state = network_state
+        @peer = peer
+        @protocol = protocol
+        @protocol_io = protocol_io
+      end
+
+      def raw_local_node_id
+        @raw_local_node_id ||= local_node_id.to_bytes
+      end
+    end
+
+  end
+end
+

data/lib/ciri/p2p/protocol_io.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+# Copyright (c) 2018 by Jiang Jinyang <jjyruby@gmail.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 'forwardable'
+require 'async/semaphore'
+require_relative 'rlpx/message'
+
+module Ciri
+  module P2P
+
+    # send/read sub protocol msg
+    class ProtocolIO
+
+      class Error < StandardError
+      end
+      class InvalidMessageCode < Error
+      end
+
+      attr_reader :protocol, :offset
+
+      def initialize(protocol, offset, frame_io)
+        @protocol = protocol
+        @offset = offset
+        @frame_io = frame_io
+        @semaphore = Async::Semaphore.new
+      end
+
+      def send_data(code, data)
+        @semaphore.acquire do
+          msg = RLPX::Message.new(code: code, size: data.size, payload: data)
+          write_msg(msg)
+        end
+      end
+
+      def write_msg(msg)
+        raise InvalidMessageCode, "code #{msg.code} must less than length #{protocol.length}" if msg.code > protocol.length
+        msg.code += offset
+        @frame_io.write_msg(msg)
+      end
+
+    end
+
+  end
+end
+

data/lib/ciri/p2p/rlpx.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+#
+
+# Copyright (c) 2018 by Jiang Jinyang <jjyruby@gmail.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 'rlpx/message'
+require_relative 'rlpx/frame_io'
+require_relative 'rlpx/protocol_messages'
+require_relative 'rlpx/protocol_handshake'
+require_relative 'rlpx/encryption_handshake'
+

data/lib/ciri/p2p/rlpx/connection.rb

@@ -0,0 +1,182 @@
+# frozen_string_literal: true
+
+# Copyright (c) 2018 by Jiang Jinyang <jjyruby@gmail.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/rlp'
+require 'socket'
+require 'forwardable'
+require_relative 'frame_io'
+require_relative 'protocol_messages'
+require_relative 'errors'
+require_relative 'encryption_handshake'
+
+module Ciri
+  module P2P
+    module RLPX
+
+      # RLPX::Connection implement RLPX protocol operations
+      # all operations end with bang(!)
+      class Connection
+        extend Forwardable
+
+        def_delegators :@frame_io, :read_msg, :write_msg, :send_data, :closed?, :close
+
+        class Error < RLPX::Error
+        end
+
+        class MessageOverflowError < Error
+        end
+
+        class UnexpectedMessageError < Error
+        end
+
+        class FormatError < Error
+        end
+
+        def initialize(io)
+          set_timeout(io)
+          @io = io
+          @frame_io = nil
+        end
+
+        # Encryption handshake, exchange keys with node, must been invoked before other operations
+        def encryption_handshake!(private_key:, remote_node_id: nil)
+          enc_handshake = EncryptionHandshake.new(private_key: private_key, remote_id: remote_node_id)
+          secrets = remote_node_id.nil? ? receiver_enc_handshake(enc_handshake) : initiator_enc_handshake(enc_handshake)
+          @frame_io = FrameIO.new(@io, secrets)
+        end
+
+        # protocol handshake
+        def protocol_handshake!(our_hs)
+          @frame_io.send_data(Code::HANDSHAKE, our_hs.rlp_encode)
+          remote_hs = read_protocol_handshake
+          # enable snappy compress if remote peer support
+          @frame_io.snappy = remote_hs.version >= SNAPPY_PROTOCOL_VERSION
+          remote_hs
+        end
+
+        private
+
+        def receiver_enc_handshake(receiver)
+          auth_msg_binary, auth_packet = read_enc_handshake_msg(ENC_AUTH_MSG_LENGTH, receiver.private_key)
+          auth_msg = AuthMsgV4.rlp_decode(auth_msg_binary)
+          receiver.handle_auth_msg(auth_msg)
+
+          auth_ack_msg = receiver.auth_ack_msg
+          auth_ack_msg_plain_text = auth_ack_msg.rlp_encode
+          auth_ack_packet = if auth_msg.got_plain
+                              raise NotImplementedError.new('not support pre eip8 plain text seal')
+                            else
+                              seal_eip8(auth_ack_msg_plain_text, receiver)
+                            end
+          @io.write(auth_ack_packet)
+          @io.flush
+
+          receiver.extract_secrets(auth_packet, auth_ack_packet, initiator: false)
+        end
+
+        def initiator_enc_handshake(initiator)
+          initiator_auth_msg = initiator.auth_msg
+          auth_msg_plain_text = initiator_auth_msg.rlp_encode
+          # seal eip8
+          auth_packet = seal_eip8(auth_msg_plain_text, initiator)
+          @io.write(auth_packet)
+          @io.flush
+
+          auth_ack_mgs_binary, auth_ack_packet = read_enc_handshake_msg(ENC_AUTH_RESP_MSG_LENGTH, initiator.private_key)
+          auth_ack_msg = AuthRespV4.rlp_decode auth_ack_mgs_binary
+          initiator.handle_auth_ack_msg(auth_ack_msg)
+
+          initiator.extract_secrets(auth_packet, auth_ack_packet, initiator: true)
+        end
+
+        def read_enc_handshake_msg(plain_size, private_key)
+          packet = @io.read(plain_size)
+
+          decrypt_binary_msg = begin
+            private_key.ecies_decrypt(packet)
+          rescue Crypto::ECIESDecryptionError => e
+            nil
+          end
+
+          # pre eip old plain format
+          return decrypt_binary_msg if decrypt_binary_msg
+
+          # try decode eip8 format
+          prefix = packet[0...2]
+          size = Ciri::Utils.big_endian_decode(prefix)
+          raise FormatError.new("EIP8 format message size #{size} less than plain_size #{plain_size}") if size < plain_size
+
+          # continue read remain bytes
+          packet << @io.read(size - plain_size + 2)
+          # decrypt message
+          [private_key.ecies_decrypt(packet[2..-1], prefix), packet]
+        end
+
+        def read_protocol_handshake
+          msg = @frame_io.read_msg
+
+          if msg.size > BASE_PROTOCOL_MAX_MSG_SIZE
+            raise MessageOverflowError.new("message size #{msg.size} is too big")
+          end
+          if msg.code == Code::DISCONNECT
+            payload = RLP.decode(msg.payload)
+            raise UnexpectedMessageError.new("expected handshake, get disconnect, reason: #{payload}")
+          end
+          if msg.code != Code::HANDSHAKE
+            raise UnexpectedMessageError.new("expected handshake, get #{msg.code}")
+          end
+          ProtocolHandshake.rlp_decode(msg.payload)
+        end
+
+        def set_timeout(io)
+          timeout = HANDSHAKE_TIMEOUT
+
+          if io.is_a?(BasicSocket)
+            secs = Integer(timeout)
+            usecs = Integer((timeout - secs) * 1_000_000)
+            optval = [secs, usecs].pack("l_2")
+            io.setsockopt Socket::SOL_SOCKET, Socket::SO_RCVTIMEO, optval
+            io.setsockopt Socket::SOL_SOCKET, Socket::SO_SNDTIMEO, optval
+          end
+        end
+
+        def seal_eip8(encoded_msg, handshake)
+          # padding encoded message, make message distinguished from pre eip8
+          encoded_msg += "\x00".b * rand(100..300)
+          prefix = encoded_prefix(encoded_msg.size + ECIES_OVERHEAD)
+
+          enc = handshake.remote_key.ecies_encrypt(encoded_msg, prefix)
+          prefix + enc
+        end
+
+        # encode 16 uint prefix
+        def encoded_prefix(n)
+          prefix = Utils.big_endian_encode(n)
+          # pad to 2 bytes
+          prefix.ljust(2, "\x00".b)
+        end
+      end
+
+    end
+  end
+end