librex 0.0.13 → 0.0.15

data/lib/rex/socket/subnet_walker.rb.ut.rb

@@ -1,28 +0,0 @@
-#!/usr/bin/env ruby
-
-$:.unshift(File.join(File.dirname(__FILE__), '..', '..'))
-
-require 'test/unit'
-require 'rex/socket/subnet_walker'
-
-class Rex::Socket::SubnetWalker::UnitTest < Test::Unit::TestCase
-
-	Klass = Rex::Socket::SubnetWalker
-
-	def test_walker
-		s = Klass.new('10.0.0.0', '255.255.255.0')
-
-		0.upto(255) { |x|
-			assert_equal('10.0.0.' + x.to_s, s.next_ip)
-		}
-		assert_nil(s.next_ip)
-
-		s.reset
-
-		0.upto(255) { |x|
-			assert_equal('10.0.0.' + x.to_s, s.next_ip)
-		}
-		assert_nil(s.next_ip)
-	end
-
-end

data/lib/rex/socket/switch_board.rb

@@ -1,278 +0,0 @@
-require 'singleton'
-require 'thread'
-require 'rex/socket'
-
-module Rex
-module Socket
-
-###
-#
-# This class provides a global routing table that associates subnets with Comm
-# classes.  Comm classes are used to instantiate objects that are tied to
-# remote network entities.  For example, the Local Comm class is used to
-# building network connections directly from the local machine whereas, for
-# instance, a Meterpreter Comm would build a local socket pair that is
-# associated with a connection established by a remote entity.  This can be
-# seen as a uniform way of communicating with hosts through arbitrary
-# channels.
-#
-###
-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
-	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
-	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
-
-		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
-
-end
-
-end
-end

data/lib/rex/socket/switch_board.rb.ut.rb

@@ -1,52 +0,0 @@
-#!/usr/bin/env ruby
-
-$:.unshift(File.join(File.dirname(__FILE__), '..', '..'))
-
-require 'test/unit'
-require 'rex/socket/switch_board'
-
-class Rex::Socket::SwitchBoard::UnitTest < Test::Unit::TestCase
-
-	Klass = Rex::Socket::SwitchBoard
-
-	def test_add
-		Klass.flush_routes
-		assert_equal(true, Klass.add_route('0.0.0.0', 0, 'foo'))
-		assert_equal(false, Klass.add_route('0.0.0.0', 0, 'foo'))
-		assert_equal(1, Klass.routes.length)
-
-		assert_equal('0.0.0.0', Klass.routes[0].subnet)
-		assert_equal('0.0.0.0', Klass.routes[0].netmask)
-		assert_equal(0, Klass.routes[0].bitmask)
-		assert_equal('foo', Klass.routes[0].comm)
-	end
-
-	def test_remove
-		Klass.flush_routes
-		assert_equal(true, Klass.add_route('0.0.0.0', 0, 'foo'))
-		assert_equal(true, Klass.remove_route('0.0.0.0', 0, 'foo'))
-		assert_equal(false, Klass.remove_route('0.0.0.0', 0, 'foo'))
-		assert_equal(0, Klass.routes.length)
-	end
-
-	def test_best_comm
-		Klass.flush_routes
-		Klass.add_route('0.0.0.0', 0, 'default')
-		Klass.add_route('1.2.3.0', 24, 'spec')
-
-		assert_equal('default', Klass.best_comm('4.5.6.7'))
-		assert_equal('spec', Klass.best_comm('1.2.3.7'))
-	end
-
-	def test_remove_by_comm
-		Klass.flush_routes
-		Klass.add_route('1.2.3.0', 24, 'foo')
-		Klass.add_route('1.2.4.0', 24, 'dog')
-
-		Klass.remove_by_comm('foo')
-
-		assert_equal('dog', Klass.best_comm('1.2.4.7'))
-		assert_nil(Klass.best_comm('1.2.3.7'))
-	end
-
-end

data/lib/rex/socket/tcp.rb

@@ -1,76 +0,0 @@
-require 'rex/socket'
-require 'rex/io/stream'
-
-###
-#
-# This class provides methods for interacting with a TCP client connection.
-#
-###
-module Rex::Socket::Tcp
-
-	include Rex::Socket
-	include Rex::IO::Stream
-	
-	##
-	#
-	# Factory
-	#
-	##
-
-	#
-	# Creates the client using the supplied hash.
-	#
-	def self.create(hash = {})
-		hash['Proto'] = 'tcp' 
-		self.create_param(Rex::Socket::Parameters.from_hash(hash))
-	end
-
-	#
-	# Wrapper around the base socket class' creation method that automatically
-	# sets the parameter's protocol to TCP.
-	#
-	def self.create_param(param)
-		param.proto = 'tcp'
-		Rex::Socket.create_param(param)
-	end
-
-	##
-	#
-	# Stream mixin implementations
-	#
-	##
-
-	#
-	# Calls shutdown on the TCP connection.
-	#
-	def shutdown(how = ::Socket::SHUT_RDWR)
-		begin
-			return (super(how) == 0)
-		rescue ::Exception
-		end
-	end
-
-	#
-	# Returns peer information (host + port) in host:port format.
-	#
-	def peerinfo
-		if (pi = getpeername)
-			return pi[1] + ':' + pi[2].to_s
-		end
-	end
-
-	#
-	# Returns local information (host + port) in host:port format.
-	#
-	def localinfo
-		if (pi = getlocalname)
-			return pi[1] + ':' + pi[2].to_s
-		end
-	end
-
-	# returns socket type
-	def type?
-		return 'tcp'
-	end
-
-end

data/lib/rex/socket/tcp.rb.ut.rb

@@ -1,64 +0,0 @@
-#!/usr/bin/env ruby
-
-$:.unshift(File.join(File.dirname(__FILE__), '..', '..'))
-
-require 'test/unit'
-require 'rex'
-
-class Rex::Socket::Tcp::UnitTest < Test::Unit::TestCase
-
-	def test_tcp
-		port = 65434
-		listener = Rex::Socket.create_tcp_server( 'LocalPort' => port )
-		client = nil
-
-		begin
-			# Connect to the temp server
-			assert_nothing_raised {
-				client = Rex::Socket.create_tcp(
-					'PeerHost' => '127.0.0.1',
-					'PeerPort' => port)
-			}
-
-			assert_kind_of(Rex::Socket::Tcp, client, 'kindof?')
-			assert_equal('127.0.0.1', client.peerhost, 'peerhost')
-			assert_equal(port, client.peerport, 'peerport')
-
-			# Accept the client connection
-			server = listener.accept
-			assert_kind_of(Socket, server, "valid server socket connection")
-
-			# do all of the tests, once for each side
-			{ 'c/s' => [client, server], 's/c' => [server, client] }.each_pair { |mode, sockets|
-				a = sockets[0]
-				b = sockets[1]
-
-				string = "test\n"
-				assert_equal(false, a.has_read_data?(1), "#{mode} : has_read_data?, no data")
-				assert_equal(string.length, b.write(string), "#{mode} : write")
-				assert_equal(true, a.has_read_data?(1), "#{mode} : has_read_data?, with data")
-				assert_equal(string, a.recv(string.length), "#{mode} : recv")
-
-				string = "string\rtest\nwith\x00null"
-				assert_equal(string.length, a << string, "#{mode} : append")
-				tmp = ''; tmp = b.>>
-				assert_equal(string, tmp, "#{mode} : append (reverse)")
-
-				string = "\x00foobar\x00"
-				assert_equal(string.length, a.send(string, 0), "#{mode} : send")
-				assert_equal(string, b.get(), "#{mode} : get")
-			}
-
-			assert_equal(true, client.shutdown(::Socket::SHUT_RD), 'client: shutdown read handle')
-			assert_equal(true, client.shutdown(::Socket::SHUT_WR), 'client: shutdown write handle')
-			assert_nothing_raised {
-				client.close
-				client = nil
-			}
-		ensure
-			client.close if (client)
-			listener.close
-		end
-	end
-
-end