net-ssh 1.1.4 → 2.0.0

data/lib/net/ssh/userauth/methods/keyboard-interactive.rb

@@ -1,104 +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'
-require 'net/ssh/userauth/constants'
-
-module Net
-  module SSH
-    module UserAuth
-      module Methods
-
-        # Implements the "keyboard-interactive" SSH authentication method.
-        class KeyboardInteractive
-          include Net::SSH::UserAuth::Constants
-
-          # Represents an information request from the server
-          InfoRequest = Struct.new( :name, :instruction, :password, :prompts )
-
-          # Represents a single prompt in an InfoRequest.
-          Prompt = Struct.new( :prompt, :echo )
-
-          USERAUTH_INFO_REQUEST  = 60
-          USERAUTH_INFO_RESPONSE = 61
-
-          # The messenger to use when communicating.
-          attr_writer :messenger
-
-          # Create a new Password authenticator. It will use the given buffers
-          # factory to create new buffer instances. The +callback+ should be
-          # a proc object to use to specialize the behavior of this
-          # authentication method.
-          def initialize( buffers, callback )
-            @buffers = buffers
-            @callback = callback
-          end
-
-          # Attempt to authenticate the given user for the given service. The
-          # data hash must specify a <tt>:password</tt> value, otherwise this
-          # will always return false.
-          def authenticate( next_service, username, data={} )
-            password = data[:password]
-
-            msg = @buffers.writer
-            msg.write_byte USERAUTH_REQUEST
-            msg.write_string username
-            msg.write_string next_service
-            msg.write_string "keyboard-interactive"
-            msg.write_string ""
-            msg.write_string ""
-            @messenger.send_message msg
-
-            loop do
-              message = @messenger.wait_for_message
-
-              case message.message_type
-                when USERAUTH_SUCCESS
-                  return true
-                when USERAUTH_FAILURE
-                  return false
-                when USERAUTH_INFO_REQUEST
-                  name = message.buffer.read_string
-                  instruction = message.buffer.read_string
-                  req = InfoRequest.new( name, instruction, password, [] )
-                  password = nil # only use the given password once
-
-                  lang_tag = message.buffer.read_string
-                  message.buffer.read_long.times do
-                    prompt = message.buffer.read_string
-                    echo = message.buffer.read_bool
-                    req.prompts << Prompt.new( prompt, echo )
-                  end
-
-                  responses = @callback.call( req )
-                  msg = @buffers.writer
-                  msg.write_byte USERAUTH_INFO_RESPONSE
-                  msg.write_long responses.length
-                  msg.write_string(*responses)
-                  @messenger.send_message msg
-                else
-                  raise Net::SSH::Exception,
-                    "unexpected reply in keyboard interactive: " +
-                      message.inspect
-              end
-            end
-          end
-        end
-
-      end
-    end
-  end
-end

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

@@ -1,70 +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'
-require 'net/ssh/userauth/constants'
-
-module Net
-  module SSH
-    module UserAuth
-      module Methods
-
-        # Implements the "password" SSH authentication method.
-        class Password
-          include Net::SSH::UserAuth::Constants
-
-          # The messenger to use when communicating.
-          attr_writer :messenger
-
-          # Create a new Password authenticator. It will use the given buffers
-          # factory to create new buffer instances.
-          def initialize( buffers )
-            @buffers = buffers
-          end
-
-          # Attempt to authenticate the given user for the given service. The
-          # data hash must specify a <tt>:password</tt> value, otherwise this
-          # will always return false.
-          def authenticate( next_service, username, data={} )
-            return false unless data[:password]
-
-            msg = @buffers.writer
-            msg.write_byte USERAUTH_REQUEST
-            msg.write_string username
-            msg.write_string next_service
-            msg.write_string "password"
-            msg.write_bool false
-            msg.write_string data[:password]
-            @messenger.send_message msg
-
-            message = @messenger.wait_for_message
-
-            case message.message_type
-              when USERAUTH_SUCCESS
-                return true
-              when USERAUTH_FAILURE, USERAUTH_PASSWD_CHANGEREQ
-                return false
-              else
-                raise Net::SSH::Exception,
-                  "unexpected reply to USERAUTH_REQUEST: #{message.inspect}"
-            end
-          end
-        end
-
-      end
-    end
-  end
-end

data/lib/net/ssh/userauth/methods/publickey.rb

@@ -1,137 +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'
-require 'net/ssh/userauth/constants'
-
-module Net
-  module SSH
-    module UserAuth
-      module Methods
-
-        # Implements the "publickey" SSH authentication method.
-        class PublicKey
-          include Net::SSH::UserAuth::Constants
-
-          # The messenger instance to use to send and receive messages
-          attr_writer :messenger
-
-          # The session id of the current SSH session
-          attr_writer :session_id
-
-          # Create a new PublicKey instance that uses the given buffer
-          # factory to produce new buffer instances.
-          def initialize( buffers )
-            @buffers = buffers
-          end
-
-          # Attempts to perform public-key authentication for the given
-          # username, trying each identity known to the key manager. If any of
-          # them succeed, returns +true+, otherwise returns +false+. The data
-          # hash must contain a UserKeyManager instance under the
-          # <tt>:key_manager</tt> key.
-          def authenticate( next_service, username, data={} )
-            key_manager = data[:key_manager]
-            return false unless key_manager
-
-            key_manager.identities.each do |identity|
-              return true if authenticate_with( identity, next_service,
-                username, key_manager )
-            end
-
-            return false
-
-          ensure
-            key_manager.finish if key_manager
-          end
-
-          # Builds a Net::SSH::Util::WriterBuffer that contains the request
-          # formatted for sending a public-key request to the server.
-          def build_request( pub_key, username, next_service, has_sig,
-                buffer=nil )
-          # begin
-            buffer ||= @buffers.writer
-
-            buffer.write_byte USERAUTH_REQUEST
-            buffer.write_string username
-            buffer.write_string next_service
-            buffer.write_string "publickey"
-            buffer.write_bool has_sig
-            buffer.write_string pub_key.ssh_type
-
-            blob = @buffers.writer
-            blob.write_key pub_key
-            buffer.write_string blob.to_s
-
-            return buffer
-          end
-          private :build_request
-
-          # Builds and sends a request formatted for a public-key
-          # authentication request.
-          def send_request( pub_key, username, next_service, signature=nil )
-            msg = build_request( pub_key, username, next_service, signature )
-            msg.write_string signature if signature
-            @messenger.send_message msg
-          end
-          private :send_request
-
-          # Attempts to perform public-key authentication for the given
-          # username, with the given identity (public key). Returns +true+ if
-          # successful, or +false+ otherwise.
-          def authenticate_with( identity, next_service, username, key_manager )
-            send_request identity, username, next_service
-
-            message = @messenger.wait_for_message
-
-            case message.message_type
-              when USERAUTH_PK_OK
-                sig_data = @buffers.writer
-                sig_data.write_string @session_id
-                build_request identity, username, next_service, true, sig_data
-
-                sig_blob = key_manager.sign( identity, sig_data )
-
-                send_request identity, username, next_service, sig_blob.to_s
-                message = @messenger.wait_for_message
-
-                case message.message_type
-                  when USERAUTH_SUCCESS
-                    return true
-                  when USERAUTH_FAILURE
-                    return false
-                  else
-                    raise Net::SSH::Exception,
-                      "unexpected server response to USERAUTH_REQUEST: " +
-                      message.inspect
-                end
-
-              when USERAUTH_FAILURE
-                return false
-
-              else
-                raise Net::SSH::Exception,
-                  "unexpected reply to USERAUTH_REQUEST: #{message.inspect}"
-            end
-          end
-          private :authenticate_with
-
-        end
-
-      end
-    end
-  end
-end

data/lib/net/ssh/userauth/methods/services.rb

@@ -1,90 +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 UserAuth
-      module Methods
-
-        def register_services( container )
-          container.namespace_define :methods do |b|
-
-            b.password do |c,p|
-              require 'net/ssh/userauth/methods/password'
-              method = Password.new( c[:transport][:buffers] )
-              method.messenger = c[:userauth][:driver]
-              method
-            end
-
-            b.keyboard_interactive do |c,p|
-              require 'net/ssh/userauth/methods/keyboard-interactive'
-              method = KeyboardInteractive.new( c[:transport][:buffers],
-                c[:keyboard_interactive_callback] )
-              method.messenger = c[:userauth][:driver]
-              method
-            end
-
-            b.keyboard_interactive_prompter do
-              require 'net/ssh/util/prompter'
-              Net::SSH::Util::Prompter.new
-            end
-
-            b.keyboard_interactive_callback do |c,p|
-              proc do |req|
-                if req.password
-                  [ req.password ] * req.prompts.length
-                else
-                  responses = []
-                  puts req.name unless req.name.empty?
-                  puts req.instruction unless req.instruction.empty?
-                  req.prompts.each do |prompt|
-                    response = prompt.echo ?
-                      gets.chomp :
-                      c[:keyboard_interactive_prompter].
-                        password( prompt.prompt )
-                    responses << response
-                  end
-                  responses
-                end
-              end
-            end
-
-            b.publickey do |c,p|
-              require 'net/ssh/userauth/methods/publickey'
-              method = PublicKey.new( c[:transport][:buffers] )
-              method.messenger = c[:userauth][:driver]
-              method.session_id = c[:transport][:session].session_id
-              method
-            end
-
-            b.hostbased do |c,p|
-              require 'net/ssh/userauth/methods/hostbased'
-              method = HostBased.new( c[:transport][:buffers] )
-              session = c[:transport][:session]
-              method.messenger = c[:userauth][:driver]
-              method.hostname = session.client_name
-              method.session_id = session.session_id
-              method
-            end
-            
-          end
-        end
-        module_function :register_services
-
-      end
-    end
-  end
-end

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

@@ -1,197 +0,0 @@
-#--
-# =============================================================================
-# Copyright (c) 2004, Guillaume Mar�ais (guillaume.marcais@free.fr),
-#   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 'dl/import'
-require 'dl/struct'
-
-require 'net/ssh/errors'
-
-module Net
-  module SSH
-    module UserAuth
-
-      # This module encapsulates the implementation of a socket factory that
-      # uses the PuTTY "pageant" utility to obtain information about SSH
-      # identities.
-      #
-      # This code is a slightly modified version of the original implementation
-      # by Guillaume Mar�ais (guillaume.marcais@free.fr). It is used and
-      # relicensed by permission.
-      module Pageant
-
-        # From Putty pageant.c
-        AGENT_MAX_MSGLEN = 8192
-        AGENT_COPYDATA_ID = 0x804e50ba
-        
-        # The definition of the Windows methods and data structures used in
-        # communicating with the pageant process.
-        module Win
-          extend DL::Importable
-          
-          dlload 'user32'
-          dlload 'kernel32'
-          
-          typealias("LPCTSTR", "char *")         # From winnt.h
-          typealias("LPVOID", "void *")          # From winnt.h
-          typealias("LPCVOID", "const void *")   # From windef.h
-          typealias("LRESULT", "long")           # From windef.h
-          typealias("WPARAM", "unsigned int *")  # From windef.h
-          typealias("LPARAM", "long *")          # From windef.h
-          typealias("PDWORD_PTR", "long *")      # From basetsd.h
-
-          # From winbase.h, winnt.h
-          INVALID_HANDLE_VALUE = -1
-          NULL = nil
-          PAGE_READWRITE = 0x0004
-          FILE_MAP_WRITE = 2
-          WM_COPYDATA = 74
-
-          SMTO_NORMAL = 0   # From winuser.h
-
-          # args: lpClassName, lpWindowName
-          extern 'HWND FindWindow(LPCTSTR, LPCTSTR)'
-
-          # args: none
-          extern 'DWORD GetCurrentThreadId()'
-
-          # args: hFile, (ignored), flProtect, dwMaximumSizeHigh,
-          #           dwMaximumSizeLow, lpName
-          extern 'HANDLE CreateFileMapping(HANDLE, void *, DWORD, DWORD, ' +
-                                          'DWORD, LPCTSTR)'
-
-          # args: hFileMappingObject, dwDesiredAccess, dwFileOffsetHigh, 
-          #           dwfileOffsetLow, dwNumberOfBytesToMap
-          extern 'LPVOID MapViewOfFile(HANDLE, DWORD, DWORD, DWORD, DWORD)'
-
-          # args: lpBaseAddress
-          extern 'BOOL UnmapViewOfFile(LPCVOID)'
-
-          # args: hObject
-          extern 'BOOL CloseHandle(HANDLE)'
-
-          # args: hWnd, Msg, wParam, lParam, fuFlags, uTimeout, lpdwResult
-          extern 'LRESULT SendMessageTimeout(HWND, UINT, WPARAM, LPARAM, ' +
-                                            'UINT, UINT, PDWORD_PTR)'
-        end
-
-        # This is the pseudo-socket implementation that mimics the interface of
-        # a socket, translating each request into a Windows messaging call to
-        # the pageant daemon. This allows pageant support to be implemented
-        # simply by replacing the socket factory used by the Agent class.
-        class Socket
-
-          private_class_method :new
-
-          # The factory method for creating a new Socket instance. The location
-          # parameter is ignored, and is only needed for compatibility with
-          # the general Socket interface.
-          def self.open( location=nil )
-            new
-          end
-
-          # Create a new instance that communicates with the running pageant 
-          # instance. If no such instance is running, this will cause an error.
-          def initialize
-            @win = Win.findWindow( "Pageant", "Pageant" )
-
-            if @win == 0
-              raise Net::SSH::Exception,
-                "pageant process not running"
-            end
-
-            @res = nil
-            @pos = 0
-          end
-          
-          # Forwards the data to #send_query, ignoring any arguments after
-          # the first. Returns 0.
-          def send( data, *args )
-            @res = send_query( data )
-            @pos = 0
-          end
-
-          # Packages the given query string and sends it to the pageant
-          # process via the Windows messaging subsystem. The result is
-          # cached, to be returned piece-wise when #read is called.
-          def send_query( query )
-            res = nil
-            filemap = 0
-            ptr = nil
-            id = DL::PtrData.malloc( DL.sizeof("L") )
-
-            mapname = "PageantRequest%08x\000" % Win.getCurrentThreadId()
-            filemap = Win.createFileMapping(Win::INVALID_HANDLE_VALUE, 
-                                            Win::NULL,
-                                            Win::PAGE_READWRITE, 0, 
-                                            AGENT_MAX_MSGLEN, mapname)
-            if filemap == 0
-              raise Net::SSH::Exception,
-                "Creation of file mapping failed"
-            end
-
-            ptr = Win.mapViewOfFile( filemap, Win::FILE_MAP_WRITE, 0, 0, 
-                                    AGENT_MAX_MSGLEN )
-
-            if ptr.nil? || ptr.null?
-              raise Net::SSH::Exception, "Mapping of file failed"
-            end
-
-            ptr[0] = query
-            
-            cds = [AGENT_COPYDATA_ID, mapname.size + 1, mapname].
-              pack("LLp").to_ptr
-            succ = Win.sendMessageTimeout( @win, Win::WM_COPYDATA, Win::NULL,
-              cds, Win::SMTO_NORMAL, 5000, id )
-
-            if succ > 0
-              retlen = 4 + ptr.to_s(4).unpack("N")[0]
-              res = ptr.to_s(retlen)
-            end        
-
-            return res
-          ensure
-            Win.unmapViewOfFile( ptr ) unless ptr.nil? || ptr.null?
-            Win.closeHandle( filemap ) if filemap != 0
-          end
-
-          # Conceptually close the socket. This doesn't really do anthing
-          # significant, but merely complies with the Socket interface.
-          def close
-            @res = nil
-            @pos = 0
-          end
-
-          # Reads +n+ bytes from the cached result of the last query. If +n+
-          # is +nil+, returns all remaining data from the last query.
-          def read(n = nil)
-            return nil unless @res
-            if n.nil?
-              start, @pos = @pos, @res.size
-              return @res[start..-1]
-            else
-              start, @pos = @pos, @pos + n
-              return @res[start, n]
-            end
-          end
-
-        end
-
-      end
-
-    end
-  end
-end