kjvarga-net-ssh 2.0.12

data/test/test_key_factory.rb

@@ -0,0 +1,67 @@
+require 'common'
+require 'net/ssh/key_factory'
+
+class TestKeyFactory < Test::Unit::TestCase
+  def test_load_unencrypted_private_RSA_key_should_return_key
+    File.expects(:read).with("/key-file").returns(rsa_key.export)
+    assert_equal rsa_key.to_der, Net::SSH::KeyFactory.load_private_key("/key-file").to_der
+  end
+
+  def test_load_unencrypted_private_DSA_key_should_return_key
+    File.expects(:read).with("/key-file").returns(dsa_key.export)
+    assert_equal dsa_key.to_der, Net::SSH::KeyFactory.load_private_key("/key-file").to_der
+  end
+
+  def test_load_encrypted_private_RSA_key_should_prompt_for_password_and_return_key
+    File.expects(:read).with("/key-file").returns(encrypted(rsa_key, "password"))
+    Net::SSH::KeyFactory.expects(:prompt).with("Enter passphrase for /key-file:", false).returns("password")
+    assert_equal rsa_key.to_der, Net::SSH::KeyFactory.load_private_key("/key-file").to_der
+  end
+
+  def test_load_encrypted_private_RSA_key_with_password_should_not_prompt_and_return_key
+    File.expects(:read).with("/key-file").returns(encrypted(rsa_key, "password"))
+    assert_equal rsa_key.to_der, Net::SSH::KeyFactory.load_private_key("/key-file", "password").to_der
+  end
+
+  def test_load_encrypted_private_DSA_key_should_prompt_for_password_and_return_key
+    File.expects(:read).with("/key-file").returns(encrypted(dsa_key, "password"))
+    Net::SSH::KeyFactory.expects(:prompt).with("Enter passphrase for /key-file:", false).returns("password")
+    assert_equal dsa_key.to_der, Net::SSH::KeyFactory.load_private_key("/key-file").to_der
+  end
+
+  def test_load_encrypted_private_DSA_key_with_password_should_not_prompt_and_return_key
+    File.expects(:read).with("/key-file").returns(encrypted(dsa_key, "password"))
+    assert_equal dsa_key.to_der, Net::SSH::KeyFactory.load_private_key("/key-file", "password").to_der
+  end
+
+  def test_load_encrypted_private_key_should_give_three_tries_for_the_password_and_then_raise_exception
+    File.expects(:read).with("/key-file").returns(encrypted(rsa_key, "password"))
+    Net::SSH::KeyFactory.expects(:prompt).times(3).with("Enter passphrase for /key-file:", false).returns("passwod","passphrase","passwd")
+    assert_raises(OpenSSL::PKey::RSAError) { Net::SSH::KeyFactory.load_private_key("/key-file") }
+  end
+
+  def test_load_public_rsa_key_should_return_key
+    File.expects(:read).with("/key-file").returns(public(rsa_key))
+    assert_equal rsa_key.to_blob, Net::SSH::KeyFactory.load_public_key("/key-file").to_blob
+  end
+
+  private
+
+    def rsa_key
+      @rsa_key ||= OpenSSL::PKey::RSA.new("0@\002\001\000\002\t\000\300\030\317\2132\340 \267\002\003\001\000\001\002\t\000\236~\232\025\350Y=\341\002\005\000\352D\217\a\002\005\000\321\352\304\321\002\005\000\242\350\206%\002\005\000\270\021\217\361\002\004~\253\214j")
+    end
+
+    def dsa_key
+      @dsa_key ||= OpenSSL::PKey::DSA.new("0\201\367\002\001\000\002A\000\203\316/\037u\272&J\265\003l3\315d\324h\372{\t8\252#\331_\026\006\035\270\266\255\343\353Z\302\276\335\336\306\220\375\202L\244\244J\206>\346\b\315\211\302L\246x\247u\a\376\366\345\302\016#\002\025\000\244\274\302\221Og\275/\302+\356\346\360\024\373wI\2573\361\002@\027\215\270r*\f\213\350C\245\021:\350 \006\\\376\345\022`\210b\262\3643\023XLKS\320\370\002\276\347A\nU\204\276\324\256`=\026\240\330\306J\316V\213\024\e\030\215\355\006\037q\337\356ln\002@\017\257\034\f\260\333'S\271#\237\230E\321\312\027\021\226\331\251Vj\220\305\316\036\v\266+\000\230\270\177B\003?t\a\305]e\344\261\334\023\253\323\251\223M\2175)a(\004\"lI8\312\303\307\a\002\024_\aznW\345\343\203V\326\246ua\203\376\201o\350\302\002")
+    end
+
+    def encrypted(key, password)
+      key.export(OpenSSL::Cipher::Cipher.new("des-ede3-cbc"), password)
+    end
+
+    def public(key)
+      result = "#{key.ssh_type} "
+      result << [Net::SSH::Buffer.from(:key, key).to_s].pack("m*").strip.tr("\n\r\t ", "")
+      result << " joe@host.test"
+    end
+end

data/test/transport/hmac/test_md5.rb

@@ -0,0 +1,39 @@
+require 'common'
+require 'net/ssh/transport/hmac/md5'
+
+module Transport; module HMAC
+
+  class TestMD5 < Test::Unit::TestCase
+    def test_expected_digest_class
+      assert_equal OpenSSL::Digest::MD5, subject.digest_class
+      assert_equal OpenSSL::Digest::MD5, subject.new.digest_class
+    end
+
+    def test_expected_key_length
+      assert_equal 16, subject.key_length
+      assert_equal 16, subject.new.key_length
+    end
+
+    def test_expected_mac_length
+      assert_equal 16, subject.mac_length
+      assert_equal 16, subject.new.mac_length
+    end
+
+    def test_expected_digest
+      hmac = subject.new("1234567890123456")
+      assert_equal "\275\345\006\307y~Oi\035<.\341\031\250<\257", hmac.digest("hello world")
+    end
+
+    def test_key_should_be_truncated_to_required_length
+      hmac = subject.new("12345678901234567890")
+      assert_equal "1234567890123456", hmac.key
+    end
+
+    private
+
+      def subject
+        Net::SSH::Transport::HMAC::MD5
+      end
+  end
+
+end; end

data/test/transport/hmac/test_md5_96.rb

@@ -0,0 +1,25 @@
+require 'common'
+require 'transport/hmac/test_md5'
+require 'net/ssh/transport/hmac/md5_96'
+
+module Transport; module HMAC
+
+  class TestMD5_96 < TestMD5
+    def test_expected_mac_length
+      assert_equal 12, subject.mac_length
+      assert_equal 12, subject.new.mac_length
+    end
+
+    def test_expected_digest
+      hmac = subject.new("1234567890123456")
+      assert_equal "\275\345\006\307y~Oi\035<.\341", hmac.digest("hello world")
+    end
+
+    private
+
+      def subject
+        Net::SSH::Transport::HMAC::MD5_96
+      end
+  end
+
+end; end

data/test/transport/hmac/test_none.rb

@@ -0,0 +1,34 @@
+require 'common'
+require 'net/ssh/transport/hmac/none'
+
+module Transport; module HMAC
+
+  class TestNone < Test::Unit::TestCase
+    def test_expected_digest_class
+      assert_equal nil, subject.digest_class
+      assert_equal nil, subject.new.digest_class
+    end
+
+    def test_expected_key_length
+      assert_equal 0, subject.key_length
+      assert_equal 0, subject.new.key_length
+    end
+
+    def test_expected_mac_length
+      assert_equal 0, subject.mac_length
+      assert_equal 0, subject.new.mac_length
+    end
+
+    def test_expected_digest
+      hmac = subject.new("1234567890123456")
+      assert_equal "", hmac.digest("hello world")
+    end
+
+    private
+
+      def subject
+        Net::SSH::Transport::HMAC::None
+      end
+  end
+
+end; end

data/test/transport/hmac/test_sha1.rb

@@ -0,0 +1,34 @@
+require 'common'
+require 'net/ssh/transport/hmac/sha1'
+
+module Transport; module HMAC
+
+  class TestSHA1 < Test::Unit::TestCase
+    def test_expected_digest_class
+      assert_equal OpenSSL::Digest::SHA1, subject.digest_class
+      assert_equal OpenSSL::Digest::SHA1, subject.new.digest_class
+    end
+
+    def test_expected_key_length
+      assert_equal 20, subject.key_length
+      assert_equal 20, subject.new.key_length
+    end
+
+    def test_expected_mac_length
+      assert_equal 20, subject.mac_length
+      assert_equal 20, subject.new.mac_length
+    end
+
+    def test_expected_digest
+      hmac = subject.new("1234567890123456")
+      assert_equal "\000\004W\202\204+&\335\311\251P\266\250\214\276\206;\022U\365", hmac.digest("hello world")
+    end
+
+    private
+
+      def subject
+        Net::SSH::Transport::HMAC::SHA1
+      end
+  end
+
+end; end

data/test/transport/hmac/test_sha1_96.rb

@@ -0,0 +1,25 @@
+require 'common'
+require 'transport/hmac/test_sha1'
+require 'net/ssh/transport/hmac/sha1_96'
+
+module Transport; module HMAC
+
+  class TestSHA1_96 < TestSHA1
+    def test_expected_mac_length
+      assert_equal 12, subject.mac_length
+      assert_equal 12, subject.new.mac_length
+    end
+
+    def test_expected_digest
+      hmac = subject.new("1234567890123456")
+      assert_equal "\000\004W\202\204+&\335\311\251P\266", hmac.digest("hello world")
+    end
+
+    private
+
+      def subject
+        Net::SSH::Transport::HMAC::SHA1_96
+      end
+  end
+
+end; end

data/test/transport/kex/test_diffie_hellman_group1_sha1.rb

@@ -0,0 +1,146 @@
+require 'common'
+require 'net/ssh/transport/kex/diffie_hellman_group1_sha1'
+require 'ostruct'
+
+module Transport; module Kex
+
+  class TestDiffieHellmanGroup1SHA1 < Test::Unit::TestCase
+    include Net::SSH::Transport::Constants
+
+    def setup
+      @dh_options = @dh = @algorithms = @connection = @server_key = 
+        @packet_data = @shared_secret = nil
+    end
+
+    def test_exchange_keys_should_return_expected_results_when_successful
+      result = exchange!
+      assert_equal session_id, result[:session_id]
+      assert_equal server_key.to_blob, result[:server_key].to_blob
+      assert_equal shared_secret, result[:shared_secret]
+      assert_equal OpenSSL::Digest::SHA1, result[:hashing_algorithm]
+    end
+
+    def test_exchange_keys_with_unverifiable_host_should_raise_exception
+      connection.verifier { false }
+      assert_raises(Net::SSH::Exception) { exchange! }
+    end
+
+    def test_exchange_keys_with_signature_key_type_mismatch_should_raise_exception
+      assert_raises(Net::SSH::Exception) { exchange! :key_type => "ssh-dss" }
+    end
+
+    def test_exchange_keys_with_host_key_type_mismatch_should_raise_exception
+      algorithms :host_key => "ssh-dss"
+      assert_raises(Net::SSH::Exception) { exchange! :key_type => "ssh-dss" }
+    end
+
+    def test_exchange_keys_when_server_signature_could_not_be_verified_should_raise_exception
+      @signature = "1234567890"
+      assert_raises(Net::SSH::Exception) { exchange! }
+    end
+
+    def test_exchange_keys_should_pass_expected_parameters_to_host_key_verifier
+      verified = false
+      connection.verifier do |data|
+        verified = true
+        assert_equal server_key.to_blob, data[:key].to_blob
+
+        blob = b(:key, data[:key]).to_s
+        fingerprint = OpenSSL::Digest::MD5.hexdigest(blob).scan(/../).join(":")
+
+        assert_equal blob, data[:key_blob]
+        assert_equal fingerprint, data[:fingerprint]
+        assert_equal connection, data[:session]
+
+        true
+      end
+
+      assert_nothing_raised { exchange! }
+      assert verified
+    end
+
+    private
+
+      def exchange!(options={})
+        connection.expect do |t, buffer|
+          assert_equal KEXDH_INIT, buffer.type
+          assert_equal dh.dh.pub_key, buffer.read_bignum
+          t.return(KEXDH_REPLY, :string, b(:key, server_key), :bignum, server_dh_pubkey, :string, b(:string, options[:key_type] || "ssh-rsa", :string, signature))
+          connection.expect do |t2, buffer2|
+            assert_equal NEWKEYS, buffer2.type
+            t2.return(NEWKEYS)
+          end
+        end
+
+        dh.exchange_keys
+      end
+
+      def dh_options(options={})
+        @dh_options = options
+      end
+
+      def dh
+        @dh ||= subject.new(algorithms, connection, packet_data.merge(:need_bytes => 20).merge(@dh_options || {}))
+      end
+
+      def algorithms(options={})
+        @algorithms ||= OpenStruct.new(:host_key => options[:host_key] || "ssh-rsa")
+      end
+
+      def connection
+        @connection ||= MockTransport.new
+      end
+
+      def subject
+        Net::SSH::Transport::Kex::DiffieHellmanGroup1SHA1
+      end
+
+      # 368 bits is the smallest possible key that will work with this, so
+      # we use it for speed reasons
+      def server_key(bits=368)
+        @server_key ||= OpenSSL::PKey::RSA.new(bits)
+      end
+
+      def packet_data
+        @packet_data ||= { :client_version_string => "client version string",
+          :server_version_string => "server version string",
+          :server_algorithm_packet => "server algorithm packet",
+          :client_algorithm_packet => "client algorithm packet" }
+      end
+
+      def server_dh_pubkey
+        @server_dh_pubkey ||= bn(1234567890)
+      end
+
+      def shared_secret
+        @shared_secret ||= OpenSSL::BN.new(dh.dh.compute_key(server_dh_pubkey), 2)
+      end
+
+      def session_id
+        @session_id ||= begin
+          buffer = Net::SSH::Buffer.from(:string, packet_data[:client_version_string],
+            :string, packet_data[:server_version_string],
+            :string, packet_data[:client_algorithm_packet],
+            :string, packet_data[:server_algorithm_packet],
+            :string, Net::SSH::Buffer.from(:key, server_key),
+            :bignum, dh.dh.pub_key,
+            :bignum, server_dh_pubkey,
+            :bignum, shared_secret)
+          OpenSSL::Digest::SHA1.digest(buffer.to_s)
+        end
+      end
+
+      def signature
+        @signature ||= server_key.ssh_do_sign(session_id)
+      end
+
+      def bn(number, base=10)
+        OpenSSL::BN.new(number.to_s, base)
+      end
+
+      def b(*args)
+        Net::SSH::Buffer.from(*args)
+      end
+  end
+
+end; end

data/test/transport/kex/test_diffie_hellman_group_exchange_sha1.rb

@@ -0,0 +1,92 @@
+require 'common'
+require 'transport/kex/test_diffie_hellman_group1_sha1'
+require 'net/ssh/transport/kex/diffie_hellman_group_exchange_sha1'
+
+module Transport; module Kex
+
+  class TestDiffieHellmanGroupExchangeSHA1 < TestDiffieHellmanGroup1SHA1
+    KEXDH_GEX_GROUP   = 31
+    KEXDH_GEX_INIT    = 32
+    KEXDH_GEX_REPLY   = 33
+    KEXDH_GEX_REQUEST = 34
+
+    def test_exchange_with_fewer_than_minimum_bits_uses_minimum_bits
+      dh_options :need_bytes => 20
+      assert_equal 1024, need_bits
+      assert_nothing_raised { exchange! }
+    end
+
+    def test_exchange_with_fewer_than_maximum_bits_uses_need_bits
+      dh_options :need_bytes => 500
+      need_bits(4000)
+      assert_nothing_raised { exchange! }
+    end
+
+    def test_exchange_with_more_than_maximum_bits_uses_maximum_bits
+      dh_options :need_bytes => 2000
+      need_bits(8192)
+      assert_nothing_raised { exchange! }
+    end
+
+    def test_that_p_and_g_are_provided_by_the_server
+      assert_nothing_raised { exchange! :p => default_p+2, :g => 3 }
+      assert_equal default_p+2, dh.dh.p
+      assert_equal 3, dh.dh.g
+    end
+
+    private
+
+      def need_bits(bits=1024)
+        @need_bits ||= bits
+      end
+
+      def default_p
+        142326151570335518660743995281621698377057354949884468943021767573608899048361360422513557553514790045512299468953431585300812548859419857171094366358158903433167915517332113861059747425408670144201099811846875730766487278261498262568348338476437200556998366087779709990807518291581860338635288400119315130179
+      end
+
+      def exchange!(options={})
+        connection.expect do |t, buffer|
+          assert_equal KEXDH_GEX_REQUEST, buffer.type
+          assert_equal 1024, buffer.read_long
+          assert_equal need_bits, buffer.read_long
+          assert_equal 8192, buffer.read_long
+          t.return(KEXDH_GEX_GROUP, :bignum, bn(options[:p] || default_p), :bignum, bn(options[:g] || 2))
+          t.expect do |t2, buffer2|
+            assert_equal KEXDH_GEX_INIT, buffer2.type
+            assert_equal dh.dh.pub_key, buffer2.read_bignum
+            t2.return(KEXDH_GEX_REPLY, :string, b(:key, server_key), :bignum, server_dh_pubkey, :string, b(:string, options[:key_type] || "ssh-rsa", :string, signature))
+            t2.expect do |t3, buffer3|
+              assert_equal NEWKEYS, buffer3.type
+              t3.return(NEWKEYS)
+            end
+          end
+        end
+
+        dh.exchange_keys
+      end
+
+      def subject
+        Net::SSH::Transport::Kex::DiffieHellmanGroupExchangeSHA1
+      end
+
+      def session_id
+        @session_id ||= begin
+          buffer = Net::SSH::Buffer.from(:string, packet_data[:client_version_string],
+            :string, packet_data[:server_version_string],
+            :string, packet_data[:client_algorithm_packet],
+            :string, packet_data[:server_algorithm_packet],
+            :string, Net::SSH::Buffer.from(:key, server_key),
+            :long,   1024,
+            :long,   need_bits, # need bits, figure this part out,
+            :long,   8192,
+            :bignum, dh.dh.p,
+            :bignum, dh.dh.g,
+            :bignum, dh.dh.pub_key,
+            :bignum, server_dh_pubkey,
+            :bignum, shared_secret)
+          OpenSSL::Digest::SHA1.digest(buffer.to_s)
+        end
+      end
+  end
+
+end; end