costan-rtunnel 0.4.0

data/test/test_frame_protocol.rb

@@ -0,0 +1,109 @@
+require 'rtunnel'
+
+require 'test/unit'
+
+require 'test/protocol_mocks.rb'
+
+# Send mock for frames.
+class EmSendFramesMock < EmSendMock
+  include RTunnel::FrameProtocol
+end
+
+# Receive mock for frames.
+class EmReceiveFramesMock < EmReceiveMock
+  include RTunnel::FrameProtocol
+  object_name :frame
+end
+
+class FrameProtocolTest < Test::Unit::TestCase
+  def setup
+    super
+    @send_mock = EmSendFramesMock.new
+  end
+  
+  def teardown
+    super
+  end
+
+  def continuous_data_test(frames)
+    truncated_data_test frames, []
+  end
+  
+  def truncated_data_test(frames, sub_lengths)
+    frames.each { |frame| @send_mock.send_frame frame }
+    in_string = @send_mock.string
+    in_strings, i = [], 0
+    sub_lengths.each do |sublen|
+      in_strings << in_string[i, sublen]
+      i += sublen
+    end
+    in_strings << in_string[i..-1] if i < in_string.length
+    out_frames = EmReceiveFramesMock.new(@send_mock.string).replay.frames
+    assert_equal frames, out_frames
+  end
+
+  def test_empty_frame
+    continuous_data_test ['']    
+  end
+  
+  def test_byte_frame
+    continuous_data_test ['F']
+  end
+
+  def test_string_frame
+    continuous_data_test [(32...128).to_a.pack('C*')]
+  end
+  
+  def test_multiple_frames
+    continuous_data_test [(32...128).to_a.pack('C*'), '', 'F', '', '1234567890']
+  end
+  
+  def test_truncated_border
+    truncated_data_test ['A', 'A'], [1, 0, 2, 0]
+  end
+  
+  def test_truncated_border_and_joined_data_size
+    truncated_data_test ['A', 'A'], [1, 1, 1, 1]
+  end
+  
+  def test_truncated_size
+    long_frame = (32...128).to_a.pack('C*') * 5
+    truncated_data_test [long_frame], [1]
+  end
+
+  def test_truncated_size_and_data
+    long_frame = (32...128).to_a.pack('C*') * 5
+    truncated_data_test [long_frame], [1, 16]
+  end
+  
+  def test_badass
+    # TODO(not_me): this test takes 4 seconds; replace with more targeted tests
+    
+    # build the badass string
+    s2_frame = 'qwertyuiopasdfgh' * 8 * 128 # 16384 characters, size is 3 bytes
+    @send_mock.send_frame s2_frame
+    s2_string = @send_mock.string
+    s2_count = 3
+    send_string = s2_string * s2_count
+    ex_frames = [s2_frame] * s2_count
+    
+    # build cut points in a string
+    s2_points = [0, 1, 2, 3, 4, 5, 127, 128, 8190, 16381, 16382, 16383]
+    cut_points = []
+    0.upto(s2_count - 1) do |i|
+      cut_points += s2_points.map { |p| p + i * s2_string.length }
+    end
+    
+    # try all combinations of cutting up the string in 4 pieces
+    0.upto(cut_points.length - 1) do |i|
+      (i + 1).upto(cut_points.length - 1) do |j|
+        (j + 1).upto(cut_points.length - 1) do |k|
+          packets = [0...cut_points[i], cut_points[i]...cut_points[j],
+                     cut_points[j]...cut_points[k], cut_points[k]..-1].
+                    map { |r| send_string[r] }
+          assert_equal ex_frames, EmReceiveFramesMock.new(packets).replay.frames
+        end
+      end
+    end
+  end
+end

data/test/test_io_extensions.rb

@@ -0,0 +1,70 @@
+require 'rtunnel'
+
+require 'stringio'
+require 'test/unit'
+
+class IOExtensionsTest < Test::Unit::TestCase  
+  def setup
+    @test_sizes = [0, 1, 10, 127, 128, (1 << 20), (1 << 45) / 3, (1 << 62) / 5]
+    @test_strings = ['', 'a',
+                     (32..127).to_a.map { |c| c.chr}.join,
+                     (32..127).to_a.map { |c| c.chr}.join * 511]
+    @str = StringIO.new
+  end
+  
+  def test_varsizes_independent
+    @test_sizes.each do |size|
+      @str = StringIO.new
+      @str.write_varsize size
+      @str.rewind
+      assert_equal size, @str.read_varsize
+    end
+  end
+ 
+  def test_varsizes_appended
+    @test_sizes.each { |size| @str.write_varsize size }
+    @str.rewind
+    @test_sizes.each do |size|
+      assert_equal size, @str.read_varsize
+    end
+  end
+  
+  def test_varsize_error
+    @str.write_varsize((1 << 62) / 3)
+    vs = @str.string
+    0.upto(vs.length - 1) do |truncated_len|
+      @str = StringIO.new
+      @str.write vs[0, truncated_len]
+      @str.rewind
+      assert_raise(RTunnel::TruncatedDataError) { @str.read_varsize }
+    end
+  end
+  
+  def test_varstring_independent
+    @test_strings.each do |str|
+      @str = StringIO.new
+      @str.write_varstring str
+      @str.rewind
+      assert_equal str, @str.read_varstring
+    end    
+  end
+  
+  def test_varstring_appended
+    @test_strings.each { |str| @str.write_varstring str }
+    @str.rewind
+    @test_strings.each do |str|
+       assert_equal str, @str.read_varstring
+    end    
+  end
+
+  def test_varstring_error
+    @str.write_varstring 'This will be truncated'
+    vs = @str.string
+    0.upto(vs.length - 1) do |truncated_len|
+      @str = StringIO.new
+      @str.write vs[0, truncated_len]
+      @str.rewind
+      assert_raise(RTunnel::TruncatedDataError) { @str.read_varstring }
+    end
+  end
+end

data/test/test_server.rb

@@ -0,0 +1,70 @@
+require 'rtunnel'
+
+require 'resolv'
+require 'test/unit'
+
+
+class ServerTest < Test::Unit::TestCase
+  def setup    
+    super
+    @server = RTunnel::Server.new(:control_address => 'localhost')
+    @localhost_addr = Resolv.getaddress 'localhost'
+  end
+  
+  def test_options
+    server = RTunnel::Server
+    assert_equal "18.241.3.100:#{RTunnel::DEFAULT_CONTROL_PORT}",
+                 server.extract_control_address('18.241.3.100')                 
+    assert_equal "18.241.3.100:9199",
+                 server.extract_control_address('18.241.3.100:9199')
+    assert_equal "#{@localhost_addr}:#{RTunnel::DEFAULT_CONTROL_PORT}",
+                 server.extract_control_address('localhost')                 
+    assert_equal "#{@localhost_addr}:9199",
+                 server.extract_control_address('localhost:9199')
+    assert_equal "0.0.0.0:9199",
+                 server.extract_control_address('9199')
+
+    assert_equal RTunnel::KEEP_ALIVE_INTERVAL,
+                 server.extract_keep_alive_interval(nil)
+    assert_equal 29, server.extract_keep_alive_interval(29)
+    
+    assert_equal 0, server.extract_lowest_listen_port(nil)
+    assert_equal 29, server.extract_lowest_listen_port(29)
+    assert_equal 65535, server.extract_highest_listen_port(nil)
+    assert_equal 29, server.extract_highest_listen_port(29)
+    
+    assert_equal nil, server.extract_authorized_keys(nil)
+    keyset = server.extract_authorized_keys 'test_data/known_hosts'
+    assert_equal RTunnel::Crypto::KeySet, keyset.class
+    assert keyset.length != 0, 'No key read from the known_hosts file'
+  end
+  
+  def test_validate_remote_listen
+    # remove Connection's new override, don't want event_machine here
+    EventMachine::Connection.class_eval do
+      class << self
+        alias_method :backup_new, :new
+        remove_method :new
+      end
+    end
+    
+    server = RTunnel::Server.new(:control_address => 'localhost',
+                                 :lowest_listen_port => 91,
+                                 :highest_listen_port => 105)
+    connection = RTunnel::Server::ControlConnection.new server
+        
+    assert !connection.validate_remote_listen('localhost', 80)
+    assert connection.validate_remote_listen('localhost', 91)
+    assert connection.validate_remote_listen('localhost', 105)
+    assert !connection.validate_remote_listen('localhost', 90)
+    assert !connection.validate_remote_listen('localhost', 106)
+
+    # re-instate Connection's new override
+    EventMachine::Connection.class_eval do
+      class << self
+        alias_method :new, :backup_new
+        remove_method :backup_new
+      end
+    end
+  end
+end

data/test/test_socket_factory.rb

@@ -0,0 +1,42 @@
+require 'rtunnel'
+
+require 'test/unit'
+
+class SocketFactoryTest < Test::Unit::TestCase
+  SF = RTunnel::SocketFactory
+  
+  def setup
+    
+  end
+
+  def teardown
+    
+  end
+  
+  def test_host_from_address
+    assert_equal nil, SF.host_from_address(nil)
+    assert_equal '127.0.0.1', SF.host_from_address('127.0.0.1')
+    assert_equal '127.0.0.1', SF.host_from_address('127.0.0.1:1234')
+    assert_equal 'fe80::1%lo0', SF.host_from_address('fe80::1%lo0')
+    assert_equal 'fe80::1%lo0', SF.host_from_address('fe80::1%lo0:19020')
+  end
+  
+  def test_port_from_address
+    assert_equal nil, SF.port_from_address(nil)
+    assert_equal nil, SF.port_from_address('127.0.0.1')
+    assert_equal 1234, SF.port_from_address('127.0.0.1:1234')
+    assert_equal nil, SF.port_from_address('fe80::1%lo0')
+    assert_equal 19020, SF.port_from_address('fe80::1%lo0:19020')
+  end
+  
+  def test_inbound
+    assert SF.inbound?(:in_port => 1)
+    assert SF.inbound?(:in_host => '1')
+    assert SF.inbound?(:in_addr => '1')
+    assert SF.inbound?(:inbound => true)
+    assert !SF.inbound?(:out_port => 1)
+    assert !SF.inbound?(:out_host => '1')
+    assert !SF.inbound?(:out_addr => '1')
+  end
+end
+

data/test/test_tunnel.rb

@@ -0,0 +1,186 @@
+require 'rtunnel'
+
+require 'test/unit'
+
+require 'rubygems'
+require 'eventmachine'
+
+require 'test/scenario_connection.rb'
+
+# Integration tests ensuring that we can start a tunnel.
+class TunnelTest < Test::Unit::TestCase
+  def setup
+    super
+    
+    @connection_time = 0.001
+    @secure_connection_time = 0.5
+    @log_level = 'debug'
+    @local_host = '127.0.0.1'
+    @listen_port = 21335
+    @tunnel_port = 21336
+    @control_port = 21337
+    @key_file = 'test_data/ssh_host_rsa_key'
+    @hosts_file = 'test_data/known_hosts'
+    
+    @tunnel_server = new_server
+    @tunnel_client = new_client
+  end
+  
+  def new_server(extra_options = {})
+    RTunnel::Server.new({
+        :control_address => "#{@local_host}:#{@control_port}",
+        :log_level => @log_level
+        }.merge(extra_options))
+  end
+  
+  def new_client(extra_options = {})
+    RTunnel::Client.new({
+            :control_address => "#{@local_host}:#{@control_port}",
+            :remote_listen_address => "#{@local_host}:#{@listen_port}",
+            :tunnel_to_address => "#{@local_host}:#{@tunnel_port}",
+            :log_level => @log_level
+            }.merge(extra_options))
+  end
+  
+  def tunnel_test(connection_time = nil)
+    @stop_proc = proc do
+      @tunnel_client.stop
+      @tunnel_server.stop
+      @stop_proc = nil
+    end
+
+    EventMachine::run do
+      @tunnel_server.start
+      @tunnel_client.start
+
+      if connection_time
+        EventMachine.add_timer(connection_time) { yield }
+      else
+        EventMachine.next_tick { yield }
+      end
+    end
+  end
+  
+  def test_client_driven_tunnel
+    tunnel_test do
+      @tunnel_server.on_remote_listen do
+        EventMachine::start_server @local_host, @tunnel_port,
+            ScenarioConnection, self, [[:recv, 'Hello'], [:send, 'World'],
+                                       [:unbind], [:stop, @stop_proc]]
+
+        EventMachine::connect @local_host, @listen_port,
+            ScenarioConnection, self, [[:send, 'Hello'], [:recv, 'World'],
+                                       [:close]]
+      end
+    end
+  end
+  
+  def test_server_driven_tunnel
+    tunnel_test do
+      @tunnel_server.on_remote_listen do
+        EventMachine::start_server @local_host, @tunnel_port,
+            ScenarioConnection, self, [[:send, 'Hello'], [:recv, 'World'],
+                                       [:close]]
+
+        EventMachine::connect @local_host, @listen_port,
+            ScenarioConnection, self, [[:recv, 'Hello'], [:send, 'World'],
+                                       [:unbind], [:stop]]
+      end  
+    end    
+  end
+  
+  def test_two_tunnels
+    start_second = lambda do
+      @tunnel_client.stop
+      @tunnel_client.start
+      @tunnel_server.on_remote_listen do
+        EventMachine::connect @local_host, @listen_port,
+            ScenarioConnection, self, [[:send, 'Hello'], [:recv, 'World'],
+                                       [:unbind], [:stop, @stop_proc]]
+      end
+    end
+    
+    tunnel_test do
+      @tunnel_server.on_remote_listen do
+        EventMachine::start_server @local_host, @tunnel_port,
+            ScenarioConnection, self, [[:recv, 'Hello'], [:send, 'World'],
+                  [:close], [:recv, 'Hello'], [:send, 'World'], [:close]]
+
+        EventMachine::connect @local_host, @listen_port,
+            ScenarioConnection, self, [[:send, 'Hello'], [:recv, 'World'],
+                                       [:proc, start_second], [:unbind]]
+      end
+    end
+  end
+  
+  def test_secure_tunnel
+    @tunnel_server = new_server :authorized_keys => @hosts_file
+    @tunnel_client = new_client :private_key => @key_file
+    tunnel_test do
+      @tunnel_server.on_remote_listen do
+        EventMachine::start_server @local_host, @tunnel_port,
+            ScenarioConnection, self, [[:recv, 'Hello'], [:send, 'World'],
+                                       [:unbind], [:stop, @stop_proc]]
+
+        EventMachine::connect @local_host, @listen_port,
+            ScenarioConnection, self, [[:send, 'Hello'], [:recv, 'World'],
+                                       [:close]]
+      end
+    end
+  end
+
+  def test_secure_async_tunnel
+    @tunnel_server = new_server :authorized_keys => @hosts_file
+    @tunnel_client = new_client :private_key => @key_file
+    tunnel_test do
+      @tunnel_server.on_remote_listen do
+        EventMachine::start_server @local_host, @tunnel_port,
+            ScenarioConnection, self, [[:send, 'World'], [:recv, 'Hello'],
+                                       [:unbind], [:stop, @stop_proc]]
+
+        EventMachine::connect @local_host, @listen_port,
+            ScenarioConnection, self, [[:send, 'Hello'], [:recv, 'World'],
+                                       [:close]]
+      end
+    end
+  end
+  
+  def test_bad_listen_address
+    @tunnel_server = new_server
+    @tunnel_client = new_client :remote_listen_address =>
+                                "18.70.0.160:#{@listen_port}"
+                                
+    tunnel_test do
+      EventMachine::start_server @local_host, @tunnel_port,
+          ScenarioConnection, self, []
+                                     
+      EventMachine::connect @local_host, @listen_port,
+          ScenarioConnection, self, [[:unbind], [:stop, @stop_proc]]
+    end
+  end
+
+  # TODO: fix this
+  def test_secure_server_rejects_unsecure_client
+    @tunnel_server = new_server :authorized_keys => @hosts_file
+    tunnel_test(@secure_connection_time) do
+      EventMachine::start_server @local_host, @tunnel_port,
+          ScenarioConnection, self, []
+                                     
+      EventMachine::connect @local_host, @listen_port,
+          ScenarioConnection, self, [[:unbind], [:stop, @stop_proc]]
+    end
+  end
+
+  # hrmf... this is testing security and its not 100% reliable... but I can't think of a better way
+  def test_secure_server_rejects_unauthorized_key
+    @tunnel_server = new_server :authorized_keys => @hosts_file
+    @tunnel_client = new_client :private_key => 'test_data/random_rsa_key'
+    tunnel_test(@secure_connection_time) do
+      EventMachine::start_server @local_host, @tunnel_port,
+          ScenarioConnection, self, []
+
+      EventMachine::connect @local_host, @listen_port,
+          ScenarioConnection, self, [[:unbind], [:stop, @stop_proc]]
+    end
+  end
+end