sonixlabs-net-ssh 2.3.0

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

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

@@ -0,0 +1,80 @@
+require 'net/ssh/errors'
+require 'net/ssh/transport/constants'
+require 'net/ssh/transport/kex/diffie_hellman_group1_sha1'
+
+module Net::SSH::Transport::Kex
+
+  # A key-exchange service implementing the
+  # "diffie-hellman-group-exchange-sha1" key-exchange algorithm.
+  class DiffieHellmanGroupExchangeSHA1 < DiffieHellmanGroup1SHA1
+    MINIMUM_BITS      = 1024
+    MAXIMUM_BITS      = 8192
+
+    KEXDH_GEX_GROUP   = 31
+    KEXDH_GEX_INIT    = 32
+    KEXDH_GEX_REPLY   = 33
+    KEXDH_GEX_REQUEST = 34
+
+    private
+
+      # Compute the number of bits needed for the given number of bytes.
+      def compute_need_bits
+
+        # for Compatibility: OpenSSH requires (need_bits * 2 + 1) length of parameter
+        need_bits = data[:need_bytes] * 8 * 2 + 1
+
+        if need_bits < MINIMUM_BITS
+          need_bits = MINIMUM_BITS
+        elsif need_bits > MAXIMUM_BITS
+          need_bits = MAXIMUM_BITS
+        end
+
+        data[:need_bits ] = need_bits
+        data[:need_bytes] = need_bits / 8
+      end
+
+      # Returns the DH key parameters for the given session.
+      def get_parameters
+        compute_need_bits
+
+        # request the DH key parameters for the given number of bits.
+        buffer = Net::SSH::Buffer.from(:byte, KEXDH_GEX_REQUEST, :long, MINIMUM_BITS,
+          :long, data[:need_bits], :long, MAXIMUM_BITS)
+        connection.send_message(buffer)
+
+        buffer = connection.next_message
+        unless buffer.type == KEXDH_GEX_GROUP
+          raise Net::SSH::Exception, "expected KEXDH_GEX_GROUP, got #{buffer.type}"
+        end
+
+        p = buffer.read_bignum
+        g = buffer.read_bignum
+
+        [p, g]
+      end
+
+      # Returns the INIT/REPLY constants used by this algorithm.
+      def get_message_types
+        [KEXDH_GEX_INIT, KEXDH_GEX_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_long MINIMUM_BITS,
+                            data[:need_bits],
+                            MAXIMUM_BITS
+        response.write_bignum dh.p, dh.g, dh.pub_key,
+                              result[:server_dh_pubkey],
+                              result[:shared_secret]
+        response
+      end
+  end
+
+end

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

@@ -0,0 +1,15 @@
+require 'net/ssh/transport/kex/diffie_hellman_group_exchange_sha1'
+
+module Net::SSH::Transport::Kex
+  if defined?(OpenSSL::Digest::SHA256)
+    # A key-exchange service implementing the
+    # "diffie-hellman-group-exchange-sha256" key-exchange algorithm.
+    class DiffieHellmanGroupExchangeSHA256 < DiffieHellmanGroupExchangeSHA1
+      def initialize(*args)
+        super(*args)
+
+        @digester = OpenSSL::Digest::SHA256
+      end
+    end
+  end
+end

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

@@ -0,0 +1,26 @@
+module Net; module SSH; module Transport
+  module KeyExpander
+
+  # Generate a key value in accordance with the SSH2 specification.
+  # (RFC4253 7.2. "Output from Key Exchange")
+  def self.expand_key(bytes, start, options={})
+    if bytes == 0
+      return ""
+    end
+
+    k = start[0, bytes]
+
+    digester = options[:digester] or raise 'No digester supplied'
+    shared   = options[:shared] or raise 'No shared secret supplied'
+    hash     = options[:hash] or raise 'No hash supplied'
+
+    while k.length < bytes
+      step = digester.digest(shared + hash + k)
+      bytes_needed = bytes - k.length
+      k << step[0, bytes_needed]
+    end
+
+    return k
+  end
+end
+end; end; end

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

@@ -0,0 +1,127 @@
+require 'openssl'
+
+module OpenSSL
+
+  # This class is originally defined in the OpenSSL module. As needed, methods
+  # have been added to it by the Net::SSH module for convenience in dealing with
+  # SSH functionality.
+  class BN
+
+    # Converts a BN object to a string. The format used is that which is
+    # required by the SSH2 protocol.
+    def to_ssh
+      if zero?
+        return [0].pack("N")
+      else
+        buf = to_s(2)
+        if buf.getbyte(0)[7] == 1
+          return [buf.length+1, 0, buf].pack("NCA*")
+        else
+          return [buf.length, buf].pack("NA*")
+        end
+      end
+    end
+
+  end
+
+  module PKey
+
+    class PKey
+      def fingerprint
+        @fingerprint ||= OpenSSL::Digest::MD5.hexdigest(to_blob).scan(/../).join(":")
+      end
+    end
+
+    # This class is originally defined in the OpenSSL module. As needed, methods
+    # have been added to it by the Net::SSH module for convenience in dealing
+    # with SSH functionality.
+    class DH
+
+      # Determines whether the pub_key for this key is valid. (This algorithm
+      # lifted more-or-less directly from OpenSSH, dh.c, dh_pub_is_valid.)
+      def valid?
+        return false if pub_key.nil? || pub_key < 0
+        bits_set = 0
+        pub_key.num_bits.times { |i| bits_set += 1 if pub_key.bit_set?(i) }
+        return ( bits_set > 1 && pub_key < p )
+      end
+
+    end
+
+    # This class is originally defined in the OpenSSL module. As needed, methods
+    # have been added to it by the Net::SSH module for convenience in dealing
+    # with SSH functionality.
+    class RSA
+
+      # Returns "ssh-rsa", which is the description of this key type used by the
+      # SSH2 protocol.
+      def ssh_type
+        "ssh-rsa"
+      end
+
+      # Converts the key to a blob, according to the SSH2 protocol.
+      def to_blob
+        @blob ||= Net::SSH::Buffer.from(:string, ssh_type, :bignum, e, :bignum, n).to_s
+      end
+
+      # Verifies the given signature matches the given data.
+      def ssh_do_verify(sig, data)
+        verify(OpenSSL::Digest::SHA1.new, sig, data)
+      end
+
+      # Returns the signature for the given data.
+      def ssh_do_sign(data)
+        sign(OpenSSL::Digest::SHA1.new, data)
+      end
+    end
+
+    # This class is originally defined in the OpenSSL module. As needed, methods
+    # have been added to it by the Net::SSH module for convenience in dealing
+    # with SSH functionality.
+    class DSA
+
+      # Returns "ssh-dss", which is the description of this key type used by the
+      # SSH2 protocol.
+      def ssh_type
+        "ssh-dss"
+      end
+
+      # Converts the key to a blob, according to the SSH2 protocol.
+      def to_blob
+        @blob ||= Net::SSH::Buffer.from(:string, ssh_type,
+          :bignum, p, :bignum, q, :bignum, g, :bignum, pub_key).to_s
+      end
+
+      # Verifies the given signature matches the given data.
+      def ssh_do_verify(sig, data)
+        sig_r = sig[0,20].unpack("H*")[0].to_i(16)
+        sig_s = sig[20,20].unpack("H*")[0].to_i(16)
+        a1sig = OpenSSL::ASN1::Sequence([
+           OpenSSL::ASN1::Integer(sig_r),
+           OpenSSL::ASN1::Integer(sig_s)
+        ])
+        return verify(OpenSSL::Digest::DSS1.new, a1sig.to_der, data)
+      end
+
+      # Signs the given data.
+      def ssh_do_sign(data)
+        sig = sign( OpenSSL::Digest::DSS1.new, data)
+        a1sig = OpenSSL::ASN1.decode( sig )
+
+        sig_r = a1sig.value[0].value.to_s(2)
+        sig_s = a1sig.value[1].value.to_s(2)
+
+        if sig_r.length > 20 || sig_s.length > 20
+          raise OpenSSL::PKey::DSAError, "bad sig size"
+        end
+
+        sig_r = "\0" * ( 20 - sig_r.length ) + sig_r if sig_r.length < 20
+        sig_s = "\0" * ( 20 - sig_s.length ) + sig_s if sig_s.length < 20
+
+        return sig_r + sig_s
+      end
+    end
+
+  end
+
+end