net-ssh-backports 6.3.0.backports

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

@@ -0,0 +1,40 @@
+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
+
+        KEXECDH_INIT              = 30
+        KEXECDH_REPLY             = 31
+
+        KEXDH_GEX_GROUP           = 31
+        KEXDH_GEX_INIT            = 32
+        KEXDH_GEX_REPLY           = 33
+        KEXDH_GEX_REQUEST         = 34
+      end
+    end
+  end
+end

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

@@ -0,0 +1,115 @@
+require 'openssl'
+require 'delegate'
+
+module Net::SSH::Transport
+  #:nodoc:
+  class OpenSSLAESCTR < SimpleDelegator
+    def initialize(original)
+      super
+      @was_reset = false
+    end
+
+    def block_size
+      16
+    end
+
+    def self.block_size
+      16
+    end
+
+    def reset
+      @was_reset = true
+    end
+
+    def iv=(iv_s)
+      super unless @was_reset
+    end
+  end
+
+  #:nodoc:
+  # Pure-Ruby implementation of Stateful Decryption Counter(SDCTR) Mode
+  # for Block Ciphers. See RFC4344 for detail.
+  module CTR
+    def self.extended(orig)
+      orig.instance_eval {
+        @remaining = String.new
+        @counter = nil
+        @counter_len = orig.block_size
+        orig.encrypt
+        orig.padding = 0
+
+        singleton_class.send(:alias_method, :_update, :update)
+        singleton_class.send(:private, :_update)
+        singleton_class.send(:undef_method, :update)
+
+        def iv
+          @counter
+        end
+
+        def iv_len
+          block_size
+        end
+
+        def iv=(iv_s)
+          @counter = iv_s if @counter.nil?
+        end
+
+        def encrypt
+          # DO NOTHING (always set to "encrypt")
+        end
+
+        def decrypt
+          # DO NOTHING (always set to "encrypt")
+        end
+
+        def padding=(pad)
+          # DO NOTHING (always 0)
+        end
+
+        def reset
+          @remaining = String.new
+        end
+
+        def update(data)
+          @remaining += data
+
+          encrypted = String.new
+
+          offset = 0
+          while (@remaining.bytesize - offset) >= block_size
+            encrypted += xor!(@remaining.slice(offset, block_size),
+                              _update(@counter))
+            increment_counter!
+            offset += block_size
+          end
+          @remaining = @remaining.slice(offset..-1)
+
+          encrypted
+        end
+
+        def final
+          s = @remaining.empty? ? '' : xor!(@remaining, _update(@counter))
+          @remaining = String.new
+          s
+        end
+
+        def xor!(s1, s2)
+          s = []
+          s1.unpack('Q*').zip(s2.unpack('Q*')) {|a,b| s.push(a ^ b) }
+          s.pack('Q*')
+        end
+        singleton_class.send(:private, :xor!)
+
+        def increment_counter!
+          c = @counter_len
+          while ((c -= 1) > 0)
+            if @counter.setbyte(c, (@counter.getbyte(c) + 1) & 0xff) != 0
+              break
+            end
+          end
+        end
+        singleton_class.send(:private, :increment_counter!)
+      }
+    end
+  end
+end

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

@@ -0,0 +1,97 @@
+require 'openssl'
+require 'openssl/digest'
+
+module Net
+  module SSH
+    module Transport
+      module HMAC
+        # The base class of all OpenSSL-based HMAC algorithm wrappers.
+        class Abstract
+          class <<self
+            def etm(*v)
+              @etm = false if !defined?(@etm)
+              if v.empty?
+                @etm = superclass.etm if @etm.nil? && superclass.respond_to?(:etm)
+                return @etm
+              elsif v.length == 1
+                @etm = v.first
+              else
+                raise ArgumentError, "wrong number of arguments (#{v.length} for 1)"
+              end
+            end
+
+            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 etm
+            self.class.etm
+          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,10 @@
+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,9 @@
+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,13 @@
+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/ripemd160.rb

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

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

@@ -0,0 +1,11 @@
+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,9 @@
+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/hmac/sha2_256.rb

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

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

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

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

@@ -0,0 +1,12 @@
+require 'net/ssh/transport/hmac/abstract'
+
+module Net::SSH::Transport::HMAC
+  # The SHA-256 Encrypt-Then-Mac HMAC algorithm. This has a mac and
+  # key length of 32, and uses the SHA-256 digest algorithm.
+  class SHA2_256_Etm < Abstract
+    etm          true
+    mac_length   32
+    key_length   32
+    digest_class OpenSSL::Digest::SHA256
+  end
+end

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

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

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

@@ -0,0 +1,9 @@
+require 'net/ssh/transport/hmac/abstract'
+
+module Net::SSH::Transport::HMAC
+  # The SHA2-512-96 HMAC algorithm. This returns only the first 12 bytes of
+  # the digest.
+  class SHA2_512_96 < SHA2_512
+    mac_length 12
+  end
+end

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

@@ -0,0 +1,12 @@
+require 'net/ssh/transport/hmac/abstract'
+
+module Net::SSH::Transport::HMAC
+  # The SHA-512 Encrypt-Then-Mac HMAC algorithm. This has a mac and
+  # key length of 64, and uses the SHA-512 digest algorithm.
+  class SHA2_512_Etm < Abstract
+    etm          true
+    mac_length   64
+    key_length   64
+    digest_class OpenSSL::Digest::SHA512
+  end
+end

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

@@ -0,0 +1,47 @@
+require 'net/ssh/transport/key_expander'
+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/sha2_256'
+require 'net/ssh/transport/hmac/sha2_256_96'
+require 'net/ssh/transport/hmac/sha2_512'
+require 'net/ssh/transport/hmac/sha2_512_96'
+require 'net/ssh/transport/hmac/sha2_256_etm'
+require 'net/ssh/transport/hmac/sha2_512_etm'
+require 'net/ssh/transport/hmac/ripemd160'
+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,
+    'hmac-sha2-256'                 => SHA2_256,
+    'hmac-sha2-256-96'              => SHA2_256_96,
+    'hmac-sha2-512'                 => SHA2_512,
+    'hmac-sha2-512-96'              => SHA2_512_96,
+    'hmac-sha2-256-etm@openssh.com' => SHA2_256_Etm,
+    'hmac-sha2-512-etm@openssh.com' => SHA2_512_Etm,
+    'hmac-ripemd160'                => RIPEMD160,
+    'hmac-ripemd160@openssh.com'    => RIPEMD160,
+    '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="", parameters = {})
+    impl = MAP[name] or raise ArgumentError, "hmac not found: #{name.inspect}"
+    impl.new(Net::SSH::Transport::KeyExpander.expand_key(impl.key_length, key, parameters))
+  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/identity_cipher.rb

@@ -0,0 +1,57 @@
+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/abstract.rb

@@ -0,0 +1,130 @@
+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
+        # Abstract class that implement Diffie-Hellman Key Exchange
+        # See https://tools.ietf.org/html/rfc4253#page-21
+        class Abstract
+          include Loggable
+          include Constants
+
+          attr_reader :algorithms
+          attr_reader :connection
+          attr_reader :data
+          attr_reader :dh
+
+          # Create a new instance of the Diffie-Hellman Key Exchange algorithm.
+          # The Diffie-Hellman (DH) key exchange provides a shared secret that
+          # cannot be determined by either party alone.  The key exchange is
+          # combined with a signature with the host key to provide host
+          # authentication.
+          def initialize(algorithms, connection, data)
+            @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
+
+            {
+              session_id: session_id,
+              server_key: result[:server_key],
+              shared_secret: result[:shared_secret],
+              hashing_algorithm: digester
+            }
+          end
+
+          def digester
+            raise NotImplementedError, 'abstract class: digester not implemented'
+          end
+
+          private
+
+          def matching?(key_ssh_type, host_key_alg)
+            return true if key_ssh_type == host_key_alg
+            return true if key_ssh_type == 'ssh-rsa' && ['rsa-sha2-512', 'rsa-sha2-256'].include?(host_key_alg)
+          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:
+            unless matching?(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 = Net::SSH::Authentication::PubKeyFingerprint.fingerprint(blob, @connection.options[:fingerprint_hash] || 'SHA256')
+
+            [blob, fingerprint]
+          rescue StandardError => 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)
+
+            server_key = result[:server_key]
+            server_sig = result[:server_sig]
+            unless connection.host_key_verifier.verify_signature { server_key.ssh_do_verify(server_sig, hash, host_key: algorithms.host_key) }
+              raise Net::SSH::Exception, 'could not verify server signature'
+            end
+
+            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