net-ssh 4.0.0.alpha1 → 4.0.0.alpha2

data/test/authentication/methods/test_none.rb

@@ -1,41 +0,0 @@
-require 'common'
-require 'net/ssh/authentication/methods/none'
-require 'authentication/methods/common'
-
-module Authentication; module Methods
-
-  class TestNone < Test::Unit::TestCase
-    include Common
-
-    def test_authenticate_should_raise_if_none_disallowed
-      transport.expect do |t,packet|
-        assert_equal USERAUTH_REQUEST, packet.type
-        assert_equal "jamis", packet.read_string
-        assert_equal "ssh-connection", packet.read_string
-        assert_equal "none", packet.read_string
-        
-        t.return(USERAUTH_FAILURE, :string, "publickey")
-      end
-
-      assert_raises Net::SSH::Authentication::DisallowedMethod do
-        subject.authenticate("ssh-connection", "jamis", "pass")
-      end
-    end
-
-    def test_authenticate_should_return_true
-      transport.expect do |t,packet|
-        assert_equal USERAUTH_REQUEST, packet.type
-        t.return(USERAUTH_SUCCESS)
-      end
-
-      assert subject.authenticate("ssh-connection", "", "")
-    end
-
-    private
-
-      def subject(options={})
-        @subject ||= Net::SSH::Authentication::Methods::None.new(session(options), options)
-      end
-  end
-
-end; end

data/test/authentication/methods/test_password.rb

@@ -1,95 +0,0 @@
-require 'common'
-require 'net/ssh/authentication/methods/password'
-require 'net/ssh/authentication/session'
-require 'authentication/methods/common'
-
-
-module Authentication; module Methods
-
-  class TestPassword < Test::Unit::TestCase
-    include Common
-
-    def test_authenticate_should_raise_if_password_disallowed
-      transport.expect do |t,packet|
-        assert_equal USERAUTH_REQUEST, packet.type
-        assert_equal "jamis", packet.read_string
-        assert_equal "ssh-connection", packet.read_string
-        assert_equal "password", packet.read_string
-        assert_equal false, packet.read_bool
-        assert_equal "the-password", packet.read_string
-
-        t.return(USERAUTH_FAILURE, :string, "publickey")
-      end
-
-      assert_raises Net::SSH::Authentication::DisallowedMethod do
-        subject.authenticate("ssh-connection", "jamis", "the-password")
-      end
-    end
-
-    def test_authenticate_ask_for_password_for_second_time_when_password_is_incorrect
-      transport.expect do |t,packet|
-        assert_equal USERAUTH_REQUEST, packet.type
-        assert_equal "jamis", packet.read_string
-        assert_equal "ssh-connection", packet.read_string
-        assert_equal "password", packet.read_string
-        assert_equal false, packet.read_bool
-        assert_equal "the-password", packet.read_string
-        t.return(USERAUTH_FAILURE, :string, "publickey,password")
-
-        t.expect do |t2, packet2|
-          assert_equal USERAUTH_REQUEST, packet2.type
-          assert_equal "jamis", packet2.read_string
-          assert_equal "ssh-connection", packet2.read_string
-          assert_equal "password", packet2.read_string
-          assert_equal false, packet2.read_bool
-          assert_equal "the-password-2", packet2.read_string
-          t.return(USERAUTH_SUCCESS)
-        end
-      end
-
-      subject.expects(:prompt).with("jamis@'s password:", false).returns("the-password-2")
-      subject.authenticate("ssh-connection", "jamis", "the-password")
-    end
-
-    def test_authenticate_ask_for_password_if_not_given
-      transport.expect do |t,packet|
-        assert_equal USERAUTH_REQUEST, packet.type
-        assert_equal "bill", packet.read_string
-        assert_equal "ssh-connection", packet.read_string
-        assert_equal "password", packet.read_string
-        assert_equal false, packet.read_bool
-        assert_equal "good-password", packet.read_string
-        t.return(USERAUTH_SUCCESS)
-      end
-
-      transport.instance_eval { @host='testhost' }
-      subject.expects(:prompt).with("bill@testhost's password:", false).returns("good-password")
-      subject.authenticate("ssh-connection", "bill", nil)
-    end
-
-    def test_authenticate_when_password_is_acceptible_should_return_true
-      transport.expect do |t,packet|
-        assert_equal USERAUTH_REQUEST, packet.type
-        t.return(USERAUTH_SUCCESS)
-      end
-
-      assert subject.authenticate("ssh-connection", "jamis", "the-password")
-    end
-
-    def test_authenticate_should_return_false_if_password_change_request_is_received
-      transport.expect do |t,packet|
-        assert_equal USERAUTH_REQUEST, packet.type
-        t.return(USERAUTH_PASSWD_CHANGEREQ, :string, "Change your password:", :string, "")
-      end
-
-      assert !subject.authenticate("ssh-connection", "jamis", "the-password")
-    end
-
-    private
-
-      def subject(options={})
-        @subject ||= Net::SSH::Authentication::Methods::Password.new(session(options), options)
-      end
-  end
-
-end; end

data/test/authentication/methods/test_publickey.rb

@@ -1,148 +0,0 @@
-require 'common'
-require 'net/ssh/authentication/methods/publickey'
-require 'authentication/methods/common'
-
-module Authentication; module Methods
-
-  class TestPublickey < Test::Unit::TestCase
-    include Common
-
-    def test_authenticate_should_return_false_when_no_key_manager_has_been_set
-      assert_equal false, subject(:key_manager => nil).authenticate("ssh-connection", "jamis")
-    end
-
-    def test_authenticate_should_return_false_when_key_manager_has_no_keys
-      assert_equal false, subject(:keys => []).authenticate("ssh-connection", "jamis")
-    end
-
-    def test_authenticate_should_return_false_if_no_keys_can_authenticate
-      transport.expect do |t, packet|
-        assert_equal USERAUTH_REQUEST, packet.type
-        assert verify_userauth_request_packet(packet, keys.first, false)
-        t.return(USERAUTH_FAILURE, :string, "hostbased,password")
-
-        t.expect do |t2, packet2|
-          assert_equal USERAUTH_REQUEST, packet2.type
-          assert verify_userauth_request_packet(packet2, keys.last, false)
-          t2.return(USERAUTH_FAILURE, :string, "hostbased,password")
-        end
-      end
-
-      assert_equal false, subject.authenticate("ssh-connection", "jamis")
-    end
-
-    def test_authenticate_should_raise_if_publickey_disallowed
-      key_manager.expects(:sign).with(&signature_parameters(keys.first)).returns("sig-one")
-
-      transport.expect do |t, packet|
-        assert_equal USERAUTH_REQUEST, packet.type
-        assert verify_userauth_request_packet(packet, keys.first, false)
-        t.return(USERAUTH_PK_OK, :string, keys.first.ssh_type, :string, Net::SSH::Buffer.from(:key, keys.first))
-
-        t.expect do |t2,packet2|
-          assert_equal USERAUTH_REQUEST, packet2.type
-          assert verify_userauth_request_packet(packet2, keys.first, true)
-          assert_equal "sig-one", packet2.read_string
-          t2.return(USERAUTH_FAILURE, :string, "hostbased,password")
-        end
-      end
-
-      assert_raises Net::SSH::Authentication::DisallowedMethod do
-        subject.authenticate("ssh-connection", "jamis")
-      end
-    end
-
-    def test_authenticate_should_return_false_if_signature_exchange_fails
-      key_manager.expects(:sign).with(&signature_parameters(keys.first)).returns("sig-one")
-      key_manager.expects(:sign).with(&signature_parameters(keys.last)).returns("sig-two")
-
-      transport.expect do |t, packet|
-        assert_equal USERAUTH_REQUEST, packet.type
-        assert verify_userauth_request_packet(packet, keys.first, false)
-        t.return(USERAUTH_PK_OK, :string, keys.first.ssh_type, :string, Net::SSH::Buffer.from(:key, keys.first))
-
-        t.expect do |t2,packet2|
-          assert_equal USERAUTH_REQUEST, packet2.type
-          assert verify_userauth_request_packet(packet2, keys.first, true)
-          assert_equal "sig-one", packet2.read_string
-          t2.return(USERAUTH_FAILURE, :string, "publickey")
-
-          t2.expect do |t3, packet3|
-            assert_equal USERAUTH_REQUEST, packet3.type
-            assert verify_userauth_request_packet(packet3, keys.last, false)
-            t3.return(USERAUTH_PK_OK, :string, keys.last.ssh_type, :string, Net::SSH::Buffer.from(:key, keys.last))
-
-            t3.expect do |t4,packet4|
-              assert_equal USERAUTH_REQUEST, packet4.type
-              assert verify_userauth_request_packet(packet4, keys.last, true)
-              assert_equal "sig-two", packet4.read_string
-              t4.return(USERAUTH_FAILURE, :string, "publickey")
-            end
-          end
-        end
-      end
-
-      assert !subject.authenticate("ssh-connection", "jamis")
-    end
-
-    def test_authenticate_should_return_true_if_any_key_can_authenticate
-      key_manager.expects(:sign).with(&signature_parameters(keys.first)).returns("sig-one")
-
-      transport.expect do |t, packet|
-        assert_equal USERAUTH_REQUEST, packet.type
-        assert verify_userauth_request_packet(packet, keys.first, false)
-        t.return(USERAUTH_PK_OK, :string, keys.first.ssh_type, :string, Net::SSH::Buffer.from(:key, keys.first))
-
-        t.expect do |t2,packet2|
-          assert_equal USERAUTH_REQUEST, packet2.type
-          assert verify_userauth_request_packet(packet2, keys.first, true)
-          assert_equal "sig-one", packet2.read_string
-          t2.return(USERAUTH_SUCCESS)
-        end
-      end
-
-      assert subject.authenticate("ssh-connection", "jamis")
-    end
-
-    private
-
-      def signature_parameters(key)
-        Proc.new do |given_key, data|
-          next false unless given_key.to_blob == key.to_blob
-          buffer = Net::SSH::Buffer.new(data)
-          buffer.read_string == "abcxyz123"      && # session-id
-          buffer.read_byte   == USERAUTH_REQUEST && # type
-          verify_userauth_request_packet(buffer, key, true)
-        end
-      end
-
-      def verify_userauth_request_packet(packet, key, has_sig)
-        packet.read_string == "jamis"          && # user-name
-        packet.read_string == "ssh-connection" && # next service
-        packet.read_string == "publickey"      && # auth-method
-        packet.read_bool   == has_sig          && # whether a signature is appended
-        packet.read_string == key.ssh_type     && # ssh key type
-        packet.read_buffer.read_key.to_blob == key.to_blob # key
-      end
-
-      @@keys = nil
-      def keys
-        @@keys ||= [OpenSSL::PKey::RSA.new(512), OpenSSL::PKey::DSA.new(512)]
-      end
-
-      def key_manager(options={})
-        @key_manager ||= begin
-          manager = stub("key_manager")
-          manager.stubs(:each_identity).multiple_yields(*(options[:keys] || keys))
-          manager
-        end
-      end
-
-      def subject(options={})
-        options[:key_manager] = key_manager(options) unless options.key?(:key_manager)
-        @subject ||= Net::SSH::Authentication::Methods::Publickey.new(session(options), options)
-      end
-
-  end
-
-end; end

data/test/authentication/test_agent.rb

@@ -1,224 +0,0 @@
-require 'common'
-require 'net/ssh/authentication/agent'
-
-module Authentication
-
-  class TestAgent < Test::Unit::TestCase
-
-    SSH2_AGENT_REQUEST_VERSION    = 1
-    SSH2_AGENT_REQUEST_IDENTITIES = 11
-    SSH2_AGENT_IDENTITIES_ANSWER  = 12
-    SSH2_AGENT_SIGN_REQUEST       = 13
-    SSH2_AGENT_SIGN_RESPONSE      = 14
-    SSH2_AGENT_FAILURE            = 30
-    SSH2_AGENT_VERSION_RESPONSE   = 103
-
-    SSH_COM_AGENT2_FAILURE        = 102
-
-    SSH_AGENT_REQUEST_RSA_IDENTITIES = 1
-    SSH_AGENT_RSA_IDENTITIES_ANSWER  = 2
-    SSH_AGENT_FAILURE                = 5
-
-    def setup
-      @original, ENV['SSH_AUTH_SOCK'] = ENV['SSH_AUTH_SOCK'], "/path/to/ssh.agent.sock"
-    end
-
-    def teardown
-      ENV['SSH_AUTH_SOCK'] = @original
-    end
-
-    def test_connect_should_use_agent_factory_to_determine_connection_type
-      factory.expects(:open).with("/path/to/ssh.agent.sock").returns(socket)
-      agent(false).connect!
-    end
-
-    def test_connect_should_raise_error_if_connection_could_not_be_established
-      factory.expects(:open).raises(SocketError)
-      assert_raises(Net::SSH::Authentication::AgentNotAvailable) { agent(false).connect! }
-    end
-
-    def test_negotiate_should_raise_error_if_ssh2_agent_response_recieved
-      socket.expect do |s, type, buffer|
-        assert_equal SSH2_AGENT_REQUEST_VERSION, type
-        assert_equal Net::SSH::Transport::ServerVersion::PROTO_VERSION, buffer.read_string
-        s.return(SSH2_AGENT_VERSION_RESPONSE)
-      end
-      assert_raises(Net::SSH::Authentication::AgentNotAvailable) { agent.negotiate! }
-    end
-
-    def test_negotiate_should_raise_error_if_response_was_unexpected
-      socket.expect do |s, type, buffer|
-        assert_equal SSH2_AGENT_REQUEST_VERSION, type
-        s.return(255)
-      end
-      assert_raises(Net::SSH::Authentication::AgentNotAvailable) { agent.negotiate! }
-    end
-
-    def test_negotiate_should_be_successful_with_expected_response
-      socket.expect do |s, type, buffer|
-        assert_equal SSH2_AGENT_REQUEST_VERSION, type
-        s.return(SSH_AGENT_RSA_IDENTITIES_ANSWER)
-      end
-      assert_nothing_raised { agent(:connect).negotiate! }
-    end
-
-    def test_identities_should_fail_if_SSH_AGENT_FAILURE_recieved
-      socket.expect do |s, type, buffer|
-        assert_equal SSH2_AGENT_REQUEST_IDENTITIES, type
-        s.return(SSH_AGENT_FAILURE)
-      end
-      assert_raises(Net::SSH::Authentication::AgentError) { agent.identities }
-    end
-
-    def test_identities_should_fail_if_SSH2_AGENT_FAILURE_recieved
-      socket.expect do |s, type, buffer|
-        assert_equal SSH2_AGENT_REQUEST_IDENTITIES, type
-        s.return(SSH2_AGENT_FAILURE)
-      end
-      assert_raises(Net::SSH::Authentication::AgentError) { agent.identities }
-    end
-
-    def test_identities_should_fail_if_SSH_COM_AGENT2_FAILURE_recieved
-      socket.expect do |s, type, buffer|
-        assert_equal SSH2_AGENT_REQUEST_IDENTITIES, type
-        s.return(SSH_COM_AGENT2_FAILURE)
-      end
-      assert_raises(Net::SSH::Authentication::AgentError) { agent.identities }
-    end
-
-    def test_identities_should_fail_if_response_is_not_SSH2_AGENT_IDENTITIES_ANSWER
-      socket.expect do |s, type, buffer|
-        assert_equal SSH2_AGENT_REQUEST_IDENTITIES, type
-        s.return(255)
-      end
-      assert_raises(Net::SSH::Authentication::AgentError) { agent.identities }
-    end
-
-    def test_identities_should_augment_identities_with_comment_field
-      key1 = key
-      key2 = OpenSSL::PKey::DSA.new(512)
-
-      socket.expect do |s, type, buffer|
-        assert_equal SSH2_AGENT_REQUEST_IDENTITIES, type
-        s.return(SSH2_AGENT_IDENTITIES_ANSWER, :long, 2, :string, Net::SSH::Buffer.from(:key, key1), :string, "My favorite key", :string, Net::SSH::Buffer.from(:key, key2), :string, "Okay, but not the best")
-      end
-
-      result = agent.identities
-      assert_equal key1.to_blob, result.first.to_blob
-      assert_equal key2.to_blob, result.last.to_blob
-      assert_equal "My favorite key", result.first.comment
-      assert_equal "Okay, but not the best", result.last.comment
-    end
-
-    def test_identities_should_ignore_unimplemented_ones
-      key1 = key
-      key2 = OpenSSL::PKey::DSA.new(512)
-      key2.to_blob[0..5]='badkey'
-      key3 = OpenSSL::PKey::DSA.new(512)
-
-      socket.expect do |s, type, buffer|
-        assert_equal SSH2_AGENT_REQUEST_IDENTITIES, type
-        s.return(SSH2_AGENT_IDENTITIES_ANSWER, :long, 3, :string, Net::SSH::Buffer.from(:key, key1), :string, "My favorite key", :string, Net::SSH::Buffer.from(:key, key2), :string, "bad", :string, Net::SSH::Buffer.from(:key, key3), :string, "Okay, but not the best")
-      end
-
-      result = agent.identities
-      assert_equal 2,result.size
-      assert_equal key1.to_blob, result.first.to_blob
-      assert_equal key3.to_blob, result.last.to_blob
-      assert_equal "My favorite key", result.first.comment
-      assert_equal "Okay, but not the best", result.last.comment
-    end
-
-    def test_close_should_close_socket
-      socket.expects(:close)
-      agent.close
-    end
-
-    def test_sign_should_fail_if_response_is_SSH_AGENT_FAILURE
-      socket.expect { |s,| s.return(SSH_AGENT_FAILURE) }
-      assert_raises(Net::SSH::Authentication::AgentError) { agent.sign(key, "hello world") }
-    end
-
-    def test_sign_should_fail_if_response_is_SSH2_AGENT_FAILURE
-      socket.expect { |s,| s.return(SSH2_AGENT_FAILURE) }
-      assert_raises(Net::SSH::Authentication::AgentError) { agent.sign(key, "hello world") }
-    end
-
-    def test_sign_should_fail_if_response_is_SSH_COM_AGENT2_FAILURE
-      socket.expect { |s,| s.return(SSH_COM_AGENT2_FAILURE) }
-      assert_raises(Net::SSH::Authentication::AgentError) { agent.sign(key, "hello world") }
-    end
-
-    def test_sign_should_fail_if_response_is_not_SSH2_AGENT_SIGN_RESPONSE
-      socket.expect { |s,| s.return(255) }
-      assert_raises(Net::SSH::Authentication::AgentError) { agent.sign(key, "hello world") }
-    end
-
-    def test_sign_should_return_signed_data_from_agent
-      socket.expect do |s,type,buffer|
-        assert_equal SSH2_AGENT_SIGN_REQUEST, type
-        assert_equal key.to_blob, Net::SSH::Buffer.new(buffer.read_string).read_key.to_blob
-        assert_equal "hello world", buffer.read_string
-        assert_equal 0, buffer.read_long
-
-        s.return(SSH2_AGENT_SIGN_RESPONSE, :string, "abcxyz123")
-      end
-
-      assert_equal "abcxyz123", agent.sign(key, "hello world")
-    end
-
-    private
-
-      class MockSocket
-        def initialize
-          @expectation = nil
-          @buffer = Net::SSH::Buffer.new
-        end
-
-        def expect(&block)
-          @expectation = block
-        end
-
-        def return(type, *args)
-          data = Net::SSH::Buffer.from(*args)
-          @buffer.append([data.length+1, type, data.to_s].pack("NCA*"))
-        end
-
-        def send(data, flags)
-          raise "got #{data.inspect} but no packet was expected" unless @expectation
-          buffer = Net::SSH::Buffer.new(data)
-          buffer.read_long # skip the length
-          type = buffer.read_byte
-          @expectation.call(self, type, buffer)
-          @expectation = nil
-        end
-
-        def read(length)
-          @buffer.read(length)
-        end
-      end
-
-      def key
-        @key ||= OpenSSL::PKey::RSA.new(512)
-      end
-
-      def socket
-        @socket ||= MockSocket.new
-      end
-
-      def factory
-        @factory ||= stub("socket factory", :open => socket)
-      end
-
-      def agent(auto=:connect)
-        @agent ||= begin
-          agent = Net::SSH::Authentication::Agent.new
-          agent.stubs(:agent_socket_factory).returns(factory)
-          agent.connect! if auto == :connect
-          agent
-        end
-      end
-
-  end
-
-end