librex 0.0.20 → 0.0.21

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

@@ -0,0 +1,107 @@
+#!/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

@@ -0,0 +1,119 @@
+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

@@ -0,0 +1,412 @@
+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