hrr_rb_ssh 0.3.0.pre3 → 0.3.0

data/lib/hrr_rb_ssh/connection.rb

@@ -11,12 +11,14 @@ module HrrRbSsh
     attr_reader \
       :username,
       :variables,
-      :options
+      :options,
+      :mode
 
-    def initialize authentication, options={}
+    def initialize authentication, mode, options={}
       @logger = Logger.new self.class.name
 
       @authentication = authentication
+      @mode = mode
       @options = options
 
       @global_request_handler = GlobalRequestHandler.new self
@@ -38,21 +40,31 @@ module HrrRbSsh
     def assign_channel
       i = 0
       res = nil
-      loop do
+      while true
         break unless @channels.keys.include?(i)
         i += 1
       end
       i
     end
 
-    def start
+    def start foreground: true
+      @logger.info { "start connection" }
       @authentication.start
       @closed = false
-      connection_loop
+      @connection_loop_thread = connection_loop_thread
+      if foreground
+        @connection_loop_thread.join
+      end
+    end
+
+    def loop
+      @connection_loop_thread.join
     end
 
     def close
+      @logger.info { "closing connection" }
       @closed = true
+      @authentication.close
       @channels.values.each do |channel|
         begin
           channel.close
@@ -62,47 +74,58 @@ module HrrRbSsh
       end
       @channels.clear
       @global_request_handler.close
+      @connection_loop_thread.join unless @connection_loop_thread == Thread.current
+      @logger.info { "connection closed" }
     end
 
     def closed?
       @closed
     end
 
-    def connection_loop
-      @logger.info { "start connection" }
-      loop do
+    def connection_loop_thread
+      @logger.info { "start connection loop" }
+      Thread.new do
         begin
-          payload = @authentication.receive
-        rescue Error::ClosedAuthentication => e
+          while true
+            begin
+              payload = @authentication.receive
+            rescue Error::ClosedAuthentication => e
+              @logger.info { "authentication closed" }
+              break
+            end
+            @username ||= @authentication.username
+            @variables ||= @authentication.variables
+            case payload[0,1].unpack("C")[0]
+            when Message::SSH_MSG_GLOBAL_REQUEST::VALUE
+              global_request payload
+            when Message::SSH_MSG_CHANNEL_OPEN::VALUE
+              channel_open payload
+            when Message::SSH_MSG_CHANNEL_OPEN_CONFIRMATION::VALUE
+              channel_open_confirmation payload
+            when Message::SSH_MSG_CHANNEL_REQUEST::VALUE
+              channel_request payload
+            when Message::SSH_MSG_CHANNEL_WINDOW_ADJUST::VALUE
+              channel_window_adjust payload
+            when Message::SSH_MSG_CHANNEL_DATA::VALUE
+              channel_data payload
+            when Message::SSH_MSG_CHANNEL_EXTENDED_DATA::VALUE
+              channel_extended_data payload
+            when Message::SSH_MSG_CHANNEL_EOF::VALUE
+              channel_eof payload
+            when Message::SSH_MSG_CHANNEL_CLOSE::VALUE
+              channel_close payload
+            else
+              @logger.warn { "received unsupported message: id: #{payload[0,1].unpack("C")[0]}" }
+            end
+          end
+        rescue => e
+          @logger.error { [e.backtrace[0], ": ", e.message, " (", e.class.to_s, ")\n\t", e.backtrace[1..-1].join("\n\t")].join }
+        ensure
           @logger.info { "closing connection loop" }
-          break
-        end
-        @username ||= @authentication.username
-        @variables ||= @authentication.variables
-        case payload[0,1].unpack("C")[0]
-        when Message::SSH_MSG_GLOBAL_REQUEST::VALUE
-          global_request payload
-        when Message::SSH_MSG_CHANNEL_OPEN::VALUE
-          channel_open payload
-        when Message::SSH_MSG_CHANNEL_OPEN_CONFIRMATION::VALUE
-          channel_open_confirmation payload
-        when Message::SSH_MSG_CHANNEL_REQUEST::VALUE
-          channel_request payload
-        when Message::SSH_MSG_CHANNEL_WINDOW_ADJUST::VALUE
-          channel_window_adjust payload
-        when Message::SSH_MSG_CHANNEL_DATA::VALUE
-          channel_data payload
-        when Message::SSH_MSG_CHANNEL_EOF::VALUE
-          channel_eof payload
-        when Message::SSH_MSG_CHANNEL_CLOSE::VALUE
-          channel_close payload
-        else
-          @logger.warn { "received unsupported message: id: #{payload[0,1].unpack("C")[0]}" }
+          close
+          @logger.info { "connection loop closed" }
         end
       end
-      @logger.info { "closing connection" }
-      close
-      @logger.info { "connection closed" }
     end
 
     def global_request payload
@@ -149,11 +172,40 @@ module HrrRbSsh
         channel.start
         send_channel_open_confirmation channel
       rescue => e
+        @logger.error { [e.backtrace[0], ": ", e.message, " (", e.class.to_s, ")\n\t", e.backtrace[1..-1].join("\n\t")].join }
         recipient_channel = message[:'sender channel']
         send_channel_open_failure recipient_channel, Message::SSH_MSG_CHANNEL_OPEN_FAILURE::ReasonCode::SSH_OPEN_CONNECT_FAILED, e.message
       end
     end
 
+    def request_channel_open channel_type, channel_specific_message={}, wait_response=true
+      @logger.info { 'request channel open' }
+      case channel_type
+      when "session"
+        channel = Channel.new self, {:'channel type' => channel_type}
+        @channels[channel.local_channel] = channel
+      end
+      message = {
+        :'message number'             => Message::SSH_MSG_CHANNEL_OPEN::VALUE,
+        :'channel type'               => channel_type,
+        :'sender channel'             => channel.local_channel,
+        :'initial window size'        => channel.local_window_size,
+        :'maximum packet size'        => channel.local_maximum_packet_size,
+      }
+      send_channel_open message.merge(channel_specific_message)
+      @logger.info { 'sent channel open' }
+      if wait_response
+        @logger.info { 'wait response' }
+        channel.wait_until_started
+      end
+      unless channel.closed?
+        @logger.info { 'channel opened' }
+        channel
+      else
+        raise "Faild opening channel"
+      end
+    end
+
     def channel_open_confirmation payload
       @logger.info { 'received ' + Message::SSH_MSG_CHANNEL_OPEN_CONFIRMATION::ID }
       message = Message::SSH_MSG_CHANNEL_OPEN_CONFIRMATION.decode payload
@@ -183,12 +235,18 @@ module HrrRbSsh
       @channels[local_channel].receive_message_queue.enq message
     end
 
+    def channel_extended_data payload
+      @logger.info { 'received ' + Message::SSH_MSG_CHANNEL_EXTENDED_DATA::ID }
+      message = Message::SSH_MSG_CHANNEL_EXTENDED_DATA.decode payload
+      local_channel = message[:'recipient channel']
+      @channels[local_channel].receive_message_queue.enq message
+    end
+
     def channel_eof payload
       @logger.info { 'received ' + Message::SSH_MSG_CHANNEL_EOF::ID }
       message = Message::SSH_MSG_CHANNEL_EOF.decode payload
       local_channel = message[:'recipient channel']
-      channel = @channels[local_channel]
-      channel.receive_message_queue.close
+      @channels[local_channel].receive_message_queue.enq message
     end
 
     def channel_close payload
@@ -197,6 +255,9 @@ module HrrRbSsh
       local_channel = message[:'recipient channel']
       channel = @channels[local_channel]
       channel.close
+      @logger.info { "wait until threads closed in channel" }
+      channel.wait_until_closed
+      @logger.info { "channel closed" }
       @logger.info { "deleting channel" }
       @channels.delete local_channel
       @logger.info { "channel deleted" }

data/lib/hrr_rb_ssh/logger.rb

@@ -25,31 +25,31 @@ module HrrRbSsh
 
     def fatal
       if @@logger
-        @@logger.fatal { "#{@name}: #{yield}" }
+        @@logger.fatal { "p#{Process.pid}.t#{Thread.current.object_id}: #{@name}: #{yield}" }
       end
     end
 
     def error
       if @@logger
-        @@logger.error { "#{@name}: #{yield}" }
+        @@logger.error { "p#{Process.pid}.t#{Thread.current.object_id}: #{@name}: #{yield}" }
       end
     end
 
     def warn
       if @@logger
-        @@logger.warn { "#{@name}: #{yield}" }
+        @@logger.warn { "p#{Process.pid}.t#{Thread.current.object_id}: #{@name}: #{yield}" }
       end
     end
 
     def info
       if @@logger
-        @@logger.info { "#{@name}: #{yield}" }
+        @@logger.info { "p#{Process.pid}.t#{Thread.current.object_id}: #{@name}: #{yield}" }
       end
     end
 
     def debug
       if @@logger
-        @@logger.debug { "#{@name}: #{yield}" }
+        @@logger.debug { "p#{Process.pid}.t#{Thread.current.object_id}: #{@name}: #{yield}" }
       end
     end
   end

data/lib/hrr_rb_ssh/server.rb

@@ -20,9 +20,9 @@ module HrrRbSsh
 
     def start io
       @logger.info { "start server service" }
-      transport      = HrrRbSsh::Transport.new      io, HrrRbSsh::Mode::SERVER, @options
-      authentication = HrrRbSsh::Authentication.new transport, @options
-      connection     = HrrRbSsh::Connection.new     authentication, @options
+      transport      = Transport.new      io, Mode::SERVER, @options
+      authentication = Authentication.new transport, Mode::SERVER, @options
+      connection     = Connection.new     authentication, Mode::SERVER, @options
       connection.start
     end
   end

data/lib/hrr_rb_ssh/transport/kex_algorithm/diffie_hellman.rb

@@ -22,74 +22,79 @@ module HrrRbSsh
             @dh.g = OpenSSL::BN.new(self.class::G)
           end
           @dh.generate_key!
+          @public_key = @dh.pub_key.to_i
         end
 
-        def start transport, mode
-          case mode
+        def start transport
+          case transport.mode
           when Mode::SERVER
-            receive_kexdh_init transport.receive
+            @k_s = transport.server_host_key_algorithm.server_public_host_key
+            @f   = @public_key
+            message = receive_kexdh_init transport.receive
+            @e = message[:'e']
+            @shared_secret = OpenSSL::BN.new(@dh.compute_key(OpenSSL::BN.new(@e)), 2).to_i
             send_kexdh_reply transport
-          else
-            raise "unsupported mode"
+          when Mode::CLIENT
+            @e   = @public_key
+            send_kexdh_init transport
+            message = receive_kexdh_reply transport.receive
+            @k_s = message[:'server public host key and certificates (K_S)']
+            @f   = message[:'f']
+            @shared_secret = OpenSSL::BN.new(@dh.compute_key(OpenSSL::BN.new(@f)), 2).to_i
           end
         end
 
-        def set_e e
-          @e = e
-        end
-
         def shared_secret
-          k = OpenSSL::BN.new(@dh.compute_key(OpenSSL::BN.new(@e)), 2).to_i
-        end
-
-        def pub_key
-          f = @dh.pub_key.to_i
+          @shared_secret
         end
 
         def hash transport
-          e = @e
-          k = shared_secret
-          f = pub_key
-
           h0_payload = {
             :'V_C' => transport.v_c,
             :'V_S' => transport.v_s,
             :'I_C' => transport.i_c,
             :'I_S' => transport.i_s,
-            :'K_S' => transport.server_host_key_algorithm.server_public_host_key,
-            :'e'   => e,
-            :'f'   => f,
-            :'k'   => k,
+            :'K_S' => @k_s,
+            :'e'   => @e,
+            :'f'   => @f,
+            :'k'   => @shared_secret,
           }
           h0 = H0.encode h0_payload
-
-          h = OpenSSL::Digest.digest self.class::DIGEST, h0
-
-          h
+          h  = OpenSSL::Digest.digest self.class::DIGEST, h0
         end
 
         def sign transport
           h = hash transport
           s = transport.server_host_key_algorithm.sign h
-
-          s
         end
 
         def receive_kexdh_init payload
-          message = Message::SSH_MSG_KEXDH_INIT.decode payload
-          set_e message[:'e']
+          Message::SSH_MSG_KEXDH_INIT.decode payload
         end
 
         def send_kexdh_reply transport
           message = {
             :'message number'                                => Message::SSH_MSG_KEXDH_REPLY::VALUE,
-            :'server public host key and certificates (K_S)' => transport.server_host_key_algorithm.server_public_host_key,
-            :'f'                                             => pub_key,
+            :'server public host key and certificates (K_S)' => @k_s,
+            :'f'                                             => @f,
             :'signature of H'                                => sign(transport),
           }
           payload = Message::SSH_MSG_KEXDH_REPLY.encode message
           transport.send payload
         end
+
+        def send_kexdh_init transport
+          message = {
+            :'message number' => Message::SSH_MSG_KEXDH_INIT::VALUE,
+            :'e'              => @e,
+          }
+          payload = Message::SSH_MSG_KEXDH_INIT.encode message
+          transport.send payload
+        end
+
+        def receive_kexdh_reply payload
+          Message::SSH_MSG_KEXDH_REPLY.decode payload
+        end
       end
     end
   end

data/lib/hrr_rb_ssh/transport/kex_algorithm/diffie_hellman_group_exchange.rb

@@ -16,25 +16,50 @@ module HrrRbSsh
           @logger = Logger.new(self.class.name)
         end
 
-        def start transport, mode
-          case mode
+        def start transport
+          case transport.mode
           when Mode::SERVER
-            receive_kex_dh_gex_request transport.receive
-            set_dh
+            message = receive_kex_dh_gex_request transport.receive
+            @min = message[:'min']
+            @n   = message[:'n']
+            @max = message[:'max']
+            initialize_dh
+            @p = @dh.p.to_i
+            @g = @dh.g.to_i
             send_kex_dh_gex_group transport
-            receive_kex_dh_gex_init transport.receive
+            @k_s = transport.server_host_key_algorithm.server_public_host_key
+            @f   = @public_key
+            message = receive_kex_dh_gex_init transport.receive
+            @e   = message[:'e']
+            @shared_secret = OpenSSL::BN.new(@dh.compute_key(OpenSSL::BN.new(@e)), 2).to_i
             send_kex_dh_gex_reply transport
-          else
-            raise "unsupported mode"
+          when Mode::CLIENT
+            @min = 1024
+            @n   = 2048
+            @max = 8192
+            send_kex_dh_gex_request transport
+            message = receive_kex_dh_gex_group transport.receive
+            @p   = message[:'p']
+            @g   = message[:'g']
+            initialize_dh [@p, @g]
+            @e   = @public_key
+            send_kex_dh_gex_init transport
+            message = receive_kex_dh_gex_reply transport.receive
+            @k_s = message[:'server public host key and certificates (K_S)']
+            @f   = message[:'f']
+            @shared_secret = OpenSSL::BN.new(@dh.compute_key(OpenSSL::BN.new(@f)), 2).to_i
           end
         end
 
-        def set_dh
-          p_list = KexAlgorithm.list_supported.map{ |e| KexAlgorithm[e] }.select{ |e| e.const_defined?(:P) }.map{ |e| [OpenSSL::BN.new(e::P,16).num_bits, e::P] }.sort_by{ |e| e[0] }.reverse
-          candidate = p_list.find{ |e| e[0] <= @n }
-          raise unless (@min .. @max).include?(candidate[0])
-          p = candidate[1]
-          g = 2
+        def initialize_dh pg=nil
+          unless pg
+            p_list = KexAlgorithm.list_supported.map{ |e| KexAlgorithm[e] }.select{ |e| e.const_defined?(:P) }.map{ |e| [OpenSSL::BN.new(e::P,16).num_bits, e::P] }.sort_by{ |e| e[0] }.reverse
+            candidate = p_list.find{ |e| e[0] <= @n }
+            raise unless (@min .. @max).include?(candidate[0])
+            p, g = candidate[1], 2
+          else
+            p, g = pg
+          end
           @dh = OpenSSL::PKey::DH.new
           if @dh.respond_to?(:set_pqg)
             @dh.set_pqg OpenSSL::BN.new(p, 16), nil, OpenSSL::BN.new(g)
@@ -43,85 +68,94 @@ module HrrRbSsh
             @dh.g = OpenSSL::BN.new(g)
           end
           @dh.generate_key!
-        end
-
-        def set_e e
-          @e = e
+          @public_key = @dh.pub_key.to_i
         end
 
         def shared_secret
-          k = OpenSSL::BN.new(@dh.compute_key(OpenSSL::BN.new(@e)), 2).to_i
-        end
-
-        def pub_key
-          f = @dh.pub_key.to_i
+          @shared_secret
         end
 
         def hash transport
-          e = @e
-          k = shared_secret
-          f = pub_key
-
           h0_payload = {
             :'V_C' => transport.v_c,
             :'V_S' => transport.v_s,
             :'I_C' => transport.i_c,
             :'I_S' => transport.i_s,
-            :'K_S' => transport.server_host_key_algorithm.server_public_host_key,
+            :'K_S' => @k_s,
             :'min' => @min,
             :'n'   => @n,
             :'max' => @max,
-            :'p'   => @dh.p.to_i,
-            :'g'   => @dh.g.to_i,
-            :'e'   => e,
-            :'f'   => f,
-            :'k'   => k,
+            :'p'   => @p,
+            :'g'   => @g,
+            :'e'   => @e,
+            :'f'   => @f,
+            :'k'   => @shared_secret,
           }
           h0 = H0.encode h0_payload
-
           h = OpenSSL::Digest.digest self.class::DIGEST, h0
-
-          h
         end
 
         def sign transport
           h = hash transport
           s = transport.server_host_key_algorithm.sign h
-          s
         end
 
         def receive_kex_dh_gex_request payload
-          message = Message::SSH_MSG_KEX_DH_GEX_REQUEST.decode payload
-          @min = message[:'min']
-          @n   = message[:'n']
-          @max = message[:'max']
+          Message::SSH_MSG_KEX_DH_GEX_REQUEST.decode payload
         end
 
         def send_kex_dh_gex_group transport
           message = {
             :'message number' => Message::SSH_MSG_KEX_DH_GEX_GROUP::VALUE,
-            :'p'              => @dh.p.to_i,
-            :'g'              => @dh.g.to_i,
+            :'p'              => @p,
+            :'g'              => @g,
           }
           payload = Message::SSH_MSG_KEX_DH_GEX_GROUP.encode message
           transport.send payload
         end
 
         def receive_kex_dh_gex_init payload
-          message = Message::SSH_MSG_KEX_DH_GEX_INIT.decode payload
-          set_e message[:'e']
+          Message::SSH_MSG_KEX_DH_GEX_INIT.decode payload
         end
 
         def send_kex_dh_gex_reply transport
           message = {
             :'message number'                                => Message::SSH_MSG_KEX_DH_GEX_REPLY::VALUE,
-            :'server public host key and certificates (K_S)' => transport.server_host_key_algorithm.server_public_host_key,
-            :'f'                                             => pub_key,
+            :'server public host key and certificates (K_S)' => @k_s,
+            :'f'                                             => @f,
             :'signature of H'                                => sign(transport),
           }
           payload = Message::SSH_MSG_KEX_DH_GEX_REPLY.encode message
           transport.send payload
         end
+
+        def send_kex_dh_gex_request transport
+          message = {
+            :'message number' => Message::SSH_MSG_KEX_DH_GEX_REQUEST::VALUE,
+            :'min'            => @min,
+            :'n'              => @n,
+            :'max'            => @max,
+          }
+          payload = Message::SSH_MSG_KEX_DH_GEX_REQUEST.encode message
+          transport.send payload
+        end
+
+        def receive_kex_dh_gex_group payload
+          Message::SSH_MSG_KEX_DH_GEX_GROUP.decode payload
+        end
+
+        def send_kex_dh_gex_init transport
+          message = {
+            :'message number' => Message::SSH_MSG_KEX_DH_GEX_INIT::VALUE,
+            :'e'              => @e,
+          }
+          payload = Message::SSH_MSG_KEX_DH_GEX_INIT.encode message
+          transport.send payload
+        end
+
+        def receive_kex_dh_gex_reply payload
+          Message::SSH_MSG_KEX_DH_GEX_REPLY.decode payload
+        end
       end
     end
   end

data/lib/hrr_rb_ssh/transport/kex_algorithm/elliptic_curve_diffie_hellman.rb

@@ -16,74 +16,79 @@ module HrrRbSsh
           @logger = Logger.new(self.class.name)
           @dh = OpenSSL::PKey::EC.new(self.class::CURVE_NAME)
           @dh.generate_key
+          @public_key = @dh.public_key.to_bn.to_i
         end
 
-        def start transport, mode
-          case mode
+        def start transport
+          case transport.mode
           when Mode::SERVER
-            receive_kexecdh_init transport.receive
+            @k_s = transport.server_host_key_algorithm.server_public_host_key
+            @q_s = @public_key
+            message = receive_kexecdh_init transport.receive
+            @q_c = message[:'Q_C']
+            @shared_secret = OpenSSL::BN.new(@dh.dh_compute_key(OpenSSL::PKey::EC::Point.new(OpenSSL::PKey::EC.new(self.class::CURVE_NAME).group, OpenSSL::BN.new(@q_c))), 2).to_i
             send_kexecdh_reply transport
-          else
-            raise "unsupported mode"
+          when Mode::CLIENT
+            @q_c = @public_key
+            send_kexecdh_init transport
+            message = receive_kexecdh_reply transport.receive
+            @k_s = message[:'K_S']
+            @q_s = message[:'Q_S']
+            @shared_secret = OpenSSL::BN.new(@dh.dh_compute_key(OpenSSL::PKey::EC::Point.new(OpenSSL::PKey::EC.new(self.class::CURVE_NAME).group, OpenSSL::BN.new(@q_s))), 2).to_i
           end
         end
 
-        def set_q_c q_c
-          @q_c = q_c
-        end
-
         def shared_secret
-          k = OpenSSL::BN.new(@dh.dh_compute_key(OpenSSL::PKey::EC::Point.new(OpenSSL::PKey::EC.new(self.class::CURVE_NAME).group, OpenSSL::BN.new(@q_c))), 2).to_i
-        end
-
-        def public_key
-          f = @dh.public_key.to_bn.to_i
+          @shared_secret
         end
 
         def hash transport
-          q_c = @q_c
-          q_s = public_key
-          k   = shared_secret
-
           h0_payload = {
             :'V_C' => transport.v_c,
             :'V_S' => transport.v_s,
             :'I_C' => transport.i_c,
             :'I_S' => transport.i_s,
-            :'K_S' => transport.server_host_key_algorithm.server_public_host_key,
-            :'Q_C' => q_c,
-            :'Q_S' => q_s,
-            :'K'   => k,
+            :'K_S' => @k_s,
+            :'Q_C' => @q_c,
+            :'Q_S' => @q_s,
+            :'K'   => @shared_secret,
           }
           h0 = H0.encode h0_payload
-
-          h = OpenSSL::Digest.digest self.class::DIGEST, h0
-
-          h
+          h  = OpenSSL::Digest.digest self.class::DIGEST, h0
         end
 
         def sign transport
           h = hash transport
           s = transport.server_host_key_algorithm.sign h
-
-          s
         end
 
         def receive_kexecdh_init payload
-          message = Message::SSH_MSG_KEXECDH_INIT.decode payload
-          set_q_c message[:'Q_C']
+          Message::SSH_MSG_KEXECDH_INIT.decode payload
         end
 
         def send_kexecdh_reply transport
           message = {
             :'message number' => Message::SSH_MSG_KEXECDH_REPLY::VALUE,
-            :'K_S'            => transport.server_host_key_algorithm.server_public_host_key,
-            :'Q_S'            => public_key,
+            :'K_S'            => @k_s,
+            :'Q_S'            => @q_s,
             :'signature of H' => sign(transport),
           }
           payload = Message::SSH_MSG_KEXECDH_REPLY.encode message
           transport.send payload
         end
+
+        def send_kexecdh_init transport
+          message = {
+            :'message number' => Message::SSH_MSG_KEXECDH_INIT::VALUE,
+            :'Q_C'            => @q_c,
+          }
+          payload = Message::SSH_MSG_KEXECDH_INIT.encode message
+          transport.send payload
+        end
+
+        def receive_kexecdh_reply payload
+          Message::SSH_MSG_KEXECDH_REPLY.decode payload
+        end
       end
     end
   end