net-ssh 6.3.0.beta1 → 7.0.1

data/lib/net/ssh/buffer.rb

@@ -70,7 +70,7 @@ module Net
 
       # Creates a new buffer, initialized to the given content. The position
       # is initialized to the beginning of the buffer.
-      def initialize(content=String.new)
+      def initialize(content = String.new)
         @content = content.to_s
         @position = 0
       end
@@ -128,7 +128,7 @@ module Net
       # would otherwise tend to grow without bound.
       #
       # Returns the buffer object itself.
-      def consume!(n=position)
+      def consume!(n = position)
         if n >= length
           # optimize for a fairly common case
           clear!
@@ -171,7 +171,7 @@ module Net
       # Reads and returns the next +count+ bytes from the buffer, starting from
       # the read position. If +count+ is +nil+, this will return all remaining
       # text in the buffer. This method will increment the pointer.
-      def read(count=nil)
+      def read(count = nil)
         count ||= length
         count = length - @position if @position + count > length
         @position += count
@@ -180,7 +180,7 @@ module Net
 
       # Reads (as #read) and returns the given number of bytes from the buffer,
       # and then consumes (as #consume!) all data up to the new read position.
-      def read!(count=nil)
+      def read!(count = nil)
         data = read(count)
         consume!
         data
@@ -283,6 +283,8 @@ module Net
             key.iqmp = iqmp
           end
           key
+        when /^ecdsa\-sha2\-(\w*)$/
+          OpenSSL::PKey::EC.read_keyblob($1, self)
         else
           raise Exception, "Cannot decode private key of type #{type}"
         end
@@ -295,29 +297,42 @@ module Net
         when /^(.*)-cert-v01@openssh\.com$/
           key = Net::SSH::Authentication::Certificate.read_certblob(self, $1)
         when /^ssh-dss$/
-          key = OpenSSL::PKey::DSA.new
-          if key.respond_to?(:set_pqg)
-            key.set_pqg(read_bignum, read_bignum, read_bignum)
-          else
-            key.p = read_bignum
-            key.q = read_bignum
-            key.g = read_bignum
-          end
-          if key.respond_to?(:set_key)
-            key.set_key(read_bignum, nil)
-          else
-            key.pub_key = read_bignum
-          end
+          p = read_bignum
+          q = read_bignum
+          g = read_bignum
+          pub_key = read_bignum
+
+          asn1 = OpenSSL::ASN1::Sequence.new(
+            [
+              OpenSSL::ASN1::Sequence.new(
+                [
+                  OpenSSL::ASN1::ObjectId.new('DSA'),
+                  OpenSSL::ASN1::Sequence.new(
+                    [
+                      OpenSSL::ASN1::Integer.new(p),
+                      OpenSSL::ASN1::Integer.new(q),
+                      OpenSSL::ASN1::Integer.new(g)
+                    ]
+                  )
+                ]
+              ),
+              OpenSSL::ASN1::BitString.new(OpenSSL::ASN1::Integer.new(pub_key).to_der)
+            ]
+          )
+
+          key = OpenSSL::PKey::DSA.new(asn1.to_der)
         when /^ssh-rsa$/
-          key = OpenSSL::PKey::RSA.new
-          if key.respond_to?(:set_key)
-            e = read_bignum
-            n = read_bignum
-            key.set_key(n, e, nil)
-          else
-            key.e = read_bignum
-            key.n = read_bignum
-          end
+          e = read_bignum
+          n = read_bignum
+
+          asn1 = OpenSSL::ASN1::Sequence(
+            [
+              OpenSSL::ASN1::Integer(n),
+              OpenSSL::ASN1::Integer(e)
+            ]
+          )
+
+          key = OpenSSL::PKey::RSA.new(asn1.to_der)
         when /^ssh-ed25519$/
           Net::SSH::Authentication::ED25519Loader.raiseUnlessLoaded("unsupported key type `#{type}'")
           key = Net::SSH::Authentication::ED25519::PubKey.read_keyblob(self)

data/lib/net/ssh/buffered_io.rb

@@ -51,7 +51,7 @@ module Net
       # Called when the #extend is called on an object, with this module as the
       # argument. It ensures that the modules instance variables are all properly
       # initialized.
-      def self.extended(object) #:nodoc:
+      def self.extended(object) # :nodoc:
         # need to use __send__ because #send is overridden in Socket
         object.__send__(:initialize_buffered_io)
       end
@@ -59,7 +59,7 @@ module Net
       # Tries to read up to +n+ bytes of data from the remote end, and appends
       # the data to the input buffer. It returns the number of bytes read, or 0
       # if no data was available to be read.
-      def fill(n=8192)
+      def fill(n = 8192)
         input.consume!
         data = recv(n)
         debug { "read #{data.length} bytes" }
@@ -72,7 +72,7 @@ module Net
 
       # Read up to +length+ bytes from the input buffer. If +length+ is nil,
       # all available data is read from the buffer. (See #available.)
-      def read_available(length=nil)
+      def read_available(length = nil)
         input.read(length || available)
       end
 
@@ -121,11 +121,11 @@ module Net
 
       public # these methods are primarily for use in tests
 
-      def write_buffer #:nodoc:
+      def write_buffer # :nodoc:
         output.to_s
       end
 
-      def read_buffer #:nodoc:
+      def read_buffer # :nodoc:
         input.to_s
       end
 
@@ -166,7 +166,7 @@ module Net
     #    http://github.com/net-ssh/net-ssh/tree/portfwfix
     #
     module ForwardedBufferedIo
-      def fill(n=8192)
+      def fill(n = 8192)
         begin
           super(n)
         rescue Errno::ECONNRESET => e

data/lib/net/ssh/config.rb

@@ -65,7 +65,7 @@ module Net
         # given +files+ (defaulting to the list of files returned by
         # #default_files), translates the resulting hash into the options
         # recognized by Net::SSH, and returns them.
-        def for(host, files=expandable_default_files)
+        def for(host, files = expandable_default_files)
           translate(files.inject({}) { |settings, file|
             load(file, host, settings)
           })
@@ -77,7 +77,7 @@ module Net
         # ones. Returns a hash containing the OpenSSH options. (See
         # #translate for how to convert the OpenSSH options into Net::SSH
         # options.)
-        def load(path, host, settings={}, base_dir = nil)
+        def load(path, host, settings = {}, base_dir = nil)
           file = File.expand_path(path)
           base_dir ||= File.dirname(file)
           return settings unless File.readable?(file)
@@ -317,7 +317,7 @@ module Net
           tail = pattern
           prefix = String.new
           while !tail.empty? do
-            head,sep,tail = tail.partition(/[\*\?]/)
+            head, sep, tail = tail.partition(/[\*\?]/)
             prefix = prefix + Regexp.quote(head)
             case sep
             when '*'
@@ -371,7 +371,7 @@ module Net
 
           conditions = conditions.each_slice(2)
           condition_matches = []
-          conditions.each do |(kind,exprs)|
+          conditions.each do |(kind, exprs)|
             exprs = unquote(exprs)
 
             case kind.downcase

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

@@ -96,12 +96,12 @@ module Net
         # The output buffer for this channel. Data written to the channel is
         # enqueued here, to be written as CHANNEL_DATA packets during each pass of
         # the event loop. See Connection::Session#process and #enqueue_pending_output.
-        attr_reader :output #:nodoc:
+        attr_reader :output # :nodoc:
 
         # The list of pending requests. Each time a request is sent which requires
         # a reply, the corresponding callback is pushed onto this queue. As responses
         # arrive, they are shifted off the front and handled.
-        attr_reader :pending_requests #:nodoc:
+        attr_reader :pending_requests # :nodoc:
 
         # Instantiates a new channel on the given connection, of the given type,
         # and with the given id. If a block is given, it will be remembered until
@@ -217,7 +217,7 @@ module Net
         #       puts "could not obtain pty"
         #     end
         #   end
-        def request_pty(opts={}, &block)
+        def request_pty(opts = {}, &block)
           extra = opts.keys - VALID_PTY_OPTIONS.keys
           raise ArgumentError, "invalid option(s) to request_pty: #{extra.inspect}" if extra.any?
 
@@ -230,9 +230,9 @@ module Net
           modes.write_byte(0)
 
           send_channel_request("pty-req", :string, opts[:term],
-            :long, opts[:chars_wide], :long, opts[:chars_high],
-            :long, opts[:pixels_wide], :long, opts[:pixels_high],
-            :string, modes.to_s, &block)
+                               :long, opts[:chars_wide], :long, opts[:chars_high],
+                               :long, opts[:pixels_wide], :long, opts[:pixels_high],
+                               :string, modes.to_s, &block)
         end
 
         # Sends data to the channel's remote endpoint. This usually has the
@@ -490,8 +490,8 @@ module Net
           fail "Channel open not yet confirmed, please call send_channel_request(or exec) from block of open_channel" unless remote_id
 
           msg = Buffer.from(:byte, CHANNEL_REQUEST,
-            :long, remote_id, :string, request_name,
-            :bool, !callback.nil?, *data)
+                            :long, remote_id, :string, request_name,
+                            :bool, !callback.nil?, *data)
           connection.send_message(msg)
           pending_requests << callback if callback
         end
@@ -503,7 +503,7 @@ module Net
         # #do_open_confirmation). This is called automatically by #process, which
         # is called from the event loop (Connection::Session#process). You will
         # generally not need to invoke it directly.
-        def enqueue_pending_output #:nodoc:
+        def enqueue_pending_output # :nodoc:
           return unless remote_id
 
           while output.length > 0
@@ -527,7 +527,7 @@ module Net
         # packet sizes, respectively. If an open-confirmation callback was
         # given when the channel was created, it is invoked at this time with
         # the channel itself as the sole argument.
-        def do_open_confirmation(remote_id, max_window, max_packet) #:nodoc:
+        def do_open_confirmation(remote_id, max_window, max_packet) # :nodoc:
           @remote_id = remote_id
           @remote_window_size = @remote_maximum_window_size = max_window
           @remote_maximum_packet_size = max_packet
@@ -553,7 +553,7 @@ module Net
         # causes the remote window size to be adjusted upwards by the given
         # number of bytes. This has the effect of allowing more data to be sent
         # from the local end to the remote end of the channel.
-        def do_window_adjust(bytes) #:nodoc:
+        def do_window_adjust(bytes) # :nodoc:
           @remote_maximum_window_size += bytes
           @remote_window_size += bytes
         end
@@ -566,7 +566,7 @@ module Net
         # CHANNEL_SUCCESS, unless the callback raised ChannelRequestFailed. The
         # callback should accept the channel as the first argument, and the
         # request-specific data as the second.
-        def do_request(request, want_reply, data) #:nodoc:
+        def do_request(request, want_reply, data) # :nodoc:
           result = true
 
           begin
@@ -587,7 +587,7 @@ module Net
         # but does not actually throttle requests that come in illegally when
         # the window size is too small. The callback is invoked with the channel
         # as the first argument, and the data as the second.
-        def do_data(data) #:nodoc:
+        def do_data(data) # :nodoc:
           update_local_window_size(data.length)
           @on_data.call(self, data) if @on_data
         end
@@ -686,7 +686,6 @@ module Net
         #
         #   channel.set_remote_env foo: 'bar', baz: 'whale'
         def set_remote_env(env)
-          env.each { |key, value| puts "E:#{key} V:#{value}" }
           env.each { |key, value| self.env(key, value) }
         end
       end

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

@@ -12,7 +12,7 @@ module Net
       class EventLoop
         include Loggable
 
-        def initialize(logger=nil)
+        def initialize(logger = nil)
           self.logger = logger
           @sessions = []
         end
@@ -60,7 +60,7 @@ module Net
           w = []
           minwait = nil
           @sessions.each do |session|
-            sr,sw,actwait = session.ev_do_calculate_rw_wait(wait)
+            sr, sw, actwait = session.ev_do_calculate_rw_wait(wait)
             minwait = actwait if actwait && (minwait.nil? || actwait < minwait)
             r.push(*sr)
             w.push(*sw)
@@ -75,18 +75,18 @@ module Net
           if readers
             readers.each do |reader|
               session = owners[reader]
-              (fired_sessions[session] ||= { r: [],w: [] })[:r] << reader
+              (fired_sessions[session] ||= { r: [], w: [] })[:r] << reader
             end
           end
           if writers
             writers.each do |writer|
               session = owners[writer]
-              (fired_sessions[session] ||= { r: [],w: [] })[:w] << writer
+              (fired_sessions[session] ||= { r: [], w: [] })[:w] << writer
             end
           end
 
-          fired_sessions.each do |s,rw|
-            s.ev_do_handle_events(rw[:r],rw[:w])
+          fired_sessions.each do |s, rw|
+            s.ev_do_handle_events(rw[:r], rw[:w])
           end
 
           @sessions.each { |s| s.ev_do_postprocess(fired_sessions.key?(s)) }
@@ -111,10 +111,10 @@ module Net
           raise "Only one session expected" unless @sessions.count == 1
 
           session = @sessions.first
-          sr,sw,actwait = session.ev_do_calculate_rw_wait(wait)
+          sr, sw, actwait = session.ev_do_calculate_rw_wait(wait)
           readers, writers, = IO.select(sr, sw, nil, actwait)
 
-          session.ev_do_handle_events(readers,writers)
+          session.ev_do_handle_events(readers, writers)
           session.ev_do_postprocess(!((readers.nil? || readers.empty?) && (writers.nil? || writers.empty?)))
         end
       end

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

@@ -41,17 +41,17 @@ module Net
         attr_reader :properties
 
         # The map of channels, each key being the local-id for the channel.
-        attr_reader :channels #:nodoc:
+        attr_reader :channels # :nodoc:
 
         # The map of listeners that the event loop knows about. See #listen_to.
-        attr_reader :listeners #:nodoc:
+        attr_reader :listeners # :nodoc:
 
         # The map of specialized handlers for opening specific channel types. See
         # #on_open_channel.
-        attr_reader :channel_open_handlers #:nodoc:
+        attr_reader :channel_open_handlers # :nodoc:
 
         # The list of callbacks for pending requests. See #send_global_request.
-        attr_reader :pending_requests #:nodoc:
+        attr_reader :pending_requests # :nodoc:
 
         class NilChannel
           def initialize(session)
@@ -65,7 +65,7 @@ module Net
 
         # Create a new connection service instance atop the given transport
         # layer. Initializes the listeners to be only the underlying socket object.
-        def initialize(transport, options={})
+        def initialize(transport, options = {})
           self.logger = transport.logger
 
           @transport = transport
@@ -149,7 +149,7 @@ module Net
         # to be run.
         #
         #   ssh.loop { ssh.busy? }
-        def busy?(include_invisible=false)
+        def busy?(include_invisible = false)
           if include_invisible
             channels.any?
           else
@@ -174,7 +174,7 @@ module Net
         #   int_pressed = false
         #   trap("INT") { int_pressed = true }
         #   ssh.loop(0.1) { not int_pressed }
-        def loop(wait=nil, &block)
+        def loop(wait = nil, &block)
           running = block || Proc.new { busy? }
           loop_forever { break unless process(wait, &running) }
           begin
@@ -222,7 +222,7 @@ module Net
         #     connections.delete_if { |ssh| !ssh.process(0.1, &condition) }
         #     break if connections.empty?
         #   end
-        def process(wait=nil, &block)
+        def process(wait = nil, &block)
           @event_loop.process(wait, &block)
         rescue StandardError
           force_channel_cleanup_on_close if closed?
@@ -255,7 +255,7 @@ module Net
         def ev_do_calculate_rw_wait(wait)
           r = listeners.keys
           w = r.select { |w2| w2.respond_to?(:pending_write?) && w2.pending_write? }
-          [r,w,io_select_wait(wait)]
+          [r, w, io_select_wait(wait)]
         end
 
         # This is called internally as part of #process.
@@ -335,13 +335,13 @@ module Net
         #   end
         #
         #   channel.wait
-        def open_channel(type="session", *extra, &on_confirm)
+        def open_channel(type = "session", *extra, &on_confirm)
           local_id = get_next_channel_id
 
           channel = Channel.new(self, type, local_id, @max_pkt_size, @max_win_size, &on_confirm)
           msg = Buffer.from(:byte, CHANNEL_OPEN, :string, type, :long, local_id,
-            :long, channel.local_maximum_window_size,
-            :long, channel.local_maximum_packet_size, *extra)
+                            :long, channel.local_maximum_window_size,
+                            :long, channel.local_maximum_packet_size, *extra)
           send_message(msg)
 
           channels[local_id] = channel
@@ -382,7 +382,7 @@ module Net
               raise "could not execute command: #{command.inspect}" unless success
 
               if status
-                channel.on_request("exit-status") do |ch2,data|
+                channel.on_request("exit-status") do |ch2, data|
                   status[:exit_code] = data.read_long
                 end
 

data/lib/net/ssh/errors.rb

@@ -45,10 +45,10 @@ module Net
     # the remember_host! method on the exception, and then retry.
     class HostKeyError < Net::SSH::Exception
       # the callback to use when #remember_host! is called
-      attr_writer :callback #:nodoc:
+      attr_writer :callback # :nodoc:
 
       # situation-specific data describing the host (see #host, #port, etc.)
-      attr_writer :data #:nodoc:
+      attr_writer :data # :nodoc:
 
       # An accessor for getting at the data that was used to look up the host
       # (see also #fingerprint, #host, #port, #ip, and #key).

data/lib/net/ssh/key_factory.rb

@@ -17,14 +17,14 @@ module Net
     class KeyFactory
       # Specifies the mapping of SSH names to OpenSSL key classes.
       MAP = {
-        'dh'    => OpenSSL::PKey::DH,
-        'rsa'   => OpenSSL::PKey::RSA,
-        'dsa'   => OpenSSL::PKey::DSA,
+        'dh' => OpenSSL::PKey::DH,
+        'rsa' => OpenSSL::PKey::RSA,
+        'dsa' => OpenSSL::PKey::DSA,
         'ecdsa' => OpenSSL::PKey::EC
       }
       MAP["ed25519"] = Net::SSH::Authentication::ED25519::PrivKey if defined? Net::SSH::Authentication::ED25519
 
-      class <<self
+      class << self
         # Fetch an OpenSSL key instance by its SSH name. It will be a new,
         # empty key of the given type.
         def get(name)
@@ -36,7 +36,7 @@ module Net
         # appropriately. The new key is returned. If the key itself is
         # encrypted (requiring a passphrase to use), the user will be
         # prompted to enter their password unless passphrase works.
-        def load_private_key(filename, passphrase=nil, ask_passphrase=true, prompt=Prompt.default)
+        def load_private_key(filename, passphrase = nil, ask_passphrase = true, prompt = Prompt.default)
           data = File.read(File.expand_path(filename))
           load_data_private_key(data, passphrase, ask_passphrase, filename, prompt)
         end
@@ -46,7 +46,7 @@ module Net
         # appropriately. The new key is returned. If the key itself is
         # encrypted (requiring a passphrase to use), the user will be
         # prompted to enter their password unless passphrase works.
-        def load_data_private_key(data, passphrase=nil, ask_passphrase=true, filename="", prompt=Prompt.default)
+        def load_data_private_key(data, passphrase = nil, ask_passphrase = true, filename = "", prompt = Prompt.default)
           key_type = classify_key(data, filename)
 
           encrypted_key = nil
@@ -86,7 +86,7 @@ module Net
         # Loads a public key. It will correctly determine whether
         # the file describes an RSA or DSA key, and will load it
         # appropriately. The new public key is returned.
-        def load_data_public_key(data, filename="")
+        def load_data_public_key(data, filename = "")
           fields = data.split(/ /)
 
           blob = nil

data/lib/net/ssh/known_hosts.rb

@@ -1,6 +1,7 @@
 require 'strscan'
 require 'openssl'
 require 'base64'
+require 'delegate'
 require 'net/ssh/buffer'
 require 'net/ssh/authentication/ed25519_loader'
 
@@ -105,10 +106,10 @@ module Net
 
       SUPPORTED_TYPE.push('ssh-ed25519') if Net::SSH::Authentication::ED25519Loader::LOADED
 
-      class <<self
+      class << self
         # Searches all known host files (see KnownHosts.hostfiles) for all keys
         # of the given host. Returns an enumerable of keys found.
-        def search_for(host, options={})
+        def search_for(host, options = {})
           HostKeys.new(search_in(hostfiles(options), host, options), host, self, options)
         end
 
@@ -127,7 +128,7 @@ module Net
         #
         # If you only want the user known host files, you can pass :user as
         # the second option.
-        def hostfiles(options, which=:all)
+        def hostfiles(options, which = :all)
           files = []
 
           files += Array(options[:user_known_hosts_file] || %w[~/.ssh/known_hosts ~/.ssh/known_hosts2]) if which == :all || which == :user
@@ -142,7 +143,7 @@ module Net
         # Looks in all user known host files (see KnownHosts.hostfiles) and tries to
         # add an entry for the given host and key to the first file it is able
         # to.
-        def add(host, key, options={})
+        def add(host, key, options = {})
           hostfiles(options, :user).each do |file|
             KnownHosts.new(file).add(host, key)
             return

data/lib/net/ssh/prompt.rb

@@ -38,7 +38,7 @@ module Net
 
         # ask input from user, a prompter might ask for multiple inputs
         # (like user and password) in a single session.
-        def ask(prompt, echo=true)
+        def ask(prompt, echo = true)
           $stdout.print(prompt)
           $stdout.flush
           ret = $stdin.noecho(&:gets).chomp

data/lib/net/ssh/proxy/http.rb

@@ -40,7 +40,7 @@ module Net
         #
         # * :user => the user name to use when authenticating to the proxy
         # * :password => the password to use when authenticating
-        def initialize(proxy_host, proxy_port=80, options={})
+        def initialize(proxy_host, proxy_port = 80, options = {})
           @proxy_host = proxy_host
           @proxy_port = proxy_port
           @options = options

data/lib/net/ssh/proxy/https.rb

@@ -16,7 +16,7 @@ module Net
         # taken by Net::SSH::Proxy::HTTP it supports:
         #
         # * :ssl_context => the SSL configuration to use for the connection
-        def initialize(proxy_host, proxy_port=80, options={})
+        def initialize(proxy_host, proxy_port = 80, options = {})
           @ssl_context = options.delete(:ssl_context) ||
                            OpenSSL::SSL::SSLContext.new
           super(proxy_host, proxy_port, options)
@@ -27,7 +27,7 @@ module Net
         # Shim to make OpenSSL::SSL::SSLSocket behave like a regular TCPSocket
         # for all intents and purposes of Net::SSH::BufferedIo
         module SSLSocketCompatibility
-          def self.extended(object) #:nodoc:
+          def self.extended(object) # :nodoc:
             object.define_singleton_method(:recv, object.method(:sysread))
             object.sync_close = true
           end

data/lib/net/ssh/proxy/socks4.rb

@@ -37,7 +37,7 @@ module Net
         # Create a new proxy connection to the given proxy host and port.
         # Optionally, a :user key may be given to identify the username
         # with which to authenticate.
-        def initialize(proxy_host, proxy_port=1080, options={})
+        def initialize(proxy_host, proxy_port = 1080, options = {})
           @proxy_host = proxy_host
           @proxy_port = proxy_port
           @options = options

data/lib/net/ssh/proxy/socks5.rb

@@ -52,7 +52,7 @@ module Net
         # Create a new proxy connection to the given proxy host and port.
         # Optionally, :user and :password options may be given to
         # identify the username and password with which to authenticate.
-        def initialize(proxy_host, proxy_port=1080, options={})
+        def initialize(proxy_host, proxy_port = 1080, options = {})
           @proxy_host = proxy_host
           @proxy_port = proxy_port
           @options = options

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

@@ -17,7 +17,7 @@ module Net
         attr_reader :session
 
         # A simple class for representing a requested remote forwarded port.
-        Remote = Struct.new(:host, :port) #:nodoc:
+        Remote = Struct.new(:host, :port) # :nodoc:
 
         # Instantiates a new Forward service instance atop the given connection
         # service session. This will register new channel open handlers to handle
@@ -105,7 +105,7 @@ module Net
         #
         #   ssh.forward.cancel_local(1234)
         #   ssh.forward.cancel_local(1234, "0.0.0.0")
-        def cancel_local(port, bind_address="127.0.0.1")
+        def cancel_local(port, bind_address = "127.0.0.1")
           socket = @local_forwarded_ports.delete([port, bind_address])
           socket.shutdown rescue nil
           socket.close rescue nil
@@ -214,7 +214,7 @@ module Net
         #     raise Net::SSH::Exception, "remote forwarding request failed"
         #   end
         #
-        def remote(port, host, remote_port, remote_host="127.0.0.1")
+        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
@@ -248,7 +248,7 @@ module Net
         #
         #   ssh.forward.cancel_remote(1234, "0.0.0.0")
         #   ssh.loop { ssh.forward.active_remotes.include?([1234, "0.0.0.0"]) }
-        def cancel_remote(port, host="127.0.0.1")
+        def cancel_remote(port, host = "127.0.0.1")
           session.send_global_request("cancel-tcpip-forward", :string, host, :long, port) do |success, response|
             if success
               @remote_forwarded_ports.delete([port, host])

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

@@ -65,7 +65,7 @@ module Net
         # be scripted.
         #
         #   channel.sends_exec "ls -l"
-        def sends_exec(command, reply=true, success=true)
+        def sends_exec(command, reply = true, success = true)
           script.sends_channel_request(self, "exec", reply, command, success)
         end
 
@@ -74,7 +74,7 @@ module Net
         # and +success+ arguments.
         #
         #   channel.sends_subsystem "sftp"
-        def sends_subsystem(subsystem, reply=true, success=true)
+        def sends_subsystem(subsystem, reply = true, success = true)
           script.sends_channel_request(self, "subsystem", reply, subsystem, success)
         end
 
@@ -124,7 +124,7 @@ module Net
         # Scripts the reception of an "exit-status" channel request packet.
         #
         #   channel.gets_exit_status(127)
-        def gets_exit_status(status=0)
+        def gets_exit_status(status = 0)
           script.gets_channel_request(self, "exit-status", false, status)
         end