minmb-net-ssh 2.5.1

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

@@ -0,0 +1,106 @@
+require 'openssl'
+require 'net/ssh/transport/ctr.rb'
+require 'net/ssh/transport/key_expander'
+require 'net/ssh/transport/identity_cipher'
+
+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",
+      "arcfour128"                  => "rc4",
+      "arcfour256"                  => "rc4",
+      "arcfour512"                  => "rc4",
+      "arcfour"                     => "rc4",
+      "camellia128-cbc"             => "camellia-128-cbc",
+      "camellia192-cbc"             => "camellia-192-cbc",
+      "camellia256-cbc"             => "camellia-256-cbc",
+      "camellia128-cbc@openssh.org" => "camellia-128-cbc",
+      "camellia192-cbc@openssh.org" => "camellia-192-cbc",
+      "camellia256-cbc@openssh.org" => "camellia-256-cbc",
+
+      "3des-ctr"                    => "des-ede3",
+      "blowfish-ctr"                => "bf-ecb",
+      "aes256-ctr"                  => "aes-256-ecb",
+      "aes192-ctr"                  => "aes-192-ecb",
+      "aes128-ctr"                  => "aes-128-ecb",
+      "cast128-ctr"                 => "cast5-ecb",
+      "camellia128-ctr"             => "camellia-128-ecb",
+      "camellia192-ctr"             => "camellia-192-ecb",
+      "camellia256-ctr"             => "camellia-256-ecb",
+      "camellia128-ctr@openssh.org" => "camellia-128-ecb",
+      "camellia192-ctr@openssh.org" => "camellia-192-ecb",
+      "camellia256-ctr@openssh.org" => "camellia-256-ecb",
+
+      "none"                        => "none",
+    }
+
+    # Ruby's OpenSSL bindings always return a key length of 16 for RC4 ciphers
+    # resulting in the error: OpenSSL::CipherError: key length too short. 
+    # The following ciphers will override this key length. 
+    KEY_LEN_OVERRIDE = {
+      "arcfour256"                  => 32,
+      "arcfour512"                  => 64
+    }
+
+
+    # Returns true if the underlying OpenSSL library supports the given cipher,
+    # and false otherwise.
+    def self.supported?(name)
+      ossl_name = SSH_TO_OSSL[name] or raise NotImplementedError, "unimplemented cipher `#{name}'"
+      return true if ossl_name == "none"
+      return 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={})
+      ossl_name = SSH_TO_OSSL[name] or raise NotImplementedError, "unimplemented cipher `#{name}'"
+      return IdentityCipher if ossl_name == "none"
+      cipher = OpenSSL::Cipher::Cipher.new(ossl_name)
+
+      cipher.send(options[:encrypt] ? :encrypt : :decrypt)
+
+      cipher.padding = 0
+
+      cipher.extend(Net::SSH::Transport::CTR) if (name =~ /-ctr(@openssh.org)?$/)
+
+      cipher.iv      = Net::SSH::Transport::KeyExpander.expand_key(cipher.iv_len, options[:iv], options) if ossl_name != "rc4"
+
+      key_len = KEY_LEN_OVERRIDE[name] || cipher.key_len
+      cipher.key_len = key_len
+      cipher.key     = Net::SSH::Transport::KeyExpander.expand_key(key_len, options[:key], options)
+      cipher.update(" " * 1536) if (ossl_name == "rc4" && name != "arcfour")
+
+      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.
+    def self.get_lengths(name)
+      ossl_name = SSH_TO_OSSL[name]
+      return [0, 0] if ossl_name.nil? || ossl_name == "none"
+
+      cipher = OpenSSL::Cipher::Cipher.new(ossl_name)
+      key_len = KEY_LEN_OVERRIDE[name] || cipher.key_len
+      cipher.key_len = key_len
+      
+      return [key_len, ossl_name=="rc4" ? 8 : cipher.block_size]
+    end
+  end
+
+end; end; end

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

@@ -0,0 +1,32 @@
+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
+  end
+end; end; end

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

@@ -0,0 +1,95 @@
+require 'openssl'
+
+module Net::SSH::Transport
+
+  # 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 = ""
+        @counter = nil
+        @counter_len = orig.block_size
+        orig.encrypt
+        orig.padding = 0
+      }
+
+      class <<orig
+        alias :_update :update
+        private :_update
+        undef :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 = ""
+        end
+
+        def update(data)
+          @remaining += data
+
+          encrypted = ""
+
+          while @remaining.bytesize >= block_size
+            encrypted += xor!(@remaining.slice!(0, block_size),
+                              _update(@counter))
+            increment_counter!
+          end
+
+          encrypted
+        end
+
+        def final
+          unless @remaining.empty?
+            s = xor!(@remaining, _update(@counter))
+          else
+            s = ""
+          end
+
+          @remaining = ""
+
+          s
+        end
+
+        private
+
+        def xor!(s1, s2)
+          s = []
+          s1.unpack('Q*').zip(s2.unpack('Q*')) {|a,b| s.push(a^b) }
+          s.pack('Q*')
+        end
+
+        def increment_counter!
+          c = @counter_len
+          while ((c -= 1) > 0)
+            if @counter.setbyte(c, (@counter.getbyte(c) + 1) & 0xff) != 0
+              break
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,45 @@
+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/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-ripemd160' => RIPEMD160,
+    'hmac-ripemd160@openssh.com' => RIPEMD160,
+    'none'           => None
+  }
+
+  # add mapping to sha2 hmac algorithms if they're available
+  MAP['hmac-sha2-256']    = SHA2_256    if defined?(::Net::SSH::Transport::HMAC::SHA2_256)
+  MAP['hmac-sha2-256-96'] = SHA2_256_96 if defined?(::Net::SSH::Transport::HMAC::SHA2_256_96)
+  MAP['hmac-sha2-512']    = SHA2_512    if defined?(::Net::SSH::Transport::HMAC::SHA2_512)
+  MAP['hmac-sha2-512-96'] = SHA2_512_96 if defined?(::Net::SSH::Transport::HMAC::SHA2_512_96)
+
+  # 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/hmac/abstract.rb

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

@@ -0,0 +1,13 @@
+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,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