hrr_rb_ssh 0.1.0

data/lib/hrr_rb_ssh/connection/channel/session/subsystem.rb

@@ -0,0 +1,31 @@
+# coding: utf-8
+# vim: et ts=2 sw=2
+
+require 'hrr_rb_ssh/logger'
+require 'hrr_rb_ssh/connection/request_handler'
+require 'hrr_rb_ssh/connection/channel/session/subsystem/context'
+
+module HrrRbSsh
+  class Connection
+    class Channel
+      module Session
+        request_type = 'subsystem'
+
+        class Subsystem
+          def self.run proc_chain, username, io, variables, message, options
+            logger = HrrRbSsh::Logger.new self.class.name
+
+            context = Context.new proc_chain, username, io, variables, message
+            handler = options.fetch('connection_channel_request_subsystem', RequestHandler.new {})
+            handler.run context
+
+            proc_chain.connect context.chain_proc
+          end
+        end
+
+        @@request_type_list ||= Hash.new
+        @@request_type_list[request_type] = Subsystem
+      end
+    end
+  end
+end

data/lib/hrr_rb_ssh/connection/channel/session.rb

@@ -0,0 +1,31 @@
+# coding: utf-8
+# vim: et ts=2 sw=2
+
+require 'hrr_rb_ssh/connection/channel/session/pty_req'
+require 'hrr_rb_ssh/connection/channel/session/env'
+require 'hrr_rb_ssh/connection/channel/session/shell'
+require 'hrr_rb_ssh/connection/channel/session/exec'
+require 'hrr_rb_ssh/connection/channel/session/subsystem'
+
+module HrrRbSsh
+  class Connection
+    class Channel
+      channel_type = 'session'
+
+      module Session
+        @@request_type_list ||= Hash.new
+
+        def self.[] key
+          @@request_type_list[key]
+        end
+
+        def self.request_type_list
+          @@request_type_list.keys
+        end
+      end
+
+      @@type_list ||= Hash.new
+      @@type_list[channel_type] = Session
+    end
+  end
+end

data/lib/hrr_rb_ssh/connection/channel.rb

@@ -0,0 +1,278 @@
+# coding: utf-8
+# vim: et ts=2 sw=2
+
+require 'socket'
+require 'hrr_rb_ssh/logger'
+require 'hrr_rb_ssh/connection/channel/proc_chain'
+require 'hrr_rb_ssh/connection/channel/session'
+
+module HrrRbSsh
+  class Connection
+    class Channel
+      @@type_list ||= Hash.new
+
+      def self.[] key
+        @@type_list[key]
+      end
+
+      def self.type_list
+        @@type_list.keys
+      end
+
+      INITIAL_WINDOW_SIZE = 100000
+      MAXIMUM_PACKET_SIZE = 100000
+
+      attr_reader \
+        :receive_payload_queue
+
+      def initialize connection, channel_type, local_channel, remote_channel, initial_window_size, maximum_packet_size
+        @logger = HrrRbSsh::Logger.new self.class.name
+
+        @connection = connection
+        @channel_type = channel_type
+        @local_channel  = local_channel
+        @remote_channel = remote_channel
+        @local_window_size          = INITIAL_WINDOW_SIZE
+        @local_maximum_packet_size  = MAXIMUM_PACKET_SIZE
+        @remote_window_size         = initial_window_size
+        @remote_maximum_packet_size = maximum_packet_size
+
+        @receive_payload_queue = Queue.new
+        @receive_data_queue = Queue.new
+
+        @proc_chain = ProcChain.new
+        @channel_io, @request_handler_io = UNIXSocket.pair
+
+        @closed = nil
+      end
+
+      def start
+        @channel_loop_thread = channel_loop_thread
+        @sender_thread       = sender_thread
+        @receiver_thread     = receiver_thread
+        @proc_chain_thread   = proc_chain_thread
+        @closed = false
+      end
+
+      def close from=:outside, exitstatus=0
+        return if @closed
+        @logger.info("close channel")
+        @closed = true
+        unless from == :proc_chain_thread
+          @proc_chain_thread.exit
+        end
+        @receive_payload_queue.close
+        @receive_data_queue.close
+        begin
+          @request_handler_io.close
+        rescue IOError # for compatibility for Ruby version < 2.3
+          Thread.pass
+        end
+        begin
+          @channel_io.close
+        rescue IOError # for compatibility for Ruby version < 2.3
+          Thread.pass
+        end
+        begin
+          if from == :proc_chain_thread
+            send_channel_eof
+            case exitstatus
+            when Integer
+              send_channel_request_exit_status exitstatus
+            else
+              @logger.warn("skip sending exit-status because exitstatus is not an instance of Integer")
+            end
+          end
+          send_channel_close
+        rescue HrrRbSsh::ClosedConnectionError => e
+          Thread.pass
+        rescue => e
+          @logger.error([e.backtrace[0], ": ", e.message, " (", e.class.to_s, ")\n\t", e.backtrace[1..-1].join("\n\t")].join)
+        end
+        @logger.info("channel closed")
+      end
+
+      def closed?
+        @closed
+      end
+
+      def channel_loop_thread
+        Thread.start do
+          @logger.info("start channel loop thread")
+          variables = {}
+          loop do
+            begin
+              message = @receive_payload_queue.deq
+              if message.nil? && @receive_payload_queue.closed?
+                @logger.info("closing channel loop thread")
+                break
+              end
+              if message.has_key?(HrrRbSsh::Message::SSH_MSG_CHANNEL_REQUEST::ID)
+                @logger.info("received channel request: #{message['request type']}")
+                request message, variables
+                if message['want reply']
+                  send_channel_success
+                end
+              elsif message.has_key?(HrrRbSsh::Message::SSH_MSG_CHANNEL_DATA::ID)
+                @logger.info("received channel data")
+                local_channel = message['recipient channel']
+                @receive_data_queue.enq message['data']
+              elsif message.has_key?(HrrRbSsh::Message::SSH_MSG_CHANNEL_WINDOW_ADJUST::ID)
+                @logger.debug("received channel window adjust")
+                @remote_window_size = [@remote_window_size + message['bytes to add'], 0xffff_ffff].min
+              else
+                @logger.warn("received unsupported message: #{message.inspect}")
+              end
+            rescue => e
+              @logger.error([e.backtrace[0], ": ", e.message, " (", e.class.to_s, ")\n\t", e.backtrace[1..-1].join("\n\t")].join)
+              break
+            end
+          end
+          close from=:channel_loop_thread
+          @logger.info("channel loop thread closed")
+        end
+      end
+
+      def sender_thread
+        Thread.start {
+          @logger.info("start sender thread")
+          loop do
+            if @channel_io.closed?
+              @logger.info("closing sender thread")
+              break
+            end
+            begin
+              data = @channel_io.readpartial(1024)
+              sendable_size = [data.size, @remote_window_size].min
+              sending_data = data[0, sendable_size]
+              send_channel_data sending_data if sendable_size > 0
+              @remote_window_size -= sendable_size
+            rescue EOFError => e
+              begin
+                @channel_io.close
+              rescue IOError # for compatibility for Ruby version < 2.3
+                Thread.pass
+              end
+            rescue IOError => e
+              @logger.warn("channel IO is closed")
+              close
+            rescue => e
+              @logger.error([e.backtrace[0], ": ", e.message, " (", e.class.to_s, ")\n\t", e.backtrace[1..-1].join("\n\t")].join)
+              close
+            end
+          end
+          @logger.info("sender thread closed")
+        }
+      end
+
+      def receiver_thread
+        Thread.start {
+          @logger.info("start receiver thread")
+          loop do
+            begin
+              data = @receive_data_queue.deq
+              if data.nil? && @receive_data_queue.closed?
+                @logger.info("closing receiver thread")
+                break
+              end
+              @channel_io.write data
+              @local_window_size -= data.size
+              if @local_window_size < INITIAL_WINDOW_SIZE/2
+                @logger.info("send channel window adjust")
+                send_channel_window_adjust
+                @local_window_size += INITIAL_WINDOW_SIZE
+              end
+            rescue IOError => e
+              @logger.warn("channel IO is closed")
+              close
+            rescue => e
+              @logger.error([e.backtrace[0], ": ", e.message, " (", e.class.to_s, ")\n\t", e.backtrace[1..-1].join("\n\t")].join)
+              close
+            end
+          end
+          @logger.info("receiver thread closed")
+        }
+      end
+
+      def proc_chain_thread
+        Thread.start {
+          @logger.info("start proc chain thread")
+          begin
+            exitstatus = @proc_chain.call_next
+          rescue => e
+            @logger.error([e.backtrace[0], ": ", e.message, " (", e.class.to_s, ")\n\t", e.backtrace[1..-1].join("\n\t")].join)
+            exitstatus = 1
+          ensure
+            @logger.info("closing proc chain thread")
+            close from=:proc_chain_thread, exitstatus=exitstatus
+            @logger.info("proc chain thread closed")
+          end
+        }
+      end
+
+      def request message, variables
+        request_type = message['request type']
+        @@type_list[@channel_type][request_type].run @proc_chain, @connection.username, @request_handler_io, variables, message, @connection.options
+      end
+
+      def send_channel_success
+        message = {
+          'SSH_MSG_CHANNEL_SUCCESS' => HrrRbSsh::Message::SSH_MSG_CHANNEL_SUCCESS::VALUE,
+          'recipient channel'       => @remote_channel,
+        }
+        payload = HrrRbSsh::Message::SSH_MSG_CHANNEL_SUCCESS.encode message
+        @connection.send payload
+      end
+
+      def send_channel_window_adjust
+        message = {
+          'SSH_MSG_CHANNEL_WINDOW_ADJUST' => HrrRbSsh::Message::SSH_MSG_CHANNEL_WINDOW_ADJUST::VALUE,
+          'recipient channel'             => @remote_channel,
+          'bytes to add'                  => INITIAL_WINDOW_SIZE,
+        }
+        payload = HrrRbSsh::Message::SSH_MSG_CHANNEL_WINDOW_ADJUST.encode message
+        @connection.send payload
+      end
+
+      def send_channel_data data
+        message = {
+          'SSH_MSG_CHANNEL_DATA' => HrrRbSsh::Message::SSH_MSG_CHANNEL_DATA::VALUE,
+          'recipient channel'    => @remote_channel,
+          'data'                 => data,
+        }
+        payload = HrrRbSsh::Message::SSH_MSG_CHANNEL_DATA.encode message
+        @connection.send payload
+      end
+
+      def send_channel_request_exit_status exitstatus
+        message = {
+          'SSH_MSG_CHANNEL_REQUEST' => HrrRbSsh::Message::SSH_MSG_CHANNEL_REQUEST::VALUE,
+          'recipient channel'       => @remote_channel,
+          'request type'            => 'exit-status',
+          'want reply'              => false,
+          'exit status'             => exitstatus,
+        }
+        payload = HrrRbSsh::Message::SSH_MSG_CHANNEL_REQUEST.encode message
+        @connection.send payload
+      end
+
+      def send_channel_eof
+        message = {
+          'SSH_MSG_CHANNEL_EOF' => HrrRbSsh::Message::SSH_MSG_CHANNEL_EOF::VALUE,
+          'recipient channel'   => @remote_channel,
+        }
+        payload = HrrRbSsh::Message::SSH_MSG_CHANNEL_EOF.encode message
+        @connection.send payload
+      end
+
+      def send_channel_close
+        message = {
+          'SSH_MSG_CHANNEL_CLOSE' => HrrRbSsh::Message::SSH_MSG_CHANNEL_CLOSE::VALUE,
+          'recipient channel'     => @remote_channel,
+        }
+        payload = HrrRbSsh::Message::SSH_MSG_CHANNEL_CLOSE.encode message
+        @connection.send payload
+      end
+    end
+  end
+end

data/lib/hrr_rb_ssh/connection/request_handler.rb

@@ -0,0 +1,18 @@
+# coding: utf-8
+# vim: et ts=2 sw=2
+
+require 'hrr_rb_ssh/logger'
+
+module HrrRbSsh
+  class Connection
+    class RequestHandler
+      def initialize &block
+        @logger = HrrRbSsh::Logger.new self.class.name
+        @proc = block
+      end
+      def run context
+        @proc.call context
+      end
+    end
+  end
+end

data/lib/hrr_rb_ssh/connection.rb

@@ -0,0 +1,170 @@
+# coding: utf-8
+# vim: et ts=2 sw=2
+
+require 'hrr_rb_ssh/logger'
+require 'hrr_rb_ssh/closed_connection_error'
+require 'hrr_rb_ssh/connection/channel'
+
+module HrrRbSsh
+  class Connection
+    attr_reader \
+      :username,
+      :options
+
+    def initialize authentication, options={}
+      @logger = HrrRbSsh::Logger.new self.class.name
+
+      @authentication = authentication
+      @options = options
+
+      @channels = Hash.new
+      @username = nil
+      @closed = nil
+    end
+
+    def send payload
+      raise ClosedConnectionError if @closed
+      begin
+        @authentication.send payload
+      rescue ClosedAuthenticationError
+        raise ClosedConnectionError
+      end
+    end
+
+    def start
+      @authentication.start
+      @closed = false
+      connection_loop
+    end
+
+    def close
+      @closed = true
+      @channels.values.each do |channel|
+        begin
+          channel.close
+        rescue => e
+          @logger.error([e.backtrace[0], ": ", e.message, " (", e.class.to_s, ")\n\t", e.backtrace[1..-1].join("\n\t")].join)
+        end
+      end
+      @channels.clear
+    end
+
+    def closed?
+      @closed
+    end
+
+    def connection_loop
+      @logger.info("start connection")
+      loop do
+        begin
+          payload = @authentication.receive
+        rescue HrrRbSsh::ClosedAuthenticationError => e
+          @logger.info("closing connection loop")
+          break
+        end
+        @username ||= @authentication.username
+        case payload[0,1].unpack("C")[0]
+        when HrrRbSsh::Message::SSH_MSG_GLOBAL_REQUEST::VALUE
+          global_request payload
+        when HrrRbSsh::Message::SSH_MSG_CHANNEL_OPEN::VALUE
+          channel_open payload
+        when HrrRbSsh::Message::SSH_MSG_CHANNEL_REQUEST::VALUE
+          channel_request payload
+        when HrrRbSsh::Message::SSH_MSG_CHANNEL_WINDOW_ADJUST::VALUE
+          channel_window_adjust payload
+        when HrrRbSsh::Message::SSH_MSG_CHANNEL_DATA::VALUE
+          channel_data payload
+        when HrrRbSsh::Message::SSH_MSG_CHANNEL_CLOSE::VALUE
+          channel_close payload
+        else
+          @logger.warn("received unsupported message: id: #{payload[0,1].unpack("C")[0]}")
+        end
+      end
+      @logger.info("closing connection")
+      close
+      @logger.info("connection closed")
+    end
+
+    def global_request payload
+      @logger.info('received ' + HrrRbSsh::Message::SSH_MSG_GLOBAL_REQUEST::ID)
+      message = HrrRbSsh::Message::SSH_MSG_GLOBAL_REQUEST.decode payload
+      if message['want reply']
+        # returns always failure because global request is not supported so far
+        send_request_failure
+      end
+    end
+
+    def channel_open payload
+      @logger.info('received ' + HrrRbSsh::Message::SSH_MSG_CHANNEL_OPEN::ID)
+      message = HrrRbSsh::Message::SSH_MSG_CHANNEL_OPEN.decode payload
+      channel_type = message['channel type']
+      local_channel  = message['sender channel']
+      remote_channel = message['sender channel']
+      initial_window_size = message['initial window size']
+      maximum_packet_size = message['maximum packet size']
+      channel = Channel.new self, channel_type, local_channel, remote_channel, initial_window_size, maximum_packet_size
+      @channels[local_channel] = channel
+      channel.start
+      send_channel_open_confirmation channel_type, local_channel, remote_channel, initial_window_size, maximum_packet_size
+    end
+
+    def channel_request payload
+      @logger.info('received ' + HrrRbSsh::Message::SSH_MSG_CHANNEL_REQUEST::ID)
+      message = HrrRbSsh::Message::SSH_MSG_CHANNEL_REQUEST.decode payload
+      local_channel = message['recipient channel']
+      @channels[local_channel].receive_payload_queue.enq message
+    end
+
+    def channel_window_adjust payload
+      @logger.info('received ' + HrrRbSsh::Message::SSH_MSG_CHANNEL_WINDOW_ADJUST::ID)
+      message = HrrRbSsh::Message::SSH_MSG_CHANNEL_WINDOW_ADJUST.decode payload
+      local_channel = message['recipient channel']
+      @channels[local_channel].receive_payload_queue.enq message
+    end
+
+    def channel_data payload
+      @logger.info('received ' + HrrRbSsh::Message::SSH_MSG_CHANNEL_DATA::ID)
+      message = HrrRbSsh::Message::SSH_MSG_CHANNEL_DATA.decode payload
+      local_channel = message['recipient channel']
+      @channels[local_channel].receive_payload_queue.enq message
+    end
+
+    def channel_close payload
+      @logger.info('received ' + HrrRbSsh::Message::SSH_MSG_CHANNEL_CLOSE::ID)
+      message = HrrRbSsh::Message::SSH_MSG_CHANNEL_CLOSE.decode payload
+      local_channel = message['recipient channel']
+      channel = @channels[local_channel]
+      channel.close
+      @channels.delete local_channel
+    end
+
+    def send_request_success
+      message = {
+        'SSH_MSG_REQUEST_SUCCESS' => HrrRbSsh::Message::SSH_MSG_REQUEST_SUCCESS::VALUE,
+      }
+      payload = HrrRbSsh::Message::SSH_MSG_REQUEST_SUCCESS.encode message
+      @authentication.send payload
+    end
+
+    def send_request_failure
+      message = {
+        'SSH_MSG_REQUEST_FAILURE' => HrrRbSsh::Message::SSH_MSG_REQUEST_FAILURE::VALUE,
+      }
+      payload = HrrRbSsh::Message::SSH_MSG_REQUEST_FAILURE.encode message
+      @authentication.send payload
+    end
+
+    def send_channel_open_confirmation channel_type, local_channel, remote_channel, initial_window_size, maximum_packet_size
+      message = {
+        'SSH_MSG_CHANNEL_OPEN_CONFIRMATION' => HrrRbSsh::Message::SSH_MSG_CHANNEL_OPEN_CONFIRMATION::VALUE,
+        'channel type'                      => channel_type,
+        'recipient channel'                 => remote_channel,
+        'sender channel'                    => local_channel,
+        'initial window size'               => initial_window_size,
+        'maximum packet size'               => maximum_packet_size,
+      }
+      payload = HrrRbSsh::Message::SSH_MSG_CHANNEL_OPEN_CONFIRMATION.encode message
+      @authentication.send payload
+    end
+  end
+end

data/lib/hrr_rb_ssh/logger.rb

@@ -0,0 +1,52 @@
+# coding: utf-8
+# vim: et ts=2 sw=2
+
+module HrrRbSsh
+  class Logger
+    def self.initialize logger
+      @@logger = logger
+    end
+
+    def self.uninitialize
+      @@logger = nil
+    end
+
+    def self.initialized?
+      @@logger != nil
+    end
+
+    def initialize name
+      @name = name
+    end
+
+    def fatal message
+      if self.class.initialized?
+        @@logger.fatal "#{@name}: #{message}"
+      end
+    end
+
+    def error message
+      if self.class.initialized?
+        @@logger.error "#{@name}: #{message}"
+      end
+    end
+
+    def warn message
+      if self.class.initialized?
+        @@logger.warn "#{@name}: #{message}"
+      end
+    end
+
+    def info message
+      if self.class.initialized?
+        @@logger.info "#{@name}: #{message}"
+      end
+    end
+
+    def debug message
+      if self.class.initialized?
+        @@logger.debug "#{@name}: #{message}"
+      end
+    end
+  end
+end

data/lib/hrr_rb_ssh/message/001_ssh_msg_disconnect.rb

@@ -0,0 +1,44 @@
+# coding: utf-8
+# vim: et ts=2 sw=2
+
+require 'hrr_rb_ssh/logger'
+require 'hrr_rb_ssh/message/codable'
+
+module HrrRbSsh
+  module Message
+    module SSH_MSG_DISCONNECT
+      module ReasonCode
+        SSH_DISCONNECT_HOST_NOT_ALLOWED_TO_CONNECT    =  1
+        SSH_DISCONNECT_PROTOCOL_ERROR                 =  2
+        SSH_DISCONNECT_KEY_EXCHANGE_FAILED            =  3
+        SSH_DISCONNECT_RESERVED                       =  4
+        SSH_DISCONNECT_MAC_ERROR                      =  5
+        SSH_DISCONNECT_COMPRESSION_ERROR              =  6
+        SSH_DISCONNECT_SERVICE_NOT_AVAILABLE          =  7
+        SSH_DISCONNECT_PROTOCOL_VERSION_NOT_SUPPORTED =  8
+        SSH_DISCONNECT_HOST_KEY_NOT_VERIFIABLE        =  9
+        SSH_DISCONNECT_CONNECTION_LOST                = 10
+        SSH_DISCONNECT_BY_APPLICATION                 = 11
+        SSH_DISCONNECT_TOO_MANY_CONNECTIONS           = 12
+        SSH_DISCONNECT_AUTH_CANCELLED_BY_USER         = 13
+        SSH_DISCONNECT_NO_MORE_AUTH_METHODS_AVAILABLE = 14
+        SSH_DISCONNECT_ILLEGAL_USER_NAME              = 15
+      end
+
+      class << self
+        include Codable
+      end
+
+      ID    = self.name.split('::').last
+      VALUE = 1
+
+      DEFINITION = [
+        # [Data Type, Field Name]
+        ['byte',      'SSH_MSG_DISCONNECT'],
+        ['uint32',    'reason code'],
+        ['string',    'description'],
+        ['string',    'language tag'],
+      ]
+    end
+  end
+end

data/lib/hrr_rb_ssh/message/002_ssh_msg_ignore.rb

@@ -0,0 +1,24 @@
+# coding: utf-8
+# vim: et ts=2 sw=2
+
+require 'hrr_rb_ssh/logger'
+require 'hrr_rb_ssh/message/codable'
+
+module HrrRbSsh
+  module Message
+    module SSH_MSG_IGNORE
+      class << self
+        include Codable
+      end
+
+      ID    = self.name.split('::').last
+      VALUE = 2
+
+      DEFINITION = [
+        # [Data Type, Field Name]
+        ['byte',      'SSH_MSG_IGNORE'],
+        ['string',    'data'],
+      ]
+    end
+  end
+end

data/lib/hrr_rb_ssh/message/003_ssh_msg_unimplemented.rb

@@ -0,0 +1,24 @@
+# coding: utf-8
+# vim: et ts=2 sw=2
+
+require 'hrr_rb_ssh/logger'
+require 'hrr_rb_ssh/message/codable'
+
+module HrrRbSsh
+  module Message
+    module SSH_MSG_UNIMPLEMENTED
+      class << self
+        include Codable
+      end
+
+      ID    = self.name.split('::').last
+      VALUE = 3
+
+      DEFINITION = [
+        # [Data Type, Field Name]
+        ['byte',      'SSH_MSG_UNIMPLEMENTED'],
+        ['uint32',    'packet sequence number of rejected message'],
+      ]
+    end
+  end
+end