net-ssh 2.9.1 → 2.9.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: aac9757449c9d417f334f8a5c44b9b69105c4c9b
+  data.tar.gz: eda8ba20fad936162084101482eb1f1c821b67a3
+SHA512:
+  metadata.gz: fc1b60e3b51388d6b66fc38b7d4aaba56ead796820c2374a0aad1b48de094c2fb382db4159425d404f66612d8e61f0a1436b16dd90873235fcacca9b64bf3da5
+  data.tar.gz: f5dce76345e1774539a47d70c4f516e52164171d38da7569fd2f0489f34cc8599d0914115ad2108d89ca12cf667fa36a062a188508d3d136692075421d4e0307

data/CHANGES.txt

@@ -1,4 +1,21 @@
+=== 2.9.2-rc3
 
+* Remove advertised algorithms that were not working (curve25519-sha256@libssh.org) [mfazekas]
+
+=== 2.9.2-rc2
+
+* number_of_password_prompts is now accepted as ssh option, by setting it 0 net-ssh will not ask for password for password auth as with previous versions [mfazekas]
+
+=== 2.9.2-rc1
+
+* Documentation fixes and refactoring to keepalive [detiber, mfazekas]
+
+=== 2.9.2-beta
+
+* Remove advertised algorithms that were not working (ssh-rsa-cert-* *ed25519 acm*-gcm@openssh.com) [mfazekas]
+* Unkown algorithms now ignored instead of failed [mfazekas]
+* Asks for password with password auth (up to number_of_password_prompts) [mfazekas]
+* Removed warnings [amatsuda]
 
 === 2.9.1 / 13 May 2014
 

data/README.rdoc

@@ -171,6 +171,11 @@ Run a single test file like this:
 
 * JRuby 1.5: 99% tests pass (448 tests, 1846 assertions, 1 failures)
 
+=== BUILDING GEM
+
+Since building the gem requires the private key if you want to build a .gem locally please use the NET_SSH_NOKEY=1 envirnoment variable:
+
+     rake build NET_SSH_NOKEY=1
 
 === PORT FORWARDING TESTS
 

data/Rakefile

@@ -1,3 +1,10 @@
+# coding: UTF-8
+#
+# Also in your terminal environment run:
+#   $ export LANG=en_US.UTF-8
+#   $ export LANGUAGE=en_US.UTF-8
+#   $ export LC_ALL=en_US.UTF-8
+
 require "rubygems"
 require "rake"
 require "rake/clean"
@@ -21,7 +28,7 @@ begin
     s.description = s.summary + " It allows you to write programs that invoke and interact with processes on remote servers, via SSH2."
     s.email = "net-ssh@solutious.com"
     s.homepage = "https://github.com/net-ssh/net-ssh"
-    s.authors = ["Jamis Buck", "Delano Mandelbaum"]
+    s.authors = ["Jamis Buck", "Delano Mandelbaum", "Miklós Fazekas"]
 
     # Note: this is run at package time not install time so if you are
     # running on jruby, you need to install jruby-pageant manually.
@@ -34,10 +41,16 @@ begin
 
     s.license = "MIT"
 
-    s.signing_key = File.join('/mnt/gem/', 'gem-private_key.pem')
-    s.cert_chain  = ['gem-public_cert.pem']
+    unless ENV['NET_SSH_NOKEY']
+      signing_key = File.join('/mnt/gem/', 'net-ssh-private_key.pem')
+      s.signing_key = File.join('/mnt/gem/', 'net-ssh-private_key.pem')
+      s.cert_chain  = ['net-ssh-public_cert.pem']
+      unless (Rake.application.top_level_tasks & ['build','install']).empty?
+        raise "No key found at #{signing_key} for signing, use rake <taskname> NET_SSH_NOKEY=1 to build without key" unless File.exist?(signing_key)
+      end
+    end
   end
-  Jeweler::GemcutterTasks.new
+  Jeweler::RubygemsDotOrgTasks.new
 rescue LoadError
   puts "Jeweler (or a dependency) not available. Install it with: sudo gem install jeweler"
 end

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

@@ -94,10 +94,16 @@ module Net; module SSH; module Authentication
 
       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
+        key_str = body.read_string
+        comment_str = body.read_string
+        begin
+          key = Buffer.new(key_str).read_key
+          key.extend(Comment)
+          key.comment = comment_str
+          identities.push key
+        rescue NotImplementedError => e
+          error { "ignoring unimplemented key:#{e.message} #{comment_str}" }
+        end
       end
 
       return identities

data/lib/net/ssh/authentication/methods/password.rb

@@ -1,4 +1,5 @@
 require 'net/ssh/errors'
+require 'net/ssh/prompt'
 require 'net/ssh/authentication/methods/abstract'
 
 module Net
@@ -8,25 +9,36 @@ module Net
 
         # Implements the "password" SSH authentication method.
         class Password < Abstract
+          include Prompt
+
           # Attempt to authenticate the given user for the given service. If
-          # the password parameter is nil, this will never do anything except
-          # return false.
+          # the password parameter is nil, this will ask for password
           def authenticate(next_service, username, password=nil)
-            return false unless password
+            retries = 0
+            max_retries =  get_max_retries
+            return false if !password && max_retries == 0
 
-            send_message(userauth_request(username, next_service, "password", false, password))
-            message = session.next_message
+            begin
+              password_to_send = password || ask_password(username)
 
-            case message.type
-              when USERAUTH_SUCCESS
-                debug { "password succeeded" }
-                return true
-              when USERAUTH_FAILURE
+              send_message(userauth_request(username, next_service, "password", false, password_to_send))
+              message = session.next_message
+              retries += 1
+
+              if message.type == USERAUTH_FAILURE
                 debug { "password failed" }
 
                 raise Net::SSH::Authentication::DisallowedMethod unless
                   message[:authentications].split(/,/).include? 'password'
+                password = nil
+              end
+            end until (message.type != USERAUTH_FAILURE || retries >= max_retries)
 
+            case message.type
+              when USERAUTH_SUCCESS
+                debug { "password succeeded" }
+                return true
+              when USERAUTH_FAILURE
                 return false
               when USERAUTH_PASSWD_CHANGEREQ
                 debug { "password change request received, failing" }
@@ -35,6 +47,19 @@ module Net
                 raise Net::SSH::Exception, "unexpected reply to USERAUTH_REQUEST: #{message.type} (#{message.inspect})"
             end
           end
+
+          private
+
+          NUMBER_OF_PASSWORD_PROMPTS = 3
+
+          def ask_password(username)
+            echo = false
+            prompt("#{username}@#{session.transport.host}'s password:", echo)
+          end
+
+          def get_max_retries
+            (session.transport.options||{})[:number_of_password_prompts] || NUMBER_OF_PASSWORD_PROMPTS
+          end
         end
 
       end

data/lib/net/ssh/buffer.rb

@@ -255,7 +255,7 @@ module Net; module SSH
           key.e = read_bignum
           key.n = read_bignum
 
-        when /^ecdsa\-sha2\-(\w*)$/, /^ssh-ed25519(-cert-v01@openssh.com)?$/
+        when /^ecdsa\-sha2\-(\w*)$/
           unless defined?(OpenSSL::PKey::EC)
             raise NotImplementedError, "unsupported key type `#{type}'"
           else

data/lib/net/ssh/config.rb

@@ -31,6 +31,7 @@ module Net; module SSH
   # * RekeyLimit => :rekey_limit
   # * User => :user
   # * UserKnownHostsFile => :user_known_hosts_file
+  # * NumberOfPasswordPrompts => :number_of_password_prompts
   #
   # Note that you will never need to use this class directly--you can control
   # whether the OpenSSH configuration files are read by passing the :config
@@ -59,7 +60,7 @@ module Net; module SSH
       # #default_files), translates the resulting hash into the options
       # recognized by Net::SSH, and returns them.
       def for(host, files=default_files)
-        hash = translate(files.inject({}) { |settings, file|
+        translate(files.inject({}) { |settings, file|
           load(file, host, settings)
         })
       end
@@ -76,7 +77,6 @@ module Net; module SSH
 
         globals = {}
         matched_host = nil
-        multi_host = []
         seen_host = false
         IO.foreach(file) do |line|
           next if line =~ /^\s*(?:#.*)?$/
@@ -220,6 +220,8 @@ module Net; module SSH
           when 'sendenv'
             multi_send_env = value.to_s.split(/\s+/)
             hash[:send_env] = multi_send_env.map { |e| Regexp.new pattern2regex(e).source, false }
+          when 'numberofpasswordprompts'
+            hash[:number_of_password_prompts] = value.to_i
           end
           hash
         end

data/lib/net/ssh/connection/channel.rb

@@ -523,7 +523,7 @@ module Net; module SSH; module Connection
           @on_open_failed.call(self, reason_code, description)
         else
           raise ChannelOpenFailed.new(reason_code, description)
-        end          
+        end
       end
 
       # Invoked when the server sends a CHANNEL_WINDOW_ADJUST packet, and

data/lib/net/ssh/connection/keepalive.rb

@@ -0,0 +1,55 @@
+require 'net/ssh/loggable'
+module Net; module SSH; module Connection
+
+class Keepalive
+  include Loggable
+
+  def initialize(session)
+    @last_keepalive_sent_at = nil
+    @unresponded_keepalive_count = 0
+    @session = session
+    self.logger = session.logger
+  end
+
+  def options
+    @session.options
+  end
+
+  def enabled?
+    options[:keepalive]
+  end
+
+  def interval
+    options[:keepalive_interval] || Session::DEFAULT_IO_SELECT_TIMEOUT
+  end
+
+  def should_send?
+    return false unless enabled?
+    return true unless @last_keepalive_sent_at
+    Time.now - @last_keepalive_sent_at >= interval
+  end
+
+  def keepalive_maxcount
+    (options[:keepalive_maxcount] || 3).to_i
+  end
+
+  def send_as_needed(readers, writers)
+    return unless readers.nil? && writers.nil?
+    return unless should_send?
+    info { "sending keepalive #{@unresponded_keepalive_count}" }
+
+    @unresponded_keepalive_count += 1
+    @session.send_global_request("keepalive@openssh.com") { |success, response|
+      debug { "keepalive response successful. Missed #{@unresponded_keepalive_count-1} keepalives" }
+      @unresponded_keepalive_count = 0
+    }
+    @last_keepalive_sent_at = Time.now
+    if keepalive_maxcount > 0 && @unresponded_keepalive_count > keepalive_maxcount
+      error { "Timeout, server #{@session.host} not responding. Missed #{@unresponded_keepalive_count-1} timeouts." }
+      @unresponded_keepalive_count = 0
+      raise Net::SSH::Timeout, "Timeout, server #{@session.host} not responding."
+    end
+  end
+end
+
+end; end; end

data/lib/net/ssh/connection/session.rb

@@ -3,6 +3,7 @@ require 'net/ssh/ruby_compat'
 require 'net/ssh/connection/channel'
 require 'net/ssh/connection/constants'
 require 'net/ssh/service/forward'
+require 'net/ssh/connection/keepalive'
 
 module Net; module SSH; module Connection
 
@@ -79,7 +80,7 @@ module Net; module SSH; module Connection
       @max_pkt_size = (options.has_key?(:max_pkt_size) ? options[:max_pkt_size] : 0x8000)
       @max_win_size = (options.has_key?(:max_win_size) ? options[:max_win_size] : 0x20000)
 
-      @last_keepalive_sent_at = nil
+      @keepalive = Keepalive.new(self)
     end
 
     # Retrieves a custom property from this instance. This can be used to
@@ -244,7 +245,7 @@ module Net; module SSH; module Connection
         writer.send_pending
       end
 
-      send_keepalive_as_needed(readers, writers)
+      @keepalive.send_as_needed(readers, writers)
       transport.rekey_as_needed
 
       return true
@@ -598,27 +599,8 @@ module Net; module SSH; module Connection
 
       def io_select_wait(wait)
         return wait if wait
-        return wait unless options[:keepalive]
-        keepalive_interval
-      end
-
-      def keepalive_interval
-        options[:keepalive_interval] || DEFAULT_IO_SELECT_TIMEOUT
-      end
-
-      def should_send_keepalive?
-        return false unless options[:keepalive]
-        return true unless @last_keepalive_sent_at
-        Time.now - @last_keepalive_sent_at >= keepalive_interval
-      end
-
-      def send_keepalive_as_needed(readers, writers)
-        return unless readers.nil? && writers.nil?
-        return unless should_send_keepalive?
-        info { "sending keepalive" }
-        msg = Net::SSH::Buffer.from(:byte, Packet::IGNORE, :string, "keepalive")
-        send_message(msg)
-        @last_keepalive_sent_at = Time.now
+        return wait unless @keepalive.enabled?
+        @keepalive.interval
       end
 
       MAP = Constants.constants.inject({}) do |memo, name|

data/lib/net/ssh/errors.rb

@@ -14,6 +14,10 @@ module Net; module SSH
   # unexpectedly.
   class Disconnect < Exception; end
 
+  # This exception is raised when the remote host has disconnected/
+  # timeouted unexpectedly.
+  class Timeout < Disconnect; end
+
   # This exception is primarily used internally, but if you have a channel
   # request handler (see Net::SSH::Connection::Channel#on_request) that you
   # want to fail in such a way that the server knows it failed, you can

data/lib/net/ssh/known_hosts.rb

@@ -15,17 +15,9 @@ module Net; module SSH
       SUPPORTED_TYPE = %w(ssh-rsa ssh-dss
                           ecdsa-sha2-nistp256
                           ecdsa-sha2-nistp384
-                          ecdsa-sha2-nistp521
-                          ssh-ed25519-cert-v01@openssh.com
-                          ssh-rsa-cert-v01@openssh.com
-                          ssh-rsa-cert-v00@openssh.com
-                          ssh-ed25519
-                          )
+                          ecdsa-sha2-nistp521)
     else
-      SUPPORTED_TYPE = %w(ssh-rsa ssh-dss
-                          ssh-rsa-cert-v01@openssh.com
-                          ssh-rsa-cert-v00@openssh.com
-                         )
+      SUPPORTED_TYPE = %w(ssh-rsa ssh-dss)
     end
 
 

data/lib/net/ssh/service/forward.rb

@@ -88,13 +88,13 @@ module Net; module SSH; module Service
         end
 
         prepare_client(client, channel, :local)
-  
+
         channel.on_open_failed do |ch, code, description|
           channel.error { "could not establish direct channel: #{description} (#{code})" }
           channel[:socket].close
         end
       end
-      
+
       local_port
     end
 
@@ -131,22 +131,52 @@ module Net; module SSH; module Service
     # the port number. The assigned port will show up in the # #active_remotes
     # list.
     #
+    # remote_host is interpreted by the server per RFC 4254, which has these
+    # special values:
+    #
+    # - "" means that connections are to be accepted on all protocol
+    #   families supported by the SSH implementation.
+    # - "0.0.0.0" means to listen on all IPv4 addresses.
+    # - "::" means to listen on all IPv6 addresses.
+    # - "localhost" means to listen on all protocol families supported by
+    #   the SSH implementation on loopback addresses only ([RFC3330] and
+    #   [RFC3513]).
+    # - "127.0.0.1" and "::1" indicate listening on the loopback
+    #   interfaces for IPv4 and IPv6, respectively.
+    #
+    # You may pass a block that will be called when the the port forward
+    # request receives a response.  This block will be passed the remote_port
+    # that was actually bound to, or nil if the binding failed.  If the block
+    # returns :no_exception, the "failed binding" exception will not be thrown.
+    #
     # If you want to block until the port is active, you could do something
     # like this:
     #
-    #   old_active_remotes = ssh.forward.active_remotes
-    #   ssh.forward.remote(80, "www.google.com", 0, "0.0.0.0")
-    #   ssh.loop { !(ssh.forward.active_remotes.length > old_active_remotes.length) }
-    #   assigned_port = (ssh.forward.active_remotes - old_active_remotes).first[0]
+    #   got_remote_port = nil
+    #   remote(port, host, remote_port, remote_host) do |actual_remote_port|
+    #     got_remote_port = actual_remote_port || :error
+    #     :no_exception # will yield the exception on my own thread
+    #   end
+    #   session.loop { !got_remote_port }
+    #   if got_remote_port == :error
+    #     raise Net::SSH::Exception, "remote forwarding request failed"
+    #   end
+    #
     def remote(port, host, remote_port, remote_host="127.0.0.1")
       session.send_global_request("tcpip-forward", :string, remote_host, :long, remote_port) do |success, response|
         if success
           remote_port = response.read_long if remote_port == 0
           debug { "remote forward from remote #{remote_host}:#{remote_port} to #{host}:#{port} established" }
           @remote_forwarded_ports[[remote_port, remote_host]] = Remote.new(host, port)
+          yield remote_port, remote_host if block_given?
         else
-          error { "remote forwarding request failed" }
-          raise Net::SSH::Exception, "remote forwarding request failed"
+          instruction = if block_given?
+            yield :error
+          end
+          unless instruction == :no_exception
+            error { "remote forwarding request failed" }
+            raise Net::SSH::Exception, "remote forwarding request failed"
+          end
         end
       end
     end
@@ -183,6 +213,16 @@ module Net; module SSH; module Service
       @remote_forwarded_ports.keys
     end
 
+    # Returns all active remote forwarded ports and where they forward to. The
+    # returned value is a hash from [<forwarding port on the local host>, <local forwarding address>]
+    # to [<port on the remote host>, <remote bind address>].
+    def active_remote_destinations
+      @remote_forwarded_ports.inject({}) do |result, (remote, local)|
+        result[[local.port, local.host]] = remote
+        result
+      end
+    end
+
     # Enables SSH agent forwarding on the given channel. The forwarded agent
     # will remain active even after the channel closes--the channel is only
     # used as the transport for enabling the forwarded connection. You should
@@ -216,7 +256,7 @@ module Net; module SSH; module Service
     end
 
     private
-      
+
       # Perform setup operations that are common to all forwarded channels.
       # +client+ is a socket, +channel+ is the channel that was just created,
       # and +type+ is an arbitrary string describing the type of the channel.
@@ -228,11 +268,11 @@ module Net; module SSH; module Service
         session.listen_to(client)
         channel[:socket] = client
 
-        channel.on_data do |ch, data|  
+        channel.on_data do |ch, data|
           debug { "data:#{data.length} on #{type} forwarded channel" }
           ch[:socket].enqueue(data)
         end
-        
+
         # Handles server close on the sending side by Miklós Fazekas
         channel.on_eof do |ch|
           debug { "eof #{type} on #{type} forwarded channel" }
@@ -251,7 +291,7 @@ module Net; module SSH; module Service
             debug { "enotconn in on_eof => shallowing exception:#{e}" }
           end
         end
-        
+
         channel.on_close do |ch|
           debug { "closing #{type} forwarded channel" }
           ch[:socket].close if !client.closed?

data/lib/net/ssh/transport/algorithms.rb

@@ -42,14 +42,12 @@ module Net; module SSH; module Transport
                          camellia192-ctr@openssh.org
                          camellia256-ctr@openssh.org
                          cast128-ctr blowfish-ctr 3des-ctr
-                         aes256-gcm@openssh.com aes128-gcm@openssh.com
                         ),
+
       :hmac        => %w(hmac-sha1 hmac-md5 hmac-sha1-96 hmac-md5-96
                          hmac-ripemd160 hmac-ripemd160@openssh.com
                          hmac-sha2-256 hmac-sha2-512 hmac-sha2-256-96
-                         hmac-sha2-512-96 none
-                         hmac-sha2-512-etm@openssh.com hmac-sha2-256-etm@openssh.com
-                         umac-128-etm@openssh.com),
+                         hmac-sha2-512-96 none),
 
       :compression => %w(none zlib@openssh.com zlib),
       :language    => %w() 
@@ -57,13 +55,10 @@ module Net; module SSH; module Transport
     if defined?(OpenSSL::PKey::EC)
       ALGORITHMS[:host_key] += %w(ecdsa-sha2-nistp256
                                   ecdsa-sha2-nistp384
-                                  ecdsa-sha2-nistp521
-                                  ssh-ed25519-cert-v01@openssh.com
-                                  ssh-ed25519)
+                                  ecdsa-sha2-nistp521)
       ALGORITHMS[:kex] += %w(ecdh-sha2-nistp256
                              ecdh-sha2-nistp384
-                             ecdh-sha2-nistp521
-                             curve25519-sha256@libssh.org)
+                             ecdh-sha2-nistp521)
     end
 
     # The underlying transport layer session that supports this object
@@ -221,8 +216,13 @@ module Net; module SSH; module Transport
           # apply the preferred algorithm order, if any
           if options[algorithm]
             algorithms[algorithm] = Array(options[algorithm]).compact.uniq
-            invalid = algorithms[algorithm].detect { |name| !ALGORITHMS[algorithm].include?(name) }
-            raise NotImplementedError, "unsupported #{algorithm} algorithm: `#{invalid}'" if invalid
+            unsupported = []
+            algorithms[algorithm].select! do |name|
+              supported = ALGORITHMS[algorithm].include?(name)
+              unsupported << name unless supported
+              supported
+            end
+            lwarn { "unsupported #{algorithm} algorithm: `#{unsupported}'" } unless unsupported.empty?
 
             # make sure all of our supported algorithms are tacked onto the
             # end, so that if the user tries to give a list of which none are

data/lib/net/ssh/transport/cipher_factory.rb

@@ -41,9 +41,6 @@ module Net; module SSH; module Transport
       "camellia192-ctr@openssh.org" => "camellia-192-ecb",
       "camellia256-ctr@openssh.org" => "camellia-256-ecb",
 
-      "aes256-gcm@openssh.com"      => "aes-256-gcm",
-      "aes128-gcm@openssh.com"      => "aes-128-gcm",
-
       "none"                        => "none",
     }
 

data/lib/net/ssh/transport/packet_stream.rb

@@ -14,6 +14,8 @@ module Net; module SSH; module Transport
   # per the SSH2 protocol. It also adds an abstraction for polling packets,
   # to allow for both blocking and non-blocking reads.
   module PacketStream
+    PROXY_COMMAND_HOST_IP = '<no hostip for proxy command>'.freeze
+
     include BufferedIo
 
     def self.extended(object)
@@ -64,7 +66,7 @@ module Net; module SSH; module Transport
           addr = getpeername
           Socket.getnameinfo(addr, Socket::NI_NUMERICHOST | Socket::NI_NUMERICSERV).first
         else
-          "<no hostip for proxy command>"
+          PROXY_COMMAND_HOST_IP
         end
     end
     

data/lib/net/ssh/transport/session.rb

@@ -93,11 +93,16 @@ module Net; module SSH; module Transport
       @host_as_string ||= begin
         string = "#{host}"
         string = "[#{string}]:#{port}" if port != DEFAULT_PORT
-        if socket.peer_ip != host
-          string2 = socket.peer_ip
+
+        peer_ip = socket.peer_ip
+
+        if peer_ip != Net::SSH::Transport::PacketStream::PROXY_COMMAND_HOST_IP &&
+           peer_ip != host
+          string2 = peer_ip
           string2 = "[#{string2}]:#{port}" if port != DEFAULT_PORT
           string << "," << string2
         end
+
         string
       end
     end

data/lib/net/ssh/version.rb

@@ -16,15 +16,15 @@ module Net; module SSH
 
     # A convenience method for instantiating a new Version instance with the
     # given +major+, +minor+, and +tiny+ components.
-    def self.[](major, minor, tiny)
-      new(major, minor, tiny)
+    def self.[](major, minor, tiny, pre = nil)
+      new(major, minor, tiny, pre)
     end
 
     attr_reader :major, :minor, :tiny
 
     # Create a new Version object with the given components.
-    def initialize(major, minor, tiny)
-      @major, @minor, @tiny = major, minor, tiny
+    def initialize(major, minor, tiny, pre = nil)
+      @major, @minor, @tiny, @pre = major, minor, tiny, pre
     end
 
     # Compare this version to the given +version+ object.
@@ -35,7 +35,7 @@ module Net; module SSH
     # Converts this version object to a string, where each of the three
     # version components are joined by the '.' character. E.g., 2.0.0.
     def to_s
-      @to_s ||= [@major, @minor, @tiny].join(".")
+      @to_s ||= [@major, @minor, @tiny, @pre].compact.join(".")
     end
 
     # Converts this version to a canonical integer that may be compared
@@ -51,10 +51,14 @@ module Net; module SSH
     MINOR = 9
 
     # The tiny component of this version of the Net::SSH library
-    TINY  = 1
+    TINY  = 2
+
+    # The prerelease component of this version of the Net::SSH library 
+    # nil allowed
+    PRE   = nil
 
     # The current version of the Net::SSH library as a Version instance
-    CURRENT = new(MAJOR, MINOR, TINY)
+    CURRENT = new(*[MAJOR, MINOR, TINY, PRE].compact)
 
     # The current version of the Net::SSH library as a String
     STRING = CURRENT.to_s