Register the services that together implement the SSH transport layer.

Source Code

# File net/ssh/transport/services.rb, line 22
def register_services( container )
  container.namespace_define :transport do |b|
    b.kex_names { Hash.new }
    b.compression_algorithms { Hash.new }
    b.decompression_algorithms { Hash.new }

    b.cipher_factories { Hash.new }
    b.hmac_factories { Hash.new }
    b.key_factories { Hash.new }
    b.buffer_factories { Hash.new }
    b.bn_factories { Hash.new }
    b.digest_factories { Hash.new }

    b.ciphers( :model => :prototype ) { |c,|
      c.cipher_factories.fetch( c.crypto_backend ) }

    b.hmacs( :model => :prototype ) { |c,|
      c.hmac_factories.fetch( c.crypto_backend ) }

    b.keys( :model => :prototype ) { |c,|
      c.key_factories.fetch( c.crypto_backend ) }

    b.buffers( :model => :prototype ) { |c,|
      c.buffer_factories.fetch( c.crypto_backend ) }

    b.bns( :model => :prototype ) { |c,|
      c.bn_factories.fetch( c.crypto_backend ) }

    b.digesters( :model => :prototype ) { |c,|
      c.digest_factories.fetch( c.crypto_backend ) }

    b.identity_cipher do
      require 'net/ssh/transport/identity-cipher'
      IdentityCipher.new
    end

    b.outgoing_packet_stream :model => :prototype_deferred do |c,|
      require 'net/ssh/transport/packet-stream'
      OutgoingPacketStream.new(
        c.ciphers, c.hmacs, c.compression_algorithms )
    end

    b.incoming_packet_stream :model => :prototype_deferred do |c,point|
      require 'net/ssh/transport/packet-stream'
      stream = IncomingPacketStream.new(
        c.ciphers, c.hmacs, c.decompression_algorithms )
      stream.buffers = c.buffers
      stream.log = c.log_for( point )
      stream
    end

    b.algorithms do
      Hash[
        :host_key => [ "ssh-dss", "ssh-rsa" ],
        :kex => [ "diffie-hellman-group-exchange-sha1",
                  "diffie-hellman-group1-sha1" ],
        :encryption => [ "3des-cbc",
                         "aes128-cbc", 
                         "blowfish-cbc",
                         "aes256-cbc",
                         "aes192-cbc",
                         "idea-cbc",
                         "none" ],
        :hmac => [ "hmac-md5",
                   "hmac-sha1",
                   "hmac-md5-96",
                   "hmac-sha1-96",
                   "none" ],
        :compression => [ "none", "zlib" ],
        :languages => []
      ]
    end

    b.default_ssh_port { 22 }

    b.socket_factory do
      require 'socket'
      TCPSocket
    end

    b.version_negotiator do |c,point|
      require 'net/ssh/transport/version-negotiator'
      VersionNegotiator.new( c.log_for( point ) )
    end

    b.algorithm_negotiator do |c,point|
      require 'net/ssh/transport/algorithm-negotiator'
      AlgorithmNegotiator.new(
        c.log_for( point ),
        c.algorithms,
        c.buffers )
    end

    b.session do |c,point|
      require 'net/ssh/transport/session'

      args = [ c[:transport_host] ]
      args << c[:transport_options] if c.knows_key?(:transport_options)

      Session.new( *args ) do |s|
        s.logger               = c[:log_for, point]
        s.default_port         = c[:default_ssh_port]
        s.version_negotiator   = c[:version_negotiator]
        s.algorithm_negotiator = c[:algorithm_negotiator]
        s.socket_factory       = c[:socket_factory]
        s.packet_sender        = c[:outgoing_packet_stream]
        s.packet_receiver      = c[:incoming_packet_stream]
        s.ciphers              = c[:ciphers]
        s.hmacs                = c[:hmacs]
        s.kexs                 = c[:kex_names]
        s.compressors          = c[:compression_algorithms]
        s.decompressors        = c[:decompression_algorithms]
      end
    end

    b.require 'net/ssh/transport/ossl/services', "#{self}::OSSL"
    b.require 'net/ssh/transport/compress/services', "#{self}::Compress"
    b.require 'net/ssh/transport/kex/services', "#{self}::Kex"
  end
end