librex 0.0.20 → 0.0.21

data/lib/rex/socket/tcp_server.rb

@@ -0,0 +1,66 @@
+require 'rex/socket'
+require 'rex/socket/tcp'
+require 'rex/io/stream_server'
+
+###
+#
+# This class provides methods for interacting with a TCP server.  It
+# implements the Rex::IO::StreamServer interface.
+#
+###
+module  Rex::Socket::TcpServer
+
+	include Rex::Socket
+	include Rex::IO::StreamServer
+
+	##
+	#
+	# Factory
+	#
+	##
+
+	#
+	# Creates the server using the supplied hash.
+	#
+	def self.create(hash = {})
+		hash['Proto'] = 'tcp'
+		hash['Server'] = 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
+		Rex::Socket.create_param(param)
+	end
+
+	#
+	# Accepts a child connection.
+	#
+	def accept(opts = {})
+		t = super()
+
+		# jRuby compatibility
+		if t.respond_to?('[]')
+			t = t[0]
+		end
+
+		if (t)
+			t.extend(Rex::Socket::Tcp)
+			t.context = self.context
+
+			pn = t.getpeername
+
+			t.peerhost = pn[1]
+			t.peerport = pn[2]
+		end
+
+		t
+	end
+
+end
+

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

@@ -0,0 +1,44 @@
+#!/usr/bin/env ruby
+
+$:.unshift(File.join(File.dirname(__FILE__), '..', '..'))
+
+require 'test/unit'
+require 'rex/socket/tcp_server'
+
+class Rex::Socket::TcpServer::UnitTest < Test::Unit::TestCase
+
+	def test_tcp_server
+		serv_port = 65433
+		serv = Rex::Socket.create_tcp_server(
+			'LocalPort' => serv_port)
+		ccli = nil
+
+		begin
+			assert_kind_of(Rex::Socket::TcpServer, serv, "valid TcpServer")
+			assert_kind_of(Rex::IO::StreamServer, serv, "valid StreamServer")
+
+			# Connect to the server
+			assert_nothing_raised {
+				ccli = Rex::Socket.create_tcp(
+					'PeerHost' => '127.0.0.1',
+					'PeerPort' => serv_port)
+			}
+			assert_kind_of(Rex::Socket::Tcp, ccli, "valid client client Tcp")
+
+			# Accept the client connection
+			scli = serv.accept
+			assert_kind_of(Rex::Socket::Tcp, scli, "valid server client Tcp")
+
+			assert_equal(2, scli.put("Yo"), "scli: put Yo")
+			assert_equal("Yo", ccli.get(), "ccli: get Yo")
+			assert(scli.methods.include?('<<'))
+			assert(scli.methods.include?('>>'))
+			assert(scli.methods.include?('has_read_data?'))
+			
+		ensure
+			ccli.close if (ccli)
+			serv.close
+		end
+	end
+
+end

data/lib/rex/socket/udp.rb

@@ -0,0 +1,164 @@
+require 'rex/socket'
+
+###
+#
+# This class provides methods for interacting with a UDP socket.
+#
+###
+module Rex::Socket::Udp
+
+	include Rex::Socket
+
+	##
+	#
+	# Factory
+	#
+	##
+
+	#
+	# Creates the client using the supplied hash.
+	#
+	def self.create(hash = {})
+		hash['Proto'] = 'udp'
+		# If we have are to bind to a LocalHost we must be a Server to avail of pivoting.
+		# Rex::Socket::Parameters will subsequently turn off the sever flag after the correct
+		# comm has been chosen.
+		if( hash['LocalHost'] )
+			hash['Server'] = true
+		end
+		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 UDP.
+	#
+	def self.create_param(param)
+		param.proto = 'udp'
+		Rex::Socket.create_param(param)
+	end
+
+	##
+	#
+	# UDP connected state methods
+	#
+	##
+
+	#
+	# Write the supplied datagram to the connected UDP socket.
+	#
+	def write(gram)
+		begin
+			return syswrite(gram)
+		rescue  ::Errno::EHOSTUNREACH,::Errno::ENETDOWN,::Errno::ENETUNREACH,::Errno::ENETRESET,::Errno::EHOSTDOWN,::Errno::EACCES,::Errno::EINVAL,::Errno::EADDRNOTAVAIL
+			return nil
+		end
+	end
+
+	alias put write
+
+	#
+	# Read a datagram from the UDP socket.
+	#
+	def read(length = 65535)
+		if length < 0
+			length = 65535
+		end
+		return sysread(length)
+	end
+
+	#
+	# Read a datagram from the UDP socket with a timeout
+	#
+	def timed_read(length = 65535, timeout=def_read_timeout)
+		begin
+			if ((rv = ::IO.select([ fd ], nil, nil, timeout)) and
+			    (rv[0]) and (rv[0][0] == fd)
+			   )
+					return read(length)
+			else
+				return ''
+			end
+		rescue Exception
+			return ''
+		end
+	end
+
+	#alias send write
+	#alias recv read
+
+	##
+	#
+	# UDP non-connected state methods
+	#
+	##
+
+	#
+	# Sends a datagram to the supplied host:port with optional flags.
+	#
+	def sendto(gram, peerhost, peerport, flags = 0)
+
+		# Catch unconnected IPv6 sockets talking to IPv4 addresses
+		peer = Rex::Socket.resolv_nbo(peerhost)
+		if (peer.length == 4 and self.ipv == 6)
+			peerhost = Rex::Socket.getaddress(peerhost)
+			if peerhost[0,7].downcase != '::ffff:'
+				peerhost = '::ffff:' + peerhost
+			end
+		end
+
+		begin
+			send(gram, flags, Rex::Socket.to_sockaddr(peerhost, peerport))
+		rescue  ::Errno::EHOSTUNREACH,::Errno::ENETDOWN,::Errno::ENETUNREACH,::Errno::ENETRESET,::Errno::EHOSTDOWN,::Errno::EACCES,::Errno::EINVAL,::Errno::EADDRNOTAVAIL
+			return nil
+		end
+
+	end
+
+	#
+	# Receives a datagram and returns the data and host:port of the requestor
+	# as [ data, host, port ].
+	#
+	def recvfrom(length = 65535, timeout=def_read_timeout)
+
+		begin
+			if ((rv = ::IO.select([ fd ], nil, nil, timeout)) and
+			    (rv[0]) and (rv[0][0] == fd)
+			   )
+					data, saddr    = recvfrom_nonblock(length)
+					af, host, port = Rex::Socket.from_sockaddr(saddr)
+
+					return [ data, host, port ]
+			else
+				return [ '', nil, nil ]
+			end
+		rescue ::Timeout::Error
+			return [ '', nil, nil ]
+		rescue ::Interrupt
+			raise $!
+		rescue ::Exception
+			return [ '', nil, nil ]
+		end
+	end
+
+	#
+	# Calls recvfrom and only returns the data
+	#
+	def get(timeout=nil)
+		data, saddr, sport = recvfrom(65535, timeout)
+		return data
+	end
+
+	#
+	# The default number of seconds to wait for a read operation to timeout.
+	#
+	def def_read_timeout
+		10
+	end
+
+	def type?
+		return 'udp'
+	end
+
+end
+

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

@@ -0,0 +1,44 @@
+#!/usr/bin/env ruby
+
+$:.unshift(File.join(File.dirname(__FILE__), '..', '..'))
+
+require 'test/unit'
+require 'rex/socket/udp'
+
+class Rex::Socket::Udp::UnitTest < Test::Unit::TestCase
+
+	def test_udp
+		serv_port = 55432
+		serv = Rex::Socket::Udp.create(
+			'LocalHost' => '127.0.0.1',
+			'LocalPort' => serv_port)
+
+		begin
+			assert_kind_of(Rex::Socket::Udp, serv, "valid Udp server instance")
+
+			# Test connected socket
+			concli = Rex::Socket::Udp.create(
+				'PeerHost' => '127.0.0.1',
+				'PeerPort' => serv_port)
+
+			assert_equal('127.0.0.1', concli.peerhost, "matching peerhost")
+			assert_equal(serv_port, concli.peerport, "matching peerport")
+			assert_equal(2, concli.write('yo'), "write succeeded")
+
+			data, host, port = serv.recvfrom
+
+			assert_equal('yo', data, "read data match")
+			assert_equal('127.0.0.1', host, "matching client host")
+
+			# Test non-connected socket
+			concli = Rex::Socket::Udp.create
+
+			assert_equal(3, concli.sendto('bob', '127.0.0.1', serv_port), "sendto")
+			data, host, port = serv.recvfrom
+			assert_equal('bob', data, "read data match")
+		ensure
+			serv.close
+		end
+	end
+
+end

data/lib/rex/struct2.rb

@@ -0,0 +1,5 @@
+#!/usr/bin/env ruby
+
+# just a shim to load all of the Struct2 libraries
+
+require 'rex/struct2/c_struct_template'

data/lib/rex/struct2/c_struct.rb

@@ -0,0 +1,181 @@
+#!/usr/bin/env ruby
+
+# Rex::Struct2
+module Rex
+module Struct2
+
+require 'rex/struct2/s_struct'
+
+class CStruct_Values
+
+	def initialize(obj)
+		@obj = obj
+	end
+
+	def [](*args)
+		o = @obj[*args]
+		return if !o
+		return o.value
+	end
+
+	def []=(*args)
+		o = @obj[*args[0 .. -2]]
+		return if !o
+		o.value = args[-1]
+	end
+
+	# this one is for HD, the whiniest girl around...
+	# allow for like v.field = whatever
+	def method_missing(sym, *args)
+		if sym.to_s[-1] == "="[0]
+			return self[sym.to_s[0 .. -2]] = args[0]
+		else
+			return self[sym.to_s]
+		end
+	end
+end
+
+class CStruct < SStruct
+
+	require 'rex/struct2/element'
+	require 'rex/struct2/generic'
+	require 'rex/struct2/s_string'
+	require 'rex/struct2/c_struct_template'
+	require 'rex/struct2/restraint'
+
+	include Rex::Struct2::Element
+
+	attr_reader  :v
+
+	@@dt_table = {
+	  'int8'      => proc { |*a| Rex::Struct2::Generic.new('C',  true, *a) },
+	  'uint8'     => proc { |*a| Rex::Struct2::Generic.new('C', false, *a) },
+	  'int16v'    => proc { |*a| Rex::Struct2::Generic.new('v',  true, *a) },
+	  'uint16v'   => proc { |*a| Rex::Struct2::Generic.new('v', false, *a) },
+	  'int32v'    => proc { |*a| Rex::Struct2::Generic.new('V',  true, *a) },
+	  'uint32v'   => proc { |*a| Rex::Struct2::Generic.new('V', false, *a) },
+	  'int64v'    => proc { |*a| Rex::Struct2::Generic.new('q',  true, *a) },
+	  'uint64v'   => proc { |*a| Rex::Struct2::Generic.new('Q', false, *a) },
+	  'int16n'    => proc { |*a| Rex::Struct2::Generic.new('n',  true, *a) },
+	  'uint16n'   => proc { |*a| Rex::Struct2::Generic.new('n', false, *a) },
+	  'int32n'    => proc { |*a| Rex::Struct2::Generic.new('N',  true, *a) },
+	  'uint32n'   => proc { |*a| Rex::Struct2::Generic.new('N', false, *a) },
+	  'string'    => proc { |*a| Rex::Struct2::SString.new(*a) },
+	  'sstruct'   => proc { |*a| Rex::Struct2::SStruct.new(*a) },
+	  'object'    => proc { |o| o },
+	  'template'  => proc { |o| o.make_struct },
+	}
+
+	# CStruct.typedef(name, factory, ... )
+	def CStruct.typedef(*args)
+		while args.length >= 2
+			name    = args.shift
+			factory = args.shift
+			@@dt_table[name] = factory
+		end
+	end
+
+	def initialize(*dts)
+		super()
+		@name_table = [ ]
+		@v = Rex::Struct2::CStruct_Values.new(self)
+
+		return self.add_from_dt(*dts)
+	end
+
+	def add_from_dt(*dts)
+		dts.each { | dt |
+			return if !dt.kind_of?(Array) || dt.length < 2
+
+			type = dt[0]
+			name = dt[1]
+
+			factory = @@dt_table[type]
+
+			return if !factory
+
+			# call with the arguments passed in
+			obj = factory.call(*(dt[2 .. -1]))
+
+			self.add_object(name, obj)
+		}
+
+		return dts.length
+	end
+
+	def add_object(*objs)
+		while objs.length >= 2
+			@name_table << objs.shift
+			self        << objs.shift
+		end
+	end
+	# apply_restraint( name, restraint, name2, restraint2 ... )
+	def apply_restraint(*ress)
+		while ress.length >= 2
+			name = ress.shift
+			res  = ress.shift
+			self[name].restraint = res
+
+			# update the restrainted object, so it will update the value
+			# of the restrainter, with the initial size.  If you don't
+			# want this behavior, um, you'll have to be careful with what
+			# you supply as default values...
+			self[name].update_restraint
+		end
+		return self
+	end
+
+	# create_restraints( [ name, stuff_to_restraint_constructor ] ... )
+	def create_restraints(*ress)
+		ress.each { |r|
+			# make a copy before we modify...
+			r = r.dup
+			# resolve names into objects
+			r[1] = self[r[1]] if r[1]
+			r[2] = self[r[2]] if r[2]
+
+			# build and apply the restraint
+			self.apply_restraint(r[0], Rex::Struct2::Restraint.new(*r[1 .. -1]))
+		}
+
+		return self
+	end
+
+	# ya ya, I know, these are weird.  I'm not sure why I even bothered
+	# to inherit from array...
+	def [](index, *other)
+		if index.kind_of?(String)
+			i = @name_table.index(index)
+			return if !i
+			return super(i)
+		else
+			return super(index, *other)
+		end
+	end
+
+	def []=(index, *other)
+		if index.kind_of?(String)
+			i = @name_table.index(index)
+			return if !i
+			return super(i, *other)
+		else
+			return super(index, *other)
+		end
+	end
+	
+	# Produce a list of field names
+	def keys
+		@name_table
+	end
+	
+	# Iterate through all fields and values
+	def each_pair(&block)
+		@name_table.each do |k|
+			block.call(k, self.v[k])
+		end
+	end
+end
+
+# end Rex::Struct2
+end
+end