devp2p 0.1.0

data/lib/devp2p/discovery/transport.rb

@@ -0,0 +1,105 @@
+# -*- encoding : ascii-8bit -*-
+
+module DEVp2p
+  module Discovery
+
+    ##
+    # Persist the list of known nodes with their reputation.
+    #
+    class Transport < BaseService
+      include Celluloid::IO
+
+      name 'discovery'
+
+      default_config(
+        discovery: {
+          listen_port: 30303,
+          listen_host: '0.0.0.0'
+        },
+        node: {
+          privkey_hex: ''
+        }
+      )
+
+      attr :protocol
+
+      def initialize(app)
+        super(app)
+        logger.info "Discovery service init"
+
+        @server = nil # will be UDPSocket
+        @protocol = Protocol.new app, Actor.current
+      end
+
+      def address
+        ip = @app.config[:discovery][:listen_host]
+        port = @app.config[:discovery][:listen_port]
+        Address.new ip, port
+      end
+
+      def send_message(address, message)
+        raise ArgumentError, 'address must be Address' unless address.instance_of?(Address)
+        logger.debug "sending", size: message.size, to: address
+
+        begin
+          @server.send message, 0, address.ip, address.udp_port
+        rescue
+          # should never reach here? udp has no connection!
+          logger.error "udp write error", error: $!
+          logger.error "waiting for recovery"
+          sleep 5
+        end
+      end
+
+      def receive_message(address, message)
+        raise ArgumentError, 'address must be Address' unless address.instance_of?(Address)
+        @protocol.receive_message address, message
+      end
+
+      def start
+        logger.info 'starting discovery'
+
+        ip = @app.config[:discovery][:listen_host]
+        port = @app.config[:discovery][:listen_port]
+
+        logger.info "starting udp listener", port: port, host: ip
+
+        @server = UDPSocket.new
+        @server.bind ip, port
+
+        super
+
+        @protocol.bootstrap(
+          @app.config[:discovery][:bootstrap_nodes].map {|x| Node.from_uri(x) }
+        )
+      end
+
+      def stop
+        logger.info "stopping discovery"
+        super
+      end
+
+      private
+
+      def logger
+        @logger ||= Logger.new "#{@app.config[:discovery][:listen_port]}.p2p.discovery"
+      end
+
+      def _run
+        maxlen = Multiplexer.max_window_size * 2
+        loop do
+          break if stopped?
+          message, info = @server.recvfrom maxlen
+          async.handle_packet message, info[3], info[1]
+        end
+      end
+
+      def handle_packet(message, ip, port)
+        logger.debug "handling packet", ip: ip, port: port, size: message.size
+        receive_message Address.new(ip, port), message
+      end
+
+    end
+
+  end
+end

data/lib/devp2p/exception.rb

@@ -0,0 +1,30 @@
+# -*- encoding : ascii-8bit -*-
+
+module DEVp2p
+
+  class MissingRequiredServiceError < StandardError; end
+  class InvalidCommandStructure < StandardError; end
+  class DuplicatedCommand < StandardError; end
+  class UnknownCommandError < StandardError; end
+  class FrameError < StandardError; end
+  class MultiplexerError < StandardError; end
+  class RLPxSessionError < StandardError; end
+  class MultiplexedSessionError < StandardError; end
+  class AuthenticationError < StandardError; end
+  class FormatError < StandardError; end
+  class InvalidKeyError < StandardError; end
+  class InvalidSignatureError < StandardError; end
+  class InvalidMACError < StandardError; end
+  class InvalidPayloadError < StandardError; end
+  class EncryptionError < StandardError; end
+  class DecryptionError < StandardError; end
+  class KademliaRoutingError < StandardError; end
+  class KademliaNodeNotFound < StandardError; end
+  class PeerError < StandardError; end
+  class ProtocolError < StandardError; end
+
+  class DefectiveMessage < StandardError; end
+  class PacketExpired < DefectiveMessage; end
+  class InvalidMessageMAC < DefectiveMessage; end
+
+end

data/lib/devp2p/frame.rb

@@ -0,0 +1,197 @@
+# -*- encoding : ascii-8bit -*-
+
+module DEVp2p
+
+  ##
+  # When sending a packet over RLPx, the packet will be framed. The frame
+  # provides information about the size of the packet and the packet's source
+  # protocol. There are three slightly different frames, depending on whether
+  # or not the frame is delivering a multi-frame packet. A multi-frame packet
+  # is a packet which is split (aka chunked) into multiple frames because it's
+  # size is larger than the protocol window size (pws, see Multiplexing). When
+  # a packet is chunked into multiple frames, there is an implicit difference
+  # between the first frame and all subsequent frames.
+  #
+  # Thus, the three frame types are normal, chunked-0 (first frame of a
+  # multi-frame packet), and chunked-n (subsequent frames of a multi-frame
+  # packet).
+  #
+  # * Single-frame packet:
+  #
+  #   header || header-mac || frame || mac
+  #
+  # * Multi-frame packet:
+  #
+  #   header || header-mac || frame-0 ||
+  #   [ header || header-mac || frame-n || ... || ]
+  #   header || header-mac || frame-last || mac
+  #
+  class Frame
+
+    extend Configurable
+    add_config(
+      header_size: 16,
+      mac_size: 16,
+      padding: 16,
+      header_sedes: RLP::Sedes::List.new(elements: [RLP::Sedes.big_endian_int]*3, strict: false)
+    )
+
+    class <<self
+      def encode_body_size(size)
+        [size].pack('I>')[1..-1]
+      end
+
+      def decode_body_size(header)
+        "\x00#{header[0,3]}".unpack('I>').first
+      end
+    end
+
+    attr :protocol_id, :cmd_id, :sequence_id, :payload, :is_chunked_n, :total_payload_size, :frames
+
+    def initialize(protocol_id, cmd_id, payload, sequence_id, window_size, is_chunked_n=false, frames=nil, frame_cipher=nil)
+      raise ArgumentError, 'invalid protocol_id' unless protocol_id < TT16
+      raise ArgumentError, 'invalid sequence_id' unless sequence_id.nil? || sequence_id < TT16
+      raise ArgumentError, 'invalid window_size' unless window_size % padding == 0
+      raise ArgumentError, 'invalid cmd_id' unless cmd_id < 256
+
+      @protocol_id = protocol_id
+      @cmd_id = cmd_id
+      @payload = payload
+      @sequence_id = sequence_id
+      @is_chunked_n = is_chunked_n
+      @frame_cipher = frame_cipher
+
+      @frames = frames || []
+      @frames.push self
+
+      # chunk payloads resulting in frames exceeing window_size
+      fs = frame_size
+      if fs > window_size
+        unless is_chunked_n
+          @is_chunked_0 = true
+          @total_payload_size = body_size
+        end
+
+        # chunk payload
+        @payload = payload[0...(window_size-fs)]
+        raise FrameError, "invalid frame size" unless frame_size <= window_size
+
+        remain = payload[@payload.size..-1]
+        raise FrameError, "invalid remain size" unless (remain.size + @payload.size) == payload.size
+
+        Frame.new(protocol_id, cmd_id, remain, sequence_id, window_size, true, @frames, frame_cipher)
+      end
+
+      raise FrameError, "invalid frame size" unless frame_size <= window_size
+    end
+
+    def frame_type
+      return :normal if normal?
+      @is_chunked_n ? :chunked_n : :chunked_0
+    end
+
+    def frame_size
+      # header16 || mac16 || dataN + [padding] || mac16
+      header_size + mac_size + body_size(true) + mac_size
+    end
+
+    ##
+    # frame-size: 3-byte integer, size of frame, big endian encoded (excludes
+    # padding)
+    #
+    def body_size(padded=false)
+      l = enc_cmd_id.size + payload.size
+      padded ? Utils.ceil16(l) : l
+    end
+
+    def normal?
+      !@is_chunked_n && !@is_chunked_0
+    end
+
+    ##
+    # header: frame-size || header-data || padding
+    #
+    # frame-size: 3-byte integer, size of frame, big endian encoded
+    # header-data:
+    #   normal: RLP::Sedes::List.new(protocol_type[, sequence_id])
+    #   chunked_0: RLP::Sedes::List.new(protocol_type, sequence_id, total_packet_size)
+    #   chunked_n: RLP::Sedes::List.new(protocol_type, sequence_id)
+    #   normal, chunked_n: RLP::Sedes::List.new(protocol_type[, sequence_id])
+    #   values:
+    #     protocol_type: < 2**16
+    #     sequence_id: < 2**16 (this value is optional for normal frames)
+    #     total_packet_size: < 2**32
+    # padding: zero-fill to 16-byte boundary
+    #
+    def header
+      raise FrameError, "invalid protocol id" unless protocol_id < 2**16
+      raise FrameError, "invalid sequence id" unless sequence_id.nil? || sequence_id < TT16
+
+      l = [protocol_id]
+      if @is_chunked_0
+        raise FrameError, 'chunked_0 must have sequence_id' if sequence_id.nil?
+        l.push sequence_id
+        l.push total_payload_size
+      elsif sequence_id
+        l.push sequence_id
+      end
+
+      header_data = RLP.encode l, sedes: header_sedes
+      raise FrameError, 'invalid rlp' unless l == RLP.decode(header_data, sedes: header_sedes, strict: false)
+
+      bs = body_size
+      raise FrameError, 'invalid body size' unless bs < 256**3
+
+      header = Frame.encode_body_size(body_size) + header_data
+      header = Utils.rzpad16 header
+      raise FrameError, 'invalid header' unless header.size == header_size
+
+      header
+    end
+
+    def enc_cmd_id
+      @is_chunked_n ? '' : RLP.encode(cmd_id, sedes: RLP::Sedes.big_endian_int)
+    end
+
+    ##
+    # frame:
+    #   normal: rlp(packet_type) [|| rlp(packet_data)] || padding
+    #   chunked_0: rlp(packet_type) || rlp(packet_data ...)
+    #   chunked_n: rlp(...packet_data) || padding
+    # padding: zero-fill to 16-byte boundary (only necessary for last frame)
+    #
+    def body
+      Utils.rzpad16 "#{enc_cmd_id}#{payload}"
+    end
+
+    def as_bytes
+      raise FrameError, 'can only be called once' if @cipher_called
+
+      if @frame_cipher
+        @cipher_called = true
+        e = @frame_cipher.encrypt(header, body)
+        raise FrameError, 'invalid frame size of encrypted frame' unless e.size == frame_size
+        e
+      else
+        h = header
+        raise FrameError, 'invalid header size' unless h.size == header_size
+
+        b = body
+        raise FrameError, 'invalid body size' unless b.size == body_size(true)
+
+        dummy_mac = "\x00" * mac_size
+        r = h + dummy_mac + b + dummy_mac
+        raise FrameError, 'invalid frame' unless r.size == frame_size
+
+        r
+      end
+    end
+
+    def to_s
+      "<Frame(#{frame_type}, len=#{frame_size}, protocol=#{protocol_id} sid=#{sequence_id})"
+    end
+    alias :inspect :to_s
+
+  end
+
+end

data/lib/devp2p/kademlia.rb

@@ -0,0 +1,48 @@
+# -*- encoding : ascii-8bit -*-
+
+module DEVp2p
+
+  ##
+  # Node discovery and network formation are implemented via a Kademlia-like
+  # protocol. The major differences are that packets are signed, node ids are
+  # the public keys, and DHT-related features are excluded. The FIND_VALUE and
+  # STORE packets are not implemented.
+  #
+  # The parameters necessary to implement the protocol are:
+  #
+  #   * bucket size of 16 (denoted k in Kademlia)
+  #   * concurrency of 3 (denoted alpha)
+  #   * 8 bits per hop (denoted b) for routing
+  #   * The eviction check interval is 75 milliseconds
+  #   * request timeouts are 300ms
+  #   * idle bucket-refresh interval is 3600 seconds
+  #
+  # Aside from the previously described exclusions, node discovery closely
+  # follows system and protocol described by Maymounkov and Mazieres.
+  #
+  module Kademlia
+    B = 8                               # bits per hop for routing
+    K = 16                              # bucket size
+    A = 3                               # alpha, parallel find node lookups
+
+    REQUEST_TIMEOUT = 3 * 300 / 1000.0  # timeout of message round trips
+    IDLE_BUCKET_REFRESH_INTERVAL = 3600 # ping all nodes in bucket if bucket was idle
+    PUBKEY_SIZE = 512
+    ID_SIZE = 256
+    MAX_NODE_ID = 2 ** ID_SIZE - 1
+
+    class <<self
+      def random_nodeid
+        SecureRandom.random_number(MAX_NODE_ID+1)
+      end
+    end
+
+  end
+
+  require 'devp2p/kademlia/node'
+  require 'devp2p/kademlia/k_bucket'
+  require 'devp2p/kademlia/routing_table'
+  require 'devp2p/kademlia/wire_interface'
+  require 'devp2p/kademlia/protocol'
+
+end

data/lib/devp2p/kademlia/k_bucket.rb

@@ -0,0 +1,178 @@
+# -*- encoding : ascii-8bit -*-
+
+module DEVp2p
+  module Kademlia
+
+    ##
+    # Each k-bucket is kept sorted by time last seen - least-recently seen node
+    # at the head, most-recently seen at the tail. For small values of i, the
+    # k-buckets will generally be empty (as no appropriate nodes will exist).
+    # For large values of i, the lists can grow up to size k, where k is a
+    # system-wide replication parameter.
+    #
+    # k is chosen such that any given k nodes are very unlikely to fail within
+    # an hour of each other (for example k = 20).
+    #
+    class KBucket
+
+      attr :left, :right, :last_updated
+
+      def initialize(left, right)
+        @left, @right = left, right
+        @nodes = []
+        @replacement_cache = []
+        @last_updated = Time.now
+      end
+
+      include Enumerable
+      def each(&block)
+        @nodes.each(&block)
+      end
+
+      ##
+      # If the sending node already exists in the recipient's k-bucket, the
+      # recipient moves it to the tail of the list.
+      #
+      # If the node is not already in the appropriate k-bucket and the bucket
+      # has fewer than k entries, then the recipient just inserts the new
+      # sender at the tail of the list.
+      #
+      # If the appropriate k-bucket is full, however, then the recipient pings
+      # the k-bucket's least-recently seen node to decide what to do:
+      #
+      #   * on success: return nil
+      #   * on bucket full: return least recently seen node for eviction check
+      #
+      def add(node)
+        @last_updated = Time.now
+
+        if include?(node) # already exists
+          delete node
+          @nodes.push node
+          nil
+        elsif size < K # add if fewer than k entries
+          @nodes.push node
+          nil
+        else # bucket is full
+          head
+        end
+      end
+
+      def add_replacement(node)
+        @replacement_cache.push node
+      end
+
+      def delete(node)
+        return unless include?(node)
+        @nodes.delete node
+      end
+
+      ##
+      # least recently seen
+      #
+      def head
+        @nodes.first
+      end
+
+      ##
+      # last recently seen
+      #
+      def tail
+        @nodes.last
+      end
+
+      def range
+        [left, right]
+      end
+
+      def midpoint
+        left + (right - left) / 2
+      end
+
+      def distance(node)
+        midpoint ^ node.id
+      end
+
+      def id_distance(id)
+        midpoint ^ id
+      end
+
+      def nodes_by_id_distance(id)
+        raise ArgumentError, 'invalid id' unless id.is_a?(Integer)
+        @nodes.sort_by {|n| n.id_distance(id) }
+      end
+
+      def should_split?
+        full? && splitable?
+      end
+
+      def splitable?
+        d = depth
+        d % B != 0 && d != ID_SIZE
+      end
+
+      ##
+      # split at the median id
+      #
+      def split
+        split_id = midpoint
+
+        lower = self.class.new left, split_id
+        upper = self.class.new split_id + 1, right
+
+        # distribute nodes
+        @nodes.each do |node|
+          bucket = node.id <= split_id ? lower : upper
+          bucket.add node
+        end
+
+        # distribute replacement nodes
+        @replacement_cache.each do |node|
+          bucket = node.id <= split_id ? lower : upper
+          bucket.add_replacement node
+        end
+
+        return lower, upper
+      end
+
+      ##
+      # depth is the prefix shared by all nodes in bucket. i.e. the number of
+      # shared leading bits.
+      #
+      def depth
+        return ID_SIZE if size < 2
+
+        bits = @nodes.map {|n| Utils.bpad(n.id, ID_SIZE) }
+        ID_SIZE.times do |i|
+          if bits.map {|b| b[0,i] }.uniq.size != 1
+            return i - 1
+          end
+        end
+
+        raise "should never be here"
+      end
+
+      def in_range?(node)
+        left <= node.id && node.id <= right
+      end
+
+      def full?
+        size == K
+      end
+
+      def size
+        @nodes.size
+      end
+
+      def include?(node)
+        @nodes.include?(node)
+      end
+
+      def empty?
+        @nodes.empty?
+      end
+
+    end
+
+  end
+end