net-ssh 1.1.4 → 2.0.0

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

@@ -1,72 +0,0 @@
-#--
-# =============================================================================
-# Copyright (c) 2004,2005 Jamis Buck (jamis@37signals.com)
-# All rights reserved.
-#
-# This source file is distributed as part of the Net::SSH Secure Shell Client
-# library for Ruby. This file (and the library as a whole) may be used only as
-# allowed by either the BSD license, or the Ruby license (or, by association
-# with the Ruby license, the GPL). See the "doc" subdirectory of the Net::SSH
-# distribution for the texts of these licenses.
-# -----------------------------------------------------------------------------
-# net-ssh website : http://net-ssh.rubyforge.org
-# project website: http://rubyforge.org/projects/net-ssh
-# =============================================================================
-#++
-
-module Net
-  module SSH
-    module Connection
-
-      # Register the services that define the "connection" layer of the SSH
-      # protocol.
-      def register_services( container )
-
-        # The :connection namespace contains all of the services in the
-        # connection layer of the SSH protocol.
-        container.namespace_define :connection do |ns|
-
-          # The :channel namespace contains the channel-specific services.
-          ns.namespace_define :channel do |ch|
-
-            # The :open service provides a proc object that may be used to
-            # request that a new channel be opened.
-            ch.open do |c,p|
-              require 'net/ssh/connection/channel'
-              lambda do |type, data|
-                Channel.open( c[:driver],
-                              c[:log_for, p],
-                              c[:transport][:buffers],
-                              type, data )
-              end
-            end
-
-            # The :create service provides a proc object that may be used to
-            # create new channels, without sending a request to the server.
-            ch.create do |c,p|
-              require 'net/ssh/connection/channel'
-              lambda do |type,rid,wsize,psize|
-                Channel.create( c[:driver],
-                                c[:log_for, p],
-                                c[:transport][:buffers],
-                                type, rid, wsize, psize )
-              end
-            end
-          end
-
-          # The :driver service manages the connection layer.
-          ns.driver do |c,p|
-            require 'net/ssh/connection/driver'
-            Driver.new( c[:transport][:session],
-                        c[:log_for, p],
-                        c[:transport][:buffers],
-                        :open => c[:channel][:open],
-                        :create => c[:channel][:create] )
-          end
-        end
-      end
-      module_function :register_services
-
-    end
-  end
-end

data/lib/net/ssh/host-key-verifier.rb

@@ -1,52 +0,0 @@
-require 'net/ssh/errors'
-require 'net/ssh/known-hosts'
-
-module Net
-  module SSH
-
-    class HostKeyVerifier
-      def verify(arguments)
-        host = canonize(arguments[:peer])
-        matches = Net::SSH::KnownHosts.search_for(host)
-
-        # we've never seen this host before, so just automatically add the key.
-        # not the most secure option (since the first hit might be the one that
-        # is hacked), but since almost nobody actually compares the key
-        # fingerprint, this is a reasonable compromise between usability and
-        # security.
-        if matches.empty?
-          Net::SSH::KnownHosts.add(host, arguments[:key])
-          return true
-        end
-
-        # If we found any matches, check to see that the key type and
-        # blob also match.
-        found = matches.any? do |key|
-          key.ssh_type == arguments[:key].ssh_type &&
-          key.to_blob  == arguments[:key].to_blob
-        end
-
-        # If a match was found, return true. Otherwise, raise an exception
-        # indicating that the key was not recognized.
-        found || process_cache_miss(host, arguments)
-      end
-
-      private
-
-        def process_cache_miss(host, args)
-          exception = HostKeyMismatch.new("fingerprint #{args[:fingerprint]} does not match for #{host.join(',')}")
-          exception.data = args
-          exception.callback = Proc.new { Net::SSH::KnownHosts.add(host, args[:key]) }
-          raise exception
-        end
-
-        def canonize(peer)
-          hosts = []
-          hosts << Net::SSH::KnownHosts.canonize(peer[:host], peer[:port])
-          hosts << Net::SSH::KnownHosts.canonize(peer[:ip], peer[:port])
-          hosts.compact
-        end
-    end
-
-  end
-end

data/lib/net/ssh/known-hosts.rb

@@ -1,96 +0,0 @@
-require 'strscan'
-require 'net/ssh/transport/ossl/buffer'
-require 'net/ssh/util/openssl'
-
-module Net; module SSH
-  class KnownHosts
-    class <<self
-      def canonize(location, port)
-        value = location
-        value = "[#{value}]:#{port}" if port && port != 22
-        value
-      end
-
-      def search_for(host)
-        search_in(hostfile_locations, host)
-      end
-
-      def add(host, key)
-        hostfile_locations.each do |file|
-          begin
-            KnownHosts.new(file).add(host, key)
-            return
-          rescue SystemCallError
-            # try the next hostfile
-          end
-        end
-      end
-
-      def search_in(files, host)
-        files.map { |file| KnownHosts.new(file).keys_for(host) }.flatten
-      end
-
-      def hostfile_locations
-        @hostfile_locations ||= [
-          "#{home_directory}/.ssh/known_hosts",
-          "#{home_directory}/.ssh/known_hosts2",
-          "/etc/ssh/ssh_known_hosts",
-          "/etc/ssh/ssh_known_hosts2"
-        ]
-      end
-
-      def home_directory
-        ENV['HOME'] ||
-          (ENV['HOMEPATH'] && "#{ENV['HOMEDRIVE']}#{ENV['HOMEPATH']}") ||
-          "/"
-      end
-    end
-
-
-    attr_reader :source
-
-    def initialize(source)
-      @source = source
-    end
-
-    def keys_for(host)
-      keys = []
-      hosts = Array(host)
-
-      File.open(source) do |file|
-        scanner = StringScanner.new("")
-        file.each_line do |line|
-          scanner.string = line
-
-          scanner.skip(/\s*/)
-          next if scanner.match?(/$|#/)
-
-          hostlist = scanner.scan(/\S+/)
-          next if (hostlist.split(/,/) & hosts).empty?
-
-          scanner.skip(/\s*/)
-          type = scanner.scan(/\S+/)
-          scanner.skip(/\s*/)
-          blob = scanner.rest.unpack("m*").first
-          keys << Net::SSH::Transport::OSSL::Buffer.new(blob).read_key
-        end
-      end
-
-      keys
-    rescue SystemCallError
-      return []
-    end
-
-    def add(host, key)
-      dir = File.dirname(source)
-      Dir.mkdir(dir, 0700) if !File.exists?(dir)
-
-      File.open(source, "a") do |file|
-        buffer = Net::SSH::Transport::OSSL::Buffer.new
-        buffer.write_key(key)
-        blob = [buffer.to_s].pack("m*").gsub(/\s/, "")
-        file.puts "#{Array(host).join(',')} #{key.ssh_type} #{blob}"
-      end
-    end
-  end
-end; end

data/lib/net/ssh/lenient-host-key-verifier.rb

@@ -1,25 +0,0 @@
-require 'net/ssh/host-key-verifier'
-
-module Net
-  module SSH
-
-    class LenientHostKeyVerifier < HostKeyVerifier
-      def verify(arguments)
-        return true if tunnelled?(arguments)
-        super
-      end
-
-      private
-
-        # A connection is potentially being tunnelled if the port is not 22,
-        # and the ip refers to the localhost.
-        def tunnelled?(args)
-          return false if args[:peer][:port].to_i == 22
-          
-          ip = args[:peer][:ip]
-          return ip == "127.0.0.1" || ip == "::1"
-        end
-    end
-
-  end
-end

data/lib/net/ssh/null-host-key-verifier.rb

@@ -1,14 +0,0 @@
-module Net
-  module SSH
-
-    # The NullHostKeyVerifier simply allows every key it sees, without
-    # bothering to verify. This mimics the pre-1.1 behavior of Net::SSH, but
-    # is not very secure.
-    class NullHostKeyVerifier
-      def verify(arguments)
-        true
-      end
-    end
-
-  end
-end

data/lib/net/ssh/service/agentforward/driver.rb

@@ -1,78 +0,0 @@
-#--
-# =============================================================================
-# Copyright (c) 2007, Chris Andrews (chris@nodnol.org),
-#   Jamis Buck (jgb3@email.byu.edu)
-# All rights reserved.
-#
-# This source file is distributed as part of the Net::SSH Secure Shell Client
-# library for Ruby. This file (and the library as a whole) may be used only as
-# allowed by either the BSD license, or the Ruby license (or, by association
-# with the Ruby license, the GPL). See the "doc" subdirectory of the Net::SSH
-# distribution for the texts of these licenses.
-# -----------------------------------------------------------------------------
-# net-ssh website : http://net-ssh.rubyforge.org
-# project website: http://rubyforge.org/projects/net-ssh
-# =============================================================================
-#++
-
-module Net
-  module SSH
-    module Service
-      module AgentForward
-
-        class Driver
-
-          def initialize( connection, buffers, log, agent )
-            @connection = connection
-            @buffers = buffers
-            @log = log
-            @agent = agent
-            @data = ''
-
-            @connection.add_channel_open_handler(
-              "auth-agent@openssh.com", &method(:do_open_channel) )
-          end
-
-          def request
-            @connection.channel_request( 'auth-agent-req@openssh.com' )
-          end
-
-          def do_open_channel( connection, channel, data )
-            channel.on_data(&method(:do_data))
-          end
-
-          # handle CHANNEL_DATA packets received on the agent-forward
-          # channel - pass complete received packets to the agent.
-          def do_data( channel, data )
-            @data = @data + data
-            reply = call_agent
-            if reply
-              channel.send_data reply
-              @data = ''
-            end
-          end
-          
-          # Called if we have any data to forward to the
-          # agent. Examines the accumulated data to see if we have a
-          # complete packet, based on the length field (the first four
-          # bytes as a network long).
-          def call_agent
-            # if we have enough data to check the length of this packet
-            if @data.length >= 4
-              packet_length = @data[0..3].unpack('N').first
-              # send the complete packet to the agent and read the
-              # response
-              if @data.length == (4 + packet_length)
-                @agent.send_raw_packet @data
-                buffer = @agent.read_raw_packet
-              end
-            end
-            buffer
-          end
-
-        end
-
-      end # AgentForward
-    end # Service
-  end # SSH
-end # Net

data/lib/net/ssh/service/agentforward/services.rb

@@ -1,41 +0,0 @@
-#--
-# =============================================================================
-# Copyright (c) 2007, Chris Andrews (chris@nodnol.org),
-#   Jamis Buck (jgb3@email.byu.edu)
-# All rights reserved.
-#
-# This source file is distributed as part of the Net::SSH Secure Shell Client
-# library for Ruby. This file (and the library as a whole) may be used only as
-# allowed by either the BSD license, or the Ruby license (or, by association
-# with the Ruby license, the GPL). See the "doc" subdirectory of the Net::SSH
-# distribution for the texts of these licenses.
-# -----------------------------------------------------------------------------
-# net-ssh website : http://net-ssh.rubyforge.org
-# project website: http://rubyforge.org/projects/net-ssh
-# =============================================================================
-#++
-
-module Net
-  module SSH
-    module Service
-      module AgentForward
-
-        def register_services( container )
-
-          container.namespace_define :agentforward do |ns|
-            ns.driver :model => :singleton_deferred do |c,p|
-              require 'net/ssh/service/agentforward/driver'
-              Driver.new( c[:connection][:driver],
-                          c[:transport][:buffers],
-                          c[:log_for, p],
-                          c[:userauth].agent)
-            end
-          end
-
-        end
-        module_function :register_services
-
-      end
-    end
-  end
-end

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

@@ -1,319 +0,0 @@
-#--
-# =============================================================================
-# Copyright (c) 2004,2005 Jamis Buck (jamis@37signals.com)
-# All rights reserved.
-#
-# This source file is distributed as part of the Net::SSH Secure Shell Client
-# library for Ruby. This file (and the library as a whole) may be used only as
-# allowed by either the BSD license, or the Ruby license (or, by association
-# with the Ruby license, the GPL). See the "doc" subdirectory of the Net::SSH
-# distribution for the texts of these licenses.
-# -----------------------------------------------------------------------------
-# net-ssh website : http://net-ssh.rubyforge.org
-# project website: http://rubyforge.org/projects/net-ssh
-# =============================================================================
-#++
-
-require 'net/ssh/errors'
-
-module Net
-  module SSH
-    module Service
-      module Forward
-
-        # The Forward::Driver class manages ports that have been forwarded.
-        # It will open a socket on each local port and listen for local
-        # connections, forwarding those connections over an SSH channel to
-        # the other end.
-        class Driver
-          
-          # The number of direct (local-to-remote) channels that have been
-          # opened.
-          attr_reader :direct_channel_count
-
-          # The number of direct (local-to-remote) channels that are currently
-          # open.
-          attr_reader :open_direct_channel_count
-
-          # Create a new Driver instance.
-          def initialize( connection, buffers, log, handlers )
-            @connection = connection
-            @buffers = buffers
-            @log = log
-            @handlers = handlers
-
-            @local_forwards = Hash.new
-            @remote_forwards = Hash.new
-            @direct_channel_count = 0
-            @open_direct_channel_count = 0
-
-            @connection.add_channel_open_handler(
-              "forwarded-tcpip", &method(:do_open_channel) )
-          end
-
-          # Open a direct "tcpip" channel to the remote machine, which will then
-          # forward the connection to the given remote-host and remote-port. The
-          # connection will appear to have come from the given port on the local
-          # machine.
-          #
-          # The handler object may respond to the following messages, in order
-          # to respond to requests over the channel:
-          #
-          # * on_receive( channel, data ): when data is received over the
-          #   channel (from the remote machine), this method will be invoked.
-          # * on_eof( channel ): when the remote machine will no longer send
-          #   data, this method will be invoked. The client may continue to send
-          #   data over the channel, however.
-          # * on_close( channel ): when the channel has been closed and is no
-          #   longer valid for passing data, this method will be invoked.
-          # * confirm( channel, local_port, remote_host, remote_port, *data ):
-          #   when the channel has been opened and the remote machine has
-          #   confirmed it, this method will be invoked. The +data+ parameters
-          #   are the same parameters as were passed to the direct_channel
-          #   method.
-          # * process( channel ): invoked after the channel is confirmed, to
-          #   process the channel. It is invoked in a new Thread.
-          #
-          # Only the +process+ method is required--the others will only be
-          # invoked if the handler responds to them.
-          def direct_channel( local_port, remote_host, remote_port,
-            handler, *data )
-          # begin
-            writer = @buffers.writer
-            writer.write_string remote_host
-            writer.write_long remote_port.to_i
-            writer.write_string "127.0.0.1"
-            writer.write_long local_port.to_i
-
-            @direct_channel_count += 1
-            @open_direct_channel_count += 1
-
-            if @log.debug?
-              @log.debug "opening direct channel for " +
-                "#{local_port}:#{remote_host}:#{remote_port}"
-            end
-
-            c = @connection.open_channel( 'direct-tcpip', writer ) do |channel|
-              if @log.debug?
-                @log.debug "direct channel confirmed for " +
-                  "#{local_port}:#{remote_host}:#{remote_port}"
-              end
-
-              if handler.respond_to?( :on_receive )
-                channel.on_data( &handler.method(:on_receive) )
-              end
-
-              if handler.respond_to?( :on_eof )
-                channel.on_eof( &handler.method(:on_eof) )
-              end
-
-              channel.on_close do |ch|
-                @open_direct_channel_count -= 1
-                handler.on_close( ch ) if handler.respond_to?( :on_close )
-              end
-
-              if handler.respond_to?( :confirm )
-                handler.confirm( channel, local_port, remote_host,
-                  remote_port, *data )
-              end
-
-              if handler.respond_to?( :process )
-                Thread.new { handler.process( channel ) }
-              end
-            end
-
-            c.on_confirm_failed do |channel, code,desc,lang|
-              raise Net::SSH::Exception, "could not open direct channel for " +
-                "#{local_port}:#{remote_host}:#{remote_port} (#{code}, #{desc})"
-            end
-
-            nil
-          end
-          
-          # Forward connections on the given local port, to the given remote
-          # host and remote port. 
-          #
-          # This method will return immediately, forwarding the connections
-          # asynchronously.
-          def local( *args )
-            if args.length < 3 || args.length > 4
-              raise ArgumentError,
-                "expected 3 or 4 parameters, got #{args.length+1}"
-            end
-
-            bind_address = "127.0.0.1"
-            bind_address = args.shift if args.first.is_a? String
-
-            local_port = args.shift.to_i
-            remote_host = args.shift
-            remote_port = args.shift
-
-            key = [ local_port.to_i, bind_address ]
-
-            if @log.debug?
-              @log.debug "starting local forwarding server on " +
-                key.inspect
-            end
-
-            socket = TCPServer.new( bind_address, local_port )
-
-            Thread.new do
-              begin
-                @local_forwards[ key ] = { :thread => Thread.current,
-                                           :socket => socket }
-
-                if @log.debug?
-                  @log.debug "listening for connections on #{key.inspect}"
-                end
-
-                while ( client = socket.accept )
-                  @log.debug "#{key.inspect} received connection" if @log.debug?
-
-                  direct_channel( local_port,
-                                  remote_host,
-                                  remote_port,
-                                  @handlers[:local].call( client ) )
-                end
-
-              rescue Exception => e
-                @log.error "error forwarding local connection: " +
-                  "#{e.class} (#{e.message})\n   " +
-                  e.backtrace.join( "\n  " )
-              end
-            end
-          end
-
-          # Initiate forwarding of the given remote port on the connected host.
-          # Forwarded packets will be passed to the given block as they are
-          # recieved. The remote-host represents the address that should be
-          # bound on the remote host, and defaults to '127.0.0.1'.
-          def remote( handler, remote_port, remote_host="127.0.0.1" )
-            if @remote_forwards[ remote_port ]
-              raise Net::SSH::Exception, "#{remote_port} is already forwarded"
-            end
-
-            writer = @buffers.writer
-            writer.write_string remote_host
-            writer.write_long remote_port.to_i
-
-            @connection.global_request( "tcpip-forward", writer
-            ) do |success, response|
-              if success
-                remote_port = response.read_long if remote_port == 0
-                @remote_forwards[ remote_port ] = { :port => remote_port,
-                                                    :handler => handler }
-                handler.setup( remote_port ) if handler.respond_to?( :setup )
-              else
-                msg = "remote port #{remote_port} could not be forwarded " +
-                      "to local host"
-                if handler.respond_to?( :error )
-                  handler.error( msg )
-                else
-                  raise Net::SSH::Exception, msg
-                end
-              end
-            end
-          end
-
-          # A convenience method for setting up a forwarded connection from the
-          # given port on the remote host, to the given host and port (local).
-          def remote_to( port, host, remote_port, remote_host="127.0.0.1" )
-          # begin
-            remote( @handlers[:remote].call( port, host ), remote_port,
-              remote_host )
-          end
-
-          # Return an array of the active forwarded local connections. Each
-          # element of the array is another array containing the local port, and
-          # the remote host and port of the connection.
-          def active_locals
-            @local_forwards.keys
-          end
-
-          # Return an array of the active forwarded remote connections. Each
-          # element of the array is an integer representing the port number of
-          # the remote host that is being forwarded to the local client.
-          def active_remotes
-            @remote_forwards.keys
-          end
-
-          # Cease forwarding connections from the given local port (and
-          # interface). The parameters must match those given to a prior call to
-          # #local. Existing forwarded connections are not affected by
-          # this call, but no more connections will be accepted on the local
-          # port.
-          def cancel_local( local_port, bind_address="127.0.0.1" )
-            key = [ local_port.to_i, bind_address ]
-
-            forward = @local_forwards[ key ]
-            @local_forwards.delete key
-
-            forward[ :socket ].shutdown
-            forward[ :thread ].terminate
-
-            true
-          end
-
-          # Cease forwarding connections from the given remote port. The
-          # +remote_host+ parameter must match the corresponding parameter that
-          # was passed to #remote. Existing forwarded connections are
-          # not affected by this call, but no more connections will be
-          # forwarded from the remote host to the local host via that port.
-          def cancel_remote( remote_port, remote_host="127.0.0.1" )
-            writer = @buffers.writer
-            writer.write_string remote_host
-            writer.write_long remote_port.to_i
-
-            @connection.global_request( "cancel-tcpip-forward", writer
-            ) do |success, response|
-              if success
-                @remote_forwards.delete remote_port
-              else
-                raise Net::SSH::Exception,
-                  "could not cancel remote forward request on " +
-                  "(#{remote_port},#{remote_host})"
-              end
-            end
-          end
-
-          # open a new channel as requested by the server
-          def do_open_channel( connection, channel, data )
-            connected_address = data.read_string
-            connected_port = data.read_long
-            originator_address = data.read_string
-            originator_port = data.read_long
-
-            forward_data = @remote_forwards[ connected_port ]
-            unless forward_data
-              raise Net::SSH::Exception,
-                "recieved invalid channel-open command for a port forward " +
-                "that was never requested"
-            end
-
-            handler = forward_data[:handler]
-
-            forward_data[:channel] = channel
-
-            if handler.respond_to?( :on_open )
-              handler.on_open( channel,
-                               connected_address, connected_port,
-                               originator_address, originator_port )
-            end
-
-            channel.on_data( &handler.method(:on_receive) )
-
-            if handler.respond_to?( :on_close )
-              channel.on_close( &handler.method(:on_close) )
-            end
-
-            if handler.respond_to?( :on_eof )
-              channel.on_eof( &handler.method(:on_eof) )
-            end
-          end
-
-        end
-
-      end # Forward
-    end # Service
-  end # SSH
-end # Net