coderrr-rtunnel 0.3.9 → 0.4.0

data/lib/rtunnel/socket_factory.rb

@@ -0,0 +1,119 @@
+require 'socket'
+
+module RTunnel::SocketFactory
+  def self.split_address(address)
+    port_index = address.index /[^:]\:[^:]/
+    if port_index
+      [address[0, port_index + 1], address[port_index + 2, address.length]]
+    else
+      [address, nil]
+    end
+  end
+  
+  def self.host_from_address(address)
+    address and split_address(address)[0]
+  end
+  
+  def self.port_from_address(address)
+    address and (port_string = split_address(address)[1]) and port_string.to_i
+  end
+  
+  def self.inbound?(options)
+    options[:inbound] or [:in_port, :in_host, :in_addr].any? { |k| options[k] }
+  end
+  
+  def self.bind_host(options)
+    options[:in_host] or host_from_address(options[:in_addr]) or '0.0.0.0'
+  end
+  
+  def self.bind_port(options)
+    options[:in_port] or port_from_address(options[:in_addr]) or 0
+  end
+  
+  def self.bind_socket_address(options)
+    Socket::pack_sockaddr_in bind_port(options), bind_host(options)
+  end
+  
+  def self.connect_host(options)
+    options[:out_host] or host_from_address(options[:out_addr])
+  end
+  
+  def self.connect_port(options)
+    options[:out_port] or port_from_address(options[:out_addr])
+  end
+  
+  def self.connect_socket_address(options)
+    Socket::pack_sockaddr_in connect_port(options), connect_host(options)
+  end
+  
+  def self.tcp?(options)
+    options[:tcp] or !options[:udp]
+  end
+  
+  def self.new_tcp_socket
+    Socket.new Socket::AF_INET, Socket::SOCK_STREAM, Socket::PF_UNSPEC
+  end
+  
+  def self.new_udp_socket
+    Socket.new Socket::AF_INET, Socket::SOCK_DGRAM, Socket::PF_UNSPEC
+  end
+  
+  def self.new_socket(options)
+    tcp?(options) ? new_tcp_socket : new_udp_socket
+  end
+  
+  def self.bind(socket, options)
+    socket.bind bind_socket_address(options)
+  end
+  
+  def self.connect(socket, options)
+    socket.connect connect_socket_address(options)
+  end
+  
+  def self.set_options(socket, options)
+    if options[:no_delay]
+      socket.setsockopt Socket::IPPROTO_TCP, Socket::TCP_NODELAY, true
+      socket.sync = true
+    end
+    
+    if options[:reuse_addr]
+      socket.setsockopt Socket::SOL_SOCKET, Socket::SO_REUSEADDR, true
+    end
+    
+    unless options[:reverse_lookup]
+      if socket.respond_to? :do_not_reverse_lookup
+        socket.do_not_reverse_lookup = true
+      else
+        # work around until the patch below actually gets committed:
+        # http://blade.nagaokaut.ac.jp/cgi-bin/scat.rb/ruby/ruby-core/2346
+        BasicSocket.do_not_reverse_lookup = true
+      end
+    end
+  end
+
+  # new sockets coming out of socket.accept will have the given options set
+  def self.set_options_on_accept_sockets(socket, options)
+    socket.instance_variable_set :@rtunnel_factory_options, options
+    def socket.accept(*args)
+      sock, addr = super
+      RTunnel::SocketFactory.set_options sock, @rtunnel_factory_options
+      return sock, addr
+    end
+  end
+  
+  def self.socket(options = {})    
+    s = new_socket options
+    set_options s, options
+    if inbound? options
+      bind s, options    
+      set_options_on_accept_sockets s, options
+    else
+      connect s, options
+    end
+    s
+  end
+  
+  def socket(options = {})
+    RTunnel::SocketFactory.socket(options)
+  end  
+end

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