net-ssh-net-ssh 2.0.12

data/lib/net/ssh/transport/constants.rb

@@ -0,0 +1,30 @@
+module Net; module SSH; module Transport
+  module Constants
+
+    #--
+    # Transport layer generic messages
+    #++
+
+    DISCONNECT                = 1
+    IGNORE                    = 2
+    UNIMPLEMENTED             = 3
+    DEBUG                     = 4
+    SERVICE_REQUEST           = 5
+    SERVICE_ACCEPT            = 6
+
+    #--
+    # Algorithm negotiation messages
+    #++
+
+    KEXINIT                   = 20
+    NEWKEYS                   = 21
+
+    #--
+    # Key exchange method specific messages
+    #++
+
+    KEXDH_INIT                = 30
+    KEXDH_REPLY               = 31
+
+  end
+end; end; end

data/lib/net/ssh/transport/hmac.rb

@@ -0,0 +1,31 @@
+require 'net/ssh/transport/hmac/md5'
+require 'net/ssh/transport/hmac/md5_96'
+require 'net/ssh/transport/hmac/sha1'
+require 'net/ssh/transport/hmac/sha1_96'
+require 'net/ssh/transport/hmac/none'
+
+# Implements a simple factory interface for fetching hmac implementations, or
+# for finding the key lengths for hmac implementations.s
+module Net::SSH::Transport::HMAC
+  # The mapping of SSH hmac algorithms to their implementations
+  MAP = {
+    'hmac-md5'     => MD5,
+    'hmac-md5-96'  => MD5_96,
+    'hmac-sha1'    => SHA1,
+    'hmac-sha1-96' => SHA1_96,
+    'none'         => None
+  }
+
+  # Retrieves a new hmac instance of the given SSH type (+name+). If +key+ is
+  # given, the new instance will be initialized with that key.
+  def self.get(name, key="")
+    impl = MAP[name] or raise ArgumentError, "hmac not found: #{name.inspect}"
+    impl.new(key)
+  end
+
+  # Retrieves the key length for the hmac of the given SSH type (+name+).
+  def self.key_length(name)
+    impl = MAP[name] or raise ArgumentError, "hmac not found: #{name.inspect}"
+    impl.key_length
+  end
+end

data/lib/net/ssh/transport/hmac/abstract.rb

@@ -0,0 +1,78 @@
+require 'openssl'
+
+module Net; module SSH; module Transport; module HMAC
+
+  # The base class of all OpenSSL-based HMAC algorithm wrappers.
+  class Abstract
+
+    class <<self
+      def key_length(*v)
+        @key_length = nil if !defined?(@key_length)
+        if v.empty?
+          @key_length = superclass.key_length if @key_length.nil? && superclass.respond_to?(:key_length)
+          return @key_length
+        elsif v.length == 1
+          @key_length = v.first
+        else
+          raise ArgumentError, "wrong number of arguments (#{v.length} for 1)"
+        end
+      end
+
+      def mac_length(*v)
+        @mac_length = nil if !defined?(@mac_length)
+        if v.empty?
+          @mac_length = superclass.mac_length if @mac_length.nil? && superclass.respond_to?(:mac_length)
+          return @mac_length
+        elsif v.length == 1
+          @mac_length = v.first
+        else
+          raise ArgumentError, "wrong number of arguments (#{v.length} for 1)"
+        end
+      end
+
+      def digest_class(*v)
+        @digest_class = nil if !defined?(@digest_class)
+        if v.empty?
+          @digest_class = superclass.digest_class if @digest_class.nil? && superclass.respond_to?(:digest_class)
+          return @digest_class
+        elsif v.length == 1
+          @digest_class = v.first
+        else
+          raise ArgumentError, "wrong number of arguments (#{v.length} for 1)"
+        end
+      end
+    end
+
+    def key_length
+      self.class.key_length
+    end
+
+    def mac_length
+      self.class.mac_length
+    end
+
+    def digest_class
+      self.class.digest_class
+    end
+
+    # The key in use for this instance.
+    attr_reader :key
+
+    def initialize(key=nil)
+      self.key = key
+    end
+
+    # Sets the key to the given value, truncating it so that it is the correct
+    # length.
+    def key=(value)
+      @key = value ? value.to_s[0,key_length] : nil
+    end
+
+    # Compute the HMAC digest for the given data string.
+    def digest(data)
+      OpenSSL::HMAC.digest(digest_class.new, key, data)[0,mac_length]
+    end
+
+  end
+
+end; end; end; end

data/lib/net/ssh/transport/hmac/md5.rb

@@ -0,0 +1,12 @@
+require 'net/ssh/transport/hmac/abstract'
+
+module Net::SSH::Transport::HMAC
+
+  # The MD5 HMAC algorithm.
+  class MD5 < Abstract
+    mac_length   16
+    key_length   16
+    digest_class OpenSSL::Digest::MD5
+  end
+
+end

data/lib/net/ssh/transport/hmac/md5_96.rb

@@ -0,0 +1,11 @@
+require 'net/ssh/transport/hmac/md5'
+
+module Net::SSH::Transport::HMAC
+
+  # The MD5-96 HMAC algorithm. This returns only the first 12 bytes of
+  # the digest.
+  class MD5_96 < MD5
+    mac_length 12
+  end
+
+end

data/lib/net/ssh/transport/hmac/none.rb

@@ -0,0 +1,15 @@
+require 'net/ssh/transport/hmac/abstract'
+
+module Net::SSH::Transport::HMAC
+
+  # The "none" algorithm. This has a key and mac length of 0.
+  class None < Abstract
+    key_length 0
+    mac_length 0
+
+    def digest(data)
+      ""
+    end
+  end
+
+end

data/lib/net/ssh/transport/hmac/sha1.rb

@@ -0,0 +1,13 @@
+require 'net/ssh/transport/hmac/abstract'
+
+module Net::SSH::Transport::HMAC
+
+  # The SHA1 HMAC algorithm. This has a mac and key length of 20, and
+  # uses the SHA1 digest algorithm.
+  class SHA1 < Abstract
+    mac_length   20
+    key_length   20
+    digest_class OpenSSL::Digest::SHA1
+  end
+
+end

data/lib/net/ssh/transport/hmac/sha1_96.rb

@@ -0,0 +1,11 @@
+require 'net/ssh/transport/hmac/sha1'
+
+module Net::SSH::Transport::HMAC
+
+  # The SHA1-96 HMAC algorithm. This returns only the first 12 bytes of
+  # the digest.
+  class SHA1_96 < SHA1
+    mac_length 12
+  end
+
+end

data/lib/net/ssh/transport/identity_cipher.rb

@@ -0,0 +1,55 @@
+module Net; module SSH; module Transport
+
+  # A cipher that does nothing but pass the data through, unchanged. This
+  # keeps things in the code nice and clean when a cipher has not yet been
+  # determined (i.e., during key exchange).
+  class IdentityCipher
+    class <<self
+      # A default block size of 8 is required by the SSH2 protocol.
+      def block_size
+        8
+      end
+
+      # Returns an arbitrary integer.
+      def iv_len
+        4
+      end
+
+      # Does nothing. Returns self.
+      def encrypt
+        self
+      end
+
+      # Does nothing. Returns self.
+      def decrypt
+        self
+      end
+
+      # Passes its single argument through unchanged.
+      def update(text)
+        text
+      end
+
+      # Returns the empty string.
+      def final
+        ""
+      end
+
+      # The name of this cipher, which is "identity".
+      def name
+        "identity"
+      end
+
+      # Does nothing. Returns nil.
+      def iv=(v)
+        nil
+      end
+
+      # Does nothing. Returns self.
+      def reset
+        self
+      end
+    end
+  end
+
+end; end; end

data/lib/net/ssh/transport/kex.rb

@@ -0,0 +1,13 @@
+require 'net/ssh/transport/kex/diffie_hellman_group1_sha1'
+require 'net/ssh/transport/kex/diffie_hellman_group_exchange_sha1'
+
+module Net::SSH::Transport
+  module Kex
+    # Maps the supported key-exchange algorithms as named by the SSH protocol
+    # to their corresponding implementors.
+    MAP = {
+      'diffie-hellman-group-exchange-sha1' => DiffieHellmanGroupExchangeSHA1,
+      'diffie-hellman-group1-sha1'         => DiffieHellmanGroup1SHA1
+    }
+  end
+end

data/lib/net/ssh/transport/kex/diffie_hellman_group1_sha1.rb

@@ -0,0 +1,208 @@
+require 'net/ssh/buffer'
+require 'net/ssh/errors'
+require 'net/ssh/loggable'
+require 'net/ssh/transport/openssl'
+require 'net/ssh/transport/constants'
+
+module Net; module SSH; module Transport; module Kex
+
+  # A key-exchange service implementing the "diffie-hellman-group1-sha1"
+  # key-exchange algorithm.
+  class DiffieHellmanGroup1SHA1
+    include Constants, Loggable
+
+    # The value of 'P', as a string, in hexadecimal
+    P_s = "FFFFFFFF" "FFFFFFFF" "C90FDAA2" "2168C234" +
+          "C4C6628B" "80DC1CD1" "29024E08" "8A67CC74" +
+          "020BBEA6" "3B139B22" "514A0879" "8E3404DD" +
+          "EF9519B3" "CD3A431B" "302B0A6D" "F25F1437" +
+          "4FE1356D" "6D51C245" "E485B576" "625E7EC6" +
+          "F44C42E9" "A637ED6B" "0BFF5CB6" "F406B7ED" +
+          "EE386BFB" "5A899FA5" "AE9F2411" "7C4B1FE6" +
+          "49286651" "ECE65381" "FFFFFFFF" "FFFFFFFF"
+
+    # The radix in which P_s represents the value of P
+    P_r = 16
+
+    # The group constant
+    G = 2
+
+    attr_reader :p
+    attr_reader :g
+    attr_reader :digester
+    attr_reader :algorithms
+    attr_reader :connection
+    attr_reader :data
+    attr_reader :dh
+
+    # Create a new instance of the DiffieHellmanGroup1SHA1 algorithm.
+    # The data is a Hash of symbols representing information
+    # required by this algorithm, which was acquired during earlier
+    # processing.
+    def initialize(algorithms, connection, data)
+      @p = OpenSSL::BN.new(P_s, P_r)
+      @g = G
+
+      @digester = OpenSSL::Digest::SHA1
+      @algorithms = algorithms
+      @connection = connection
+
+      @data = data.dup
+      @dh = generate_key
+      @logger = @data.delete(:logger)
+    end
+
+    # Perform the key-exchange for the given session, with the given
+    # data. This method will return a hash consisting of the
+    # following keys:
+    #
+    # * :session_id
+    # * :server_key
+    # * :shared_secret
+    # * :hashing_algorithm
+    #
+    # The caller is expected to be able to understand how to use these
+    # deliverables.
+    def exchange_keys
+      result = send_kexinit
+      verify_server_key(result[:server_key])
+      session_id = verify_signature(result)
+      confirm_newkeys
+
+      return { :session_id        => session_id, 
+               :server_key        => result[:server_key],
+               :shared_secret     => result[:shared_secret],
+               :hashing_algorithm => digester }
+    end
+
+    private
+    
+      # Returns the DH key parameters for the current connection.
+      def get_parameters
+        [p, g]
+      end
+
+      # Returns the INIT/REPLY constants used by this algorithm.
+      def get_message_types
+        [KEXDH_INIT, KEXDH_REPLY]
+      end
+
+      # Build the signature buffer to use when verifying a signature from
+      # the server.
+      def build_signature_buffer(result)
+        response = Net::SSH::Buffer.new
+        response.write_string data[:client_version_string],
+                              data[:server_version_string],
+                              data[:client_algorithm_packet],
+                              data[:server_algorithm_packet],
+                              result[:key_blob]
+        response.write_bignum dh.pub_key,
+                              result[:server_dh_pubkey],
+                              result[:shared_secret]
+        response
+      end
+
+      # Generate a DH key with a private key consisting of the given
+      # number of bytes.
+      def generate_key #:nodoc:
+        dh = OpenSSL::PKey::DH.new
+
+        dh.p, dh.g = get_parameters
+        dh.priv_key = OpenSSL::BN.rand(data[:need_bytes] * 8)
+
+        dh.generate_key! until dh.valid?
+
+        dh
+      end
+
+      # Send the KEXDH_INIT message, and expect the KEXDH_REPLY. Return the
+      # resulting buffer.
+      #
+      # Parse the buffer from a KEXDH_REPLY message, returning a hash of
+      # the extracted values.
+      def send_kexinit #:nodoc:
+        init, reply = get_message_types
+
+        # send the KEXDH_INIT message
+        buffer = Net::SSH::Buffer.from(:byte, init, :bignum, dh.pub_key)
+        connection.send_message(buffer)
+
+        # expect the KEXDH_REPLY message
+        buffer = connection.next_message
+        raise Net::SSH::Exception, "expected REPLY" unless buffer.type == reply
+
+        result = Hash.new
+
+        result[:key_blob] = buffer.read_string
+        result[:server_key] = Net::SSH::Buffer.new(result[:key_blob]).read_key
+        result[:server_dh_pubkey] = buffer.read_bignum
+        result[:shared_secret] = OpenSSL::BN.new(dh.compute_key(result[:server_dh_pubkey]), 2)
+
+        sig_buffer = Net::SSH::Buffer.new(buffer.read_string)
+        sig_type = sig_buffer.read_string
+        if sig_type != algorithms.host_key
+          raise Net::SSH::Exception,
+            "host key algorithm mismatch for signature " +
+            "'#{sig_type}' != '#{algorithms.host_key}'"
+        end
+        result[:server_sig] = sig_buffer.read_string
+
+        return result
+      end
+
+      # Verify that the given key is of the expected type, and that it
+      # really is the key for the session's host. Raise Net::SSH::Exception
+      # if it is not.
+      def verify_server_key(key) #:nodoc:
+        if key.ssh_type != algorithms.host_key
+          raise Net::SSH::Exception,
+            "host key algorithm mismatch " +
+            "'#{key.ssh_type}' != '#{algorithms.host_key}'"
+        end
+
+        blob, fingerprint = generate_key_fingerprint(key)
+
+        unless connection.host_key_verifier.verify(:key => key, :key_blob => blob, :fingerprint => fingerprint, :session => connection)
+          raise Net::SSH::Exception, "host key verification failed"
+        end
+      end
+
+      def generate_key_fingerprint(key)
+        blob = Net::SSH::Buffer.from(:key, key).to_s
+        fingerprint = OpenSSL::Digest::MD5.hexdigest(blob).scan(/../).join(":")
+
+        [blob, fingerprint]
+      rescue ::Exception => e
+        [nil, "(could not generate fingerprint: #{e.message})"]
+      end
+
+      # Verify the signature that was received. Raise Net::SSH::Exception
+      # if the signature could not be verified. Otherwise, return the new
+      # session-id.
+      def verify_signature(result) #:nodoc:
+        response = build_signature_buffer(result)
+
+        hash = @digester.digest(response.to_s)
+
+        unless result[:server_key].ssh_do_verify(result[:server_sig], hash)
+          raise Net::SSH::Exception, "could not verify server signature"
+        end
+
+        return hash
+      end
+
+      # Send the NEWKEYS message, and expect the NEWKEYS message in
+      # reply.
+      def confirm_newkeys #:nodoc:
+        # send own NEWKEYS message first (the wodSSHServer won't send first)
+        response = Net::SSH::Buffer.new
+        response.write_byte(NEWKEYS)
+        connection.send_message(response)
+
+        # wait for the server's NEWKEYS message
+        buffer = connection.next_message
+        raise Net::SSH::Exception, "expected NEWKEYS" unless buffer.type == NEWKEYS
+      end
+  end
+
+end; end; end; end