net-ssh 4.2.0 → 7.0.1

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

@@ -5,40 +5,42 @@ require 'net/ssh/transport/algorithms'
 require 'net/ssh/transport/constants'
 require 'net/ssh/transport/kex'
 
-module Net; module SSH; module Test
-
-  # An implementation of a key-exchange strategy specifically for unit tests.
-  # (This strategy would never really work against a real SSH server--it makes
-  # too many assumptions about the server's response.)
-  #
-  # This registers itself with the transport key-exchange system as the
-  # "test" algorithm.
-  class Kex
-    include Net::SSH::Transport::Constants
-
-    # Creates a new instance of the testing key-exchange algorithm with the
-    # given arguments.
-    def initialize(algorithms, connection, data)
-      @connection = connection
-    end
-
-    # Exchange keys with the server. This returns a hash of constant values,
-    # and does not actually exchange keys.
-    def exchange_keys
-      result = Net::SSH::Buffer.from(:byte, NEWKEYS)
-      @connection.send_message(result)
-
-      buffer = @connection.next_message
-      raise Net::SSH::Exception, "expected NEWKEYS" unless buffer.type == NEWKEYS
-
-      { session_id: "abc-xyz",
-        server_key: OpenSSL::PKey::RSA.new(512),
-        shared_secret: OpenSSL::BN.new("1234567890", 10),
-        hashing_algorithm: OpenSSL::Digest::SHA1 }
+module Net
+  module SSH
+    module Test
+      # An implementation of a key-exchange strategy specifically for unit tests.
+      # (This strategy would never really work against a real SSH server--it makes
+      # too many assumptions about the server's response.)
+      #
+      # This registers itself with the transport key-exchange system as the
+      # "test" algorithm.
+      class Kex
+        include Net::SSH::Transport::Constants
+
+        # Creates a new instance of the testing key-exchange algorithm with the
+        # given arguments.
+        def initialize(algorithms, connection, data)
+          @connection = connection
+        end
+
+        # Exchange keys with the server. This returns a hash of constant values,
+        # and does not actually exchange keys.
+        def exchange_keys
+          result = Net::SSH::Buffer.from(:byte, NEWKEYS)
+          @connection.send_message(result)
+
+          buffer = @connection.next_message
+          raise Net::SSH::Exception, "expected NEWKEYS" unless buffer.type == NEWKEYS
+
+          { session_id: "abc-xyz",
+            server_key: OpenSSL::PKey::RSA.new(512),
+            shared_secret: OpenSSL::BN.new("1234567890", 10),
+            hashing_algorithm: OpenSSL::Digest::SHA1 }
+        end
+      end
     end
   end
-
-end; end; end
+end
 
 Net::SSH::Transport::Algorithms::ALGORITHMS[:kex] << "test"
 Net::SSH::Transport::Kex::MAP["test"] = Net::SSH::Test::Kex

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

@@ -1,51 +1,53 @@
 require 'net/ssh/packet'
 require 'net/ssh/test/packet'
 
-module Net; module SSH; module Test
-
-  # This is a specialization of Net::SSH::Test::Packet for representing mock
-  # packets that are sent from the local (client) host. These are created
-  # automatically by Net::SSH::Test::Script and Net::SSH::Test::Channel by any
-  # of the sends_* methods.
-  class LocalPacket < Packet
-    attr_reader :init
-
-    # Extend the default Net::SSH::Test::Packet constructor to also accept an
-    # optional block, which is used to finalize the initialization of the
-    # packet when #process is first called.
-    def initialize(type, *args, &block)
-      super(type, *args)
-      @init = block
-    end
-
-    # Returns +true+; this is a local packet.
-    def local?
-      true
-    end
-
-    # Called by Net::SSH::Test::Extensions::PacketStream#test_enqueue_packet
-    # to mimic remote processing of a locally-sent packet. It compares the
-    # packet it was given with the contents of this LocalPacket's data, to see
-    # if what was sent matches what was scripted. If it differs in any way,
-    # an exception is raised.
-    def process(packet)
-      @init.call(Net::SSH::Packet.new(packet.to_s)) if @init
-      type = packet.read_byte
-      raise "expected #{@type}, but got #{type}" if @type != type
-
-      @data.zip(types).each do |expected, _type|
-        _type ||= case expected
-          when nil then break
-          when Numeric then :long
-          when String then :string
-          when TrueClass, FalseClass then :bool
+module Net
+  module SSH
+    module Test
+      # This is a specialization of Net::SSH::Test::Packet for representing mock
+      # packets that are sent from the local (client) host. These are created
+      # automatically by Net::SSH::Test::Script and Net::SSH::Test::Channel by any
+      # of the sends_* methods.
+      class LocalPacket < Packet
+        attr_reader :init
+
+        # Extend the default Net::SSH::Test::Packet constructor to also accept an
+        # optional block, which is used to finalize the initialization of the
+        # packet when #process is first called.
+        def initialize(type, *args, &block)
+          super(type, *args)
+          @init = block
+        end
+
+        # Returns +true+; this is a local packet.
+        def local?
+          true
+        end
+
+        # Called by Net::SSH::Test::Extensions::PacketStream#test_enqueue_packet
+        # to mimic remote processing of a locally-sent packet. It compares the
+        # packet it was given with the contents of this LocalPacket's data, to see
+        # if what was sent matches what was scripted. If it differs in any way,
+        # an exception is raised.
+        def process(packet)
+          @init.call(Net::SSH::Packet.new(packet.to_s)) if @init
+          type = packet.read_byte
+          raise "expected #{@type}, but got #{type}" if @type != type
+
+          @data.zip(types).each do |expected, _type|
+            _type ||= case expected
+                      when nil then break
+                      when Numeric then :long
+                      when String then :string
+                      when TrueClass, FalseClass then :bool
+                      end
+
+            actual = packet.send("read_#{_type}")
+            next if expected.nil?
+            raise "expected #{_type} #{expected.inspect} but got #{actual.inspect}" unless expected == actual
           end
-
-        actual = packet.send("read_#{_type}")
-        next if expected.nil?
-        raise "expected #{_type} #{expected.inspect} but got #{actual.inspect}" unless expected == actual
+        end
       end
     end
   end
-
-end; end; end
+end

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

@@ -1,98 +1,101 @@
 require 'net/ssh/connection/constants'
 require 'net/ssh/transport/constants'
 
-module Net; module SSH; module Test
+module Net
+  module SSH
+    module Test
+      # This is an abstract class, not to be instantiated directly, subclassed by
+      # Net::SSH::Test::LocalPacket and Net::SSH::Test::RemotePacket. It implements
+      # functionality common to those subclasses.
+      #
+      # These packets are not true packets, in that they don't represent what was
+      # actually sent between the hosst; rather, they represent what was expected
+      # to be sent, as dictated by the script (Net::SSH::Test::Script). Thus,
+      # though they are defined with data elements, these data elements are used
+      # to either validate data that was sent by the local host (Net::SSH::Test::LocalPacket)
+      # or to mimic the sending of data by the remote host (Net::SSH::Test::RemotePacket).
+      class Packet
+        include Net::SSH::Transport::Constants
+        include Net::SSH::Connection::Constants
 
-  # This is an abstract class, not to be instantiated directly, subclassed by
-  # Net::SSH::Test::LocalPacket and Net::SSH::Test::RemotePacket. It implements
-  # functionality common to those subclasses.
-  #
-  # These packets are not true packets, in that they don't represent what was
-  # actually sent between the hosst; rather, they represent what was expected
-  # to be sent, as dictated by the script (Net::SSH::Test::Script). Thus,
-  # though they are defined with data elements, these data elements are used
-  # to either validate data that was sent by the local host (Net::SSH::Test::LocalPacket)
-  # or to mimic the sending of data by the remote host (Net::SSH::Test::RemotePacket).
-  class Packet
-    include Net::SSH::Transport::Constants
-    include Net::SSH::Connection::Constants
+        # Register a custom channel request. extra_parts is an array of types
+        # of extra parameters
+        def self.register_channel_request(request, extra_parts)
+          @registered_requests ||= {}
+          @registered_requests[request] = { extra_parts: extra_parts }
+        end
 
-    # Register a custom channel request. extra_parts is an array of types
-    # of extra parameters
-    def self.register_channel_request(request, extra_parts)
-      @registered_requests ||= {}
-      @registered_requests[request] = {extra_parts: extra_parts}
-    end
+        def self.registered_channel_requests(request)
+          @registered_requests && @registered_requests[request]
+        end
 
-    def self.registered_channel_requests(request)
-      @registered_requests && @registered_requests[request]
-    end
+        # Ceate a new packet of the given +type+, and with +args+ being a list of
+        # data elements in the order expected for packets of the given +type+
+        # (see #types).
+        def initialize(type, *args)
+          @type = self.class.const_get(type.to_s.upcase)
+          @data = args
+        end
 
-    # Ceate a new packet of the given +type+, and with +args+ being a list of
-    # data elements in the order expected for packets of the given +type+
-    # (see #types).
-    def initialize(type, *args)
-      @type = self.class.const_get(type.to_s.upcase)
-      @data = args
-    end
+        # The default for +remote?+ is false. Subclasses should override as necessary.
+        def remote?
+          false
+        end
 
-    # The default for +remote?+ is false. Subclasses should override as necessary.
-    def remote?
-      false
-    end
+        # The default for +local?+ is false. Subclasses should override as necessary.
+        def local?
+          false
+        end
 
-    # The default for +local?+ is false. Subclasses should override as necessary.
-    def local?
-      false
-    end
+        # Instantiates the packets data elements. When the packet was first defined,
+        # some elements may not have been fully realized, and were described as
+        # Proc objects rather than atomic types. This invokes those Proc objects
+        # and replaces them with their returned values. This allows for values
+        # like Net::SSH::Test::Channel#remote_id to be used in scripts before
+        # the remote_id is known (since it is only known after a channel has been
+        # confirmed open).
+        def instantiate!
+          @data.map! { |i| i.respond_to?(:call) ? i.call : i }
+        end
 
-    # Instantiates the packets data elements. When the packet was first defined,
-    # some elements may not have been fully realized, and were described as
-    # Proc objects rather than atomic types. This invokes those Proc objects
-    # and replaces them with their returned values. This allows for values 
-    # like Net::SSH::Test::Channel#remote_id to be used in scripts before
-    # the remote_id is known (since it is only known after a channel has been
-    # confirmed open).
-    def instantiate!
-      @data.map! { |i| i.respond_to?(:call) ? i.call : i }
-    end
+        # Returns an array of symbols describing the data elements for packets of
+        # the same type as this packet. These types are used to either validate
+        # sent packets (Net::SSH::Test::LocalPacket) or build received packets
+        # (Net::SSH::Test::RemotePacket).
+        #
+        # Not all packet types are defined here. As new packet types are required
+        # (e.g., a unit test needs to test that the remote host sent a packet that
+        # is not implemented here), the description of that packet should be
+        # added. Unsupported packet types will otherwise raise an exception.
+        def types
+          @types ||= case @type
+                     when KEXINIT
+                       %i[long long long long
+                          string string string string string string string string string string
+                          bool]
+                     when NEWKEYS then []
+                     when CHANNEL_OPEN then %i[string long long long]
+                     when CHANNEL_OPEN_CONFIRMATION then %i[long long long long]
+                     when CHANNEL_DATA then %i[long string]
+                     when CHANNEL_EXTENDED_DATA then %i[long long string]
+                     when CHANNEL_EOF, CHANNEL_CLOSE, CHANNEL_SUCCESS, CHANNEL_FAILURE then [:long]
+                     when CHANNEL_REQUEST
+                       parts = %i[long string bool]
+                       case @data[1]
+                       when "exec", "subsystem", "shell" then parts << :string
+                       when "exit-status" then parts << :long
+                       when "pty-req" then parts.concat(%i[string long long long long string])
+                       when "env" then parts.contact(%i[string string])
+                       else
+                         request = Packet.registered_channel_requests(@data[1])
+                         raise "don't know what to do about #{@data[1]} channel request" unless request
 
-    # Returns an array of symbols describing the data elements for packets of
-    # the same type as this packet. These types are used to either validate
-    # sent packets (Net::SSH::Test::LocalPacket) or build received packets
-    # (Net::SSH::Test::RemotePacket).
-    #
-    # Not all packet types are defined here. As new packet types are required
-    # (e.g., a unit test needs to test that the remote host sent a packet that
-    # is not implemented here), the description of that packet should be
-    # added. Unsupported packet types will otherwise raise an exception.
-    def types
-      @types ||= case @type
-        when KEXINIT then 
-          [:long, :long, :long, :long,
-           :string, :string, :string, :string, :string, :string, :string, :string, :string, :string,
-           :bool]
-        when NEWKEYS then []
-        when CHANNEL_OPEN then [:string, :long, :long, :long]
-        when CHANNEL_OPEN_CONFIRMATION then [:long, :long, :long, :long]
-        when CHANNEL_DATA then [:long, :string]
-        when CHANNEL_EXTENDED_DATA then [:long, :long, :string]
-        when CHANNEL_EOF, CHANNEL_CLOSE, CHANNEL_SUCCESS, CHANNEL_FAILURE then [:long]
-        when CHANNEL_REQUEST
-          parts = [:long, :string, :bool]
-          case @data[1]
-          when "exec", "subsystem","shell" then parts << :string
-          when "exit-status" then parts << :long
-          when "pty-req" then parts.concat([:string, :long, :long, :long, :long, :string])
-          when "env" then parts.contact([:string,:string])
-          else
-            request = Packet.registered_channel_requests(@data[1])
-            raise "don't know what to do about #{@data[1]} channel request" unless request
-            parts.concat(request[:extra_parts])
-          end
-        else raise "don't know how to parse packet type #{@type}"
+                         parts.concat(request[:extra_parts])
+                       end
+                     else raise "don't know how to parse packet type #{@type}"
+                     end
         end
+      end
     end
   end
-
-end; end; end
+end

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

@@ -1,38 +1,40 @@
 require 'net/ssh/buffer'
 require 'net/ssh/test/packet'
 
-module Net; module SSH; module Test
+module Net
+  module SSH
+    module Test
+      # This is a specialization of Net::SSH::Test::Packet for representing mock
+      # packets that are received by the local (client) host. These are created
+      # automatically by Net::SSH::Test::Script and Net::SSH::Test::Channel by any
+      # of the gets_* methods.
+      class RemotePacket < Packet
+        # Returns +true+; this is a remote packet.
+        def remote?
+          true
+        end
 
-  # This is a specialization of Net::SSH::Test::Packet for representing mock
-  # packets that are received by the local (client) host. These are created
-  # automatically by Net::SSH::Test::Script and Net::SSH::Test::Channel by any
-  # of the gets_* methods.
-  class RemotePacket < Packet
-    # Returns +true+; this is a remote packet.
-    def remote?
-      true
-    end
-
-    # The #process method should only be called on Net::SSH::Test::LocalPacket
-    # packets; if it is attempted on a remote packet, then it is an expectation
-    # mismatch (a remote packet was received when a local packet was expected
-    # to be sent). This will happen when either your test script
-    # (Net::SSH::Test::Script) or your program are wrong.
-    def process(packet)
-      raise "received packet type #{packet.read_byte} and was not expecting any packet"
-    end
+        # The #process method should only be called on Net::SSH::Test::LocalPacket
+        # packets; if it is attempted on a remote packet, then it is an expectation
+        # mismatch (a remote packet was received when a local packet was expected
+        # to be sent). This will happen when either your test script
+        # (Net::SSH::Test::Script) or your program are wrong.
+        def process(packet)
+          raise "received packet type #{packet.read_byte} and was not expecting any packet"
+        end
 
-    # Returns this remote packet as a string, suitable for parsing by 
-    # Net::SSH::Transport::PacketStream and friends. When a remote packet is
-    # received, this method is called and the result concatenated onto the
-    # input buffer for the packet stream.
-    def to_s
-      @to_s ||= begin
-        instantiate!
-        string = Net::SSH::Buffer.from(:byte, @type, *types.zip(@data).flatten).to_s
-        [string.length, string].pack("NA*")
+        # Returns this remote packet as a string, suitable for parsing by
+        # Net::SSH::Transport::PacketStream and friends. When a remote packet is
+        # received, this method is called and the result concatenated onto the
+        # input buffer for the packet stream.
+        def to_s
+          @to_s ||= begin
+            instantiate!
+            string = Net::SSH::Buffer.from(:byte, @type, *types.zip(@data).flatten).to_s
+            [string.length, string].pack("NA*")
+          end
+        end
       end
     end
   end
-
-end; end; end
+end