super-fast-gem 0.0.1

data/net-ssh-7.3.3/lib/net/ssh/transport/cipher_factory.rb

@@ -0,0 +1,130 @@
+require 'openssl'
+require 'net/ssh/transport/ctr.rb'
+require 'net/ssh/transport/aes128_gcm'
+require 'net/ssh/transport/aes256_gcm'
+require 'net/ssh/transport/key_expander'
+require 'net/ssh/transport/identity_cipher'
+require 'net/ssh/transport/chacha20_poly1305_cipher_loader'
+require 'net/ssh/transport/openssl_cipher_extensions'
+
+module Net
+  module SSH
+    module Transport
+      # Implements a factory of OpenSSL cipher algorithms.
+      class CipherFactory
+        # Maps the SSH name of a cipher to it's corresponding OpenSSL name
+        SSH_TO_OSSL = {
+          "3des-cbc" => "des-ede3-cbc",
+          "blowfish-cbc" => "bf-cbc",
+          "aes256-cbc" => "aes-256-cbc",
+          "aes192-cbc" => "aes-192-cbc",
+          "aes128-cbc" => "aes-128-cbc",
+          "idea-cbc" => "idea-cbc",
+          "cast128-cbc" => "cast-cbc",
+          "rijndael-cbc@lysator.liu.se" => "aes-256-cbc",
+          "3des-ctr" => "des-ede3",
+          "blowfish-ctr" => "bf-ecb",
+
+          "aes256-ctr" => ::OpenSSL::Cipher.ciphers.include?("aes-256-ctr") ? "aes-256-ctr" : "aes-256-ecb",
+          "aes192-ctr" => ::OpenSSL::Cipher.ciphers.include?("aes-192-ctr") ? "aes-192-ctr" : "aes-192-ecb",
+          "aes128-ctr" => ::OpenSSL::Cipher.ciphers.include?("aes-128-ctr") ? "aes-128-ctr" : "aes-128-ecb",
+          'cast128-ctr' => 'cast5-ecb',
+
+          'none' => 'none'
+        }
+
+        SSH_TO_CLASS = {
+          'aes256-gcm@openssh.com' => Net::SSH::Transport::AES256_GCM,
+          'aes128-gcm@openssh.com' => Net::SSH::Transport::AES128_GCM
+        }.tap do |hash|
+          if Net::SSH::Transport::ChaCha20Poly1305CipherLoader::LOADED
+            hash['chacha20-poly1305@openssh.com'] =
+              Net::SSH::Transport::ChaCha20Poly1305Cipher
+          end
+        end
+
+        # Returns true if the underlying OpenSSL library supports the given cipher,
+        # and false otherwise.
+        def self.supported?(name)
+          return true if SSH_TO_CLASS.key?(name)
+
+          ossl_name = SSH_TO_OSSL[name] or raise NotImplementedError, "unimplemented cipher `#{name}'"
+          return true if ossl_name == "none"
+
+          return SSH_TO_CLASS.key?(name) || OpenSSL::Cipher.ciphers.include?(ossl_name)
+        end
+
+        # Retrieves a new instance of the named algorithm. The new instance
+        # will be initialized using an iv and key generated from the given
+        # iv, key, shared, hash and digester values. Additionally, the
+        # cipher will be put into encryption or decryption mode, based on the
+        # value of the +encrypt+ parameter.
+        def self.get(name, options = {})
+          klass = SSH_TO_CLASS[name]
+          unless klass.nil?
+            key_len = klass.key_length
+            key = Net::SSH::Transport::KeyExpander.expand_key(key_len, options[:key], options)
+            return klass.new(encrypt: options[:encrypt], key: key)
+          end
+
+          ossl_name = SSH_TO_OSSL[name] or raise NotImplementedError, "unimplemented cipher `#{name}'"
+          return IdentityCipher if ossl_name == "none"
+
+          cipher = OpenSSL::Cipher.new(ossl_name)
+
+          cipher.send(options[:encrypt] ? :encrypt : :decrypt)
+
+          cipher.padding = 0
+
+          cipher.extend(Net::SSH::Transport::OpenSSLCipherExtensions)
+          if name =~ /-ctr(@openssh.org)?$/
+            if ossl_name !~ /-ctr/
+              cipher.extend(Net::SSH::Transport::CTR)
+            else
+              cipher = Net::SSH::Transport::OpenSSLAESCTR.new(cipher)
+            end
+          end
+          cipher.iv = Net::SSH::Transport::KeyExpander.expand_key(cipher.iv_len, options[:iv], options)
+
+          key_len = cipher.key_len
+          cipher.key_len = key_len
+          cipher.key = Net::SSH::Transport::KeyExpander.expand_key(key_len, options[:key], options)
+
+          return cipher
+        end
+
+        # Returns a two-element array containing the [ key-length,
+        # block-size ] for the named cipher algorithm. If the cipher
+        # algorithm is unknown, or is "none", 0 is returned for both elements
+        # of the tuple.
+        # if :iv_len option is supplied the third return value will be ivlen
+        def self.get_lengths(name, options = {})
+          klass = SSH_TO_CLASS[name]
+          return [klass.key_length, klass.block_size] unless klass.nil?
+
+          ossl_name = SSH_TO_OSSL[name]
+          if ossl_name.nil? || ossl_name == "none"
+            result = [0, 0]
+            result << 0 if options[:iv_len]
+          else
+            cipher = OpenSSL::Cipher.new(ossl_name)
+            key_len = cipher.key_len
+            cipher.key_len = key_len
+
+            block_size =
+              case ossl_name
+              when /\-ctr/
+                Net::SSH::Transport::OpenSSLAESCTR.block_size
+              else
+                cipher.block_size
+              end
+
+            result = [key_len, block_size]
+            result << cipher.iv_len if options[:iv_len]
+          end
+          result
+        end
+      end
+    end
+  end
+end

data/net-ssh-7.3.3/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/net-ssh-7.3.3/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/net-ssh-7.3.3/lib/net/ssh/transport/gcm_cipher.rb

@@ -0,0 +1,207 @@
+require 'net/ssh/loggable'
+
+module Net
+  module SSH
+    module Transport
+      ## Extension module for aes(128|256)gcm ciphers
+      module GCMCipher
+        # rubocop:disable Metrics/AbcSize
+        def self.extended(orig)
+          # rubocop:disable Metrics/BlockLength
+          orig.class_eval do
+            include Net::SSH::Loggable
+
+            attr_reader   :cipher
+            attr_reader   :key
+            attr_reader   :nonce
+
+            #
+            # Semantically gcm cipher supplies the OpenSSL iv interface with a nonce
+            #   as it is not randomly generated due to being supplied from a counter.
+            # The RFC's use IV and nonce interchangeably.
+            #
+            def initialize(encrypt:, key:)
+              @cipher = OpenSSL::Cipher.new(algo_name)
+              @key    = key
+              key_len = @cipher.key_len
+              if key.size != key_len
+                error_message = "#{cipher_name}: keylength does not match"
+                error { error_message }
+                raise error_message
+              end
+              encrypt ? @cipher.encrypt : @cipher.decrypt
+              @cipher.key = key
+
+              @nonce = {
+                fixed: nil,
+                invocation_counter: 0
+              }
+            end
+
+            def update_cipher_mac(payload, _sequence_number)
+              #
+              # --- RFC 5647 7.3 ---
+              # When using AES-GCM with secure shell, the packet_length field is to
+              # be treated as additional authenticated data, not as plaintext.
+              #
+              length_data      = [payload.bytesize].pack('N')
+
+              cipher.auth_data = length_data
+
+              encrypted_data   = cipher.update(payload) << cipher.final
+
+              mac              = cipher.auth_tag
+
+              incr_nonce
+              length_data + encrypted_data + mac
+            end
+
+            #
+            # --- RFC 5647 ---
+            # uint32    packet_length;  // 0 <= packet_length < 2^32
+            #
+            def read_length(data, _sequence_number)
+              data.unpack1('N')
+            end
+
+            #
+            # --- RFC 5647 ---
+            # In AES-GCM secure shell, the inputs to the authenticated encryption
+            # are:
+            #  PT (Plain Text)
+            #      byte      padding_length; // 4 <= padding_length < 256
+            #      byte[n1]  payload;        // n1 = packet_length-padding_length-1
+            #      byte[n2]  random_padding; // n2 = padding_length
+            #  AAD (Additional Authenticated Data)
+            #      uint32    packet_length;  // 0 <= packet_length < 2^32
+            #  IV (Initialization Vector)
+            #      As described in section 7.1.
+            #  BK (Block Cipher Key)
+            #      The appropriate Encryption Key formed during the Key Exchange.
+            #
+            def read_and_mac(data, mac, _sequence_number)
+              # The authentication tag will be placed in the MAC field at the end of the packet
+
+              # OpenSSL does not verify auth tag length
+              # GCM mode allows arbitrary sizes for the auth_tag up to 128 bytes and a single
+              #   byte allows authentication to pass. If single byte auth tags are possible
+              #   an attacker would require no more than 256 attempts to forge a valid tag.
+              #
+              raise 'incorrect auth_tag length' unless mac.to_s.length == mac_length
+
+              packet_length    = data.unpack1('N')
+
+              cipher.auth_tag  = mac.to_s
+              cipher.auth_data = [packet_length].pack('N')
+
+              result = cipher.update(data[4...]) << cipher.final
+              incr_nonce
+              result
+            end
+
+            def mac_length
+              16
+            end
+
+            def block_size
+              16
+            end
+
+            def self.block_size
+              16
+            end
+
+            #
+            # --- RFC 5647 ---
+            # N_MIN       minimum nonce (IV) length        12 octets
+            # N_MAX       maximum nonce (IV) length        12 octets
+            #
+            def iv_len
+              12
+            end
+
+            #
+            # --- RFC 5288 ---
+            # Each value of the nonce_explicit MUST be distinct for each distinct
+            # invocation of the GCM encrypt function for any fixed key. Failure to
+            # meet this uniqueness requirement can significantly degrade security.
+            # The nonce_explicit MAY be the 64-bit sequence number.
+            #
+            # --- RFC 5116 ---
+            # (2.1) Applications that can generate distinct nonces SHOULD use the nonce
+            # formation method defined in Section 3.2, and MAY use any
+            # other method that meets the uniqueness requirement.
+            #
+            # (3.2) The following method to construct nonces is RECOMMENDED.
+            #
+            #  <- variable -> <- variable ->
+            #  - - - - - - -  - - - - - - -
+            # |    fixed     |    counter   |
+            #
+            # Initial octets consist of a fixed field and final octets consist of a
+            # Counter field. Implementations SHOULD support 12-octet nonces in which
+            # the Counter field is four octets long.
+            # The Counter fields of successive nonces form a monotonically increasing
+            # sequence, when those fields are regarded as unsignd integers in network
+            # byte order.
+            # The Counter part SHOULD be equal to zero for the first nonce and increment
+            # by one for each successive nonce that is generated.
+            # The Fixed field MUST remain constant for all nonces that are generated for
+            # a given encryption device.
+            #
+            # --- RFC 5647 ---
+            # The invocation field is treated as a 64-bit integer and is increment after
+            # each invocation of AES-GCM to process a binary packet.
+            # AES-GCM produces a keystream in blocks of 16-octets that is used to
+            # encrypt the plaintext. This keystream is produced by encrypting the
+            # following 16-octet data structure:
+            #
+            # uint32 fixed;              // 4 octets
+            # uint64 invocation_counter; // 8 octets
+            # unit32 block_counter;      // 4 octets
+            #
+            # The block_counter is initially set to one (1) and increment as each block
+            # of key is produced.
+            #
+            # The reader is reminded that SSH requires that the data to be encrypted
+            # MUST be padded out to a multiple of the block size (16-octets for AES-GCM).
+            #
+            def incr_nonce
+              return if nonce[:fixed].nil?
+
+              nonce[:invocation_counter] = [nonce[:invocation_counter].to_s.unpack1('B*').to_i(2) + 1].pack('Q>*')
+
+              apply_nonce
+            end
+
+            def nonce=(iv_s)
+              return if nonce[:fixed]
+
+              nonce[:fixed]              = iv_s[0...4]
+              nonce[:invocation_counter] = iv_s[4...12]
+
+              apply_nonce
+            end
+
+            def apply_nonce
+              cipher.iv = "#{nonce[:fixed]}#{nonce[:invocation_counter]}"
+            end
+
+            #
+            # --- RFC 5647 ---
+            # If AES-GCM is selected as the encryption algorithm for a given
+            # tunnel, AES-GCM MUST also be selected as the Message Authentication
+            # Code (MAC) algorithm.  Conversely, if AES-GCM is selected as the MAC
+            # algorithm, it MUST also be selected as the encryption algorithm.
+            #
+            def implicit_mac?
+              true
+            end
+          end
+        end
+        # rubocop:enable Metrics/BlockLength
+      end
+      # rubocop:enable Metrics/AbcSize
+    end
+  end
+end

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

@@ -0,0 +1,113 @@
+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 aead(*v)
+              @aead = false if !defined?(@aead)
+              if v.empty?
+                @aead = superclass.aead if @aead.nil? && superclass.respond_to?(:aead)
+                return @aead
+              elsif v.length == 1
+                @aead = v.first
+              else
+                raise ArgumentError, "wrong number of arguments (#{v.length} for 1)"
+              end
+            end
+
+            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 aead
+            self.class.aead
+          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/net-ssh-7.3.3/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/net-ssh-7.3.3/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/net-ssh-7.3.3/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/net-ssh-7.3.3/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/net-ssh-7.3.3/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/net-ssh-7.3.3/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/net-ssh-7.3.3/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