hrr_rb_ssh 0.1.4 → 0.1.5

data/lib/hrr_rb_ssh/authentication/method/publickey/algorithm/ecdsa_sha2_nistp521.rb

@@ -0,0 +1,84 @@
+# coding: utf-8
+# vim: et ts=2 sw=2
+
+require 'hrr_rb_ssh/logger'
+require 'hrr_rb_ssh/data_type'
+
+module HrrRbSsh
+  class Authentication
+    class Method
+      class Publickey
+        class Algorithm
+          class EcdsaSha2Nistp521 < Algorithm
+            NAME = 'ecdsa-sha2-nistp521'
+            PREFERENCE = 50
+            DIGEST = 'sha512'
+            IDENTIFIER = 'nistp521'
+            CURVE_NAME = 'secp521r1'
+
+            def initialize
+              @logger = HrrRbSsh::Logger.new(self.class.name)
+            end
+
+            def verify_public_key public_key_algorithm_name, public_key, public_key_blob
+              public_key = case public_key
+                           when String
+                             OpenSSL::PKey::EC.new(public_key)
+                           when OpenSSL::PKey::EC
+                             public_key
+                           else
+                             return false
+                           end
+              public_key_message = {
+                :'public key algorithm name' => public_key_algorithm_name,
+                :'[identifier]'              => self.class::IDENTIFIER,
+                :'Q'                         => public_key.public_key.to_bn.to_s(2)
+              }
+              public_key_blob == PublicKeyBlob.encode(public_key_message)
+            end
+
+            def verify_signature session_id, message
+              signature_message   = Signature.decode message[:'signature']
+              signature_algorithm = signature_message[:'public key algorithm name']
+              signature_blob      = signature_message[:'signature blob']
+
+              public_key = PublicKeyBlob.decode message[:'public key blob']
+              algorithm = OpenSSL::PKey::EC.new(self.class::CURVE_NAME)
+              algorithm.public_key = OpenSSL::PKey::EC::Point.new(algorithm.group, OpenSSL::BN.new(public_key[:'Q'], 2))
+
+              data_message = {
+                :'session identifier'        => session_id,
+                :'message number'            => message[:'message number'],
+                :'user name'                 => message[:'user name'],
+                :'service name'              => message[:'service name'],
+                :'method name'               => message[:'method name'],
+                :'with signature'            => message[:'with signature'],
+                :'public key algorithm name' => message[:'public key algorithm name'],
+                :'public key blob'           => message[:'public key blob'],
+              }
+              data_blob = SignatureBlob.encode data_message
+
+              hash = OpenSSL::Digest.digest(DIGEST, data_blob)
+              ecdsa_signature_blob = EcdsaSignatureBlob.decode signature_blob
+              sign_r = ecdsa_signature_blob[:'r']
+              sign_s = ecdsa_signature_blob[:'s']
+              sign_asn1 = OpenSSL::ASN1::Sequence.new(
+                [
+                  OpenSSL::ASN1::Integer.new(OpenSSL::BN.new(sign_r)),
+                  OpenSSL::ASN1::Integer.new(OpenSSL::BN.new(sign_s)),
+                ]
+              )
+              sign_der = sign_asn1.to_der
+              (signature_algorithm == message[:'public key algorithm name']) && algorithm.dsa_verify_asn1(hash, sign_der)
+            end
+          end
+        end
+      end
+    end
+  end
+end
+
+require 'hrr_rb_ssh/authentication/method/publickey/algorithm/ecdsa_sha2_nistp521/public_key_blob'
+require 'hrr_rb_ssh/authentication/method/publickey/algorithm/ecdsa_sha2_nistp521/signature_blob'
+require 'hrr_rb_ssh/authentication/method/publickey/algorithm/ecdsa_sha2_nistp521/signature'
+require 'hrr_rb_ssh/authentication/method/publickey/algorithm/ecdsa_sha2_nistp521/ecdsa_signature_blob'

data/lib/hrr_rb_ssh/authentication/method/publickey/algorithm/ssh_dss/public_key_blob.rb

@@ -15,11 +15,11 @@ module HrrRbSsh
                 include Codable
               end
               DEFINITION = [
-                [DataType::String, 'public key algorithm name'],
-                [DataType::Mpint,  'p'],
-                [DataType::Mpint,  'q'],
-                [DataType::Mpint,  'g'],
-                [DataType::Mpint,  'y'],
+                [DataType::String, :'public key algorithm name'],
+                [DataType::Mpint,  :'p'],
+                [DataType::Mpint,  :'q'],
+                [DataType::Mpint,  :'g'],
+                [DataType::Mpint,  :'y'],
               ]
             end
           end

data/lib/hrr_rb_ssh/authentication/method/publickey/algorithm/ssh_dss/signature.rb

@@ -15,8 +15,8 @@ module HrrRbSsh
                 include Codable
               end
               DEFINITION = [
-                [DataType::String, 'public key algorithm name'],
-                [DataType::String, 'signature blob'],
+                [DataType::String, :'public key algorithm name'],
+                [DataType::String, :'signature blob'],
               ]
             end
           end

data/lib/hrr_rb_ssh/authentication/method/publickey/algorithm/ssh_dss/signature_blob.rb

@@ -15,14 +15,14 @@ module HrrRbSsh
                 include Codable
               end
               DEFINITION = [
-                [DataType::String,  'session identifier'],
-                [DataType::Byte,    'message number'],
-                [DataType::String,  'user name'],
-                [DataType::String,  'service name'],
-                [DataType::String,  'method name'],
-                [DataType::Boolean, 'with signature'],
-                [DataType::String,  'public key algorithm name'],
-                [DataType::String,  'public key blob'],
+                [DataType::String,  :'session identifier'],
+                [DataType::Byte,    :'message number'],
+                [DataType::String,  :'user name'],
+                [DataType::String,  :'service name'],
+                [DataType::String,  :'method name'],
+                [DataType::Boolean, :'with signature'],
+                [DataType::String,  :'public key algorithm name'],
+                [DataType::String,  :'public key blob'],
               ]
             end
           end

data/lib/hrr_rb_ssh/authentication/method/publickey/algorithm/ssh_dss.rb

@@ -28,44 +28,44 @@ module HrrRbSsh
                              return false
                            end
               public_key_message = {
-                'public key algorithm name' => public_key_algorithm_name,
-                'p'                         => public_key.p.to_i,
-                'g'                         => public_key.g.to_i,
-                'q'                         => public_key.q.to_i,
-                'y'                         => public_key.pub_key.to_i,
+                :'public key algorithm name' => public_key_algorithm_name,
+                :'p'                         => public_key.p.to_i,
+                :'g'                         => public_key.g.to_i,
+                :'q'                         => public_key.q.to_i,
+                :'y'                         => public_key.pub_key.to_i,
               }
               public_key_blob == PublicKeyBlob.encode(public_key_message)
             end
 
             def verify_signature session_id, message
-              signature_message   = Signature.decode message['signature']
-              signature_algorithm = signature_message['public key algorithm name']
-              signature_blob      = signature_message['signature blob']
+              signature_message   = Signature.decode message[:'signature']
+              signature_algorithm = signature_message[:'public key algorithm name']
+              signature_blob      = signature_message[:'signature blob']
 
-              public_key = PublicKeyBlob.decode message['public key blob']
+              public_key = PublicKeyBlob.decode message[:'public key blob']
               algorithm = OpenSSL::PKey::DSA.new
               if algorithm.respond_to?(:set_pqg)
-                algorithm.set_pqg public_key['p'], public_key['q'], public_key['g']
+                algorithm.set_pqg public_key[:'p'], public_key[:'q'], public_key[:'g']
               else
-                algorithm.p = public_key['p']
-                algorithm.q = public_key['q']
-                algorithm.g = public_key['g']
+                algorithm.p = public_key[:'p']
+                algorithm.q = public_key[:'q']
+                algorithm.g = public_key[:'g']
               end
               if algorithm.respond_to?(:set_key)
-                algorithm.set_key public_key['y'], nil
+                algorithm.set_key public_key[:'y'], nil
               else
-                algorithm.pub_key = public_key['y']
+                algorithm.pub_key = public_key[:'y']
               end
 
               data_message = {
-                'session identifier'        => session_id,
-                'message number'            => message['message number'],
-                'user name'                 => message['user name'],
-                'service name'              => message['service name'],
-                'method name'               => message['method name'],
-                'with signature'            => message['with signature'],
-                'public key algorithm name' => message['public key algorithm name'],
-                'public key blob'           => message['public key blob'],
+                :'session identifier'        => session_id,
+                :'message number'            => message[:'message number'],
+                :'user name'                 => message[:'user name'],
+                :'service name'              => message[:'service name'],
+                :'method name'               => message[:'method name'],
+                :'with signature'            => message[:'with signature'],
+                :'public key algorithm name' => message[:'public key algorithm name'],
+                :'public key blob'           => message[:'public key blob'],
               }
               data_blob = SignatureBlob.encode data_message
 
@@ -79,7 +79,7 @@ module HrrRbSsh
                 ]
               )
               sign_der = sign_asn1.to_der
-              (signature_algorithm == message['public key algorithm name']) && algorithm.sysverify(hash, sign_der)
+              (signature_algorithm == message[:'public key algorithm name']) && algorithm.sysverify(hash, sign_der)
             end
           end
         end

data/lib/hrr_rb_ssh/authentication/method/publickey/algorithm/ssh_rsa/public_key_blob.rb

@@ -15,9 +15,9 @@ module HrrRbSsh
                 include Codable
               end
               DEFINITION = [
-                [DataType::String, 'public key algorithm name'],
-                [DataType::Mpint,  'e'],
-                [DataType::Mpint,  'n'],
+                [DataType::String, :'public key algorithm name'],
+                [DataType::Mpint,  :'e'],
+                [DataType::Mpint,  :'n'],
               ]
             end
           end

data/lib/hrr_rb_ssh/authentication/method/publickey/algorithm/ssh_rsa/signature.rb

@@ -15,8 +15,8 @@ module HrrRbSsh
                 include Codable
               end
               DEFINITION = [
-                [DataType::String, 'public key algorithm name'],
-                [DataType::String, 'signature blob'],
+                [DataType::String, :'public key algorithm name'],
+                [DataType::String, :'signature blob'],
               ]
             end
           end

data/lib/hrr_rb_ssh/authentication/method/publickey/algorithm/ssh_rsa/signature_blob.rb

@@ -15,14 +15,14 @@ module HrrRbSsh
                 include Codable
               end
               DEFINITION = [
-                [DataType::String,  'session identifier'],
-                [DataType::Byte,    'message number'],
-                [DataType::String,  'user name'],
-                [DataType::String,  'service name'],
-                [DataType::String,  'method name'],
-                [DataType::Boolean, 'with signature'],
-                [DataType::String,  'public key algorithm name'],
-                [DataType::String,  'public key blob'],
+                [DataType::String,  :'session identifier'],
+                [DataType::Byte,    :'message number'],
+                [DataType::String,  :'user name'],
+                [DataType::String,  :'service name'],
+                [DataType::String,  :'method name'],
+                [DataType::Boolean, :'with signature'],
+                [DataType::String,  :'public key algorithm name'],
+                [DataType::String,  :'public key blob'],
               ]
             end
           end

data/lib/hrr_rb_ssh/authentication/method/publickey/algorithm/ssh_rsa.rb

@@ -28,40 +28,40 @@ module HrrRbSsh
                              return false
                            end
               public_key_message = {
-                'public key algorithm name' => public_key_algorithm_name,
-                'e'                         => public_key.e.to_i,
-                'n'                         => public_key.n.to_i,
+                :'public key algorithm name' => public_key_algorithm_name,
+                :'e'                         => public_key.e.to_i,
+                :'n'                         => public_key.n.to_i,
               }
               public_key_blob == PublicKeyBlob.encode(public_key_message)
             end
 
             def verify_signature session_id, message
-              signature_message   = Signature.decode message['signature']
-              signature_algorithm = signature_message['public key algorithm name']
-              signature_blob      = signature_message['signature blob']
+              signature_message   = Signature.decode message[:'signature']
+              signature_algorithm = signature_message[:'public key algorithm name']
+              signature_blob      = signature_message[:'signature blob']
 
-              public_key = PublicKeyBlob.decode message['public key blob']
+              public_key = PublicKeyBlob.decode message[:'public key blob']
               algorithm = OpenSSL::PKey::RSA.new
               if algorithm.respond_to?(:set_key)
-                algorithm.set_key public_key['n'], public_key['e'], nil
+                algorithm.set_key public_key[:'n'], public_key[:'e'], nil
               else
-                algorithm.e = public_key['e']
-                algorithm.n = public_key['n']
+                algorithm.e = public_key[:'e']
+                algorithm.n = public_key[:'n']
               end
 
               data_message = {
-                'session identifier'        => session_id,
-                'message number'            => message['message number'],
-                'user name'                 => message['user name'],
-                'service name'              => message['service name'],
-                'method name'               => message['method name'],
-                'with signature'            => message['with signature'],
-                'public key algorithm name' => message['public key algorithm name'],
-                'public key blob'           => message['public key blob'],
+                :'session identifier'        => session_id,
+                :'message number'            => message[:'message number'],
+                :'user name'                 => message[:'user name'],
+                :'service name'              => message[:'service name'],
+                :'method name'               => message[:'method name'],
+                :'with signature'            => message[:'with signature'],
+                :'public key algorithm name' => message[:'public key algorithm name'],
+                :'public key blob'           => message[:'public key blob'],
               }
               data_blob = SignatureBlob.encode data_message
 
-              (signature_algorithm == message['public key algorithm name']) && algorithm.verify(DIGEST, signature_blob, data_blob)
+              (signature_algorithm == message[:'public key algorithm name']) && algorithm.verify(DIGEST, signature_blob, data_blob)
             end
           end
         end

data/lib/hrr_rb_ssh/authentication/method/publickey/algorithm.rb

@@ -20,3 +20,6 @@ end
 
 require 'hrr_rb_ssh/authentication/method/publickey/algorithm/ssh_dss'
 require 'hrr_rb_ssh/authentication/method/publickey/algorithm/ssh_rsa'
+require 'hrr_rb_ssh/authentication/method/publickey/algorithm/ecdsa_sha2_nistp256'
+require 'hrr_rb_ssh/authentication/method/publickey/algorithm/ecdsa_sha2_nistp384'
+require 'hrr_rb_ssh/authentication/method/publickey/algorithm/ecdsa_sha2_nistp521'

data/lib/hrr_rb_ssh/authentication/method/publickey/context.rb

@@ -25,13 +25,13 @@ module HrrRbSsh
             @session_id = session_id
             @message    = message
 
-            @message_number            = message['message number']
-            @service_name              = message['service name']
-            @method_name               = message['method name']
-            @with_signature            = message['with signature']
-            @public_key_algorithm_name = message['public key algorithm name']
-            @public_key_blob           = message['public key blob']
-            @signature                 = message['signature']
+            @message_number            = message[:'message number']
+            @service_name              = message[:'service name']
+            @method_name               = message[:'method name']
+            @with_signature            = message[:'with signature']
+            @public_key_algorithm_name = message[:'public key algorithm name']
+            @public_key_blob           = message[:'public key blob']
+            @signature                 = message[:'signature']
           end
 
           def verify username, public_key_algorithm_name, public_key

data/lib/hrr_rb_ssh/authentication/method/publickey.rb

@@ -17,18 +17,18 @@ module HrrRbSsh
         end
 
         def authenticate userauth_request_message
-          public_key_algorithm_name = userauth_request_message['public key algorithm name']
+          public_key_algorithm_name = userauth_request_message[:'public key algorithm name']
           unless Algorithm.list_preferred.include?(public_key_algorithm_name)
             @logger.info("unsupported public key algorithm: #{public_key_algorithm_name}")
             return false
           end
-          unless userauth_request_message['with signature']
+          unless userauth_request_message[:'with signature']
             @logger.info("public key algorithm is ok, require signature")
-            public_key_blob = userauth_request_message['public key blob']
+            public_key_blob = userauth_request_message[:'public key blob']
             userauth_pk_ok_message public_key_algorithm_name, public_key_blob
           else
             @logger.info("verify signature")
-            username = userauth_request_message['user name']
+            username = userauth_request_message[:'user name']
             algorithm = Algorithm[public_key_algorithm_name].new
             context = Context.new(username, algorithm, @session_id, userauth_request_message)
             @authenticator.authenticate context
@@ -37,9 +37,9 @@ module HrrRbSsh
 
         def userauth_pk_ok_message public_key_algorithm_name, public_key_blob
           message = {
-            'message number'                             => HrrRbSsh::Message::SSH_MSG_USERAUTH_PK_OK::VALUE,
-            'public key algorithm name from the request' => public_key_algorithm_name,
-            'public key blob from the request'           => public_key_blob,
+            :'message number'                             => HrrRbSsh::Message::SSH_MSG_USERAUTH_PK_OK::VALUE,
+            :'public key algorithm name from the request' => public_key_algorithm_name,
+            :'public key blob from the request'           => public_key_blob,
           }
           payload = HrrRbSsh::Message::SSH_MSG_USERAUTH_PK_OK.encode message
         end

data/lib/hrr_rb_ssh/authentication.rb

@@ -68,14 +68,14 @@ module HrrRbSsh
         case payload[0,1].unpack("C")[0]
         when HrrRbSsh::Message::SSH_MSG_USERAUTH_REQUEST::VALUE
           userauth_request_message = HrrRbSsh::Message::SSH_MSG_USERAUTH_REQUEST.decode payload
-          method_name = userauth_request_message['method name']
+          method_name = userauth_request_message[:'method name']
           method = Method[method_name].new({'session id' => @transport.session_id}.merge(@options))
           result = method.authenticate(userauth_request_message)
           case result
           when TrueClass
             @logger.info("verified")
             send_userauth_success
-            @username = userauth_request_message['user name']
+            @username = userauth_request_message[:'user name']
             @closed = false
             break
           when FalseClass
@@ -94,9 +94,9 @@ module HrrRbSsh
 
     def send_userauth_failure
       message = {
-        'message number'                    => HrrRbSsh::Message::SSH_MSG_USERAUTH_FAILURE::VALUE,
-        'authentications that can continue' => Method.list_preferred,
-        'partial success'                   => false,
+        :'message number'                    => HrrRbSsh::Message::SSH_MSG_USERAUTH_FAILURE::VALUE,
+        :'authentications that can continue' => Method.list_preferred,
+        :'partial success'                   => false,
       }
       payload = HrrRbSsh::Message::SSH_MSG_USERAUTH_FAILURE.encode message
       @transport.send payload
@@ -104,7 +104,7 @@ module HrrRbSsh
 
     def send_userauth_success
       message = {
-        'message number' => HrrRbSsh::Message::SSH_MSG_USERAUTH_SUCCESS::VALUE,
+        :'message number' => HrrRbSsh::Message::SSH_MSG_USERAUTH_SUCCESS::VALUE,
       }
       payload = HrrRbSsh::Message::SSH_MSG_USERAUTH_SUCCESS.encode message
       @transport.send payload

data/lib/hrr_rb_ssh/codable.rb

@@ -25,8 +25,13 @@ module HrrRbSsh
       logger.debug('encoding message: ' + message.inspect)
       definition = common_definition + conditional_definition(message.merge complementary_message)
       definition.map{ |data_type, field_name|
-        field_value = if message[field_name].instance_of? ::Proc then message[field_name].call else message[field_name] end
-        data_type.encode( field_value )
+        begin
+          field_value = if message[field_name].instance_of? ::Proc then message[field_name].call else message[field_name] end
+          data_type.encode( field_value )
+        rescue => e
+          logger.debug("'field_name', 'field_value': #{field_name.inspect}, #{field_value.inspect}")
+          raise e
+        end
       }.join
     end
 

data/lib/hrr_rb_ssh/connection/channel/channel_type/direct_tcpip.rb

@@ -0,0 +1,102 @@
+# coding: utf-8
+# vim: et ts=2 sw=2
+
+require 'hrr_rb_ssh/logger'
+
+module HrrRbSsh
+  class Connection
+    class Channel
+      class ChannelType
+        class DirectTcpip < ChannelType
+          NAME = 'direct-tcpip'
+
+          def initialize connection, channel, message
+            @logger = HrrRbSsh::Logger.new self.class.name
+            @connection = connection
+            @channel = channel
+            @host_to_connect       = message[:'host to connect']
+            @port_to_connect       = message[:'port to connect']
+            @originator_IP_address = message[:'originator IP address']
+            @originator_port       = message[:'originator port']
+          end
+
+          def start
+            @socket = TCPSocket.new @host_to_connect, @port_to_connect
+            @sender_thread = sender_thread
+            @receiver_thread = receiver_thread
+          end
+
+          def close
+            begin
+              if @sender_thread_finished && @receiver_thread_finished
+                @logger.info("closing direct-tcpip")
+                @socket.close
+                @channel.close from=:channel_type_instance
+                @logger.info("direct-tcpip closed")
+              end
+            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
+
+          def sender_thread
+            Thread.new(@socket){ |s|
+              begin
+                loop do
+                  begin
+                    @channel.request_handler_io.write s.readpartial(10240)
+                  rescue EOFError
+                    @logger.info("socket is EOF")
+                    @channel.request_handler_io.close_write
+                    break
+                  rescue IOError
+                    @logger.info("socket is closed")
+                    @channel.request_handler_io.close_write
+                    break
+                  rescue => e
+                    @logger.error([e.backtrace[0], ": ", e.message, " (", e.class.to_s, ")\n\t", e.backtrace[1..-1].join("\n\t")].join)
+                    @channel.request_handler_io.close_write
+                    break
+                  end
+                end
+                @logger.info("finishing sender thread")
+                @sender_thread_finished = true
+                close
+              ensure
+                @logger.info("sender thread finished")
+              end
+            }
+          end
+
+          def receiver_thread
+            Thread.new(@socket){ |s|
+              begin
+                loop do
+                  begin
+                    s.write @channel.request_handler_io.readpartial(10240)
+                  rescue EOFError
+                    @logger.info("io is EOF")
+                    s.close_write
+                    break
+                  rescue IOError
+                    @logger.info("socket is closed")
+                    break
+                  rescue => e
+                    @logger.error([e.backtrace[0], ": ", e.message, " (", e.class.to_s, ")\n\t", e.backtrace[1..-1].join("\n\t")].join)
+                    s.close_write
+                    break
+                  end
+                end
+                @logger.info("finishing receiver thread")
+                @receiver_thread_finished = true
+                close
+              ensure
+                @logger.info("receiver thread finished")
+              end
+            }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/hrr_rb_ssh/connection/channel/channel_type/session/proc_chain/chain_context.rb

@@ -0,0 +1,26 @@
+# coding: utf-8
+# vim: et ts=2 sw=2
+
+require 'hrr_rb_ssh/logger'
+
+module HrrRbSsh
+  class Connection
+    class Channel
+      class ChannelType
+        class Session
+          class ProcChain
+            class ChainContext
+              def initialize proc_chain
+                @logger = HrrRbSsh::Logger.new self.class.name
+                @proc_chain = proc_chain
+              end
+              def call_next *args
+                @proc_chain.call_next *args
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,29 @@
+# coding: utf-8
+# vim: et ts=2 sw=2
+
+require 'hrr_rb_ssh/logger'
+require 'hrr_rb_ssh/connection/channel/channel_type/session/proc_chain/chain_context'
+
+module HrrRbSsh
+  class Connection
+    class Channel
+      class ChannelType
+        class Session
+          class ProcChain
+            def initialize
+              @logger = HrrRbSsh::Logger.new self.class.name
+              @q = Queue.new
+            end
+            def connect next_proc
+              @q.enq next_proc if next_proc
+            end
+            def call_next *args
+              next_proc = @q.deq
+              next_proc.call ChainContext.new(self), *args
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/hrr_rb_ssh/connection/channel/channel_type/session/request_type/env/context.rb

@@ -29,8 +29,8 @@ module HrrRbSsh
                   @variables  = variables
                   @vars       = variables
 
-                  @variable_name  = message['variable name']
-                  @variable_value = message['variable value']
+                  @variable_name  = message[:'variable name']
+                  @variable_value = message[:'variable value']
                 end
 
                 def chain_proc &block

data/lib/hrr_rb_ssh/connection/channel/channel_type/session/request_type/exec/context.rb

@@ -28,7 +28,7 @@ module HrrRbSsh
                   @variables  = variables
                   @vars       = variables
 
-                  @command = message['command']
+                  @command = message[:'command']
                 end
 
                 def chain_proc &block