hrr_rb_ssh 0.1.9 → 0.2.0

data/lib/hrr_rb_ssh/connection.rb

@@ -2,7 +2,7 @@
 # vim: et ts=2 sw=2
 
 require 'hrr_rb_ssh/logger'
-require 'hrr_rb_ssh/closed_connection_error'
+require 'hrr_rb_ssh/error/closed_connection'
 require 'hrr_rb_ssh/connection/global_request_handler'
 require 'hrr_rb_ssh/connection/channel'
 
@@ -13,7 +13,7 @@ module HrrRbSsh
       :options
 
     def initialize authentication, options={}
-      @logger = HrrRbSsh::Logger.new self.class.name
+      @logger = Logger.new self.class.name
 
       @authentication = authentication
       @options = options
@@ -25,11 +25,11 @@ module HrrRbSsh
     end
 
     def send payload
-      raise ClosedConnectionError if @closed
+      raise Error::ClosedConnection if @closed
       begin
         @authentication.send payload
-      rescue ClosedAuthenticationError
-        raise ClosedConnectionError
+      rescue Error::ClosedAuthentication
+        raise Error::ClosedConnection
       end
     end
 
@@ -71,27 +71,27 @@ module HrrRbSsh
       loop do
         begin
           payload = @authentication.receive
-        rescue HrrRbSsh::ClosedAuthenticationError => e
+        rescue Error::ClosedAuthentication => 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
+        when Message::SSH_MSG_GLOBAL_REQUEST::VALUE
           global_request payload
-        when HrrRbSsh::Message::SSH_MSG_CHANNEL_OPEN::VALUE
+        when Message::SSH_MSG_CHANNEL_OPEN::VALUE
           channel_open payload
-        when HrrRbSsh::Message::SSH_MSG_CHANNEL_OPEN_CONFIRMATION::VALUE
+        when Message::SSH_MSG_CHANNEL_OPEN_CONFIRMATION::VALUE
           channel_open_confirmation payload
-        when HrrRbSsh::Message::SSH_MSG_CHANNEL_REQUEST::VALUE
+        when Message::SSH_MSG_CHANNEL_REQUEST::VALUE
           channel_request payload
-        when HrrRbSsh::Message::SSH_MSG_CHANNEL_WINDOW_ADJUST::VALUE
+        when Message::SSH_MSG_CHANNEL_WINDOW_ADJUST::VALUE
           channel_window_adjust payload
-        when HrrRbSsh::Message::SSH_MSG_CHANNEL_DATA::VALUE
+        when Message::SSH_MSG_CHANNEL_DATA::VALUE
           channel_data payload
-        when HrrRbSsh::Message::SSH_MSG_CHANNEL_EOF::VALUE
+        when Message::SSH_MSG_CHANNEL_EOF::VALUE
           channel_eof payload
-        when HrrRbSsh::Message::SSH_MSG_CHANNEL_CLOSE::VALUE
+        when Message::SSH_MSG_CHANNEL_CLOSE::VALUE
           channel_close payload
         else
           @logger.warn { "received unsupported message: id: #{payload[0,1].unpack("C")[0]}" }
@@ -103,8 +103,8 @@ module HrrRbSsh
     end
 
     def global_request payload
-      @logger.info { 'received ' + HrrRbSsh::Message::SSH_MSG_GLOBAL_REQUEST::ID }
-      message = HrrRbSsh::Message::SSH_MSG_GLOBAL_REQUEST.decode payload
+      @logger.info { 'received ' + Message::SSH_MSG_GLOBAL_REQUEST::ID }
+      message = Message::SSH_MSG_GLOBAL_REQUEST.decode payload
       begin
         @global_request_handler.request message
       rescue
@@ -124,7 +124,7 @@ module HrrRbSsh
       @channels[channel.local_channel] = channel
       @logger.info { 'channel opened' }
       message = {
-        :'message number'             => HrrRbSsh::Message::SSH_MSG_CHANNEL_OPEN::VALUE,
+        :'message number'             => Message::SSH_MSG_CHANNEL_OPEN::VALUE,
         :'channel type'               => "forwarded-tcpip",
         :'sender channel'             => channel.local_channel,
         :'initial window size'        => channel.local_window_size,
@@ -138,8 +138,8 @@ module HrrRbSsh
     end
 
     def channel_open payload
-      @logger.info { 'received ' + HrrRbSsh::Message::SSH_MSG_CHANNEL_OPEN::ID }
-      message = HrrRbSsh::Message::SSH_MSG_CHANNEL_OPEN.decode payload
+      @logger.info { 'received ' + Message::SSH_MSG_CHANNEL_OPEN::ID }
+      message = Message::SSH_MSG_CHANNEL_OPEN.decode payload
       begin
         channel = Channel.new self, message
         @channels[channel.local_channel] = channel
@@ -152,45 +152,45 @@ module HrrRbSsh
     end
 
     def channel_open_confirmation payload
-      @logger.info { 'received ' + HrrRbSsh::Message::SSH_MSG_CHANNEL_OPEN_CONFIRMATION::ID }
-      message = HrrRbSsh::Message::SSH_MSG_CHANNEL_OPEN_CONFIRMATION.decode payload
+      @logger.info { 'received ' + Message::SSH_MSG_CHANNEL_OPEN_CONFIRMATION::ID }
+      message = Message::SSH_MSG_CHANNEL_OPEN_CONFIRMATION.decode payload
       channel = @channels[message[:'recipient channel']]
       channel.set_remote_parameters message
       channel.start
     end
 
     def channel_request payload
-      @logger.info { 'received ' + HrrRbSsh::Message::SSH_MSG_CHANNEL_REQUEST::ID }
-      message = HrrRbSsh::Message::SSH_MSG_CHANNEL_REQUEST.decode payload
+      @logger.info { 'received ' + Message::SSH_MSG_CHANNEL_REQUEST::ID }
+      message = Message::SSH_MSG_CHANNEL_REQUEST.decode payload
       local_channel = message[:'recipient channel']
       @channels[local_channel].receive_message_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
+      @logger.info { 'received ' + Message::SSH_MSG_CHANNEL_WINDOW_ADJUST::ID }
+      message = Message::SSH_MSG_CHANNEL_WINDOW_ADJUST.decode payload
       local_channel = message[:'recipient channel']
       @channels[local_channel].receive_message_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
+      @logger.info { 'received ' + Message::SSH_MSG_CHANNEL_DATA::ID }
+      message = Message::SSH_MSG_CHANNEL_DATA.decode payload
       local_channel = message[:'recipient channel']
       @channels[local_channel].receive_message_queue.enq message
     end
 
     def channel_eof payload
-      @logger.info { 'received ' + HrrRbSsh::Message::SSH_MSG_CHANNEL_EOF::ID }
-      message = HrrRbSsh::Message::SSH_MSG_CHANNEL_EOF.decode 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
     end
 
     def channel_close payload
-      @logger.info { 'received ' + HrrRbSsh::Message::SSH_MSG_CHANNEL_CLOSE::ID }
-      message = HrrRbSsh::Message::SSH_MSG_CHANNEL_CLOSE.decode payload
+      @logger.info { 'received ' + Message::SSH_MSG_CHANNEL_CLOSE::ID }
+      message = Message::SSH_MSG_CHANNEL_CLOSE.decode payload
       local_channel = message[:'recipient channel']
       channel = @channels[local_channel]
       channel.close
@@ -201,47 +201,47 @@ module HrrRbSsh
 
     def send_request_success
       message = {
-        :'message number' => HrrRbSsh::Message::SSH_MSG_REQUEST_SUCCESS::VALUE,
+        :'message number' => Message::SSH_MSG_REQUEST_SUCCESS::VALUE,
       }
-      payload = HrrRbSsh::Message::SSH_MSG_REQUEST_SUCCESS.encode message
+      payload = Message::SSH_MSG_REQUEST_SUCCESS.encode message
       @authentication.send payload
     end
 
     def send_request_failure
       message = {
-        :'message number' => HrrRbSsh::Message::SSH_MSG_REQUEST_FAILURE::VALUE,
+        :'message number' => Message::SSH_MSG_REQUEST_FAILURE::VALUE,
       }
-      payload = HrrRbSsh::Message::SSH_MSG_REQUEST_FAILURE.encode message
+      payload = Message::SSH_MSG_REQUEST_FAILURE.encode message
       @authentication.send payload
     end
 
     def send_channel_open message
-      payload = HrrRbSsh::Message::SSH_MSG_CHANNEL_OPEN.encode message
+      payload = Message::SSH_MSG_CHANNEL_OPEN.encode message
       @authentication.send payload
     end
 
     def send_channel_open_confirmation channel
       message = {
-        :'message number'      => HrrRbSsh::Message::SSH_MSG_CHANNEL_OPEN_CONFIRMATION::VALUE,
+        :'message number'      => Message::SSH_MSG_CHANNEL_OPEN_CONFIRMATION::VALUE,
         :'channel type'        => channel.channel_type,
         :'recipient channel'   => channel.remote_channel,
         :'sender channel'      => channel.local_channel,
         :'initial window size' => channel.local_window_size,
         :'maximum packet size' => channel.local_maximum_packet_size,
       }
-      payload = HrrRbSsh::Message::SSH_MSG_CHANNEL_OPEN_CONFIRMATION.encode message
+      payload = Message::SSH_MSG_CHANNEL_OPEN_CONFIRMATION.encode message
       @authentication.send payload
     end
 
     def send_channel_open_failure recipient_channel, reason_code, description
       message = {
-        :'message number'      => HrrRbSsh::Message::SSH_MSG_CHANNEL_OPEN_FAILURE::VALUE,
+        :'message number'      => Message::SSH_MSG_CHANNEL_OPEN_FAILURE::VALUE,
         :'recipient channel'   => recipient_channel,
         :'reason code'         => reason_code,
         :'description'         => description,
         :'language tag'        => "",
       }
-      payload = HrrRbSsh::Message::SSH_MSG_CHANNEL_OPEN_FAILURE.encode message
+      payload = Message::SSH_MSG_CHANNEL_OPEN_FAILURE.encode message
       @authentication.send payload
     end
   end

data/lib/hrr_rb_ssh/data_type.rb

@@ -93,9 +93,6 @@ module HrrRbSsh
         unless arg.kind_of? ::Integer
           raise ArgumentError, "must be a kind of Integer, but got #{arg.inspect}"
         end
-        if arg.size > 0xffff_ffff
-          raise ArgumentError, "must be shorter than or equal to #{0xffff_ffff}, but got length #{arg.size}"
-        end
         bn = ::OpenSSL::BN.new(arg)
         if bn < 0
           # get 2's complement

data/lib/hrr_rb_ssh/error/closed_authentication.rb

@@ -0,0 +1,9 @@
+# coding: utf-8
+# vim: et ts=2 sw=2
+
+module HrrRbSsh
+  class Error
+    class ClosedAuthentication < Error
+    end
+  end
+end

data/lib/hrr_rb_ssh/{closed_transport_error.rb → error/closed_connection.rb}

@@ -2,6 +2,8 @@
 # vim: et ts=2 sw=2
 
 module HrrRbSsh
-  class ClosedTransportError < StandardError
+  class Error
+    class ClosedConnection < Error
+    end
   end
 end

data/lib/hrr_rb_ssh/{closed_authentication_error.rb → error/closed_transport.rb}

@@ -2,6 +2,8 @@
 # vim: et ts=2 sw=2
 
 module HrrRbSsh
-  class ClosedAuthenticationError < StandardError
+  class Error
+    class ClosedTransport < Error
+    end
   end
 end

data/lib/hrr_rb_ssh/error.rb

@@ -0,0 +1,11 @@
+# coding: utf-8
+# vim: et ts=2 sw=2
+
+module HrrRbSsh
+  class Error < ::StandardError
+  end
+end
+
+require 'hrr_rb_ssh/error/closed_transport'
+require 'hrr_rb_ssh/error/closed_authentication'
+require 'hrr_rb_ssh/error/closed_connection'

data/lib/hrr_rb_ssh/{closed_connection_error.rb → mode.rb}

@@ -2,6 +2,8 @@
 # vim: et ts=2 sw=2
 
 module HrrRbSsh
-  class ClosedConnectionError < StandardError
+  module Mode
+    SERVER = :server
+    CLIENT = :client
   end
 end

data/lib/hrr_rb_ssh/server.rb

@@ -0,0 +1,23 @@
+# coding: utf-8
+# vim: et ts=2 sw=2
+
+require 'hrr_rb_ssh/logger'
+require 'hrr_rb_ssh/transport'
+require 'hrr_rb_ssh/authentication'
+require 'hrr_rb_ssh/connection'
+
+module HrrRbSsh
+  class Server
+    def initialize io, options={}
+      @logger = Logger.new self.class.name
+      @transport      = HrrRbSsh::Transport.new      io, HrrRbSsh::Mode::SERVER, options
+      @authentication = HrrRbSsh::Authentication.new @transport, options
+      @connection     = HrrRbSsh::Connection.new     @authentication, options
+    end
+
+    def start
+      @logger.info { "start server service" }
+      @connection.start
+    end
+  end
+end

data/lib/hrr_rb_ssh/transport/compression_algorithm/functionable.rb

@@ -9,7 +9,7 @@ module HrrRbSsh
     class CompressionAlgorithm
       module Functionable
         def initialize direction
-          @logger = HrrRbSsh::Logger.new(self.class.name)
+          @logger = Logger.new(self.class.name)
           case direction
           when Direction::OUTGOING
             @deflator = ::Zlib::Deflate.new

data/lib/hrr_rb_ssh/transport/compression_algorithm/unfunctionable.rb

@@ -8,7 +8,7 @@ module HrrRbSsh
     class CompressionAlgorithm
       module Unfunctionable
         def initialize direction=nil
-          @logger = HrrRbSsh::Logger.new(self.class.name)
+          @logger = Logger.new(self.class.name)
         end
 
         def deflate data

data/lib/hrr_rb_ssh/transport/encryption_algorithm/functionable.rb

@@ -14,12 +14,12 @@ module HrrRbSsh
         end
 
         def initialize direction, iv, key
-          @logger = HrrRbSsh::Logger.new(self.class.name)
+          @logger = Logger.new(self.class.name)
           @cipher = OpenSSL::Cipher.new(self.class::CIPHER_NAME)
           case direction
-          when HrrRbSsh::Transport::Direction::OUTGOING
+          when Direction::OUTGOING
             @cipher.encrypt
-          when HrrRbSsh::Transport::Direction::INCOMING
+          when Direction::INCOMING
             @cipher.decrypt
           end
           @cipher.padding = 0

data/lib/hrr_rb_ssh/transport/encryption_algorithm/unfunctionable.rb

@@ -13,7 +13,7 @@ module HrrRbSsh
         end
 
         def initialize direction=nil, iv=nil, key=nil
-          @logger = HrrRbSsh::Logger.new(self.class.name)
+          @logger = Logger.new(self.class.name)
         end
 
         def block_size

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

@@ -4,13 +4,16 @@
 require 'openssl'
 require 'hrr_rb_ssh/logger'
 require 'hrr_rb_ssh/data_type'
+require 'hrr_rb_ssh/transport/kex_algorithm/iv_computable'
 
 module HrrRbSsh
   class Transport
     class KexAlgorithm
       module DiffieHellman
+        include IvComputable
+
         def initialize
-          @logger = HrrRbSsh::Logger.new(self.class.name)
+          @logger = Logger.new(self.class.name)
           @dh = OpenSSL::PKey::DH.new
           if @dh.respond_to?(:set_pqg)
             @dh.set_pqg OpenSSL::BN.new(self.class::P, 16), nil, OpenSSL::BN.new(self.class::G)
@@ -23,7 +26,7 @@ module HrrRbSsh
 
         def start transport, mode
           case mode
-          when HrrRbSsh::Transport::Mode::SERVER
+          when Mode::SERVER
             receive_kexdh_init transport.receive
             send_kexdh_reply transport
           else
@@ -72,62 +75,19 @@ module HrrRbSsh
           s
         end
 
-        def build_key(_k, h, _x, session_id, key_length)
-          k = DataType::Mpint.encode _k
-          x = DataType::Byte.encode _x
-
-          key = OpenSSL::Digest.digest(self.class::DIGEST, k + h + x + session_id)
-
-          while key.length < key_length
-            key = key + OpenSSL::Digest.digest(self.class::DIGEST, k + h + key )
-          end
-
-          key[0, key_length]
-        end
-
-        def iv_c_to_s transport, encryption_algorithm_c_to_s_name
-          key_length = HrrRbSsh::Transport::EncryptionAlgorithm[encryption_algorithm_c_to_s_name]::IV_LENGTH
-          build_key(shared_secret, hash(transport), 'A'.ord, transport.session_id, key_length)
-        end
-
-        def iv_s_to_c transport, encryption_algorithm_s_to_c_name
-          key_length = HrrRbSsh::Transport::EncryptionAlgorithm[encryption_algorithm_s_to_c_name]::IV_LENGTH
-          build_key(shared_secret, hash(transport), 'B'.ord, transport.session_id, key_length)
-        end
-
-        def key_c_to_s transport, encryption_algorithm_c_to_s_name
-          key_length = HrrRbSsh::Transport::EncryptionAlgorithm[encryption_algorithm_c_to_s_name]::KEY_LENGTH
-          build_key(shared_secret, hash(transport), 'C'.ord, transport.session_id, key_length)
-        end
-
-        def key_s_to_c transport, encryption_algorithm_s_to_c_name
-          key_length = HrrRbSsh::Transport::EncryptionAlgorithm[encryption_algorithm_s_to_c_name]::KEY_LENGTH
-          build_key(shared_secret, hash(transport), 'D'.ord, transport.session_id, key_length)
-        end
-
-        def mac_c_to_s transport, mac_algorithm_c_to_s_name
-          key_length = HrrRbSsh::Transport::MacAlgorithm[mac_algorithm_c_to_s_name]::KEY_LENGTH
-          build_key(shared_secret, hash(transport), 'E'.ord, transport.session_id, key_length)
-        end
-
-        def mac_s_to_c transport, mac_algorithm_s_to_c_name
-          key_length = HrrRbSsh::Transport::MacAlgorithm[mac_algorithm_s_to_c_name]::KEY_LENGTH
-          build_key(shared_secret, hash(transport), 'F'.ord, transport.session_id, key_length)
-        end
-
         def receive_kexdh_init payload
-          message = HrrRbSsh::Message::SSH_MSG_KEXDH_INIT.decode payload
+          message = Message::SSH_MSG_KEXDH_INIT.decode payload
           set_e message[:'e']
         end
 
         def send_kexdh_reply transport
           message = {
-            :'message number'                                => HrrRbSsh::Message::SSH_MSG_KEXDH_REPLY::VALUE,
+            :'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,
             :'signature of H'                                => sign(transport),
           }
-          payload = HrrRbSsh::Message::SSH_MSG_KEXDH_REPLY.encode message
+          payload = Message::SSH_MSG_KEXDH_REPLY.encode message
           transport.send payload
         end
       end

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

@@ -4,18 +4,21 @@
 require 'openssl'
 require 'hrr_rb_ssh/logger'
 require 'hrr_rb_ssh/data_type'
+require 'hrr_rb_ssh/transport/kex_algorithm/iv_computable'
 
 module HrrRbSsh
   class Transport
     class KexAlgorithm
       module DiffieHellmanGroupExchange
+        include IvComputable
+
         def initialize
-          @logger = HrrRbSsh::Logger.new(self.class.name)
+          @logger = Logger.new(self.class.name)
         end
 
         def start transport, mode
           case mode
-          when HrrRbSsh::Transport::Mode::SERVER
+          when Mode::SERVER
             receive_kex_dh_gex_request transport.receive
             set_dh
             send_kex_dh_gex_group transport
@@ -87,51 +90,8 @@ module HrrRbSsh
           s
         end
 
-        def build_key(_k, h, _x, session_id, key_length)
-          k = DataType::Mpint.encode _k
-          x = DataType::Byte.encode _x
-
-          key = OpenSSL::Digest.digest(self.class::DIGEST, k + h + x + session_id)
-
-          while key.length < key_length
-            key = key + OpenSSL::Digest.digest(self.class::DIGEST, k + h + key )
-          end
-
-          key[0, key_length]
-        end
-
-        def iv_c_to_s transport, encryption_algorithm_c_to_s_name
-          key_length = HrrRbSsh::Transport::EncryptionAlgorithm[encryption_algorithm_c_to_s_name]::IV_LENGTH
-          build_key(shared_secret, hash(transport), 'A'.ord, transport.session_id, key_length)
-        end
-
-        def iv_s_to_c transport, encryption_algorithm_s_to_c_name
-          key_length = HrrRbSsh::Transport::EncryptionAlgorithm[encryption_algorithm_s_to_c_name]::IV_LENGTH
-          build_key(shared_secret, hash(transport), 'B'.ord, transport.session_id, key_length)
-        end
-
-        def key_c_to_s transport, encryption_algorithm_c_to_s_name
-          key_length = HrrRbSsh::Transport::EncryptionAlgorithm[encryption_algorithm_c_to_s_name]::KEY_LENGTH
-          build_key(shared_secret, hash(transport), 'C'.ord, transport.session_id, key_length)
-        end
-
-        def key_s_to_c transport, encryption_algorithm_s_to_c_name
-          key_length = HrrRbSsh::Transport::EncryptionAlgorithm[encryption_algorithm_s_to_c_name]::KEY_LENGTH
-          build_key(shared_secret, hash(transport), 'D'.ord, transport.session_id, key_length)
-        end
-
-        def mac_c_to_s transport, mac_algorithm_c_to_s_name
-          key_length = HrrRbSsh::Transport::MacAlgorithm[mac_algorithm_c_to_s_name]::KEY_LENGTH
-          build_key(shared_secret, hash(transport), 'E'.ord, transport.session_id, key_length)
-        end
-
-        def mac_s_to_c transport, mac_algorithm_s_to_c_name
-          key_length = HrrRbSsh::Transport::MacAlgorithm[mac_algorithm_s_to_c_name]::KEY_LENGTH
-          build_key(shared_secret, hash(transport), 'F'.ord, transport.session_id, key_length)
-        end
-
         def receive_kex_dh_gex_request payload
-          message = HrrRbSsh::Message::SSH_MSG_KEX_DH_GEX_REQUEST.decode payload
+          message = Message::SSH_MSG_KEX_DH_GEX_REQUEST.decode payload
           @min = message[:'min']
           @n   = message[:'n']
           @max = message[:'max']
@@ -139,27 +99,27 @@ module HrrRbSsh
 
         def send_kex_dh_gex_group transport
           message = {
-            :'message number' => HrrRbSsh::Message::SSH_MSG_KEX_DH_GEX_GROUP::VALUE,
+            :'message number' => Message::SSH_MSG_KEX_DH_GEX_GROUP::VALUE,
             :'p'              => @dh.p.to_i,
             :'g'              => @dh.g.to_i,
           }
-          payload = HrrRbSsh::Message::SSH_MSG_KEX_DH_GEX_GROUP.encode message
+          payload = Message::SSH_MSG_KEX_DH_GEX_GROUP.encode message
           transport.send payload
         end
 
         def receive_kex_dh_gex_init payload
-          message = HrrRbSsh::Message::SSH_MSG_KEX_DH_GEX_INIT.decode payload
+          message = Message::SSH_MSG_KEX_DH_GEX_INIT.decode payload
           set_e message[:'e']
         end
 
         def send_kex_dh_gex_reply transport
           message = {
-            :'message number'                                => HrrRbSsh::Message::SSH_MSG_KEX_DH_GEX_REPLY::VALUE,
+            :'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,
             :'signature of H'                                => sign(transport),
           }
-          payload = HrrRbSsh::Message::SSH_MSG_KEX_DH_GEX_REPLY.encode message
+          payload = Message::SSH_MSG_KEX_DH_GEX_REPLY.encode message
           transport.send payload
         end
       end

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

@@ -4,20 +4,23 @@
 require 'openssl'
 require 'hrr_rb_ssh/logger'
 require 'hrr_rb_ssh/data_type'
+require 'hrr_rb_ssh/transport/kex_algorithm/iv_computable'
 
 module HrrRbSsh
   class Transport
     class KexAlgorithm
       module EllipticCurveDiffieHellman
+        include IvComputable
+
         def initialize
-          @logger = HrrRbSsh::Logger.new(self.class.name)
+          @logger = Logger.new(self.class.name)
           @dh = OpenSSL::PKey::EC.new(self.class::CURVE_NAME)
           @dh.generate_key
         end
 
         def start transport, mode
           case mode
-          when HrrRbSsh::Transport::Mode::SERVER
+          when Mode::SERVER
             receive_kexecdh_init transport.receive
             send_kexecdh_reply transport
           else
@@ -66,62 +69,19 @@ module HrrRbSsh
           s
         end
 
-        def build_key(_k, h, _x, session_id, key_length)
-          k = DataType::Mpint.encode _k
-          x = DataType::Byte.encode _x
-
-          key = OpenSSL::Digest.digest(self.class::DIGEST, k + h + x + session_id)
-
-          while key.length < key_length
-            key = key + OpenSSL::Digest.digest(self.class::DIGEST, k + h + key )
-          end
-
-          key[0, key_length]
-        end
-
-        def iv_c_to_s transport, encryption_algorithm_c_to_s_name
-          key_length = HrrRbSsh::Transport::EncryptionAlgorithm[encryption_algorithm_c_to_s_name]::IV_LENGTH
-          build_key(shared_secret, hash(transport), 'A'.ord, transport.session_id, key_length)
-        end
-
-        def iv_s_to_c transport, encryption_algorithm_s_to_c_name
-          key_length = HrrRbSsh::Transport::EncryptionAlgorithm[encryption_algorithm_s_to_c_name]::IV_LENGTH
-          build_key(shared_secret, hash(transport), 'B'.ord, transport.session_id, key_length)
-        end
-
-        def key_c_to_s transport, encryption_algorithm_c_to_s_name
-          key_length = HrrRbSsh::Transport::EncryptionAlgorithm[encryption_algorithm_c_to_s_name]::KEY_LENGTH
-          build_key(shared_secret, hash(transport), 'C'.ord, transport.session_id, key_length)
-        end
-
-        def key_s_to_c transport, encryption_algorithm_s_to_c_name
-          key_length = HrrRbSsh::Transport::EncryptionAlgorithm[encryption_algorithm_s_to_c_name]::KEY_LENGTH
-          build_key(shared_secret, hash(transport), 'D'.ord, transport.session_id, key_length)
-        end
-
-        def mac_c_to_s transport, mac_algorithm_c_to_s_name
-          key_length = HrrRbSsh::Transport::MacAlgorithm[mac_algorithm_c_to_s_name]::KEY_LENGTH
-          build_key(shared_secret, hash(transport), 'E'.ord, transport.session_id, key_length)
-        end
-
-        def mac_s_to_c transport, mac_algorithm_s_to_c_name
-          key_length = HrrRbSsh::Transport::MacAlgorithm[mac_algorithm_s_to_c_name]::KEY_LENGTH
-          build_key(shared_secret, hash(transport), 'F'.ord, transport.session_id, key_length)
-        end
-
         def receive_kexecdh_init payload
-          message = HrrRbSsh::Message::SSH_MSG_KEXECDH_INIT.decode payload
+          message = Message::SSH_MSG_KEXECDH_INIT.decode payload
           set_q_c message[:'Q_C']
         end
 
         def send_kexecdh_reply transport
           message = {
-            :'message number' => HrrRbSsh::Message::SSH_MSG_KEXECDH_REPLY::VALUE,
+            :'message number' => Message::SSH_MSG_KEXECDH_REPLY::VALUE,
             :'K_S'            => transport.server_host_key_algorithm.server_public_host_key,
             :'Q_S'            => public_key,
             :'signature of H' => sign(transport),
           }
-          payload = HrrRbSsh::Message::SSH_MSG_KEXECDH_REPLY.encode message
+          payload = Message::SSH_MSG_KEXECDH_REPLY.encode message
           transport.send payload
         end
       end