net-ssh 6.2.0.rc2 → 7.0.1

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

@@ -1,5 +1,6 @@
 require 'net/ssh/transport/kex/diffie_hellman_group1_sha1'
 require 'net/ssh/transport/kex/diffie_hellman_group14_sha1'
+require 'net/ssh/transport/kex/diffie_hellman_group14_sha256'
 require 'net/ssh/transport/kex/diffie_hellman_group_exchange_sha1'
 require 'net/ssh/transport/kex/diffie_hellman_group_exchange_sha256'
 require 'net/ssh/transport/kex/ecdh_sha2_nistp256'
@@ -12,13 +13,14 @@ module Net::SSH::Transport
     # Maps the supported key-exchange algorithms as named by the SSH protocol
     # to their corresponding implementors.
     MAP = {
-      'diffie-hellman-group1-sha1'           => DiffieHellmanGroup1SHA1,
-      'diffie-hellman-group14-sha1'          => DiffieHellmanGroup14SHA1,
-      'diffie-hellman-group-exchange-sha1'   => DiffieHellmanGroupExchangeSHA1,
+      'diffie-hellman-group1-sha1' => DiffieHellmanGroup1SHA1,
+      'diffie-hellman-group14-sha1' => DiffieHellmanGroup14SHA1,
+      'diffie-hellman-group14-sha256' => DiffieHellmanGroup14SHA256,
+      'diffie-hellman-group-exchange-sha1' => DiffieHellmanGroupExchangeSHA1,
       'diffie-hellman-group-exchange-sha256' => DiffieHellmanGroupExchangeSHA256,
-      'ecdh-sha2-nistp256'                   => EcdhSHA2NistP256,
-      'ecdh-sha2-nistp384'                   => EcdhSHA2NistP384,
-      'ecdh-sha2-nistp521'                   => EcdhSHA2NistP521
+      'ecdh-sha2-nistp256' => EcdhSHA2NistP256,
+      'ecdh-sha2-nistp384' => EcdhSHA2NistP384,
+      'ecdh-sha2-nistp521' => EcdhSHA2NistP521
     }
 
     if Net::SSH::Transport::Kex::Curve25519Sha256Loader::LOADED

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

@@ -1,28 +1,27 @@
-module Net 
-  module SSH 
+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={})
+        def self.expand_key(bytes, start, options = {})
           if bytes == 0
             return ""
           end
-      
+
           k = start[0, bytes]
           return k if k.length >= 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

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

@@ -2,7 +2,6 @@ require 'openssl'
 require 'net/ssh/authentication/pub_key_fingerprint'
 
 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.
@@ -24,7 +23,6 @@ module OpenSSL
   end
 
   module PKey
-
     class PKey
       include Net::SSH::Authentication::PubKeyFingerprint
     end
@@ -37,6 +35,7 @@ module OpenSSL
       # 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)
@@ -53,9 +52,7 @@ module OpenSSL
         "ssh-rsa"
       end
 
-      def ssh_signature_type
-        ssh_type
-      end
+      alias ssh_signature_type ssh_type
 
       # Converts the key to a blob, according to the SSH2 protocol.
       def to_blob
@@ -77,8 +74,16 @@ module OpenSSL
       end
 
       # Returns the signature for the given data.
-      def ssh_do_sign(data)
-        sign(OpenSSL::Digest::SHA1.new, data)
+      def ssh_do_sign(data, sig_alg = nil)
+        digester =
+          if sig_alg == "rsa-sha2-512"
+            OpenSSL::Digest::SHA512.new
+          elsif sig_alg == "rsa-sha2-256"
+            OpenSSL::Digest::SHA256.new
+          else
+            OpenSSL::Digest::SHA1.new
+          end
+        sign(digester, data)
       end
     end
 
@@ -92,20 +97,18 @@ module OpenSSL
         "ssh-dss"
       end
 
-      def ssh_signature_type
-        ssh_type
-      end
+      alias ssh_signature_type ssh_type
 
       # 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
+                                        :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, options = {})
-        sig_r = sig[0,20].unpack("H*")[0].to_i(16)
-        sig_s = sig[20,20].unpack("H*")[0].to_i(16)
+        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)
@@ -114,14 +117,15 @@ module OpenSSL
       end
 
       # Signs the given data.
-      def ssh_do_sign(data)
+      def ssh_do_sign(data, sig_alg = nil)
         sig = sign(OpenSSL::Digest::SHA1.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)
 
-        raise OpenSSL::PKey::DSAError, "bad sig size" if sig_r.length > 20 || sig_s.length > 20
+        sig_size = params["q"].num_bits / 8
+        raise OpenSSL::PKey::DSAError, "bad sig size" if sig_r.length > sig_size || sig_s.length > sig_size
 
         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
@@ -155,10 +159,22 @@ module OpenSSL
 
         public_key_oct = buffer.read_string
         begin
-          key = OpenSSL::PKey::EC.new(OpenSSL::PKey::EC::CurveNameAlias[curve_name_in_key])
-          group = key.group
+          curvename = OpenSSL::PKey::EC::CurveNameAlias[curve_name_in_key]
+          group = OpenSSL::PKey::EC::Group.new(curvename)
           point = OpenSSL::PKey::EC::Point.new(group, OpenSSL::BN.new(public_key_oct, 2))
-          key.public_key = point
+          asn1 = OpenSSL::ASN1::Sequence(
+            [
+              OpenSSL::ASN1::Sequence(
+                [
+                  OpenSSL::ASN1::ObjectId("id-ecPublicKey"),
+                  OpenSSL::ASN1::ObjectId(curvename)
+                ]
+              ),
+              OpenSSL::ASN1::BitString(point.to_octet_string(:uncompressed))
+            ]
+          )
+
+          key = OpenSSL::PKey::EC.new(asn1.to_der)
 
           return key
         rescue OpenSSL::PKey::ECError
@@ -172,9 +188,7 @@ module OpenSSL
         "ecdsa-sha2-#{CurveNameAliasInv[group.curve_name]}"
       end
 
-      def ssh_signature_type
-        ssh_type
-      end
+      alias ssh_signature_type ssh_type
 
       def digester
         if group.curve_name =~ /^[a-z]+(\d+)\w*\z/
@@ -227,7 +241,7 @@ module OpenSSL
       end
 
       # Returns the signature for the given data.
-      def ssh_do_sign(data)
+      def ssh_do_sign(data, sig_alg = nil)
         digest = digester.digest(data)
         sig = dsa_sign_asn1(digest)
         a1sig = OpenSSL::ASN1.decode(sig)
@@ -245,6 +259,8 @@ module OpenSSL
           "ecdsa-sha2-#{CurveNameAliasInv[group.curve_name]}"
         end
 
+        alias ssh_signature_type ssh_type
+
         # Converts the key to a blob, according to the SSH2 protocol.
         def to_blob
           @blob ||= Net::SSH::Buffer.from(:string, ssh_type,

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

@@ -8,7 +8,6 @@ require 'net/ssh/transport/state'
 module Net
   module SSH
     module Transport
-
       # A module that builds additional functionality onto the Net::SSH::BufferedIo
       # module. It adds SSH encryption, compression, and packet validation, as
       # per the SSH2 protocol. It also adds an abstraction for polling packets,
@@ -81,7 +80,7 @@ module Net
         # available or not, and will return nil if there is no packet ready to be
         # returned. If the mode parameter is :block, then this method will block
         # until a packet is available or timeout seconds have passed.
-        def next_packet(mode=:nonblock, timeout=nil)
+        def next_packet(mode = :nonblock, timeout = nil)
           case mode
           when :nonblock then
             packet = poll_next_packet
@@ -222,6 +221,7 @@ module Net
           if @packet.nil?
             minimum = server.block_size < 4 ? 4 : server.block_size
             return nil if available < minimum + aad_length
+
             data = read_available(minimum + aad_length)
 
             # decipher it
@@ -275,7 +275,6 @@ module Net
         end
       end
       # rubocop:enable Metrics/AbcSize
-
     end
   end
 end

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

@@ -2,10 +2,9 @@ require 'net/ssh/errors'
 require 'net/ssh/loggable'
 require 'net/ssh/version'
 
-module Net 
-  module SSH 
+module Net
+  module SSH
     module Transport
-
       # Negotiates the SSH protocol version and trades information about server
       # and client. This is never used directly--it is always called by the
       # transport layer as part of the initialization process of the transport
@@ -15,40 +14,41 @@ module Net
       # the authoritative reference for any queries regarding the version in effect.
       class ServerVersion
         include Loggable
-    
+
         # The SSH version string as reported by Net::SSH
         PROTO_VERSION = "SSH-2.0-Ruby/Net::SSH_#{Net::SSH::Version::CURRENT} #{RUBY_PLATFORM}"
-    
+
         # Any header text sent by the server prior to sending the version.
         attr_reader :header
-    
+
         # The version string reported by the server.
         attr_reader :version
-    
+
         # Instantiates a new ServerVersion and immediately (and synchronously)
         # negotiates the SSH protocol in effect, using the given socket.
         def initialize(socket, logger, timeout = nil)
-          @header = ""
+          @header = String.new
           @version = nil
           @logger = logger
           negotiate!(socket, timeout)
         end
-    
+
         private
-    
+
         # Negotiates the SSH protocol to use, via the given socket. If the server
         # reports an incompatible SSH version (e.g., SSH1), this will raise an
         # exception.
         def negotiate!(socket, timeout)
           info { "negotiating protocol version" }
-    
+
           debug { "local is `#{PROTO_VERSION}'" }
           socket.write "#{PROTO_VERSION}\r\n"
           socket.flush
-    
+
           raise Net::SSH::ConnectionTimeout, "timeout during server version negotiating" if timeout && !IO.select([socket], nil, nil, timeout)
+
           loop do
-            @version = ""
+            @version = String.new
             loop do
               begin
                 b = socket.readpartial(1)
@@ -60,14 +60,15 @@ module Net
               break if b == "\n"
             end
             break if @version.match(/^SSH-/)
+
             @header << @version
           end
-    
+
           @version.chomp!
           debug { "remote is `#{@version}'" }
-    
+
           raise Net::SSH::Exception, "incompatible SSH version `#{@version}'" unless @version.match(/^SSH-(1\.99|2\.0)-/)
-    
+
           raise Net::SSH::ConnectionTimeout, "timeout during client version negotiating" if timeout && !IO.select(nil, [socket], nil, timeout)
         end
       end

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

@@ -15,7 +15,6 @@ require 'net/ssh/verifiers/never'
 module Net
   module SSH
     module Transport
-
       # The transport layer represents the lowest level of the SSH protocol, and
       # implements basic message exchanging and protocol initialization. It will
       # never be instantiated directly (unless you really know what you're about),
@@ -56,7 +55,7 @@ module Net
         # Instantiates a new transport layer abstraction. This will block until
         # the initial key exchange completes, leaving you with a ready-to-use
         # transport session.
-        def initialize(host, options={})
+        def initialize(host, options = {})
           self.logger = options[:logger]
 
           @host = host
@@ -160,6 +159,7 @@ module Net
         # one is performed, causing this method to block until it completes.
         def rekey_as_needed
           return if algorithms.pending?
+
           socket.if_needs_rekey? { rekey! }
         end
 
@@ -186,7 +186,7 @@ module Net
         # received, it will be enqueued and otherwise ignored. When a key-exchange
         # is not in process, and consume_queue is true, packets will be first
         # read from the queue before the socket is queried.
-        def poll_message(mode=:nonblock, consume_queue=true)
+        def poll_message(mode = :nonblock, consume_queue = true)
           loop do
             return @queue.shift if consume_queue && @queue.any? && algorithms.allow?(@queue.first)
 
@@ -211,6 +211,7 @@ module Net
 
             else
               return packet if algorithms.allow?(packet)
+
               push(packet)
             end
           end
@@ -222,6 +223,7 @@ module Net
         def wait
           loop do
             break if block_given? && yield
+
             message = poll_message(:nonblock, false)
             push(message) if message
             break if !block_given?
@@ -250,27 +252,27 @@ module Net
         # Configure's the packet stream's client state with the given set of
         # options. This is typically used to define the cipher, compression, and
         # hmac algorithms to use when sending packets to the server.
-        def configure_client(options={})
+        def configure_client(options = {})
           socket.client.set(options)
         end
 
         # Configure's the packet stream's server state with the given set of
         # options. This is typically used to define the cipher, compression, and
         # hmac algorithms to use when reading packets from the server.
-        def configure_server(options={})
+        def configure_server(options = {})
           socket.server.set(options)
         end
 
         # Sets a new hint for the packet stream, which the packet stream may use
         # to change its behavior. (See PacketStream#hints).
-        def hint(which, value=true)
+        def hint(which, value = true)
           socket.hints[which] = value
         end
 
         public
 
         # this method is primarily for use in tests
-        attr_reader :queue #:nodoc:
+        attr_reader :queue # :nodoc:
 
         private
 

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

@@ -2,10 +2,9 @@ require 'zlib'
 require 'net/ssh/transport/cipher_factory'
 require 'net/ssh/transport/hmac'
 
-module Net 
-  module SSH 
+module Net
+  module SSH
     module Transport
-
       # Encapsulates state information about one end of an SSH connection. Such
       # state includes the packet sequence number, the algorithms in use, how
       # many packets and blocks have been processed since the last reset, and so
@@ -14,46 +13,46 @@ module Net
       class State
         # The socket object that owns this state object.
         attr_reader :socket
-    
+
         # The next packet sequence number for this socket endpoint.
         attr_reader :sequence_number
-    
+
         # The hmac algorithm in use for this endpoint.
         attr_reader :hmac
-    
+
         # The compression algorithm in use for this endpoint.
         attr_reader :compression
-    
+
         # The compression level to use when compressing data (or nil, for the default).
         attr_reader :compression_level
-    
+
         # The number of packets processed since the last call to #reset!
         attr_reader :packets
-    
+
         # The number of data blocks processed since the last call to #reset!
         attr_reader :blocks
-    
+
         # The cipher algorithm in use for this socket endpoint.
         attr_reader :cipher
-    
+
         # The block size for the cipher
         attr_reader :block_size
-    
+
         # The role that this state plays (either :client or :server)
         attr_reader :role
-    
+
         # The maximum number of packets that this endpoint wants to process before
         # needing a rekey.
         attr_accessor :max_packets
-    
+
         # The maximum number of blocks that this endpoint wants to process before
         # needing a rekey.
         attr_accessor :max_blocks
-    
+
         # The user-specified maximum number of bytes that this endpoint ought to
         # process before needing a rekey.
         attr_accessor :rekey_limit
-    
+
         # Creates a new state object, belonging to the given socket. Initializes
         # the algorithms to "none".
         def initialize(socket, role)
@@ -65,9 +64,9 @@ module Net
           @hmac = HMAC.get("none")
           @compression = nil
           @compressor = @decompressor = nil
-          @next_iv = ""
+          @next_iv = String.new
         end
-    
+
         # A convenience method for quickly setting multiple values in a single
         # command.
         def set(values)
@@ -76,19 +75,19 @@ module Net
           end
           reset!
         end
-    
+
         def update_cipher(data)
           result = cipher.update(data)
           update_next_iv(role == :client ? result : data)
           return result
         end
-    
+
         def final_cipher
           result = cipher.final
           update_next_iv(role == :client ? result : "", true)
           return result
         end
-    
+
         # Increments the counters. The sequence number is incremented (and remapped
         # so it always fits in a 32-bit integer). The number of packets and blocks
         # are also incremented.
@@ -97,18 +96,18 @@ module Net
           @packets += 1
           @blocks += (packet_length + 4) / @block_size
         end
-    
+
         # The compressor object to use when compressing data. This takes into account
         # the desired compression level.
         def compressor
           @compressor ||= Zlib::Deflate.new(compression_level || Zlib::DEFAULT_COMPRESSION)
         end
-    
+
         # The decompressor object to use when decompressing data.
         def decompressor
           @decompressor ||= Zlib::Inflate.new(nil)
         end
-    
+
         # Returns true if data compression/decompression is enabled. This will
         # return true if :standard compression is selected, or if :delayed
         # compression is selected and the :authenticated hint has been received
@@ -116,33 +115,35 @@ module Net
         def compression?
           compression == :standard || (compression == :delayed && socket.hints[:authenticated])
         end
-    
+
         # Compresses the data. If no compression is in effect, this will just return
         # the data unmodified, otherwise it uses #compressor to compress the data.
         def compress(data)
           data = data.to_s
           return data unless compression?
+
           compressor.deflate(data, Zlib::SYNC_FLUSH)
         end
-    
+
         # Deompresses the data. If no compression is in effect, this will just return
         # the data unmodified, otherwise it uses #decompressor to decompress the data.
         def decompress(data)
           data = data.to_s
           return data unless compression?
+
           decompressor.inflate(data)
         end
-    
+
         # Resets the counters on the state object, but leaves the sequence_number
         # unchanged. It also sets defaults for and recomputes the max_packets and
         # max_blocks values.
         def reset!
           @packets = @blocks = 0
-    
+
           @max_packets ||= 1 << 31
-    
+
           @block_size = cipher.block_size
-    
+
           if max_blocks.nil?
             # cargo-culted from openssh. the idea is that "the 2^(blocksize*2)
             # limit is too expensive for 3DES, blowfish, etc., so enforce a 1GB
@@ -152,16 +153,16 @@ module Net
             else
               @max_blocks = (1 << 30) / @block_size
             end
-    
+
             # if a limit on the # of bytes has been given, convert that into a
             # minimum number of blocks processed.
-    
+
             @max_blocks = [@max_blocks, rekey_limit / @block_size].min if rekey_limit
           end
-    
+
           cleanup
         end
-    
+
         # Closes any the compressor and/or decompressor objects that have been
         # instantiated.
         def cleanup
@@ -169,17 +170,17 @@ module Net
             @compressor.finish if !@compressor.finished?
             @compressor.close
           end
-    
+
           if @decompressor
             # we call reset here so that we don't get warnings when we try to
             # close the decompressor
             @decompressor.reset
             @decompressor.close
           end
-    
+
           @compressor = @decompressor = nil
         end
-    
+
         # Returns true if the number of packets processed exceeds the maximum
         # number of packets, or if the number of blocks processed exceeds the
         # maximum number of blocks.
@@ -187,22 +188,21 @@ module Net
           max_packets && packets > max_packets ||
           max_blocks && blocks > max_blocks
         end
-    
+
         private
-    
-        def update_next_iv(data, reset=false)
+
+        def update_next_iv(data, reset = false)
           @next_iv << data
           @next_iv = @next_iv[@next_iv.size - cipher.iv_len..-1]
-    
+
           if reset
             cipher.reset
             cipher.iv = @next_iv
           end
-    
+
           return data
         end
       end
-
     end
   end
 end

data/lib/net/ssh/verifiers/accept_new.rb

@@ -5,7 +5,6 @@ require 'net/ssh/verifiers/always'
 module Net
   module SSH
     module Verifiers
-
       # Does a strict host verification, looking the server up in the known
       # host files to see if a key has already been seen for this server. If this
       # server does not appear in any host file, this will silently add the
@@ -29,7 +28,6 @@ module Net
           return true
         end
       end
-
     end
   end
 end