librex 0.0.68 → 0.0.70

data/lib/rex/socket/ssl_tcp_server.rb

@@ -11,163 +11,178 @@ require 'rex/io/stream_server'
 ###
 module Rex::Socket::SslTcpServer
 
-	@@loaded_openssl = false
-
-	begin
-		require 'openssl'
-		@@loaded_openssl = true
-		require 'openssl/nonblock'
-	rescue ::Exception
-	end
-
-	include Rex::Socket::TcpServer
-
-	##
-	#
-	# Factory
-	#
-	##
-
-	def self.create(hash = {})
-		hash['Proto']  = 'tcp'
-		hash['Server'] = true
-		hash['SSL']    = true
-		self.create_param(Rex::Socket::Parameters.from_hash(hash))
-	end
-
-	#
-	# Wrapper around the base class' creation method that automatically sets
-	# the parameter's protocol to TCP and sets the server flag to true.
-	#
-	def self.create_param(param)
-		param.proto  = 'tcp'
-		param.server = true
-		param.ssl    = true
-		Rex::Socket.create_param(param)
-	end
-
-	def initsock(params = nil)
-		raise RuntimeError, "No OpenSSL support" if not @@loaded_openssl
-		self.sslctx  = makessl(params.ssl_cert)
-		super
-	end
-
-	def accept(opts = {})
-		sock = super()
-		return if not sock
-
-		begin
-			ssl = OpenSSL::SSL::SSLSocket.new(sock, self.sslctx)
-
-			if not allow_nonblock?(ssl)
-				ssl.accept
-			else
-				begin
-					ssl.accept_nonblock
-
-				# Ruby 1.8.7 and 1.9.0/1.9.1 uses a standard Errno
-				rescue ::Errno::EAGAIN, ::Errno::EWOULDBLOCK
-						IO::select(nil, nil, nil, 0.10)
-						retry
-
-				# Ruby 1.9.2+ uses IO::WaitReadable/IO::WaitWritable
-				rescue ::Exception => e
-					if ::IO.const_defined?('WaitReadable') and e.kind_of?(::IO::WaitReadable)
-						IO::select( [ ssl ], nil, nil, 0.10 )
-						retry
-					end
-
-					if ::IO.const_defined?('WaitWritable') and e.kind_of?(::IO::WaitWritable)
-						IO::select( nil, [ ssl ], nil, 0.10 )
-						retry
-					end
-
-					raise e
-				end
-			end
-
-			sock.extend(Rex::Socket::SslTcp)
-			sock.sslsock = ssl
-			sock.sslctx  = self.sslctx
-
-			return sock
-
-		rescue ::OpenSSL::SSL::SSLError
-			sock.close
-			nil
-		end
-	end
-
-
-	#
-	# Create a new ssl context.  If +ssl_cert+ is not given, generates a new
-	# key and a leaf certificate with random values.
-	#
-	def makessl(ssl_cert=nil)
-
-		if ssl_cert
-			cert = OpenSSL::X509::Certificate.new(ssl_cert)
-			key = OpenSSL::PKey::RSA.new(ssl_cert)
-		else
-			key = OpenSSL::PKey::RSA.new(1024){ }
-			cert = OpenSSL::X509::Certificate.new
-			cert.version = 2
-			cert.serial = rand(0xFFFFFFFF)
-			# name = OpenSSL::X509::Name.new([["C","JP"],["O","TEST"],["CN","localhost"]])
-			subject = OpenSSL::X509::Name.new([
-					["C","US"],
-					['ST', Rex::Text.rand_state()],
-					["L", Rex::Text.rand_text_alpha(rand(20) + 10)],
-					["O", Rex::Text.rand_text_alpha(rand(20) + 10)],
-					["CN", Rex::Text.rand_hostname],
-				])
-			issuer = OpenSSL::X509::Name.new([
-					["C","US"],
-					['ST', Rex::Text.rand_state()],
-					["L", Rex::Text.rand_text_alpha(rand(20) + 10)],
-					["O", Rex::Text.rand_text_alpha(rand(20) + 10)],
-					["CN", Rex::Text.rand_hostname],
-				])
-
-			cert.subject = subject
-			cert.issuer = issuer
-			cert.not_before = Time.now - (3600 * 365)
-			cert.not_after = Time.now + (3600 * 365)
-			cert.public_key = key.public_key
-			ef = OpenSSL::X509::ExtensionFactory.new(nil,cert)
-			cert.extensions = [
-				ef.create_extension("basicConstraints","CA:FALSE"),
-				ef.create_extension("subjectKeyIdentifier","hash"),
-				ef.create_extension("extendedKeyUsage","serverAuth"),
-				ef.create_extension("keyUsage","keyEncipherment,dataEncipherment,digitalSignature")
-			]
-			ef.issuer_certificate = cert
-			cert.add_extension ef.create_extension("authorityKeyIdentifier", "keyid:always,issuer:always")
-			cert.sign(key, OpenSSL::Digest::SHA1.new)
-		end
-
-		ctx = OpenSSL::SSL::SSLContext.new()
-		ctx.key = key
-		ctx.cert = cert
-
-		ctx.session_id_context = Rex::Text.rand_text(16)
-
-		return ctx
-	end
-
-	#
-	# This flag determines whether to use the non-blocking openssl
-	# API calls when they are available. This is still buggy on
-	# Linux/Mac OS X, but is required on Windows
-	#
-	def allow_nonblock?(sock=self.sock)
-		avail = sock.respond_to?(:accept_nonblock)
-		if avail and Rex::Compat.is_windows
-			return true
-		end
-		false
-	end
-
-	attr_accessor :sslctx
+  @@loaded_openssl = false
+
+  begin
+    require 'openssl'
+    @@loaded_openssl = true
+    require 'openssl/nonblock'
+  rescue ::Exception
+  end
+
+  include Rex::Socket::TcpServer
+
+  ##
+  #
+  # Factory
+  #
+  ##
+
+  def self.create(hash = {})
+    hash['Proto']  = 'tcp'
+    hash['Server'] = true
+    hash['SSL']    = true
+    self.create_param(Rex::Socket::Parameters.from_hash(hash))
+  end
+
+  #
+  # Wrapper around the base class' creation method that automatically sets
+  # the parameter's protocol to TCP and sets the server flag to true.
+  #
+  def self.create_param(param)
+    param.proto  = 'tcp'
+    param.server = true
+    param.ssl    = true
+    Rex::Socket.create_param(param)
+  end
+
+  def initsock(params = nil)
+    raise RuntimeError, "No OpenSSL support" if not @@loaded_openssl
+    self.sslctx  = makessl(params)
+    super
+  end
+
+  # (see TcpServer#accept)
+  def accept(opts = {})
+    sock = super()
+    return if not sock
+
+    begin
+      ssl = OpenSSL::SSL::SSLSocket.new(sock, self.sslctx)
+
+      if not allow_nonblock?(ssl)
+        ssl.accept
+      else
+        begin
+          ssl.accept_nonblock
+
+        # Ruby 1.8.7 and 1.9.0/1.9.1 uses a standard Errno
+        rescue ::Errno::EAGAIN, ::Errno::EWOULDBLOCK
+            IO::select(nil, nil, nil, 0.10)
+            retry
+
+        # Ruby 1.9.2+ uses IO::WaitReadable/IO::WaitWritable
+        rescue ::Exception => e
+          if ::IO.const_defined?('WaitReadable') and e.kind_of?(::IO::WaitReadable)
+            IO::select( [ ssl ], nil, nil, 0.10 )
+            retry
+          end
+
+          if ::IO.const_defined?('WaitWritable') and e.kind_of?(::IO::WaitWritable)
+            IO::select( nil, [ ssl ], nil, 0.10 )
+            retry
+          end
+
+          raise e
+        end
+      end
+
+      sock.extend(Rex::Socket::SslTcp)
+      sock.sslsock = ssl
+      sock.sslctx  = self.sslctx
+
+      return sock
+
+    rescue ::OpenSSL::SSL::SSLError
+      sock.close
+      nil
+    end
+  end
+
+
+  #
+  # Create a new ssl context.  If +ssl_cert+ is not given, generates a new
+  # key and a leaf certificate with random values.
+  #
+  # @param [Rex::Socket::Parameters] params
+  # @return [::OpenSSL::SSL::SSLContext]
+  def makessl(params)
+    ssl_cert = params.ssl_cert
+    if ssl_cert
+      cert = OpenSSL::X509::Certificate.new(ssl_cert)
+      key = OpenSSL::PKey::RSA.new(ssl_cert)
+    else
+      key = OpenSSL::PKey::RSA.new(1024){ }
+      cert = OpenSSL::X509::Certificate.new
+      cert.version = 2
+      cert.serial = rand(0xFFFFFFFF)
+      # name = OpenSSL::X509::Name.new([["C","JP"],["O","TEST"],["CN","localhost"]])
+      subject = OpenSSL::X509::Name.new([
+          ["C","US"],
+          ['ST', Rex::Text.rand_state()],
+          ["L", Rex::Text.rand_text_alpha(rand(20) + 10)],
+          ["O", Rex::Text.rand_text_alpha(rand(20) + 10)],
+          ["CN", Rex::Text.rand_hostname],
+        ])
+      issuer = OpenSSL::X509::Name.new([
+          ["C","US"],
+          ['ST', Rex::Text.rand_state()],
+          ["L", Rex::Text.rand_text_alpha(rand(20) + 10)],
+          ["O", Rex::Text.rand_text_alpha(rand(20) + 10)],
+          ["CN", Rex::Text.rand_hostname],
+        ])
+
+      cert.subject = subject
+      cert.issuer = issuer
+      cert.not_before = Time.now - (3600 * 365)
+      cert.not_after = Time.now + (3600 * 365)
+      cert.public_key = key.public_key
+      ef = OpenSSL::X509::ExtensionFactory.new(nil,cert)
+      cert.extensions = [
+        ef.create_extension("basicConstraints","CA:FALSE"),
+        ef.create_extension("subjectKeyIdentifier","hash"),
+        ef.create_extension("extendedKeyUsage","serverAuth"),
+        ef.create_extension("keyUsage","keyEncipherment,dataEncipherment,digitalSignature")
+      ]
+      ef.issuer_certificate = cert
+      cert.add_extension ef.create_extension("authorityKeyIdentifier", "keyid:always,issuer:always")
+      cert.sign(key, OpenSSL::Digest::SHA1.new)
+    end
+
+    ctx = OpenSSL::SSL::SSLContext.new()
+    ctx.key = key
+    ctx.cert = cert
+    ctx.options = 0
+
+
+    # Older versions of OpenSSL do not export the OP_NO_COMPRESSION symbol
+    if defined?(OpenSSL::SSL::OP_NO_COMPRESSION)
+      # enable/disable the SSL/TLS-level compression
+      if params.ssl_compression
+        ctx.options &= ~OpenSSL::SSL::OP_NO_COMPRESSION
+      else
+        ctx.options |= OpenSSL::SSL::OP_NO_COMPRESSION
+      end
+    end
+
+    ctx.session_id_context = Rex::Text.rand_text(16)
+
+    return ctx
+  end
+
+  #
+  # This flag determines whether to use the non-blocking openssl
+  # API calls when they are available. This is still buggy on
+  # Linux/Mac OS X, but is required on Windows
+  #
+  def allow_nonblock?(sock=self.sock)
+    avail = sock.respond_to?(:accept_nonblock)
+    if avail and Rex::Compat.is_windows
+      return true
+    end
+    false
+  end
+
+  attr_accessor :sslctx
 end
 

data/lib/rex/socket/subnet_walker.rb

@@ -12,63 +12,63 @@ module Socket
 ###
 class SubnetWalker
 
-	#
-	# Initializes a subnet walker instance using the supplied subnet
-	# information.
-	#
-	def initialize(subnet, netmask)
-		self.subnet  = Socket.resolv_to_dotted(subnet)
-		self.netmask = Socket.resolv_to_dotted(netmask)
+  #
+  # Initializes a subnet walker instance using the supplied subnet
+  # information.
+  #
+  def initialize(subnet, netmask)
+    self.subnet  = Socket.resolv_to_dotted(subnet)
+    self.netmask = Socket.resolv_to_dotted(netmask)
 
-		reset
-	end
+    reset
+  end
 
-	#
-	# Resets the subnet walker back to its original state.
-	#
-	def reset
-		self.curr_ip     = self.subnet.split('.')
-		self.num_ips     = (1 << (32 - Socket.net2bitmask(self.netmask).to_i))
-		self.curr_ip_idx = 0
-	end
+  #
+  # Resets the subnet walker back to its original state.
+  #
+  def reset
+    self.curr_ip     = self.subnet.split('.')
+    self.num_ips     = (1 << (32 - Socket.net2bitmask(self.netmask).to_i))
+    self.curr_ip_idx = 0
+  end
 
-	#
-	# Returns the next IP address.
-	#
-	def next_ip
-		if (curr_ip_idx >= num_ips)
-			return nil
-		end
+  #
+  # Returns the next IP address.
+  #
+  def next_ip
+    if (curr_ip_idx >= num_ips)
+      return nil
+    end
 
-		if (curr_ip_idx > 0)
-			self.curr_ip[3] = (curr_ip[3].to_i + 1) % 256
-			self.curr_ip[2] = (curr_ip[2].to_i + 1) % 256 if (curr_ip[3] == 0)
-			self.curr_ip[1] = (curr_ip[1].to_i + 1) % 256 if (curr_ip[2] == 0)
-			self.curr_ip[0] = (curr_ip[0].to_i + 1) % 256 if (curr_ip[1] == 0)
-		end
+    if (curr_ip_idx > 0)
+      self.curr_ip[3] = (curr_ip[3].to_i + 1) % 256
+      self.curr_ip[2] = (curr_ip[2].to_i + 1) % 256 if (curr_ip[3] == 0)
+      self.curr_ip[1] = (curr_ip[1].to_i + 1) % 256 if (curr_ip[2] == 0)
+      self.curr_ip[0] = (curr_ip[0].to_i + 1) % 256 if (curr_ip[1] == 0)
+    end
 
-		self.curr_ip_idx += 1
-	
-		self.curr_ip.join('.')
-	end
+    self.curr_ip_idx += 1
 
-	#
-	# The subnet that is being enumerated.
-	#
-	attr_reader :subnet
-	#
-	# The netmask of the subnet.
-	#
-	attr_reader :netmask
-	#
-	# The total number of IPs within the subnet.
-	#
-	attr_reader :num_ips
+    self.curr_ip.join('.')
+  end
+
+  #
+  # The subnet that is being enumerated.
+  #
+  attr_reader :subnet
+  #
+  # The netmask of the subnet.
+  #
+  attr_reader :netmask
+  #
+  # The total number of IPs within the subnet.
+  #
+  attr_reader :num_ips
 
 protected
 
-	attr_writer   :subnet, :netmask, :num_ips # :nodoc:
-	attr_accessor :curr_ip, :curr_ip_idx # :nodoc:
+  attr_writer   :subnet, :netmask, :num_ips # :nodoc:
+  attr_accessor :curr_ip, :curr_ip_idx # :nodoc:
 
 end
 

data/lib/rex/socket/switch_board.rb

@@ -20,268 +20,268 @@ module Socket
 ###
 class SwitchBoard
 
-	include Singleton
-	include Enumerable
-
-	def initialize
-		@_initialized = false
-	end
-
-	###
-	#
-	# This class represents a logical switch board route.
-	# TODO: Enable this to work with IPv6 addresses
-	#
-	###
-	class Route
-		def initialize(subnet, netmask, comm)
-			self.subnet      = subnet
-			self.netmask     = netmask
-			self.comm        = comm
-			self.subnet_nbo  = Socket.resolv_nbo_i(subnet)
-			self.netmask_nbo = Socket.resolv_nbo_i(netmask)
-		end
-
-		#
-		# Sort according to bitmask
-		#
-		def <=>(other)
-			self.bitmask <=> other.bitmask
-		end
-
-		#
-		# Convert the netmask to a bitmask and cache it.
-		#
-		def bitmask
-			@_bitmask = Socket.net2bitmask(self.netmask) if (@_bitmask == nil)
-			@_bitmask
-		end
-
-		attr_reader :subnet, :netmask, :comm
-		attr_reader :subnet_nbo, :netmask_nbo
-	protected
-		attr_writer :subnet, :netmask, :comm
-		attr_writer :subnet_nbo, :netmask_nbo
-	end
-
-	##
-	#
-	# Class method wrappers
-	#
-	##
-
-	#
-	# Adds a route to the switch board routing table using the supplied Comm
-	# instance.
-	#
-	def self.add_route(subnet, mask, comm)
-		ret = self.instance.add_route(subnet, mask, comm)
-		if ret && comm.respond_to?(:routes) && comm.routes.kind_of?(Array)
-			comm.routes << "#{subnet}/#{mask}"
-		end
-		ret
-	end
-
-	#
-	# Removes a route from the switch board routing table for the supplied
-	# subnet routing through the supplied Comm instance.
-	#
-	def self.remove_route(subnet, mask, comm)
-		ret = self.instance.remove_route(subnet, mask, comm)
-		if ret && comm.respond_to?(:routes) && comm.routes.kind_of?(Array)
-			comm.routes.delete "#{subnet}/#{mask}"
-		end
-		ret
-	end
-
-	#
-	# Flush all the routes from the switch board routing table.
-	#
-	def self.flush_routes
-		ret = self.instance.flush_routes
-	end
-
-	#
-	# Enumerate each route in the routing table.
-	#
-	def self.each(&block)
-		self.instance.each(&block)
-	end
-
-	#
-	# Returns the array of routes.
-	#
-	def self.routes
-		self.instance.routes
-	end
-
-	def self.route_exists?(subnet, mask)
-		self.instance.route_exists?(subnet, mask)
-	end
-
-	#
-	# Returns the Comm instance that should be used for the supplied address.
-	# If no comm can be found, the default Local Comm is returned.
-	#
-	def self.best_comm(addr)
-		self.instance.best_comm(addr)
-	end
-
-	#
-	# Removes all routes that go through the supplied Comm.
-	#
-	def self.remove_by_comm(comm)
-		self.instance.remove_by_comm(comm)
-	end
-
-	##
-	#
-	# Instance methods
-	#
-	##
-
-	#
-	# Adds a route for a given subnet and netmask destined through a given comm
-	# instance.
-	#
-	def add_route(subnet, mask, comm)
-		# If a bitmask was supplied, convert it.
-		netmask = (mask.to_s =~ /^\d+$/) ? Rex::Socket.bit2netmask(mask.to_i) : mask
-		rv      = true
-
-		_init
-
-		mutex.synchronize {
-			# If the route already exists, return false to the caller.
-			if (route_exists?(subnet, netmask) == false)
-				self.routes << Route.new(subnet, netmask, comm)
-			else
-				rv = false
-			end
-		}
-
-		rv
-	end
-
-	#
-	# Removes a route for a given subnet and netmask destined through a given
-	# comm instance.
-	#
-	def remove_route(subnet, mask, comm)
-		# If a bitmask was supplied, convert it.
-		netmask = (mask.to_s =~ /^\d+$/) ? Rex::Socket.bit2netmask(mask.to_i) : mask
-		rv      = false
-
-		_init
-
-		mutex.synchronize {
-			self.routes.delete_if { |route|
-				if (route.subnet == subnet and route.netmask == netmask and route.comm == comm)
-					rv = true
-				else
-					false
-				end
-			}
-		}
-
-		rv
-	end
-
-	#
-	# Flushes all established routes.
-	#
-	def flush_routes
-		_init
-
-		# Remove each of the individual routes so the comms don't think they're
-		# still routing after a flush.
-		self.routes.each { |r|
-			if r.comm.respond_to? :routes
-				r.comm.routes.delete("#{r.subnet}/#{r.netmask}")
-			end
-		}
-		# Re-initialize to an empty array
-		self.routes = Array.new
-	end
-
-	#
-	# Checks to see if a route already exists for the supplied subnet and
-	# netmask.
-	#
-	def route_exists?(subnet, netmask)
-		each { |route|
-			return true if (route.subnet == subnet and route.netmask == netmask)
-		}
-
-		false
-	end
-
-	#
-	# Enumerates each entry in the routing table.
-	#
-	def each(&block)
-		_init
-
-		routes.each(&block)
-	end
-
-	#
-	# Finds the best possible comm for the supplied target address.
-	#
-	def best_comm(addr)
-
-		addr_nbo = Socket.resolv_nbo_i(addr)
-		comm     = nil
-		msb      = 0
-
-		each { |route|
-			if ((route.subnet_nbo & route.netmask_nbo) ==
-			    (addr_nbo & route.netmask_nbo))
-				if (route.bitmask >= msb)
-					comm = route.comm
-					msb  = route.bitmask
-				end
-			end
-		}
-
-		comm
-	end
-
-	#
-	# Remove all routes that go through the supplied comm.
-	#
-	def remove_by_comm(comm)
-		_init
-		mutex.synchronize {
-			routes.delete_if { |route|
-				route.comm == comm
-			}
-		}
-	end
-
-	#
-	# The routes array.
-	#
-	attr_reader :routes
-	#
-	# The mutex protecting the routes array.
-	#
-	attr_reader :mutex
+  include Singleton
+  include Enumerable
+
+  def initialize
+    @_initialized = false
+  end
+
+  ###
+  #
+  # This class represents a logical switch board route.
+  # TODO: Enable this to work with IPv6 addresses
+  #
+  ###
+  class Route
+    def initialize(subnet, netmask, comm)
+      self.subnet      = subnet
+      self.netmask     = netmask
+      self.comm        = comm
+      self.subnet_nbo  = Socket.resolv_nbo_i(subnet)
+      self.netmask_nbo = Socket.resolv_nbo_i(netmask)
+    end
+
+    #
+    # Sort according to bitmask
+    #
+    def <=>(other)
+      self.bitmask <=> other.bitmask
+    end
+
+    #
+    # Convert the netmask to a bitmask and cache it.
+    #
+    def bitmask
+      @_bitmask = Socket.net2bitmask(self.netmask) if (@_bitmask == nil)
+      @_bitmask
+    end
+
+    attr_reader :subnet, :netmask, :comm
+    attr_reader :subnet_nbo, :netmask_nbo
+  protected
+    attr_writer :subnet, :netmask, :comm
+    attr_writer :subnet_nbo, :netmask_nbo
+  end
+
+  ##
+  #
+  # Class method wrappers
+  #
+  ##
+
+  #
+  # Adds a route to the switch board routing table using the supplied Comm
+  # instance.
+  #
+  def self.add_route(subnet, mask, comm)
+    ret = self.instance.add_route(subnet, mask, comm)
+    if ret && comm.respond_to?(:routes) && comm.routes.kind_of?(Array)
+      comm.routes << "#{subnet}/#{mask}"
+    end
+    ret
+  end
+
+  #
+  # Removes a route from the switch board routing table for the supplied
+  # subnet routing through the supplied Comm instance.
+  #
+  def self.remove_route(subnet, mask, comm)
+    ret = self.instance.remove_route(subnet, mask, comm)
+    if ret && comm.respond_to?(:routes) && comm.routes.kind_of?(Array)
+      comm.routes.delete "#{subnet}/#{mask}"
+    end
+    ret
+  end
+
+  #
+  # Flush all the routes from the switch board routing table.
+  #
+  def self.flush_routes
+    ret = self.instance.flush_routes
+  end
+
+  #
+  # Enumerate each route in the routing table.
+  #
+  def self.each(&block)
+    self.instance.each(&block)
+  end
+
+  #
+  # Returns the array of routes.
+  #
+  def self.routes
+    self.instance.routes
+  end
+
+  def self.route_exists?(subnet, mask)
+    self.instance.route_exists?(subnet, mask)
+  end
+
+  #
+  # Returns the Comm instance that should be used for the supplied address.
+  # If no comm can be found, the default Local Comm is returned.
+  #
+  def self.best_comm(addr)
+    self.instance.best_comm(addr)
+  end
+
+  #
+  # Removes all routes that go through the supplied Comm.
+  #
+  def self.remove_by_comm(comm)
+    self.instance.remove_by_comm(comm)
+  end
+
+  ##
+  #
+  # Instance methods
+  #
+  ##
+
+  #
+  # Adds a route for a given subnet and netmask destined through a given comm
+  # instance.
+  #
+  def add_route(subnet, mask, comm)
+    # If a bitmask was supplied, convert it.
+    netmask = (mask.to_s =~ /^\d+$/) ? Rex::Socket.bit2netmask(mask.to_i) : mask
+    rv      = true
+
+    _init
+
+    mutex.synchronize {
+      # If the route already exists, return false to the caller.
+      if (route_exists?(subnet, netmask) == false)
+        self.routes << Route.new(subnet, netmask, comm)
+      else
+        rv = false
+      end
+    }
+
+    rv
+  end
+
+  #
+  # Removes a route for a given subnet and netmask destined through a given
+  # comm instance.
+  #
+  def remove_route(subnet, mask, comm)
+    # If a bitmask was supplied, convert it.
+    netmask = (mask.to_s =~ /^\d+$/) ? Rex::Socket.bit2netmask(mask.to_i) : mask
+    rv      = false
+
+    _init
+
+    mutex.synchronize {
+      self.routes.delete_if { |route|
+        if (route.subnet == subnet and route.netmask == netmask and route.comm == comm)
+          rv = true
+        else
+          false
+        end
+      }
+    }
+
+    rv
+  end
+
+  #
+  # Flushes all established routes.
+  #
+  def flush_routes
+    _init
+
+    # Remove each of the individual routes so the comms don't think they're
+    # still routing after a flush.
+    self.routes.each { |r|
+      if r.comm.respond_to? :routes
+        r.comm.routes.delete("#{r.subnet}/#{r.netmask}")
+      end
+    }
+    # Re-initialize to an empty array
+    self.routes = Array.new
+  end
+
+  #
+  # Checks to see if a route already exists for the supplied subnet and
+  # netmask.
+  #
+  def route_exists?(subnet, netmask)
+    each { |route|
+      return true if (route.subnet == subnet and route.netmask == netmask)
+    }
+
+    false
+  end
+
+  #
+  # Enumerates each entry in the routing table.
+  #
+  def each(&block)
+    _init
+
+    routes.each(&block)
+  end
+
+  #
+  # Finds the best possible comm for the supplied target address.
+  #
+  def best_comm(addr)
+
+    addr_nbo = Socket.resolv_nbo_i(addr)
+    comm     = nil
+    msb      = 0
+
+    each { |route|
+      if ((route.subnet_nbo & route.netmask_nbo) ==
+          (addr_nbo & route.netmask_nbo))
+        if (route.bitmask >= msb)
+          comm = route.comm
+          msb  = route.bitmask
+        end
+      end
+    }
+
+    comm
+  end
+
+  #
+  # Remove all routes that go through the supplied comm.
+  #
+  def remove_by_comm(comm)
+    _init
+    mutex.synchronize {
+      routes.delete_if { |route|
+        route.comm == comm
+      }
+    }
+  end
+
+  #
+  # The routes array.
+  #
+  attr_reader :routes
+  #
+  # The mutex protecting the routes array.
+  #
+  attr_reader :mutex
 
 protected
 
-	attr_writer :routes, :mutex # :nodoc:
-
-	#
-	# Initializes the underlying stuff.
-	#
-	def _init
-		if (@_initialized != true)
-			@_initialized = true
-			self.routes   = Array.new
-			self.mutex    = Mutex.new
-		end
-	end
+  attr_writer :routes, :mutex # :nodoc:
+
+  #
+  # Initializes the underlying stuff.
+  #
+  def _init
+    if (@_initialized != true)
+      @_initialized = true
+      self.routes   = Array.new
+      self.mutex    = Mutex.new
+    end
+  end
 
 end