bitcourier 0.0.1

checksums.yaml

@@ -0,0 +1,15 @@
+---
+!binary "U0hBMQ==":
+  metadata.gz: !binary |-
+    NThjZTExNWE0MzhkMzhiM2EyYTE3OTIwMzJiYmZhOGJlMGIyM2JlNA==
+  data.tar.gz: !binary |-
+    MDlmYTFiM2YzNDg4Mjk2MWFiNGFiZDYxNDgxYTgxZWNmNjM1ZDAyOQ==
+SHA512:
+  metadata.gz: !binary |-
+    Mzg0NzdkNWJjZDQ2MTZmY2EzZDZmMDg3Njk4OGI1MDllNWY1MGQ3ZjIxZDAy
+    OWE5MjZjMDJhYjg0ZjljZjM4YjBlMTdlNDEzNDFiMGY1YmZkYjQ2MjQ2ZjQ4
+    NDZlYjczNjFiZThlYjUxNjkxMTg1ODc4MzY0ZGYzNzQ4ZmU2NTQ=
+  data.tar.gz: !binary |-
+    NjljMjk3ZmJjYjEzYzkxYTIyY2JkMDdmNGQzMDIzNDdmODYwNDJmMGY4NWVm
+    NGFkOGQ2ZWUxMjRlZTZkYTg4N2VkYTA3OWU0MDZkMDkwMWExZjQxZjY2MDZl
+    NGIzNGUwNWE4NDg0YmVkNjM5MzU1Mzk2NGMyY2U5NGIxMWRkNTQ=

data/.gitignore

@@ -0,0 +1,18 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp/*
+.*.swp

data/.travis.yml

@@ -0,0 +1,13 @@
+language: ruby
+rvm:
+  - 2.0.0
+  - 1.9.3
+  - 1.9.2
+  - jruby-18mode
+  - jruby-19mode
+  - rbx-18mode
+  - rbx-19mode
+  - ruby-head
+  - jruby-head
+  - 1.8.7
+  - ree

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in bitcourier.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Karol Sarnacki
+
+MIT License
+
+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.

data/README.md

@@ -0,0 +1,34 @@
+# Bitcourier
+
+[![Build Status](https://travis-ci.org/elpassion/bitcourier.png)](https://travis-ci.org/elpassion/bitcourier)
+[![Dependency Status](https://gemnasium.com/elpassion/bitcourier.png)](https://gemnasium.com/elpassion/bitcourier)
+
+Decentralized and trustless communication protocol used to anonymously send encrypted messages via peer-to-peer network.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'bitcourier'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install bitcourier
+
+## Usage
+
+Start Bitcourier node on port 6081 (this is the default port):
+
+    $ bitcourier node -p 6081
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1,10 @@
+require 'bundler/gem_tasks'
+require 'rake/testtask'
+
+task :default => :test
+
+Rake::TestTask.new do |task|
+  task.libs << 'lib' << 'spec'
+  task.pattern = 'spec/bitcourier/**/*_spec.rb'
+  task.verbose = true
+end

data/bin/bitcourier

@@ -0,0 +1,19 @@
+#!/usr/bin/env ruby
+
+$:.unshift File.dirname(__FILE__) + '/../lib'
+
+require 'thor'
+require 'bitcourier'
+
+class BitcourierCli < Thor
+
+  desc 'node', 'Start Bitcourier node'
+  method_option :port, default: 6081, aliases: '-p', desc: 'port on which the Bitcourier node will listen'
+  def node
+    daemon = Bitcourier::Daemon.new
+    daemon.run(options.port)
+  end
+
+end
+
+BitcourierCli.start

data/bitcourier.gemspec

@@ -0,0 +1,27 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'bitcourier/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'bitcourier'
+  spec.version       = Bitcourier::VERSION
+  spec.authors       = ['EL Passion']
+  spec.email         = ['account@elpassion.com']
+  spec.description   = %q{Decentralized and trustless communication protocol used to anonymously send encrypted messages via peer-to-peer network}
+  spec.summary       = %q{Decentralized and trustless communication protocol used to anonymously send encrypted messages via peer-to-peer network}
+  spec.homepage      = 'https://github.com/elpassion/bitcourier'
+  spec.license       = 'MIT'
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ['lib']
+
+  spec.add_dependency 'thor', '~> 0.18.1'
+
+  spec.add_development_dependency 'bundler', '~> 1.3'
+  spec.add_development_dependency 'minitest', '>= 5.0.8'
+  spec.add_development_dependency 'rake'
+  spec.add_development_dependency 'simplecov', '>= 0.7.1'
+end

data/lib/bitcourier.rb

@@ -0,0 +1,11 @@
+require 'bitcourier/protocol'
+require 'bitcourier/network'
+require 'bitcourier/node'
+require 'bitcourier/node_manager'
+require 'bitcourier/daemon'
+require 'bitcourier/peer'
+require 'bitcourier/peer_list'
+require 'bitcourier/version'
+
+module Bitcourier
+end

data/lib/bitcourier/daemon.rb

@@ -0,0 +1,33 @@
+require 'securerandom'
+
+module Bitcourier
+
+  class Daemon
+    attr_accessor :server, :client, :node_manager, :peer_list, :nonce
+
+    def initialize
+      self.server       = Network::Server.new self
+      self.node_manager = NodeManager.new self
+      self.client       = Network::Client.new self
+      self.peer_list    = PeerList.new
+      self.nonce        = SecureRandom.random_number(2**64)
+    end
+
+    def start
+      server_thread = server.run
+      client_thread = client.run
+
+      server_thread.join
+      client_thread.join
+    end
+
+    def run(port)
+      server.port = port
+
+      start
+    end
+  end
+
+end
+
+Thread.abort_on_exception = true

data/lib/bitcourier/network.rb

@@ -0,0 +1,5 @@
+require 'bitcourier/network/server'
+require 'bitcourier/network/client'
+
+module Bitcourier
+end

data/lib/bitcourier/network/client.rb

@@ -0,0 +1,65 @@
+require 'timeout'
+
+module Bitcourier
+  module Network
+    class Client
+      PEER_CONNECTION_RETRY_DELAY = 5 # In seconds
+      NEXT_PEER_DELAY             = 5
+      CONNECT_TIMEOUT             = 5
+
+      def initialize context
+        @context = context
+      end
+
+      def run
+        @thread = Thread.new do
+          loop do
+            if @context.node_manager.needs_nodes?
+              if peer_connection = next_peer_connection
+                @context.node_manager.add_socket peer_connection, true
+              else
+                sleep(NEXT_PEER_DELAY)
+              end
+            else
+              sleep(NEXT_PEER_DELAY)
+            end
+          end
+        end
+      end
+
+      private
+
+      def next_peer_connection
+        socket = nil
+
+        if peer = @context.peer_list.next
+          print "Connecting to #{peer.ip}:#{peer.port}... "
+
+          timeout(CONNECT_TIMEOUT) do
+            socket = TCPSocket.new(peer.ip, peer.port)
+          end
+
+          print "Connected.\n"
+
+          peer.touch
+          @context.peer_list.store(peer)
+        end
+      rescue Errno::ECONNREFUSED
+        print "Connection refused.\n"
+
+        peer.retry_in PEER_CONNECTION_RETRY_DELAY
+        @context.peer_list.store(peer)
+      rescue Errno::ETIMEDOUT, Timeout::Error
+        print "Timed out.\n"
+
+        peer.retry_in PEER_CONNECTION_RETRY_DELAY
+        @context.peer_list.store(peer)
+      rescue Exception => e
+        print "#{e.class}: #{e}\n"
+        puts e.backtrace
+      ensure
+        return socket
+      end
+    end
+  end
+end

data/lib/bitcourier/network/server.rb

@@ -0,0 +1,32 @@
+require 'socket'
+module Bitcourier
+  module Network
+    class Server
+      DEFAULT_PORT = 6081
+
+      attr_accessor :port
+
+      def initialize context, port = DEFAULT_PORT
+        @port = port
+        @context = context
+      end
+
+      def run
+        @server = TCPServer.new @port
+
+        puts "Started server on port #{@port}"
+
+        @thread = Thread.new do
+          loop do
+            socket = @server.accept
+            @context.node_manager.add_socket socket, false
+          end
+        end
+      end
+
+      def ip_string
+
+      end
+    end
+  end
+end

data/lib/bitcourier/node.rb

@@ -0,0 +1,172 @@
+module Bitcourier
+  class Node
+
+    class State
+      class Unimplemented < StandardError; end
+
+      attr_accessor :node
+
+      def initialize node
+        self.node = node
+      end
+
+      def method_missing method, args
+        name = method.id2name
+
+        if name.start_with? 'on_'
+          puts "Can't handle #{name[3..-1]} in current state"
+        else
+          super(method, args)
+        end
+      end
+
+      def set_state state
+        node.set_state state
+      end
+
+      def on_enter
+      end
+
+      def on_leave
+      end
+    end
+
+    class ActiveHandshake < State
+      def on_enter
+        node.send_hello
+      end
+
+      def on_hello msg
+        if msg.protocol_version == Protocol::Message::Hello::PROTOCOL_VERSION
+          node.remote_port = msg.port
+          set_state ReadyState
+        else
+          node.disconnect
+        end
+      end
+    end
+
+    class PassiveHandshake < State
+      def on_hello msg
+        version_ok = msg.protocol_version == Protocol::Message::Hello::PROTOCOL_VERSION
+        nonce_ok = msg.nonce != node.context.nonce
+
+        if version_ok and nonce_ok
+          node.remote_port = msg.port
+          node.send_hello
+          set_state ReadyState
+        else
+          node.disconnect
+        end
+      end
+    end
+
+    class ReadyState < State
+      def on_enter
+        node.remember_peer
+        node.send_message(Protocol::Message::GetPeerList.new)
+      end
+
+      def on_get_peer_list msg
+        node.send_peer_list
+      end
+
+      def on_peer_info msg
+        node.on_peer_info(msg)
+      end
+    end
+
+    attr_accessor :socket, :context, :remote_port
+
+    def initialize(context, socket)
+      self.socket = socket
+      self.context = context
+    end
+
+    def set_state state
+      self.state.on_leave if self.state
+      self.state = state.new(self)
+      self.state.on_enter
+    end
+
+    def disconnect
+      socket.close
+    end
+
+    def remember_peer
+      remote_ip = socket.peeraddr[3]
+      peer      = Peer.new remote_ip, remote_port
+
+      context.peer_list.store peer
+    end
+
+    def send_hello
+      msg = Protocol::Message::Hello.new
+      msg.port = context.server.port
+      msg.nonce = context.nonce
+      send_message msg
+    end
+
+    def send_peer_list
+      context.peer_list.peers.each do |peer|
+        msg = Protocol::Message::PeerInfo.new
+        msg.ip = peer.ip
+        msg.port = peer.port
+        msg.last_seen_at = peer.last_seen_at
+        send_message msg
+      end
+    end
+
+    def send_message msg
+      data = msg.pack
+      socket.write data
+    end
+
+    def on_peer_info msg
+      context.peer_list.store Peer.new(msg.ip, msg.port, msg.last_seen_at)
+    end
+
+    def on_message msg
+      return if state.nil?
+
+      case msg
+        when Protocol::Message::Hello
+          state.on_hello(msg)
+        when Protocol::Message::GetPeerList
+          state.on_get_peer_list(msg)
+        when Protocol::Message::PeerInfo
+          state.on_peer_info(msg)
+        else
+          puts "Don't know how to handle message class #{msg.class}"
+      end
+    end
+
+    def run
+      @thread = Thread.new do
+        buffer = ''
+
+        begin
+          loop do
+            data = socket.recv(1024)
+
+            break if data.length == 0
+
+            buffer += data
+
+            while (message_size = Protocol::Message::Base.message_size(buffer)) > 0
+              message_data = buffer.slice!(0, message_size)
+              message = Protocol::Message::Base.unpack(message_data)
+              on_message message
+            end
+          end
+        rescue IOError
+          puts "Connection closed"
+        end
+
+      end
+    end
+
+    attr_accessor :state
+
+  end
+end

data/lib/bitcourier/node_manager.rb

@@ -0,0 +1,35 @@
+module Bitcourier
+  class NodeManager
+    MINIMUM_NODES = 3
+
+    attr_accessor :context
+
+    def initialize context
+      self.nodes   = []
+      self.context = context
+    end
+
+    def needs_nodes?
+      nodes.count < MINIMUM_NODES
+    end
+
+    def add_socket socket, active = false
+      node = Node.new context, socket
+
+      if active
+        node.set_state Node::ActiveHandshake
+      else
+        node.set_state Node::PassiveHandshake
+      end
+
+      nodes << node
+
+      node.run
+    end
+
+    private
+
+    attr_accessor :nodes
+
+  end
+end

data/lib/bitcourier/peer.rb

@@ -0,0 +1,46 @@
+module Bitcourier
+  class Peer
+    attr_accessor :ip, :port, :last_seen_at, :next_connection_at
+
+    def initialize ip, port, last_seen_at = nil, next_connection_at = Time.now.utc
+      self.ip                 = ip
+      self.port               = port
+      self.last_seen_at       = last_seen_at
+      self.next_connection_at = next_connection_at
+    end
+
+    def touch(timestamp = Time.now.utc)
+      self.last_seen_at = [last_seen_at || Time.at(0).utc, timestamp || Time.now.utc].max
+    end
+
+    def update(peer)
+      touch(peer.last_seen_at)
+      self.next_connection_at = peer.next_connection_at
+    end
+
+    def can_connect?(time = Time.now.utc)
+      next_connection_at < time
+    end
+
+    def retry_in delay
+      self.next_connection_at = Time.now + delay
+    end
+
+    def to_a
+      [
+          ip,
+          port,
+          last_seen_at && last_seen_at.to_i,
+          next_connection_at && next_connection_at.to_i
+      ]
+    end
+
+    def same?(other)
+      other && (ip == other.ip) && (port == other.port)
+    end
+
+    def self.from_a a
+      new(a[0], a[1].to_i, a[2] && Time.at(a[2].to_i).utc, a[3] && Time.at(a[3].to_i).utc)
+    end
+  end
+end

data/lib/bitcourier/peer_list.rb

@@ -0,0 +1,72 @@
+module Bitcourier
+  class PeerList
+    attr_reader :peers
+
+    def initialize
+      @peers   = []
+      @storage = Storage.new(self)
+
+      load
+    end
+
+    def store(peer)
+      if existing = find(peer)
+        existing.update(peer)
+      else
+        peers << peer
+      end
+
+      save
+    end
+
+    def next
+      peers.select(&:can_connect?).sample
+    end
+
+    private
+
+    attr_reader :storage
+
+    def find(peer)
+      peers.detect { |existing| existing.same?(peer) }
+    end
+
+    def save
+      storage.write
+    end
+
+    def load
+      storage.read
+
+      seed if peers.size == 0
+    end
+
+    def seed
+      store Peer.new('146.185.167.10', 6081)
+    end
+
+    class Storage
+      PATH = './tmp/peer_list.txt'
+      
+      def initialize list
+        @list = list
+      end
+
+      def read
+        File.read(PATH).lines.map do |line|
+          @list.store Peer.from_a(line.split('|'))
+        end
+      rescue Errno::ENOENT
+        return []
+      end
+
+      def write
+        File.open(PATH, 'w') do |file|
+          @list.peers.each do |peer|
+            file.puts peer.to_a.join('|')
+          end
+        end
+      end
+    end
+  end
+end

data/lib/bitcourier/protocol.rb

@@ -0,0 +1 @@
+require 'bitcourier/protocol/message'

data/lib/bitcourier/protocol/message.rb

@@ -0,0 +1,4 @@
+require 'bitcourier/protocol/message/base'
+require 'bitcourier/protocol/message/get_peer_list'
+require 'bitcourier/protocol/message/hello'
+require 'bitcourier/protocol/message/peer_info'

data/lib/bitcourier/protocol/message/base.rb

@@ -0,0 +1,62 @@
+module Bitcourier
+  module Protocol
+    module Message
+      class Base
+        MAGIC_BYTES = 0x1234
+        HEADER_SIZE = 6
+
+        def header
+          [MAGIC_BYTES, self.class::ID, payload.size].pack('SSS')
+        end
+
+        def payload
+          ''
+        end
+
+        def pack
+          header + payload
+        end
+
+        def extract bytes
+        end
+
+        def self.unpack bytes
+          magic, id, length = unpack_header(bytes)
+
+          return nil if magic != MAGIC_BYTES # wrong magic
+          return nil if length + HEADER_SIZE > bytes.size # partial package
+          return nil unless klass = find_message_class(id)
+
+          msg = klass.new
+          msg.extract bytes[HEADER_SIZE..-1]
+
+          msg
+        end
+
+        def self.message_size bytes
+          return 0 if bytes.size < HEADER_SIZE
+
+          _, _, length = unpack_header(bytes)
+
+          return 0 if bytes.size < (length + HEADER_SIZE)
+
+          return length + HEADER_SIZE
+        end
+
+        private
+
+        def self.unpack_header bytes
+          bytes[0...HEADER_SIZE].unpack('SSS')
+        end
+
+        def self.find_message_class id
+          [Hello, GetPeerList, PeerInfo].each do |message_class|
+            return message_class if message_class::ID == id
+          end
+
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/bitcourier/protocol/message/get_peer_list.rb

@@ -0,0 +1,9 @@
+module Bitcourier
+  module Protocol
+    module Message
+      class GetPeerList < Base
+        ID = 0x2
+      end
+    end
+  end
+end

data/lib/bitcourier/protocol/message/hello.rb

@@ -0,0 +1,29 @@
+module Bitcourier
+  module Protocol
+    module Message
+      class Hello < Base
+        ID               = 0x1
+        PROTOCOL_VERSION = 1
+
+        attr_accessor :protocol_version, :port, :nonce
+
+        def initialize
+          self.protocol_version = PROTOCOL_VERSION
+        end
+
+        def payload
+          [protocol_version.to_i, port.to_i, nonce.to_i].pack('SSQ')
+        end
+
+        def extract bytes
+          data = bytes.unpack('SSQ')
+
+          self.protocol_version = data[0]
+          self.port             = data[1]
+          self.nonce            = data[2]
+        end
+
+      end
+    end
+  end
+end

data/lib/bitcourier/protocol/message/peer_info.rb

@@ -0,0 +1,34 @@
+module Bitcourier
+  module Protocol
+    module Message
+
+      class PeerInfo < Base
+        ID = 0x3
+
+        attr_accessor :ip, :port, :last_seen_at
+
+        def payload
+          [ip_array, port.to_i, last_seen_at.to_i].flatten.pack('CCCCSL')
+        end
+
+        def extract bytes
+          data = bytes.unpack('CCCCSL')
+
+          self.ip           = data[0..3].join('.')
+          self.port         = data[4].to_i
+          self.last_seen_at = Time.at(data[5].to_i).utc
+
+          self
+        end
+
+        private
+
+        def ip_array
+          ip.split('.').map(&:to_i)
+        end
+
+      end
+
+    end
+  end
+end

data/lib/bitcourier/version.rb

@@ -0,0 +1,3 @@
+module Bitcourier
+  VERSION = '0.0.1'
+end

data/spec/bitcourier/protocol/message/base_spec.rb

@@ -0,0 +1,45 @@
+require 'spec_helper'
+
+describe Bitcourier::Protocol::Message::Base do
+
+  describe '::unpack' do
+
+    describe 'given GetPeerList packet bytes' do
+      it 'returns GetPeerList message object' do
+        get_peer_list_bytes = "4\x12\x02\x00\x00\x00".force_encoding('ASCII-8BIT')
+        get_peer_list       = Bitcourier::Protocol::Message::Base.unpack(get_peer_list_bytes)
+
+        get_peer_list.must_be_instance_of Bitcourier::Protocol::Message::GetPeerList
+      end
+    end
+
+    describe 'given Hello packet bytes' do
+      it 'returns Hello message object' do
+        hello_bytes = "4\x12\x01\x00\f\x00\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00".force_encoding('ASCII-8BIT')
+        hello       = Bitcourier::Protocol::Message::Base.unpack(hello_bytes)
+
+        hello.must_be_instance_of Bitcourier::Protocol::Message::Hello
+      end
+    end
+
+    describe 'given PeerInfo packet bytes' do
+      it 'returns PeerInfo message object' do
+        peer_info_bytes = "4\x12\x03\x00\n\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00".force_encoding('ASCII-8BIT')
+        peer_info       = Bitcourier::Protocol::Message::Base.unpack(peer_info_bytes)
+
+        peer_info.must_be_instance_of Bitcourier::Protocol::Message::PeerInfo
+      end
+    end
+
+    describe 'given unknown packet bytes' do
+      it 'returns nil' do
+        unknown_bytes = "4\x12\xFF\x00\x00\x00".force_encoding('ASCII-8BIT')
+        unknown       = Bitcourier::Protocol::Message::Base.unpack(unknown_bytes)
+
+        unknown.must_be_nil
+      end
+    end
+
+  end
+
+end

data/spec/bitcourier/protocol/message/hello_spec.rb

@@ -0,0 +1,33 @@
+require 'spec_helper'
+
+describe Bitcourier::Protocol::Message::Hello do
+  before do
+    @hello       = Bitcourier::Protocol::Message::Hello.new
+    @hello_bytes = "{\x00\x11\x00\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF".force_encoding('ASCII-8BIT')
+  end
+
+  it 'initiates with default version number' do
+    @hello.protocol_version.must_equal Bitcourier::Protocol::Message::Hello::PROTOCOL_VERSION
+  end
+
+  describe '#payload' do
+    it 'returns payload bytes' do
+      @hello.protocol_version = 123
+      @hello.port             = 17
+      @hello.nonce            = 2**64 - 1
+
+      @hello.payload.must_equal @hello_bytes
+    end
+  end
+
+  describe '#extract' do
+    it 'extracts payload bytes to object values' do
+      @hello.extract @hello_bytes
+
+      @hello.protocol_version.must_equal 123
+      @hello.port.must_equal 17
+      @hello.nonce.must_equal 2**64 - 1
+    end
+  end
+
+end

data/spec/bitcourier/protocol/message/peer_info_spec.rb

@@ -0,0 +1,29 @@
+require 'spec_helper'
+
+describe Bitcourier::Protocol::Message::PeerInfo do
+  before do
+    @peer_info       = Bitcourier::Protocol::Message::PeerInfo.new
+    @peer_info_bytes = "\x01\x02\x03\x04\xFF\xFF\xAF5\xA24".force_encoding('ASCII-8BIT')
+  end
+
+  describe '#payload' do
+    it 'returns payload bytes' do
+      @peer_info.ip           = '1.2.3.4'
+      @peer_info.port         = 65535
+      @peer_info.last_seen_at = Time.utc(1997, 12, 25, 10, 30, 7)
+
+      @peer_info.payload.must_equal @peer_info_bytes
+    end
+  end
+
+  describe '#extract' do
+    it 'extracts payload bytes to object values' do
+      @peer_info.extract @peer_info_bytes
+
+      @peer_info.ip.must_equal '1.2.3.4'
+      @peer_info.port.must_equal 65535
+      @peer_info.last_seen_at.must_equal Time.utc(1997, 12, 25, 10, 30, 7)
+    end
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,17 @@
+$LOAD_PATH.unshift File.expand_path('../../lib', __FILE__)
+
+if RUBY_VERSION < '1.9'
+  class String
+    def force_encoding(encoding)
+      self
+    end
+  end
+end
+
+gem 'minitest' # ensure we are using the gem version
+
+require 'bitcourier'
+require 'minitest/autorun'
+require 'simplecov'
+
+SimpleCov.start

metadata

@@ -0,0 +1,152 @@
+--- !ruby/object:Gem::Specification
+name: bitcourier
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- EL Passion
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-10-26 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: thor
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.18.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.18.1
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 5.0.8
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 5.0.8
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 0.7.1
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 0.7.1
+description: Decentralized and trustless communication protocol used to anonymously
+  send encrypted messages via peer-to-peer network
+email:
+- account@elpassion.com
+executables:
+- bitcourier
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .travis.yml
+- Gemfile
+- Gemfile.lock
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/bitcourier
+- bitcourier.gemspec
+- lib/bitcourier.rb
+- lib/bitcourier/daemon.rb
+- lib/bitcourier/network.rb
+- lib/bitcourier/network/client.rb
+- lib/bitcourier/network/server.rb
+- lib/bitcourier/node.rb
+- lib/bitcourier/node_manager.rb
+- lib/bitcourier/peer.rb
+- lib/bitcourier/peer_list.rb
+- lib/bitcourier/protocol.rb
+- lib/bitcourier/protocol/message.rb
+- lib/bitcourier/protocol/message/base.rb
+- lib/bitcourier/protocol/message/get_peer_list.rb
+- lib/bitcourier/protocol/message/hello.rb
+- lib/bitcourier/protocol/message/peer_info.rb
+- lib/bitcourier/version.rb
+- spec/bitcourier/protocol/message/base_spec.rb
+- spec/bitcourier/protocol/message/hello_spec.rb
+- spec/bitcourier/protocol/message/peer_info_spec.rb
+- spec/spec_helper.rb
+- tmp/.gitkeep
+homepage: https://github.com/elpassion/bitcourier
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.1.10
+signing_key: 
+specification_version: 4
+summary: Decentralized and trustless communication protocol used to anonymously send
+  encrypted messages via peer-to-peer network
+test_files:
+- spec/bitcourier/protocol/message/base_spec.rb
+- spec/bitcourier/protocol/message/hello_spec.rb
+- spec/bitcourier/protocol/message/peer_info_spec.rb
+- spec/spec_helper.rb
+has_rdoc: