librex 0.0.17 → 0.0.18

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

@@ -1,107 +0,0 @@
-#!/usr/bin/env ruby
-
-$:.unshift(File.join(File.dirname(__FILE__), '..'))
-
-require 'test/unit'
-require 'rex/socket'
-require 'rex/socket/tcp'
-
-class Rex::Socket::UnitTest < Test::Unit::TestCase
-
-	def test_ip
-		assert_equal(true,Rex::Socket.dotted_ip?('0.0.0.0'), 'valid IP min')
-		assert_equal(true,Rex::Socket.dotted_ip?('255.255.255.255'), 'valid IP max')
-		assert_equal(false,Rex::Socket.dotted_ip?('0.0.0.0.0'), 'too many sections')
-		assert_equal(false,Rex::Socket.dotted_ip?('0..0.0.0'), 'too many dots')
-		assert_equal(false,Rex::Socket.dotted_ip?('00.0.0'), 'not enough dots')
-		assert_equal(false,Rex::Socket.dotted_ip?('256.256.256.256'), 'numbers too big')
-	end
-
-	def test_create
-		port = 64442
-		serv = TCPServer.new('127.0.0.1', port)
-
-		sock = nil
-		assert_nothing_raised {
-			sock = Rex::Socket.create(
-				'PeerHost' => '127.0.0.1',
-				'PeerPort' => port,
-				'Proto'    => 'tcp')
-		}
-		assert_kind_of(Rex::Socket::Tcp, sock, "socket factory creation")
-
-		sock = nil
-		assert_nothing_raised {
-			sock = Rex::Socket.create_tcp(
-				'PeerHost' => '127.0.0.1',
-				'PeerPort' => port)
-		}
-		assert_kind_of(Rex::Socket::Tcp, sock, "tcp socket factory creation")
-
-		serv.close
-	end
-
-	def test_to_sockaddr
-		assert_equal(([2] + [0]*14).pack("sC*"), Rex::Socket.to_sockaddr(0, 0), "null sockaddr")
-=begin
-# This is platform dependent, pain to test
-		if (Rex::Socket.support_ipv6?)
-			# Use the constant for AF_INET6 since it is different per platform
-			# (10 on linux and 28 on BSD)
-			inaddr_any_sockaddr = ([::Socket::AF_INET6, 22] + [0]*24).pack('sSC*')
-		else
-			inaddr_any_sockaddr = ([2, 22] + [0]*12).pack('snC*')
-		end
-=end
-		assert_equal(([2, 0x16, 1, 2, 3, 4] + [0]*8).pack('snC*'), Rex::Socket.to_sockaddr("1.2.3.4", 22), "1.2.3.4 addr, port 22 sockaddr")
-	end
-
-	def test_from_sockaddr
-		# 1.9.1 raises ArgumentError if we don't have an af == AF_INET or AF_INET6
-		af, host, port = Rex::Socket.from_sockaddr(([2, 0] + [0]*12).pack('snC*'))
-		assert_equal(2, af, "af = 2")
-		assert_equal('0.0.0.0', host, "zero host")
-		assert_equal(0, port, "zero port")
-
-		af, host, port = Rex::Socket.from_sockaddr(([2, 22]+[0]*12).pack('snC*'))
-		assert_equal(2, af, "af = 2")
-		assert_equal(22, port, "port = 22")
-		assert_equal('0.0.0.0', host, "zero host")
-
-		af, host, port = Rex::Socket.from_sockaddr(([2, 22, 1, 2, 3, 4] + [0]*8).pack('snC*') )
-		assert_equal(2, af, "af = 2")
-		assert_equal('1.2.3.4', host, "host = '1.2.3.4'")
-		assert_equal(22, port, "port = 22")
-	end
-
-	def test_resolv_nbo
-		assert_equal("\x04\x03\x02\x01", Rex::Socket.resolv_nbo("4.3.2.1"))
-	end
-
-	def test_net2bitmask
-		assert_equal(32, Rex::Socket.net2bitmask('255.255.255.255'))
-		assert_equal(28, Rex::Socket.net2bitmask('255.255.255.240'))
-		assert_equal(24, Rex::Socket.net2bitmask('255.255.255.0'))
-		assert_equal(16, Rex::Socket.net2bitmask('255.255.0.0'))
-	end
-
-	def test_bit2netmask
-		assert_equal("255.255.255.255", Rex::Socket.bit2netmask(32))
-		assert_equal("255.255.255.254", Rex::Socket.bit2netmask(31))
-		assert_equal("255.255.255.240", Rex::Socket.bit2netmask(28))
-		assert_equal("255.255.255.0", Rex::Socket.bit2netmask(24))
-		assert_equal("255.255.0.0", Rex::Socket.bit2netmask(16))
-	end
-
-	def test_is_internal
-		assert( ! Rex::Socket.is_internal?("1.2.3.4"))
-		assert( ! Rex::Socket.is_internal?("172.15.3.4"))
-		assert( ! Rex::Socket.is_internal?("172.32.3.4"))
-		assert(Rex::Socket.is_internal?("10.2.3.4"))
-		assert(Rex::Socket.is_internal?("192.168.3.4"))
-		16.upto(31) do |octet|
-			assert(Rex::Socket.is_internal?("172.#{octet}.3.4"))
-		end
-	end
-
-end

data/lib/rex/socket/comm.rb

@@ -1,119 +0,0 @@
-require 'rex/socket'
-
-module Rex
-module Socket
-
-###
-#
-# This mixin provides the basic interface that a derived class must implement
-# in order to be a compatible comm class.  The base comm class also supports
-# registering event handlers that can be notified when sockets are being
-# created and have been created.  This allows code to extend sockets on
-# creation from the single point that they are created.
-#
-###
-module Comm
-
-	###
-	# 
-	# This mixin provides stubs for event notification handlers that can be
-	# registered with a Comm factory to be called when various events occur,
-	# such as socket instantiation.
-	#
-	###
-	module Events
-
-		#
-		# This callback is notified when a socket is being created and is passed
-		# the parameters that will be used to create it.
-		#
-		def on_before_socket_create(comm, param)
-		end
-
-		#
-		# This callback is notified when a new socket is created and the
-		# parameters that were used to create it.  This provides the callback
-		# with a chance to extend or otherwise modify the socket before it's
-		# passed on to the actual requestor.
-		#
-		def on_socket_created(comm, sock, param)
-		end
-
-	end
-
-	#
-	# Creates a compatible socket based on the supplied uniform parameters.
-	#
-	def self.create(param)
-		raise NotImplementedError
-	end
-
-	#
-	# Indicates whether or not this comm can be chained with other chainable
-	# comms.  This is particularly important for things like Proxy Comms that
-	# can be proxied through one another.  The semantics of this are currently
-	# undefined and will probably need some more thought.
-	#
-	def chainable?
-		false
-	end
-
-	#
-	# Registers an event handler that implements the Rex::Socket::Comm::Event
-	# interface in at least some fashion.  Event handlers are notified when
-	# sockets are created through the Comm instance that they register against.
-	#
-	def register_event_handler(handler)
-		if (handlers == nil)
-			self.handlers        = []
-		end
-
-		self.handlers << handler
-	end
-
-	#
-	# Deregisters a previously registered event handler.
-	#
-	def deregister_event_handler(handler)
-		if (handlers)
-			handlers.delete(handler)
-		end
-	end
-
-	#
-	# Enumerates each registered event handler so that they can be notified of
-	# an event.
-	#
-	def each_event_handler(&block)
-		if (handlers)
-			handlers.each(&block)
-		end
-	end
-
-	#
-	# Notifies handlers of the before socket create event.
-	#
-	def notify_before_socket_create(comm, param)
-		each_event_handler() { |handler|
-			handler.on_before_socket_create(comm, param)
-		}
-	end
-
-	#
-	# Notifies handlers of the socket created event.
-	#
-	def notify_socket_created(comm, sock, param)
-		each_event_handler() { |handler|
-			handler.on_socket_created(comm, sock, param)
-		}
-	end
-
-protected
-
-	attr_accessor :handlers # :nodoc:
-	attr_accessor :handlers_rwlock # :nodoc:
-
-end
-
-end
-end

data/lib/rex/socket/comm/local.rb

@@ -1,412 +0,0 @@
-require 'singleton'
-require 'rex/socket'
-require 'rex/socket/tcp'
-require 'rex/socket/ssl_tcp'
-require 'rex/socket/ssl_tcp_server'
-require 'rex/socket/udp'
-require 'rex/socket/ip'
-require 'timeout'
-
-###
-#
-# Local communication class factory.
-#
-###
-class Rex::Socket::Comm::Local
-
-	include Singleton
-	include Rex::Socket::Comm
-
-	#
-	# Creates an instance of a socket using the supplied parameters.
-	#
-	def self.create(param)
-
-		# Work around jRuby socket implementation issues
-		if(RUBY_PLATFORM == 'java')
-			return self.create_jruby(param)
-		end
-
-		case param.proto
-			when 'tcp'
-				return create_by_type(param, ::Socket::SOCK_STREAM, ::Socket::IPPROTO_TCP)
-			when 'udp'
-				return create_by_type(param, ::Socket::SOCK_DGRAM, ::Socket::IPPROTO_UDP)
-			when 'ip'
-				return create_ip(param)
-			else
-				raise Rex::UnsupportedProtocol.new(param.proto), caller
-		end
-	end
-
-	#
-	# Creates an instance of a socket using the supplied parameters.
-	# Use various hacks to make this work with jRuby
-	#
-	def self.create_jruby(param)
-		sock = nil
-
-		# Notify handlers of the before socket create event.
-		self.instance.notify_before_socket_create(self, param)
-
-		case param.proto
-			when 'tcp'
-				if (param.server?)
-					sock  = TCPServer.new(param.localport, param.localhost)
-					klass = Rex::Socket::TcpServer
-					if (param.ssl)
-						klass = Rex::Socket::SslTcpServer
-					end
-					sock.extend(klass)
-
-				else
-					sock = TCPSocket.new(param.peerhost, param.peerport)
-					klass = Rex::Socket::Tcp
-					if (param.ssl)
-						klass = Rex::Socket::SslTcp
-					end
-					sock.extend(klass)
-				end
-			when 'udp'
-				if (param.server?)
-					sock = UDPServer.new(param.localport, param.localhost)
-					klass = Rex::Socket::UdpServer
-					sock.extend(klass)
-				else
-					sock = UDPSocket.new(param.peerhost, param.peerport)
-					klass = Rex::Socket::Udp
-					sock.extend(klass)
-				end
-			else
-				raise Rex::UnsupportedProtocol.new(param.proto), caller
-		end
-
-		sock.initsock(param)
-		self.instance.notify_socket_created(self, sock, param)
-		return sock
-	end
-
-
-	#
-	# Creates a raw IP socket using the supplied Parameter instance.
-	# Special-cased because of how different it is from UDP/TCP
-	#
-	def self.create_ip(param)
-		self.instance.notify_before_socket_create(self, param)
-
-		sock = ::Socket.open(::Socket::PF_INET, ::Socket::SOCK_RAW, ::Socket::IPPROTO_RAW)
-		sock.setsockopt(::Socket::IPPROTO_IP, ::Socket::IP_HDRINCL, 1)
-
-		# Configure broadcast support
-		sock.setsockopt(::Socket::SOL_SOCKET, ::Socket::SO_BROADCAST, true)
-
-		if (param.bare? == false)
-			sock.extend(::Rex::Socket::Ip)
-			sock.initsock(param)
-		end
-
-		self.instance.notify_socket_created(self, sock, param)
-
-		sock
-	end
-
-
-	#
-	# Creates a socket using the supplied Parameter instance.
-	#
-	def self.create_by_type(param, type, proto = 0)
-
-		# Whether to use IPv6 addressing
-		usev6 = false
-
-		# Detect IPv6 addresses and enable IPv6 accordingly
-		if ( Rex::Socket.support_ipv6?())
-
-			# Allow the caller to force IPv6
-			if (param.v6)
-				usev6 = true
-			end
-
-			# Force IPv6 mode for non-connected UDP sockets
-			if (type == ::Socket::SOCK_DGRAM and not param.peerhost)
-				# FreeBSD allows IPv6 socket creation, but throws an error on sendto()
-
-				if (not Rex::Compat.is_freebsd())
-					usev6 = true
-				end
-			end
-
-			local = Rex::Socket.resolv_nbo(param.localhost) if param.localhost
-			peer  = Rex::Socket.resolv_nbo(param.peerhost) if param.peerhost
-
-			if (local and local.length == 16)
-				usev6 = true
-			end
-
-			if (peer and peer.length == 16)
-				usev6 = true
-			end
-
-			if (usev6)
-				if (local and local.length == 4)
-					if (local == "\x00\x00\x00\x00")
-						param.localhost = '::'
-					elsif (local == "\x7f\x00\x00\x01")
-						param.localhost = '::1'
-					else
-						param.localhost = '::ffff:' + Rex::Socket.getaddress(param.localhost)
-					end
-				end
-
-				if (peer and peer.length == 4)
-					if (peer == "\x00\x00\x00\x00")
-						param.peerhost = '::'
-					elsif (peer == "\x7f\x00\x00\x01")
-						param.peerhost = '::1'
-					else
-						param.peerhost = '::ffff:' + Rex::Socket.getaddress(param.peerhost)
-					end
-				end
-
-				param.v6 = true
-			end
-		else
-			# No IPv6 support
-			param.v6 = false
-		end
-
-		# Notify handlers of the before socket create event.
-		self.instance.notify_before_socket_create(self, param)
-
-		# Create the socket
-		sock = nil
-		if (param.v6)
-			sock = ::Socket.new(::Socket::AF_INET6, type, proto)
-		else
-			sock = ::Socket.new(::Socket::AF_INET, type, proto)
-		end
-
-		# Bind to a given local address and/or port if they are supplied
-		if (param.localhost || param.localport)
-			begin
-				sock.setsockopt(::Socket::SOL_SOCKET, ::Socket::SO_REUSEADDR, true)
-
-				sock.bind(Rex::Socket.to_sockaddr(param.localhost, param.localport))
-
-			rescue ::Errno::EADDRNOTAVAIL,::Errno::EADDRINUSE
-				sock.close
-				raise Rex::AddressInUse.new(param.localhost, param.localport), caller
-			end
-		end
-
-		# Configure broadcast support for all datagram sockets
-		if (type == ::Socket::SOCK_DGRAM)
-			sock.setsockopt(::Socket::SOL_SOCKET, ::Socket::SO_BROADCAST, true)
-		end
-
-		# If a server TCP instance is being created...
-		if (param.server?)
-			sock.listen(128)
-
-			if (param.bare? == false)
-				klass = Rex::Socket::TcpServer
-				if (param.ssl)
-					klass = Rex::Socket::SslTcpServer
-				end
-				sock.extend(klass)
-
-				sock.initsock(param)
-			end
-		# Otherwise, if we're creating a client...
-		else
-			chain = []
-
-			# If we were supplied with host information
-			if (param.peerhost)
-				begin
-					ip = param.peerhost
-					port = param.peerport
-
-					if param.proxies
-						chain = param.proxies.dup
-						chain.push(['host',param.peerhost,param.peerport])
-						ip = chain[0][1]
-						port = chain[0][2].to_i
-					end
-
-					begin
-						Timeout.timeout(param.timeout) do
-							sock.connect(Rex::Socket.to_sockaddr(ip, port))
-						end
-					rescue ::Timeout::Error
-						raise ::Errno::ETIMEDOUT
-					end
-
-				rescue ::Errno::EHOSTUNREACH,::Errno::ENETDOWN,::Errno::ENETUNREACH,::Errno::ENETRESET,::Errno::EHOSTDOWN,::Errno::EACCES,::Errno::EINVAL
-					sock.close
-					raise Rex::HostUnreachable.new(param.peerhost, param.peerport), caller
-
-				rescue ::Errno::EADDRNOTAVAIL,::Errno::EADDRINUSE
-					sock.close
-					raise Rex::AddressInUse.new(param.peerhost, param.peerport), caller
-
-				rescue Errno::ETIMEDOUT
-					sock.close
-					raise Rex::ConnectionTimeout.new(param.peerhost, param.peerport), caller
-
-				rescue ::Errno::ECONNRESET,::Errno::ECONNREFUSED,::Errno::ENOTCONN,::Errno::ECONNABORTED
-					sock.close
-					raise Rex::ConnectionRefused.new(param.peerhost, param.peerport), caller
-				end
-			end
-
-			if (param.bare? == false)
-				case param.proto
-					when 'tcp'
-						klass = Rex::Socket::Tcp
-						sock.extend(klass)
-						sock.initsock(param)
-					when 'udp'
-						sock.extend(Rex::Socket::Udp)
-						sock.initsock(param)
-				end
-			end
-
-			if chain.size > 1
-				chain.each_with_index {
-					|proxy, i|
-					next_hop = chain[i + 1]
-					if next_hop
-						proxy(sock, proxy[0], next_hop[1], next_hop[2])
-					end
-				}
-			end
-
-			# Now extend the socket with SSL and perform the handshake
-			if(param.bare? == false and param.ssl)
-				klass = Rex::Socket::SslTcp
-				sock.extend(klass)
-				sock.initsock(param)
-			end
-
-
-		end
-
-		# Notify handlers that a socket has been created.
-		self.instance.notify_socket_created(self, sock, param)
-
-		sock
-	end
-
-	def self.proxy(sock, type, host, port)
-
-		#$stdout.print("PROXY\n")
-		case type.downcase
-		when 'http'
-			setup = "CONNECT #{host}:#{port} HTTP/1.0\r\n\r\n"
-			size = sock.put(setup)
-			if (size != setup.length)
-				raise Rex::ConnectionProxyError.new(host, port, type, "Failed to send the entire request to the proxy"), caller
-			end
-
-			begin
-				ret = sock.get_once(39,30)
-			rescue IOError
-				raise Rex::ConnectionProxyError.new(host, port, type, "Failed to receive a response from the proxy"), caller
-			end
-
-			if ret.nil?
-				raise Rex::ConnectionProxyError.new(host, port, type, "Failed to receive a response from the proxy"), caller
-			end
-
-			resp = Rex::Proto::Http::Response.new
-			resp.update_cmd_parts(ret.split(/\r?\n/)[0])
-
-			if resp.code != 200
-				raise Rex::ConnectionProxyError.new(host, port, type, "The proxy returned a non-OK response"), caller
-			end
-		when 'socks4'
-			setup = [4,1,port.to_i].pack('CCn') + Socket.gethostbyname(host)[3] + Rex::Text.rand_text_alpha(rand(8)+1) + "\x00"
-			size = sock.put(setup)
-			if (size != setup.length)
-				raise Rex::ConnectionProxyError.new(host, port, type, "Failed to send the entire request to the proxy"), caller
-			end
-
-			begin
-				ret = sock.get_once(8, 30)
-			rescue IOError
-				raise Rex::ConnectionProxyError.new(host, port, type, "Failed to receive a response from the proxy"), caller
-			end
-
-			if (ret.nil? or ret.length < 8)
-				raise Rex::ConnectionProxyError.new(host, port, type, "Failed to receive a complete response from the proxy"), caller
-			end
-			if ret[1,1] != "\x5a"
-				raise Rex::ConnectionProxyError.new(host, port, type, "Proxy responded with error code #{ret[0,1].unpack("C")[0]}"), caller
-			end
-		when 'socks5'
-			auth_methods = [5,1,0].pack('CCC')
-			size = sock.put(auth_methods)
-			if (size != auth_methods.length)
-				raise Rex::ConnectionProxyError.new(host, port, type, "Failed to send the entire request to the proxy"), caller
-			end
-			ret = sock.get_once(2,30)
-			if (ret[1,1] == "\xff")
-				raise Rex::ConnectionProxyError.new(host, port, type, "The proxy requires authentication"), caller
-			end
-
-			if (Rex::Socket.is_ipv4?(host))
-				addr = Rex::Socket.gethostbyname(host)[3]
-				setup = [5,1,0,1].pack('C4') + addr + [port.to_i].pack('n')
-			elsif (Rex::Socket.support_ipv6? and Rex::Socket.is_ipv6?(host))
-				# IPv6 stuff all untested
-				addr = Rex::Socket.gethostbyname(host)[3]
-				setup = [5,1,0,4].pack('C4') + addr + [port.to_i].pack('n')
-			else
-				# Then it must be a domain name.
-				# Unfortunately, it looks like the host has always been
-				# resolved by the time it gets here, so this code never runs.
-				setup = [5,1,0,3].pack('C4') + [host.length].pack('C') + host + [port.to_i].pack('n')
-			end
-
-			size = sock.put(setup)
-			if (size != setup.length)
-				raise Rex::ConnectionProxyError.new(host, port, type, "Failed to send the entire request to the proxy"), caller
-			end
-
-			begin
-				response = sock.get_once(10, 30)
-			rescue IOError
-				raise Rex::ConnectionProxyError.new(host, port, type, "Failed to receive a response from the proxy"), caller
-			end
-
-			if (response.nil? or response.length < 10)
-				raise Rex::ConnectionProxyError.new(host, port, type, "Failed to receive a complete response from the proxy"), caller
-			end
-			if response[1,1] != "\x00"
-				raise Rex::ConnectionProxyError.new(host, port, type, "Proxy responded with error code #{response[1,1].unpack("C")[0]}"), caller
-			end
-		else
-			raise RuntimeError, "The proxy type specified is not valid", caller
-		end
-	end
-
-	##
-	#
-	# Registration
-	#
-	##
-
-	def self.register_event_handler(handler) # :nodoc:
-		self.instance.register_event_handler(handler)
-	end
-
-	def self.deregister_event_handler(handler) # :nodoc:
-		self.instance.deregister_event_handler(handler)
-	end
-
-	def self.each_event_handler(handler) # :nodoc:
-		self.instance.each_event_handler(handler)
-	end
-
-end