net-ssh 2.3.0 → 2.4.0

data/CHANGELOG.rdoc

@@ -1,4 +1,8 @@
 
+=== 2.4.0 / 17 May 2012
+
+* Support for JRuby + Pageant + Windows [arturaz]
+
 === 2.3.0 / 11 Jan 2012
 
 * Support for hmac-sha2 and diffie-hellman-group-exchange-sha256 [Ryosuke Yamazaki]

data/lib/net/ssh/authentication/agent.rb

@@ -1,179 +1,23 @@
 require 'net/ssh/buffer'
 require 'net/ssh/errors'
 require 'net/ssh/loggable'
-require 'net/ssh/transport/server_version'
-
-# Only load pageant on Windows, Ruby 1.8.x
-if File::ALT_SEPARATOR && !(RUBY_PLATFORM =~ /java/) && RUBY_VERSION < "1.9"
-  require 'net/ssh/authentication/pageant' 
-end
 
 module Net; module SSH; module Authentication
+  PLATFORM = File::ALT_SEPARATOR \
+    ? RUBY_PLATFORM =~ /java/ ? :java_win32 : :win32 \
+    : RUBY_PLATFORM =~ /java/ ? :java : :unix
 
   # A trivial exception class for representing agent-specific errors.
   class AgentError < Net::SSH::Exception; end
 
   # An exception for indicating that the SSH agent is not available.
   class AgentNotAvailable < AgentError; end
-
-  # This class implements a simple client for the ssh-agent protocol. It
-  # does not implement any specific protocol, but instead copies the
-  # behavior of the ssh-agent functions in the OpenSSH library (3.8).
-  #
-  # This means that although it behaves like a SSH1 client, it also has
-  # some SSH2 functionality (like signing data).
-  class Agent
-    include Loggable
-
-    # A simple module for extending keys, to allow comments to be specified
-    # for them.
-    module Comment
-      attr_accessor :comment
-    end
-
-    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_ANSWER1 = 2
-    SSH_AGENT_RSA_IDENTITIES_ANSWER2 = 5
-    SSH_AGENT_FAILURE                = 5
-
-    # The underlying socket being used to communicate with the SSH agent.
-    attr_reader :socket
-
-    # Instantiates a new agent object, connects to a running SSH agent,
-    # negotiates the agent protocol version, and returns the agent object.
-    def self.connect(logger=nil)
-      agent = new(logger)
-      agent.connect!
-      agent.negotiate!
-      agent
-    end
-
-    # Creates a new Agent object, using the optional logger instance to
-    # report status.
-    def initialize(logger=nil)
-      self.logger = logger
-    end
-
-    # Connect to the agent process using the socket factory and socket name
-    # given by the attribute writers. If the agent on the other end of the
-    # socket reports that it is an SSH2-compatible agent, this will fail
-    # (it only supports the ssh-agent distributed by OpenSSH).
-    def connect!
-      begin
-        debug { "connecting to ssh-agent" }
-        @socket = agent_socket_factory.open(ENV['SSH_AUTH_SOCK'])
-      rescue
-        error { "could not connect to ssh-agent" }
-        raise AgentNotAvailable, $!.message
-      end
-    end
-
-    # Attempts to negotiate the SSH agent protocol version. Raises an error
-    # if the version could not be negotiated successfully.
-    def negotiate!
-      # determine what type of agent we're communicating with
-      type, body = send_and_wait(SSH2_AGENT_REQUEST_VERSION, :string, Transport::ServerVersion::PROTO_VERSION)
-
-      if type == SSH2_AGENT_VERSION_RESPONSE
-        raise NotImplementedError, "SSH2 agents are not yet supported"
-      elsif type != SSH_AGENT_RSA_IDENTITIES_ANSWER1 && type != SSH_AGENT_RSA_IDENTITIES_ANSWER2
-        raise AgentError, "unknown response from agent: #{type}, #{body.to_s.inspect}"
-      end
-    end
-
-    # Return an array of all identities (public keys) known to the agent.
-    # Each key returned is augmented with a +comment+ property which is set
-    # to the comment returned by the agent for that key.
-    def identities
-      type, body = send_and_wait(SSH2_AGENT_REQUEST_IDENTITIES)
-      raise AgentError, "could not get identity count" if agent_failed(type)
-      raise AgentError, "bad authentication reply: #{type}" if type != SSH2_AGENT_IDENTITIES_ANSWER
-
-      identities = []
-      body.read_long.times do
-        key = Buffer.new(body.read_string).read_key
-        key.extend(Comment)
-        key.comment = body.read_string
-        identities.push key
-      end
-
-      return identities
-    end
-
-    # Closes this socket. This agent reference is no longer able to
-    # query the agent.
-    def close
-      @socket.close
-    end
-
-    # Using the agent and the given public key, sign the given data. The
-    # signature is returned in SSH2 format.
-    def sign(key, data)
-      type, reply = send_and_wait(SSH2_AGENT_SIGN_REQUEST, :string, Buffer.from(:key, key), :string, data, :long, 0)
-
-      if agent_failed(type)
-        raise AgentError, "agent could not sign data with requested identity"
-      elsif type != SSH2_AGENT_SIGN_RESPONSE
-        raise AgentError, "bad authentication response #{type}"
-      end
-
-      return reply.read_string
-    end
-
-    private
-
-      # Returns the agent socket factory to use.
-      def agent_socket_factory
-        if File::ALT_SEPARATOR
-          Pageant::Socket
-        else
-          UNIXSocket
-        end
-      end
-
-      # Send a new packet of the given type, with the associated data.
-      def send_packet(type, *args)
-        buffer = Buffer.from(*args)
-        data = [buffer.length + 1, type.to_i, buffer.to_s].pack("NCA*")
-        debug { "sending agent request #{type} len #{buffer.length}" }
-        @socket.send data, 0
-      end
-
-      # Read the next packet from the agent. This will return a two-part
-      # tuple consisting of the packet type, and the packet's body (which
-      # is returned as a Net::SSH::Buffer).
-      def read_packet
-        buffer = Net::SSH::Buffer.new(@socket.read(4))
-        buffer.append(@socket.read(buffer.read_long))
-        type = buffer.read_byte
-        debug { "received agent packet #{type} len #{buffer.length-4}" }
-        return type, buffer
-      end
-
-      # Send the given packet and return the subsequent reply from the agent.
-      # (See #send_packet and #read_packet).
-      def send_and_wait(type, *args)
-        send_packet(type, *args)
-        read_packet
-      end
-
-      # Returns +true+ if the parameter indicates a "failure" response from
-      # the agent, and +false+ otherwise.
-      def agent_failed(type)
-        type == SSH_AGENT_FAILURE ||
-        type == SSH2_AGENT_FAILURE ||
-        type == SSH_COM_AGENT2_FAILURE
-      end
-  end
-
 end; end; end
+
+case Net::SSH::Authentication::PLATFORM
+when :java_win32
+  # Java pageant requires whole different agent.
+  require 'net/ssh/authentication/agent/java_pageant'
+else
+  require 'net/ssh/authentication/agent/socket'
+end

data/lib/net/ssh/authentication/agent/java_pageant.rb

@@ -0,0 +1,85 @@
+require 'jruby_pageant'
+
+module Net; module SSH; module Authentication
+
+  # This class implements an agent for JRuby + Pageant.
+  #
+  # Written by Artūras Šlajus <arturas.slajus@gmail.com>
+  class Agent
+    include Loggable
+    include JRubyPageant
+
+    # A simple module for extending keys, to allow blobs and comments to be
+    # specified for them.
+    module Key
+      # :blob is used by OpenSSL::PKey::RSA#to_blob
+      attr_accessor :java_blob
+      attr_accessor :comment
+    end
+
+    # Instantiates a new agent object, connects to a running SSH agent,
+    # negotiates the agent protocol version, and returns the agent object.
+    def self.connect(logger=nil)
+      agent = new(logger)
+      agent.connect!
+      agent
+    end
+
+    # Creates a new Agent object, using the optional logger instance to
+    # report status.
+    def initialize(logger=nil)
+      self.logger = logger
+    end
+
+    # Connect to the agent process using the socket factory and socket name
+    # given by the attribute writers. If the agent on the other end of the
+    # socket reports that it is an SSH2-compatible agent, this will fail
+    # (it only supports the ssh-agent distributed by OpenSSH).
+    def connect!
+      debug { "connecting to Pageant ssh-agent (via java connector)" }
+      @agent_proxy = JRubyPageant.create
+      unless @agent_proxy.is_running
+        raise AgentNotAvailable, "Pageant is not running!"
+      end
+      debug { "connection to Pageant ssh-agent (via java connector) succeeded" }
+    rescue AgentProxyException => e
+      error { "could not connect to Pageant ssh-agent (via java connector)" }
+      raise AgentNotAvailable, e.message, e.backtrace
+    end
+
+    # Return an array of all identities (public keys) known to the agent.
+    # Each key returned is augmented with a +comment+ property which is set
+    # to the comment returned by the agent for that key.
+    def identities
+      debug { "getting identities from Pageant" }
+      @agent_proxy.get_identities.map do |identity|
+        blob = identity.get_blob
+        key = Buffer.new(String.from_java_bytes(blob)).read_key
+        key.extend(Key)
+        key.java_blob = blob
+        key.comment = String.from_java_bytes(identity.get_comment)
+        key
+      end
+    rescue AgentProxyException => e
+      raise AgentError, "Cannot get identities: #{e.message}", e.backtrace
+    end
+
+    # Simulate agent close. This agent reference is no longer able to
+    # query the agent.
+    def close
+      @agent_proxy = nil
+    end
+
+    # Using the agent and the given public key, sign the given data. The
+    # signature is returned in SSH2 format.
+    def sign(key, data)
+      signed = @agent_proxy.sign(key.java_blob, data.to_java_bytes)
+      String.from_java_bytes(signed)
+    rescue AgentProxyException => e
+      raise AgentError,
+        "agent could not sign data with requested identity: #{e.message}",
+        e.backtrace
+    end
+  end
+
+end; end; end

data/lib/net/ssh/authentication/agent/socket.rb

@@ -0,0 +1,170 @@
+require 'net/ssh/transport/server_version'
+
+# Only load pageant on Windows
+if Net::SSH::Authentication::PLATFORM == :win32
+  require 'net/ssh/authentication/pageant'
+end
+
+module Net; module SSH; module Authentication
+
+  # This class implements a simple client for the ssh-agent protocol. It
+  # does not implement any specific protocol, but instead copies the
+  # behavior of the ssh-agent functions in the OpenSSH library (3.8).
+  #
+  # This means that although it behaves like a SSH1 client, it also has
+  # some SSH2 functionality (like signing data).
+  class Agent
+    include Loggable
+
+    # A simple module for extending keys, to allow comments to be specified
+    # for them.
+    module Comment
+      attr_accessor :comment
+    end
+
+    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_ANSWER1 = 2
+    SSH_AGENT_RSA_IDENTITIES_ANSWER2 = 5
+    SSH_AGENT_FAILURE                = 5
+
+    # The underlying socket being used to communicate with the SSH agent.
+    attr_reader :socket
+
+    # Instantiates a new agent object, connects to a running SSH agent,
+    # negotiates the agent protocol version, and returns the agent object.
+    def self.connect(logger=nil)
+      agent = new(logger)
+      agent.connect!
+      agent.negotiate!
+      agent
+    end
+
+    # Creates a new Agent object, using the optional logger instance to
+    # report status.
+    def initialize(logger=nil)
+      self.logger = logger
+    end
+
+    # Connect to the agent process using the socket factory and socket name
+    # given by the attribute writers. If the agent on the other end of the
+    # socket reports that it is an SSH2-compatible agent, this will fail
+    # (it only supports the ssh-agent distributed by OpenSSH).
+    def connect!
+      begin
+        debug { "connecting to ssh-agent" }
+        @socket = agent_socket_factory.open(ENV['SSH_AUTH_SOCK'])
+      rescue
+        error { "could not connect to ssh-agent" }
+        raise AgentNotAvailable, $!.message
+      end
+    end
+
+    # Attempts to negotiate the SSH agent protocol version. Raises an error
+    # if the version could not be negotiated successfully.
+    def negotiate!
+      # determine what type of agent we're communicating with
+      type, body = send_and_wait(SSH2_AGENT_REQUEST_VERSION, :string, Transport::ServerVersion::PROTO_VERSION)
+
+      if type == SSH2_AGENT_VERSION_RESPONSE
+        raise NotImplementedError, "SSH2 agents are not yet supported"
+      elsif type != SSH_AGENT_RSA_IDENTITIES_ANSWER1 && type != SSH_AGENT_RSA_IDENTITIES_ANSWER2
+        raise AgentError, "unknown response from agent: #{type}, #{body.to_s.inspect}"
+      end
+    end
+
+    # Return an array of all identities (public keys) known to the agent.
+    # Each key returned is augmented with a +comment+ property which is set
+    # to the comment returned by the agent for that key.
+    def identities
+      type, body = send_and_wait(SSH2_AGENT_REQUEST_IDENTITIES)
+      raise AgentError, "could not get identity count" if agent_failed(type)
+      raise AgentError, "bad authentication reply: #{type}" if type != SSH2_AGENT_IDENTITIES_ANSWER
+
+      identities = []
+      body.read_long.times do
+        key = Buffer.new(body.read_string).read_key
+        key.extend(Comment)
+        key.comment = body.read_string
+        identities.push key
+      end
+
+      return identities
+    end
+
+    # Closes this socket. This agent reference is no longer able to
+    # query the agent.
+    def close
+      @socket.close
+    end
+
+    # Using the agent and the given public key, sign the given data. The
+    # signature is returned in SSH2 format.
+    def sign(key, data)
+      type, reply = send_and_wait(SSH2_AGENT_SIGN_REQUEST, :string, Buffer.from(:key, key), :string, data, :long, 0)
+
+      if agent_failed(type)
+        raise AgentError, "agent could not sign data with requested identity"
+      elsif type != SSH2_AGENT_SIGN_RESPONSE
+        raise AgentError, "bad authentication response #{type}"
+      end
+
+      return reply.read_string
+    end
+
+    private
+
+    # Returns the agent socket factory to use.
+    def agent_socket_factory
+      if Net::SSH::Authentication::PLATFORM == :win32
+        Pageant::socket_factory
+      else
+        UNIXSocket
+      end
+    end
+
+    # Send a new packet of the given type, with the associated data.
+    def send_packet(type, *args)
+      buffer = Buffer.from(*args)
+      data = [buffer.length + 1, type.to_i, buffer.to_s].pack("NCA*")
+      debug { "sending agent request #{type} len #{buffer.length}" }
+      @socket.send data, 0
+    end
+
+    # Read the next packet from the agent. This will return a two-part
+    # tuple consisting of the packet type, and the packet's body (which
+    # is returned as a Net::SSH::Buffer).
+    def read_packet
+      buffer = Net::SSH::Buffer.new(@socket.read(4))
+      buffer.append(@socket.read(buffer.read_long))
+      type = buffer.read_byte
+      debug { "received agent packet #{type} len #{buffer.length-4}" }
+      return type, buffer
+    end
+
+    # Send the given packet and return the subsequent reply from the agent.
+    # (See #send_packet and #read_packet).
+    def send_and_wait(type, *args)
+      send_packet(type, *args)
+      read_packet
+    end
+
+    # Returns +true+ if the parameter indicates a "failure" response from
+    # the agent, and +false+ otherwise.
+    def agent_failed(type)
+      type == SSH_AGENT_FAILURE ||
+        type == SSH2_AGENT_FAILURE ||
+        type == SSH_COM_AGENT2_FAILURE
+    end
+  end
+
+end; end; end

data/lib/net/ssh/authentication/pageant.rb

@@ -1,5 +1,13 @@
 require 'dl/import'
-require 'dl/struct'
+
+if RUBY_VERSION < "1.9"
+  require 'dl/struct'
+end
+
+if RUBY_VERSION =~ /^1.9/
+  require 'dl/types'
+  require 'dl'
+end
 
 require 'net/ssh/errors'
 
@@ -17,15 +25,23 @@ module Net; module SSH; module Authentication
     # From Putty pageant.c
     AGENT_MAX_MSGLEN = 8192
     AGENT_COPYDATA_ID = 0x804e50ba
-    
+
     # The definition of the Windows methods and data structures used in
     # communicating with the pageant process.
     module Win
-      extend DL::Importable
-      
-      dlload 'user32'
-      dlload 'kernel32'
-      
+      if RUBY_VERSION < "1.9"
+        extend DL::Importable
+
+        dlload 'user32'
+        dlload 'kernel32'
+      end
+
+      if RUBY_VERSION =~ /^1.9/
+        extend DL::Importer
+        dlload 'user32','kernel32'
+        include DL::Win32Types
+      end
+
       typealias("LPCTSTR", "char *")         # From winnt.h
       typealias("LPVOID", "void *")          # From winnt.h
       typealias("LPCVOID", "const void *")   # From windef.h
@@ -52,7 +68,7 @@ module Net; module SSH; module Authentication
       # args: hFile, (ignored), flProtect, dwMaximumSizeHigh,
       #           dwMaximumSizeLow, lpName
       extern 'HANDLE CreateFileMapping(HANDLE, void *, DWORD, DWORD, ' +
-                                      'DWORD, LPCTSTR)'
+        'DWORD, LPCTSTR)'
 
       # args: hFileMappingObject, dwDesiredAccess, dwFileOffsetHigh, 
       #           dwfileOffsetLow, dwNumberOfBytesToMap
@@ -66,7 +82,11 @@ module Net; module SSH; module Authentication
 
       # args: hWnd, Msg, wParam, lParam, fuFlags, uTimeout, lpdwResult
       extern 'LRESULT SendMessageTimeout(HWND, UINT, WPARAM, LPARAM, ' +
-                                        'UINT, UINT, PDWORD_PTR)'
+        'UINT, UINT, PDWORD_PTR)'
+      if RUBY_VERSION < "1.9"
+        alias_method :FindWindow,:findWindow
+        module_function :FindWindow
+      end
     end
 
     # This is the pseudo-socket implementation that mimics the interface of
@@ -87,7 +107,7 @@ module Net; module SSH; module Authentication
       # Create a new instance that communicates with the running pageant 
       # instance. If no such instance is running, this will cause an error.
       def initialize
-        @win = Win.findWindow("Pageant", "Pageant")
+        @win = Win.FindWindow("Pageant", "Pageant")
 
         if @win == 0
           raise Net::SSH::Exception,
@@ -97,7 +117,7 @@ module Net; module SSH; module Authentication
         @res = nil
         @pos = 0
       end
-      
+
       # Forwards the data to #send_query, ignoring any arguments after
       # the first. Returns 0.
       def send(data, *args)
@@ -132,11 +152,11 @@ module Net; module SSH; module Authentication
         end
 
         ptr[0] = query
-        
+
         cds = [AGENT_COPYDATA_ID, mapname.size + 1, mapname].
           pack("LLp").to_ptr
         succ = Win.sendMessageTimeout(@win, Win::WM_COPYDATA, Win::NULL,
-          cds, Win::SMTO_NORMAL, 5000, id)
+                                      cds, Win::SMTO_NORMAL, 5000, id)
 
         if succ > 0
           retlen = 4 + ptr.to_s(4).unpack("N")[0]
@@ -178,6 +198,67 @@ module Net; module SSH; module Authentication
 
     end
 
+    # Socket changes for Ruby 1.9
+    # Functionality is the same as Ruby 1.8 but it includes the new calls to 
+    # the DL module as well as other pointer transformations
+    class Socket19 < Socket
+      # Packages the given query string and sends it to the pageant
+      # process via the Windows messaging subsystem. The result is
+      # cached, to be returned piece-wise when #read is called.
+      def send_query(query)
+        res = nil
+        filemap = 0
+        ptr = nil
+        id = DL.malloc(DL::SIZEOF_LONG)
+
+        mapname = "PageantRequest%08x\000" % Win.GetCurrentThreadId()
+
+        filemap = Win.CreateFileMapping(Win::INVALID_HANDLE_VALUE, 
+                                        Win::NULL,
+                                        Win::PAGE_READWRITE, 0, 
+                                        AGENT_MAX_MSGLEN, mapname)
+
+        if filemap == 0 || filemap == Win::INVALID_HANDLE_VALUE
+          raise Net::SSH::Exception,
+            "Creation of file mapping failed"
+        end
+
+        ptr = Win.MapViewOfFile(filemap, Win::FILE_MAP_WRITE, 0, 0, 
+                                0)
+
+        if ptr.nil? || ptr.null?
+          raise Net::SSH::Exception, "Mapping of file failed"
+        end
+
+        DL::CPtr.new(ptr)[0,query.size]=query
+
+        cds = DL::CPtr.to_ptr [AGENT_COPYDATA_ID, mapname.size + 1, mapname].
+          pack("LLp")
+        succ = Win.SendMessageTimeout(@win, Win::WM_COPYDATA, Win::NULL,
+                                      cds, Win::SMTO_NORMAL, 5000, id)
+
+        if succ > 0
+          retlen = 4 + ptr.to_s(4).unpack("N")[0]
+          res = ptr.to_s(retlen)
+        end        
+
+        return res
+      ensure
+        Win.UnmapViewOfFile(ptr) unless ptr.nil? || ptr.null?
+        Win.CloseHandle(filemap) if filemap != 0
+      end
+    end
+
+    # Selects which socket to use depending on the ruby version
+    # This is needed due changes in the DL module.
+    def self.socket_factory
+      if RUBY_VERSION < "1.9"
+        Socket
+      else
+        Socket19
+      end
+    end
+
   end
 
 end; end; end

data/lib/net/ssh/version.rb

@@ -48,7 +48,7 @@ module Net; module SSH
     MAJOR = 2
 
     # The minor component of this version of the Net::SSH library
-    MINOR = 3
+    MINOR = 4
 
     # The tiny component of this version of the Net::SSH library
     TINY  = 0

data/net-ssh.gemspec

@@ -1,21 +1,26 @@
 @spec = Gem::Specification.new do |s|
-	s.name = "net-ssh"
-        s.rubyforge_project = 'net-ssh'
-	s.version = "2.3.0"
-	s.summary = "Net::SSH: a pure-Ruby implementation of the SSH2 client protocol."
-	s.description = s.summary
-	s.authors = ["Jamis Buck", "Delano Mandelbaum"]
-	s.email = ["net-ssh@solutious.com"]
-	s.homepage = "http://github.com/net-ssh/net-ssh"
-  
+  s.name = "net-ssh"
+  s.rubyforge_project = 'net-ssh'
+  s.version = "2.4.0"
+  s.summary = "Net::SSH: a pure-Ruby implementation of the SSH2 client protocol."
+  s.description = s.summary + " It allows you to write programs that invoke and interact with processes on remote servers, via SSH2."
+  s.authors = ["Jamis Buck", "Delano Mandelbaum"]
+  s.email = ["net-ssh@solutious.com"]
+  s.homepage = "http://github.com/net-ssh/net-ssh"
+
   s.extra_rdoc_files = %w[README.rdoc THANKS.rdoc CHANGELOG.rdoc]
   s.has_rdoc = true
   s.rdoc_options = ["--line-numbers", "--title", s.summary, "--main", "README.rdoc"]
   s.require_paths = %w[lib]
   s.rubygems_version = '1.3.2'
-  
+
+  # This has two flavours with java one actually doing something and other
+  # one just raising error. This is a workaround for no ability to specify
+  # platform specific dependencies in gemspecs.
+  s.add_dependency 'jruby-pageant', ">=1.0.2"
+
   s.executables = %w[]
-  
+
   # = MANIFEST =
   s.files = %w(
   CHANGELOG.rdoc
@@ -26,6 +31,8 @@
   THANKS.rdoc
   lib/net/ssh.rb
   lib/net/ssh/authentication/agent.rb
+  lib/net/ssh/authentication/agent/java_pageant.rb
+  lib/net/ssh/authentication/agent/socket.rb
   lib/net/ssh/authentication/constants.rb
   lib/net/ssh/authentication/key_manager.rb
   lib/net/ssh/authentication/methods/abstract.rb
@@ -141,5 +148,5 @@
   test/transport/test_state.rb
   )
 
-  
+
 end

data/test/authentication/test_key_manager.rb

@@ -18,7 +18,9 @@ module Authentication
       manager.add "/second"
       manager.add "/third"
       manager.add "/second"
-      assert_equal %w(/first /second /third), manager.key_files
+      assert_true manager.key_files.length == 3
+      final_files = manager.key_files.map {|item| item.split('/').last}
+      assert_equal %w(first second third), final_files
     end
 
     def test_use_agent_should_be_set_to_false_if_agent_could_not_be_found
@@ -30,9 +32,10 @@ module Authentication
 
     def test_each_identity_should_load_from_key_files
       manager.stubs(:agent).returns(nil)
-
-      stub_file_private_key "/first", rsa
-      stub_file_private_key "/second", dsa
+      first = File.expand_path("/first")
+      second = File.expand_path("/second")
+      stub_file_private_key first, rsa
+      stub_file_private_key second, dsa      
 
       identities = []
       manager.each_identity { |identity| identities << identity }
@@ -40,9 +43,9 @@ module Authentication
       assert_equal 2, identities.length
       assert_equal rsa.to_blob, identities.first.to_blob
       assert_equal dsa.to_blob, identities.last.to_blob
-
-      assert_equal({:from => :file, :file => "/first", :key => rsa}, manager.known_identities[rsa])
-      assert_equal({:from => :file, :file => "/second", :key => dsa}, manager.known_identities[dsa])
+      
+      assert_equal({:from => :file, :file => first, :key => rsa}, manager.known_identities[rsa])
+      assert_equal({:from => :file, :file => second, :key => dsa}, manager.known_identities[dsa])
     end
 
     def test_identities_should_load_from_agent
@@ -62,7 +65,8 @@ module Authentication
     def test_only_identities_with_key_files_should_load_from_agent_of_keys_only_set
       manager(:keys_only => true).stubs(:agent).returns(agent)
 
-      stub_file_private_key "/first", rsa
+      first = File.expand_path("/first")
+      stub_file_private_key first, rsa
 
       identities = []
       manager.each_identity { |identity| identities << identity }
@@ -76,8 +80,10 @@ module Authentication
     def test_identities_without_public_key_files_should_not_be_touched_if_identity_loaded_from_agent
       manager.stubs(:agent).returns(agent)
 
-      stub_file_public_key  "/first", rsa
-      stub_file_private_key "/second", dsa, :passphrase => :should_not_be_asked
+      first = File.expand_path("/first")
+      stub_file_public_key  first, rsa
+      second = File.expand_path("/second")
+      stub_file_private_key second, dsa, :passphrase => :should_not_be_asked
 
       identities = []
       manager.each_identity do |identity|
@@ -98,7 +104,8 @@ module Authentication
 
     def test_sign_with_file_originated_key_should_load_private_key_and_sign_with_it
       manager.stubs(:agent).returns(nil)
-      stub_file_private_key "/first", rsa(512)
+      first = File.expand_path("/first")
+      stub_file_private_key first, rsa(512)
       rsa.expects(:ssh_do_sign).with("hello, world").returns("abcxyz123")
       manager.each_identity { |identity| } # preload the known_identities
       assert_equal "\0\0\0\assh-rsa\0\0\0\011abcxyz123", manager.sign(rsa, "hello, world")

data/test/test_config.rb

@@ -3,8 +3,9 @@ require 'net/ssh/config'
 
 class TestConfig < Test::Unit::TestCase
   def test_load_for_non_existant_file_should_return_empty_hash
-    File.expects(:readable?).with("/bogus/file").returns(false)
-    assert_equal({}, Net::SSH::Config.load("/bogus/file", "host.name"))
+    bogus_file = File.expand_path("/bogus/file")
+    File.expects(:readable?).with(bogus_file).returns(false)
+    assert_equal({}, Net::SSH::Config.load(bogus_file, "host.name"))
   end
 
   def test_load_should_expand_path

data/test/test_key_factory.rb

@@ -2,53 +2,57 @@ require 'common'
 require 'net/ssh/key_factory'
 
 class TestKeyFactory < Test::Unit::TestCase
+  def setup
+    @key_file = File.expand_path("/key-file")
+  end
+  
   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
+    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
+    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
+    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
+    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
+    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
+    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") }
+    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_encrypted_private_key_should_raise_exception_without_asking_passphrase
-    File.expects(:read).with("/key-file").returns(encrypted(rsa_key, "password"))
+    File.expects(:read).with(@key_file).returns(encrypted(rsa_key, "password"))
     Net::SSH::KeyFactory.expects(:prompt).never
-    assert_raises(OpenSSL::PKey::RSAError) { Net::SSH::KeyFactory.load_private_key("/key-file", nil, false) }
+    assert_raises(OpenSSL::PKey::RSAError) { Net::SSH::KeyFactory.load_private_key(@key_file, nil, false) }
   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
+    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

metadata

@@ -2,7 +2,7 @@
 name: net-ssh
 version: !ruby/object:Gem::Version 
   prerelease: 
-  version: 2.3.0
+  version: 2.4.0
 platform: ruby
 authors: 
 - Jamis Buck
@@ -11,10 +11,20 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2012-01-11 00:00:00 Z
-dependencies: []
-
-description: "Net::SSH: a pure-Ruby implementation of the SSH2 client protocol."
+date: 2012-05-17 00:00:00 Z
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: jruby-pageant
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 1.0.2
+  type: :runtime
+  version_requirements: *id001
+description: "Net::SSH: a pure-Ruby implementation of the SSH2 client protocol. It allows you to write programs that invoke and interact with processes on remote servers, via SSH2."
 email: 
 - net-ssh@solutious.com
 executables: []
@@ -34,6 +44,8 @@ files:
 - THANKS.rdoc
 - lib/net/ssh.rb
 - lib/net/ssh/authentication/agent.rb
+- lib/net/ssh/authentication/agent/java_pageant.rb
+- lib/net/ssh/authentication/agent/socket.rb
 - lib/net/ssh/authentication/constants.rb
 - lib/net/ssh/authentication/key_manager.rb
 - lib/net/ssh/authentication/methods/abstract.rb