rtunnel 0.3.8 → 0.4.0

data/spec/cmds_spec.rb

@@ -0,0 +1,127 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+require 'cmds'
+
+include RTunnel
+
+describe RTunnel::CreateConnectionCommand do
+  it "should be able to serialize and parse itself" do
+    serialized = CreateConnectionCommand.new("id").to_s
+
+    cmd = Command.parse(serialized)
+    cmd.class.should == CreateConnectionCommand
+    cmd.conn_id.should == "id"
+  end
+
+  it "should be able to match itself and remove itself from the stream" do
+    serialized = CreateConnectionCommand.new("abcbdefg").to_s
+
+    Command.match(serialized).should == true
+    Command.parse(serialized)
+    serialized.should be_empty
+  end
+end
+
+describe RTunnel::SendDataCommand do
+  it "should be able to serialzied and parse itself" do
+    serialized = SendDataCommand.new("id", "here is some data").to_s
+
+    cmd = Command.parse(serialized)
+    cmd.class.should == SendDataCommand
+    cmd.conn_id.should == "id"
+    cmd.data.should == "here is some data"
+  end
+
+  it "should be able to match itself and remove itself from the stream" do
+    serialized = SendDataCommand.new("abcbdefg", "and here is some data").to_s
+
+    serialized << "WAY MORE CRAP DATA!!!"
+
+    Command.match(serialized).should == true
+    Command.parse(serialized)
+    serialized.should == "WAY MORE CRAP DATA!!!"
+  end
+end
+
+describe RTunnel::CloseConnectionCommand do
+  it "should be able to serialize and parse itself" do
+    serialized = CloseConnectionCommand.new("id").to_s
+
+    cmd = Command.parse(serialized)
+    cmd.class.should == CloseConnectionCommand
+    cmd.conn_id.should == "id"
+  end
+
+  it "should be able to match itself and remove itself from the stream" do
+    serialized = CloseConnectionCommand.new("abcbdefg").to_s
+
+    Command.match(serialized).should == true
+    Command.parse(serialized)
+    serialized.should be_empty
+  end
+end
+
+describe RTunnel::PingCommand do
+  it "should be able to serialize and parse itself" do
+    serialized = PingCommand.new.to_s
+
+    cmd = Command.parse(serialized)
+    cmd.class.should == PingCommand
+  end
+
+  it "should be able to match itself and remove itself from the stream" do
+    serialized = PingCommand.new.to_s
+
+    Command.match(serialized).should == true
+    Command.parse(serialized)
+    serialized.should be_empty
+  end
+end
+
+
+describe RTunnel::RemoteListenCommand do
+  it "should be able to serialize and parse itself" do
+    serialized = RemoteListenCommand.new("0.0.0.0:1234").to_s
+
+    cmd = Command.parse(serialized)
+    cmd.class.should == RemoteListenCommand
+    cmd.address.should == "0.0.0.0:1234"
+  end
+
+  it "should be able to match itself and remove itself from the stream" do
+    serialized = RemoteListenCommand.new("0.0.0.0:1234").to_s
+
+    Command.match(serialized).should == true
+    Command.parse(serialized)
+    serialized.should be_empty
+  end
+end
+
+
+describe RTunnel::Command do
+  it "should be able to match a command in a stream" do
+    Command.match("C1234abc|").should == true
+    Command.match("C1234abc").should == false
+    Command.match("C1234abc|C|").should == true
+
+    Command.match("Did|15|DATA").should == false
+    Command.match("Did|1|DATA").should == true
+    Command.match("Did|4|\0\0\0\0").should == true
+
+    data = "C1234abc|D1234abc|15|here is my dataX1234abc|L0.0.0.0:1234|CASDF"
+    cmd1 = Command.parse(data)
+    cmd2 = Command.parse(data)
+    cmd3 = Command.parse(data)
+    cmd4 = Command.parse(data)
+    cmd1.class.should == CreateConnectionCommand
+    cmd1.conn_id.should == "1234abc"
+    cmd2.class.should == SendDataCommand
+    cmd2.conn_id.should == "1234abc"
+    cmd3.class.should == CloseConnectionCommand
+    cmd3.conn_id.should == "1234abc"
+    cmd4.class.should == RemoteListenCommand
+    cmd4.address.should == "0.0.0.0:1234"
+
+    Command.match(data).should == false
+  end
+end

data/spec/integration_spec.rb

@@ -0,0 +1,105 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+require 'client'
+require 'server'
+
+describe "RTunnel" do
+  class TextServer < GServer
+    def initialize(port, text)
+      @text = text
+      super(port)
+    end
+
+    def serve(io)
+      io.write(@text)
+    end
+  end
+
+  def read_from_address(addr)
+    timeout(2) { TCPSocket.open(*addr.split(/:/)) {|s| s.read } }
+  end
+
+  it "should work!" do
+    begin
+      server = RTunnel::Server.new(:control_address => 'localhost:9999')
+      client = RTunnel::Client.new(:control_address => 'localhost:9999', :remote_listen_address => '30002', :tunnel_to_address => '30003')
+
+      server.start
+      client.start
+
+      s = TextServer.new(30003, echo_text = "tunnel this txt plz!")
+      s.start
+
+      sleep 0.5
+
+      # direct connect (sanity check)
+      read_from_address('localhost:30003').should == echo_text
+      # tunneled connect
+      read_from_address('localhost:30002').should == echo_text
+    ensure
+      begin
+        client.stop
+        server.stop
+        s.stop
+      rescue
+      end
+    end
+  end
+
+  it "should ping all clients periodically" do
+    begin
+      server = RTunnel::Server.new(:control_address => 'localhost:9999', :ping_interval => 0.2)
+      clients = []
+      clients << RTunnel::Client.new(:control_address => 'localhost:9999', :remote_listen_address => '30002', :tunnel_to_address => '30003')
+      clients << RTunnel::Client.new(:control_address => 'localhost:9999', :remote_listen_address => '30012', :tunnel_to_address => '30013')
+      server.start
+      clients.each{|c|c.start}
+
+      pings = Hash.new {|h,k| h[k] = [] }
+      t = Thread.new do
+        loop do
+          clients.each do |client|
+            pings[client] << client.instance_eval { @last_ping }
+          end
+          sleep 0.05
+        end
+      end
+
+      sleep 2
+
+      clients.each do |client|
+        # 2 seconds, 0.2 pings a sec = ~10 pings
+        (9..11).should include(pings[client].uniq.size)
+      end
+    ensure
+      t.kill
+      begin
+        clients.each{|c|c.stop}
+        server.stop
+      rescue
+        p $!,$@
+      end
+    end
+  end
+
+  it "the client shouldnt fail even if there is no server running at the tunnel_to address" do
+    begin
+      server = RTunnel::Server.new(:control_address => 'localhost:9999')
+      client = RTunnel::Client.new(:control_address => 'localhost:9999', :remote_listen_address => '30002', :tunnel_to_address => '30003')
+
+      server.start
+      client.start
+
+      sleep 0.5
+
+      # tunneled connect
+      read_from_address('localhost:30002').should be_empty
+    ensure
+      begin
+        client.stop
+        server.stop
+      rescue
+      end
+    end
+  end
+end

data/spec/server_spec.rb

@@ -0,0 +1,21 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+require 'server'
+
+include RTunnel
+describe RTunnel::Server, "addresses" do
+  it "control address should listen on all interfaces and use default control port if not specified" do
+    Server.new(:control_address => nil).
+      instance_eval { @control_address }.should == "0.0.0.0:#{DEFAULT_CONTROL_PORT}"
+
+    Server.new(:control_address => '5555').
+      instance_eval { @control_address }.should == "0.0.0.0:5555"
+
+    Server.new(:control_address => 'interface2').
+      instance_eval { @control_address }.should == "interface2:#{DEFAULT_CONTROL_PORT}"
+
+    Server.new(:control_address => 'interface2:2222').
+      instance_eval { @control_address }.should == "interface2:2222"
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,3 @@
+$LOAD_PATH << File.dirname(__FILE__) + "/../lib"
+
+require 'spec'

data/test/command_stubs.rb

@@ -0,0 +1,77 @@
+# Contains generate_ and verify_ names for all RTunnel commands.
+module CommandStubs
+  @@test_id1 = "1029384756ALSKDJFH"
+  @@test_id2 = "ALSKDJFH1029384756"
+  @@test_address = "192.168.43.95"
+  @@data = (0..255).to_a.pack('C*')
+  @@ekey = (128...192).to_a.pack('C*') * 8
+  @@pubfp = (0...128).to_a.pack('C*') * 5
+  
+  def generate_keep_alive
+    RTunnel::KeepAliveCommand.new
+  end
+  def verify_keep_alive(cmd)
+    assert_equal RTunnel::KeepAliveCommand, cmd.class
+  end
+  
+  def generate_create
+    RTunnel::CreateConnectionCommand.new @@test_id1
+  end
+  def verify_create(cmd)
+    assert_equal RTunnel::CreateConnectionCommand, cmd.class
+    assert_equal @@test_id1, cmd.connection_id
+  end
+  
+  def generate_close
+    RTunnel::CloseConnectionCommand.new @@test_id2
+  end
+  def verify_close(cmd)
+    assert_equal RTunnel::CloseConnectionCommand, cmd.class
+    assert_equal @@test_id2, cmd.connection_id
+  end
+
+  def generate_listen
+    RTunnel::RemoteListenCommand.new @@test_address
+  end
+  def verify_listen(cmd)
+    assert_equal RTunnel::RemoteListenCommand, cmd.class
+    assert_equal @@test_address, cmd.address
+  end
+
+  def generate_send
+    RTunnel::SendDataCommand.new @@test_id1, @@data
+  end
+  def verify_send(cmd)
+    assert_equal RTunnel::SendDataCommand, cmd.class
+    assert_equal @@test_id1, cmd.connection_id
+    assert_equal @@data, cmd.data
+  end
+  
+  def generate_set_sk
+    RTunnel::SetSessionKeyCommand.new @@ekey
+  end
+  def verify_set_sk(cmd)
+    assert_equal RTunnel::SetSessionKeyCommand, cmd.class
+    assert_equal @@ekey, cmd.encrypted_keys
+  end
+
+  def generate_gen_sk
+    RTunnel::GenerateSessionKeyCommand.new @@pubfp
+  end
+  def verify_gen_sk(cmd)
+    assert_equal RTunnel::GenerateSessionKeyCommand, cmd.class
+    assert_equal @@pubfp, cmd.public_key_fp
+  end
+
+  # An array with the names of all commands.
+  # Use these names to obtain the names of the genrate_ and verify_ methods.
+  def self.command_names
+    [:keep_alive, :create, :close, :listen, :send, :gen_sk, :set_sk]
+  end
+
+  # A sequence of command names useful for testing "real" connections.
+  def self.command_test_sequence
+    [:create, :keep_alive, :gen_sk, :set_sk, :keep_alive, :listen, :keep_alive,
+     :send, :send, :keep_alive, :keep_alive, :send, :close]
+  end
+end

data/test/protocol_mocks.rb

@@ -0,0 +1,43 @@
+# Mocks the sending end of an EventMachine connection.
+# The sent data is concatenated in a string available by calling #string.
+class EmSendMock  
+  attr_reader :string
+  
+  def initialize
+    @string = ''
+  end
+  
+  def send_data(data)
+    @string << data
+  end
+end
+
+# Mocks the receiving end of an EventMachine connection.
+# The data to be received is passed as an array of strings to the constructor.
+# Calling #replay mocks receiving the data.
+class EmReceiveMock
+  attr_accessor :strings
+  attr_accessor :objects
+  
+  def initialize(strings = [''])
+    @strings = strings
+    @objects = []
+  end
+  
+  def replay
+    @strings.each { |str| receive_data str }
+    self
+  end
+
+  def receive_object(object)
+    @objects << object
+  end
+  
+  # Declares the name of the object to be received. For instance, a frame
+  # protocol would use :frame for name. This generates a receive_frame method,
+  # and a frames accessor.
+  def self.object_name(name)
+    alias_method "receive_#{name}".to_sym, :receive_object
+    alias_method "#{name}s".to_sym, :objects
+  end
+end

data/test/scenario_connection.rb

@@ -0,0 +1,109 @@
+require 'rubygems'
+require 'eventmachine'
+
+# Event Machine connection that runs a fixed send-expect scenario.
+class ScenarioConnection < EventMachine::Connection
+  def initialize(test_case, scenario = nil)
+    super()
+
+    @test_case = test_case
+    @scenario = scenario || yield
+    @ignore_unbind = false
+    next_step
+  end
+
+  def post_init
+    scenario_can_send
+  end
+
+  def receive_data(data)
+    scenario_received data
+  end
+
+  def unbind
+    return if @ignore_unbind
+
+    unless @step and @step.first == :unbind
+      scenario_fail "Received unexpected unbind\n"
+    end
+    next_step
+    while @step and @step.first == :proc
+      @step.last.call
+      next_step
+    end
+    if @step and @step.first == :stop
+      scenario_stop @step.last
+    end
+  end
+
+  # Called when data is received. Plays the connection scenario.
+  def scenario_received(data)
+    unless @step and @step.first == :recv
+      scenario_fail "Received unexpected data: #{data}\n"
+    end
+
+    @test_case.send :assert_equal, @step.last, data
+    next_step
+    scenario_can_send
+  end
+
+  # Called when data can be sent. Plays the connection scenario.
+  def scenario_can_send
+    while @step
+      case @step.first
+      when :proc
+        @step.last.call
+      when :send
+        send_data @step.last
+      else
+        break
+      end
+      next_step
+    end
+
+    unless @step
+      # EM might stifle this exception and reraise
+      msg = "Scenario completed prematurely"
+      $stderr.puts msg
+      fail msg
+    end
+
+    case @step.first
+    when :receive
+      # wait to receive
+      return
+    when :unbind
+      # wait for unbind
+      return
+    when :close
+      @ignore_unbind = true
+      close_connection_after_writing
+      next_step
+    end
+  end
+
+  def scenario_fail(fail_message)
+    if @step
+      fail_message << "Expected to #{@step.inspect}"
+    else
+      fail_message << "Scenario was completed\n"
+    end
+    @test_case.send :fail, fail_message
+  end
+
+  def scenario_stop(stop_proc)
+    if stop_proc.kind_of? Proc
+      # call the proc, then give em time to stop all its servers
+      stop_proc.call
+      EventMachine.add_timer 0.1 do
+        EventMachine.stop_event_loop
+      end
+    else
+      EventMachine.stop_event_loop
+    end
+  end
+
+  def next_step
+    @step = @scenario.shift
+  end
+end

data/test/test_client.rb

@@ -0,0 +1,48 @@
+require 'rtunnel'
+
+require 'openssl'
+require 'resolv'
+require 'test/unit'
+
+class ClientTest < Test::Unit::TestCase
+  def setup
+    @client = RTunnel::Client.new(:control_address => 'localhost',
+                                  :remote_listen_address => '9199',
+                                  :tunnel_to_address => '4444',
+                                  :private_key => 'test_data/ssh_host_rsa_key',
+                                  :tunnel_timeout => 5)
+    @localhost_addr = Resolv.getaddress 'localhost'
+  end
+  
+  def test_options
+    client = RTunnel::Client
+    assert_equal "18.241.3.100:#{RTunnel::DEFAULT_CONTROL_PORT}",
+                 client.extract_control_address('18.241.3.100')                 
+    assert_equal "18.241.3.100:9199",
+                 client.extract_control_address('18.241.3.100:9199')
+    assert_equal "#{@localhost_addr}:#{RTunnel::DEFAULT_CONTROL_PORT}",
+                 client.extract_control_address('localhost')                 
+    assert_equal "#{@localhost_addr}:9199",
+                 client.extract_control_address('localhost:9199')
+
+    assert_equal "0.0.0.0:9199",
+                 client.extract_remote_listen_address('9199')                 
+    assert_equal "18.241.3.100:9199",
+                 client.extract_remote_listen_address('18.241.3.100:9199')                 
+    assert_equal "#{@localhost_addr}:9199",
+                 client.extract_remote_listen_address('localhost:9199')
+
+    assert_equal "18.241.3.100:9199",
+                 client.extract_tunnel_to_address('18.241.3.100:9199')                 
+    assert_equal "#{@localhost_addr}:9199",
+                 client.extract_tunnel_to_address('9199')
+                 
+    assert_equal RTunnel::TUNNEL_TIMEOUT, client.extract_tunnel_timeout(nil)
+    assert_equal 29, client.extract_tunnel_timeout(29)
+    
+    assert_equal nil, client.extract_private_key(nil)
+    key = client.extract_private_key 'test_data/ssh_host_rsa_key'
+    assert_equal OpenSSL::PKey::RSA, key.class
+    assert_equal File.read('test_data/ssh_host_rsa_key'), key.to_pem
+  end
+end

data/test/test_command_protocol.rb

@@ -0,0 +1,82 @@
+require 'rtunnel'
+
+require 'test/unit'
+
+require 'test/command_stubs.rb'
+require 'test/protocol_mocks.rb'
+
+# Send mock for commands.
+class EmSendCommandsMock < EmSendMock
+  include RTunnel::CommandProtocol
+end
+
+# Receive mock for commands.
+class EmReceiveCommandsMock < EmReceiveMock
+  include RTunnel::CommandProtocol
+  object_name :command
+end
+
+class CommandProtocolTest < Test::Unit::TestCase
+  include CommandStubs
+  C = RTunnel::Crypto
+  
+  def setup
+    super
+    @send_mock = EmSendCommandsMock.new
+  end
+  
+  def teardown
+    super
+  end
+  
+  def commandset_test(names)
+    @send_mock.outgoing_command_hasher = @hasher if @hasher
+    names.each do |name|
+      command = self.send "generate_#{name}".to_sym
+      @send_mock.send_command command
+    end
+    receive_mock = EmReceiveCommandsMock.new([@send_mock.string])
+    receive_mock.incoming_command_hasher = C::Hasher.new(@hasher.key) if @hasher
+    o_commands = receive_mock.replay.commands
+    self.assert_equal names.length, o_commands.length
+    names.each_index do |i|
+      self.send "verify_#{names[i]}", o_commands[i]
+    end
+  end
+  
+  CommandStubs.command_names.each do |name|
+    define_method "test_#{name}".to_sym do
+      commandset_test [name]
+    end
+
+    define_method "test_signed_#{name}".to_sym do
+      @hasher = C::Hasher.new
+      commandset_test [name]
+    end
+    
+    define_method "test_signed_#{name}_has_signature".to_sym do
+      sig_send_mock = EmSendCommandsMock.new
+      sig_send_mock.outgoing_command_hasher = C::Hasher.new
+      outputs = [@send_mock, sig_send_mock].map do |mock|
+        mock.send_command self.send("generate_#{name}".to_sym)
+        mock.string
+      end
+      assert outputs.first.length < outputs.last.length,
+             "No signature generated"
+    end
+    
+    define_method "test_signed_#{name}_enforces_signature".to_sym do
+      @send_mock.outgoing_command_hasher = hasher = C::Hasher.new
+      @send_mock.send_command self.send("generate_#{name}".to_sym)      
+      signed_str = @send_mock.string
+      
+      0.upto(signed_str.length - 1) do |i|
+        bad_str = signed_str.dup
+        bad_str[i] ^= 0x01
+        recv_mock = EmReceiveCommandsMock.new([bad_str])
+        recv_mock.incoming_command_hasher = C::Hasher.new hasher.key
+        assert_equal [], recv_mock.replay.commands
+      end      
+    end
+  end
+end

data/test/test_commands.rb

@@ -0,0 +1,49 @@
+require 'rtunnel'
+
+require 'stringio'
+require 'test/unit'
+
+require 'test/command_stubs.rb'
+
+class CommandsTest < Test::Unit::TestCase
+  include CommandStubs
+  
+  def setup
+    super
+    @str = StringIO.new
+  end
+    
+  CommandStubs.command_names.each do |cmd|
+    define_method "test_#{cmd}_encode" do
+      command = self.send "generate_#{cmd}"
+      command.encode @str
+      @str.rewind
+      decoded_command = RTunnel::Command.decode @str
+      self.send "verify_#{cmd}", decoded_command
+      assert_equal "", @str.read, "Command #{cmd} did not consume its entire outpt"
+    end
+    
+    define_method "test_#{cmd}_to_encoded_str" do
+      command = self.send "generate_#{cmd}"
+      command.encode @str
+      @str.rewind
+      assert_equal @str.read, command.to_encoded_str
+    end    
+  end
+  
+  def test_all_encodes
+    sequence = CommandStubs.command_test_sequence
+    sequence.each { |cmd| self.send("generate_#{cmd}").encode @str }
+    @str.rewind
+    sequence.each do |cmd|
+      command = RTunnel::Command.decode(@str)
+      self.send "verify_#{cmd}", command
+    end
+    assert_equal "", @str.read
+  end
+  
+  def test_codes
+    # TODO(not_me): it'd be nice to have more than a smoke test here
+    assert_equal String, RTunnel::Command.printable_codes.class
+  end
+end

data/test/test_connection_id.rb

@@ -0,0 +1,30 @@
+require 'rtunnel'
+
+require 'test/unit'
+
+class ConnectionIdTest < Test::Unit::TestCase
+  class CidWrapper
+    include RTunnel::ConnectionId
+  end
+
+  def setup
+    @server = CidWrapper.new
+  end
+
+  def test_ids_are_unique
+    n_ids = 1024
+    ids = (0...n_ids).map { @server.new_connection_id }
+    assert_equal n_ids, ids.uniq.length
+  end
+    
+  def test_id_sequences_are_not_trivial
+    n_servers = 256
+    n_ids = 16
+    sequences = (0...n_servers).map { CidWrapper.new }.map do |server|
+      (0...n_ids).map { server.new_connection_id }
+    end
+    0.upto(n_ids - 1) do |i|
+      assert_equal n_servers, sequences.map { |seq| seq[i] }.uniq.length
+    end
+  end
+end