poolparty 1.3.15 → 1.4.0

data/vendor/gems/net-ssh/lib/net/ssh/transport/hmac/abstract.rb

@@ -1,78 +0,0 @@
-require 'openssl'
-
-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/vendor/gems/net-ssh/lib/net/ssh/transport/hmac/md5.rb

@@ -1,12 +0,0 @@
-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/vendor/gems/net-ssh/lib/net/ssh/transport/hmac/md5_96.rb

@@ -1,11 +0,0 @@
-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/vendor/gems/net-ssh/lib/net/ssh/transport/hmac/none.rb

@@ -1,15 +0,0 @@
-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/vendor/gems/net-ssh/lib/net/ssh/transport/hmac/sha1.rb

@@ -1,13 +0,0 @@
-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/vendor/gems/net-ssh/lib/net/ssh/transport/hmac/sha1_96.rb

@@ -1,11 +0,0 @@
-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/vendor/gems/net-ssh/lib/net/ssh/transport/hmac.rb

@@ -1,31 +0,0 @@
-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/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,
-    '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="")
-    impl = MAP[name] or raise ArgumentError, "hmac not found: #{name.inspect}"
-    impl.new(key)
-  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/vendor/gems/net-ssh/lib/net/ssh/transport/identity_cipher.rb

@@ -1,55 +0,0 @@
-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/vendor/gems/net-ssh/lib/net/ssh/transport/kex/diffie_hellman_group1_sha1.rb

@@ -1,208 +0,0 @@
-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/vendor/gems/net-ssh/lib/net/ssh/transport/kex/diffie_hellman_group_exchange_sha1.rb

@@ -1,77 +0,0 @@
-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
-        need_bits = data[:need_bytes] * 8
-        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/vendor/gems/net-ssh/lib/net/ssh/transport/kex.rb

@@ -1,13 +0,0 @@
-require 'net/ssh/transport/kex/diffie_hellman_group1_sha1'
-require 'net/ssh/transport/kex/diffie_hellman_group_exchange_sha1'
-
-module Net::SSH::Transport
-  module Kex
-    # Maps the supported key-exchange algorithms as named by the SSH protocol
-    # to their corresponding implementors.
-    MAP = {
-      'diffie-hellman-group-exchange-sha1' => DiffieHellmanGroupExchangeSHA1,
-      'diffie-hellman-group1-sha1'         => DiffieHellmanGroup1SHA1
-    }
-  end
-end

data/vendor/gems/net-ssh/lib/net/ssh/transport/openssl.rb

@@ -1,128 +0,0 @@
-require 'openssl'
-require 'net/ssh/buffer'
-
-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