coderrr-rtunnel 0.3.9 → 0.4.0

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

data/test/test_crypto.rb

@@ -0,0 +1,127 @@
+require 'rtunnel'
+
+require 'openssl'
+require 'test/unit'
+
+class CryptoTest < Test::Unit::TestCase
+  C = RTunnel::Crypto
+  
+  @@rsa_key_path = 'test_data/ssh_host_rsa_key' 
+  @@dsa_key_path = 'test_data/ssh_host_dsa_key' 
+  @@known_hosts_path = 'test_data/known_hosts' 
+  @@authorized_keys_path = 'test_data/authorized_keys2'
+  
+  def test_read_private_key
+    key = C.read_private_key @@rsa_key_path
+    assert_equal File.read(@@rsa_key_path), key.to_pem
+    assert_equal OpenSSL::PKey::RSA, key.class
+
+    key = C.read_private_key @@dsa_key_path
+    assert_equal File.read(@@dsa_key_path), key.to_pem
+    assert_equal OpenSSL::PKey::DSA, key.class
+  end
+  
+  def test_read_known_hosts
+    keys = C.read_authorized_keys @@known_hosts_path    
+    verify_authorized_keys keys    
+  end
+
+  def test_read_authorized_keys
+    keys = C.read_authorized_keys @@authorized_keys_path
+    verify_authorized_keys keys    
+  end
+  
+  def verify_authorized_keys(keys)
+    assert_equal 4, keys.length
+    assert_equal [OpenSSL::PKey::RSA] * 3 + [OpenSSL::PKey::DSA],
+                 keys.map { |k| k.class }
+    assert_equal C.read_private_key(@@rsa_key_path).public_key.to_pem,
+                 keys[1].to_pem
+    assert_equal C.read_private_key(@@dsa_key_path).public_key.to_pem,
+                 keys[3].to_pem    
+  end
+  
+  def test_key_fingerprint
+    keys = C.read_authorized_keys @@known_hosts_path
+
+    assert_equal 4, keys.map { |k| C.key_fingerprint k }.uniq.length
+    keys.each { |k| assert_equal C.key_fingerprint(k), C.key_fingerprint(k) }
+  end
+  
+  def test_load_public_keys
+    keyset = C.load_public_keys @@known_hosts_path
+    rsa_key = C.read_private_key @@rsa_key_path
+    dsa_key = C.read_private_key @@dsa_key_path
+    
+    assert_equal rsa_key.public_key.to_pem,
+                 keyset[C.key_fingerprint(rsa_key)].to_pem
+    assert_equal dsa_key.public_key.to_pem,
+                 keyset[C.key_fingerprint(dsa_key)].to_pem
+  end
+  
+  def test_key_encryption
+    test_data = 'qwertyuiopasdfghjklzxcvbnm' * 2
+    rsa_key = C.read_private_key @@rsa_key_path
+    dsa_key = C.read_private_key @@rsa_key_path
+    
+    [rsa_key, dsa_key].each do |key|
+      encrypted_data = C.encrypt_with_key key.public_key, test_data
+      decrypted_data = C.decrypt_with_key key, encrypted_data
+      
+      assert_equal test_data, decrypted_data
+      0.upto(test_data.length - 4) do |i|
+        assert !encrypted_data.index(test_data[i, 4]),
+               'Encryption did not wipe the original pattern'
+      end
+    end
+  end
+  
+  def test_encryption_depends_on_key
+    num_keys = 16
+    test_data = 'qwertyuiopasdfghjklzxcvbnm' * 2
+    keys = (0...num_keys).map { OpenSSL::PKey::RSA.generate 1024, 35 }
+    assert_equal num_keys, keys.map { |k| C.encrypt_with_key k, test_data }.
+                                uniq.length
+  end
+  
+  def test_hasher_random_keys_are_random
+    num_keys = 1024
+    assert_equal num_keys, (0...num_keys).map { C::Hasher.random_key }.
+                                          uniq.length
+  end
+  
+  def test_hasher_random_keys_yield_random_results
+    num_keys = 1024
+    test_data = 'qwertyuiopasdfghjklzxcvbnm' * 2
+    assert_equal num_keys, (0...num_keys).map { C::Hasher.new.hash test_data }.
+                                          uniq.length
+  end
+  
+  def test_hasher_hashes_are_finite
+    num_blocks = 64
+    block = 'qwertyuiopasdfghjklzxcvbnm'
+    
+    hasher = C::Hasher.new
+    hash_length = hasher.hash('').length
+    1.upto(num_blocks) { |n| assert_equal hash_length, hasher.hash(block * n).
+                                                              length }
+  end
+  
+  def test_hasher_has_state
+    num_blocks = 1024
+    block = 'qwertyuiopasdfghjklzxcvbnm'
+    hasher = C::Hasher.new
+    
+    assert_equal num_blocks, (0...num_blocks).map { hasher.hash block}.uniq.
+                                               length
+  end
+  
+  def test_hasher_is_reproducible
+    hasher = C::Hasher.new
+    hasher2 = C::Hasher.new hasher.key
+    
+    num_blocks = 128
+    block = 'qwertyuiopasdfghjklzxcvbnm'
+    1.upto(num_blocks) { assert_equal hasher.hash(block), hasher2.hash(block) }
+  end
+end

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