librex 0.0.1

data/lib/rex/post/meterpreter/extensions/stdapi/fs/file_stat.rb

@@ -0,0 +1,103 @@
+#!/usr/bin/env ruby
+
+require 'rex/post/file_stat'
+require 'rex/post/meterpreter/extensions/stdapi/stdapi'
+
+module Rex
+module Post
+module Meterpreter
+module Extensions
+module Stdapi
+module Fs
+
+###
+#
+# This class wrappers gathering information about a given file and implements
+# the Rex::Post::FileStat interface in terms of data acquisition.
+#
+###
+class FileStat < Rex::Post::FileStat
+
+	class <<self
+		attr_accessor :client
+	end
+
+	@@struct_stat = [
+	  'st_dev',     4,  # 0
+	  'st_ino',     2,  # 4
+	  'st_mode',    2,  # 6
+	  'st_nlink',   2,  # 8
+	  'st_uid',     2,  # 10
+	  'st_gid',     2,  # 12
+	  'pad1',       2,  # 14
+	  'st_rdev',    4,  # 16
+	  'st_size',    4,  # 20
+	  'st_atime',   8,  # 24
+	  'st_mtime',   8,  # 32
+	  'st_ctime',   8,  # 40
+	]
+
+	##
+	#
+	# Constructor
+	#
+	##
+
+	#
+	# Returns an instance of a FileStat object.
+	#
+	def initialize(file)
+		self.stathash = stat(file) if (file)
+	end
+
+	#
+	# Swaps in a new stat hash.
+	#
+	def update(stat_buf)
+		elem   = @@struct_stat
+		hash   = {}
+		offset = 0
+		index  = 0
+
+		while (index < elem.length)
+			size = elem[index + 1]
+
+			value   = stat_buf[offset, size].unpack(size == 2 ? 'v' : 'V')[0]
+			offset += size
+
+			hash[elem[index]] = value
+
+			index += 2
+		end
+
+		return (self.stathash = hash)
+	end
+
+protected
+
+	##
+	#
+	# Initializer
+	#
+	##
+
+	#
+	# Gets information about the supplied file and returns a populated
+	# hash to the requestor.
+	#
+	def stat(file)
+		request = Packet.create_request('stdapi_fs_stat')
+
+		request.add_tlv(TLV_TYPE_FILE_PATH, file)
+
+		response = self.class.client.send_request(request)
+		stat_buf = response.get_tlv(TLV_TYPE_STAT_BUF).value
+
+		# Next, we go through the returned stat_buf and fix up the values
+		# and insert them into a hash
+		return update(stat_buf)
+	end
+
+end
+
+end; end; end; end; end; end

data/lib/rex/post/meterpreter/extensions/stdapi/fs/io.rb

@@ -0,0 +1,48 @@
+#!/usr/bin/env ruby
+
+require 'rex/post/io'
+
+module Rex
+module Post
+module Meterpreter
+module Extensions
+module Stdapi
+module Fs
+
+##
+#
+# The IO class acts as a base class for things that would normally implement
+# the IO interface.  The methods it implements are for general operations that
+# are common to all channels, such as read, write, and close.
+#
+##
+class IO < Rex::Post::IO
+
+	#
+	# Read the specified number of bytes from the channel.
+	#
+	def sysread(length = nil)
+		self.filed.read(length)
+	end
+
+	alias read sysread
+
+	#
+	# Writes the supplied buffer to the channel.
+	#
+	def syswrite(buf)
+		self.filed.write(buf)
+	end
+
+	alias write syswrite
+
+	#
+	# Closes the channel.
+	#
+	def close
+		self.filed.close
+	end
+
+end
+
+end; end; end; end; end; end

data/lib/rex/post/meterpreter/extensions/stdapi/net/config.rb

@@ -0,0 +1,144 @@
+#!/usr/bin/env ruby
+
+require 'rex/post/meterpreter/extensions/stdapi/tlv'
+require 'rex/post/meterpreter/extensions/stdapi/net/route'
+require 'rex/post/meterpreter/extensions/stdapi/net/interface'
+
+module Rex
+module Post
+module Meterpreter
+module Extensions
+module Stdapi
+module Net
+
+###
+#
+# This class provides an interface to the network configuration
+# that exists on the remote machine, such as interfaces, and
+# routes.
+#
+###
+class Config
+
+	##
+	#
+	# Constructor
+	#
+	##
+
+	#
+	# Initializes a Config instance that is used to get information about the
+	# network configuration of the remote machine.
+	#
+	def initialize(client)
+		self.client = client
+	end
+
+	##
+	#
+	# Interfaces
+	#
+	##
+
+	#
+	# Enumerates each interface.
+	#
+	def each_interface(&block)
+		get_interfaces().each(&block)
+	end
+
+	#
+	# Returns an array of network interfaces with each element.
+	#
+	# being an Interface
+	def get_interfaces
+		request = Packet.create_request('stdapi_net_config_get_interfaces')
+		ifaces  = []
+
+		response = client.send_request(request)
+
+		response.each(TLV_TYPE_NETWORK_INTERFACE) { |iface|
+			ifaces << Interface.new(
+					iface.get_tlv_value(TLV_TYPE_IP),
+					iface.get_tlv_value(TLV_TYPE_NETMASK),
+					iface.get_tlv_value(TLV_TYPE_MAC_ADDRESS),
+					iface.get_tlv_value(TLV_TYPE_MAC_NAME))
+		}
+
+		return ifaces
+	end
+
+	alias interfaces get_interfaces
+
+	##
+	#
+	# Routing
+	#
+	##
+
+	#
+	# Enumerates each route.
+	#
+	def each_route(&block)
+		get_routes().each(&block)
+	end
+
+	#
+	# Returns an array of routes with each element being a Route.
+	#
+	def get_routes
+		request = Packet.create_request('stdapi_net_config_get_routes')
+		routes  = []
+
+		response = client.send_request(request)
+
+		# Build out the array of routes
+		response.each(TLV_TYPE_NETWORK_ROUTE) { |route|
+			routes << Route.new(
+					route.get_tlv_value(TLV_TYPE_SUBNET),
+					route.get_tlv_value(TLV_TYPE_NETMASK),
+					route.get_tlv_value(TLV_TYPE_GATEWAY))
+		}
+
+		return routes
+	end
+	
+	alias routes get_routes
+
+	#
+	# Adds a route to the target machine.
+	# 
+	def add_route(subnet, netmask, gateway)
+		request = Packet.create_request('stdapi_net_config_add_route')
+
+		request.add_tlv(TLV_TYPE_SUBNET_STRING, subnet)
+		request.add_tlv(TLV_TYPE_NETMASK_STRING, netmask)
+		request.add_tlv(TLV_TYPE_GATEWAY_STRING, gateway)
+
+		response = client.send_request(request)
+
+		return true
+	end
+
+	#
+	# Removes a route from the target machine.
+	#
+	def remove_route(subnet, netmask, gateway)
+		request = Packet.create_request('stdapi_net_config_remove_route')
+
+		request.add_tlv(TLV_TYPE_SUBNET_STRING, subnet)
+		request.add_tlv(TLV_TYPE_NETMASK_STRING, netmask)
+		request.add_tlv(TLV_TYPE_GATEWAY_STRING, gateway)
+
+		response = client.send_request(request)
+
+		return true
+	end
+
+protected
+	
+	attr_accessor :client # :nodoc:
+
+end
+
+end; end; end; end; end; end

data/lib/rex/post/meterpreter/extensions/stdapi/net/interface.rb

@@ -0,0 +1,73 @@
+#!/usr/bin/env ruby
+
+require 'ipaddr'
+
+module Rex
+module Post
+module Meterpreter
+module Extensions
+module Stdapi
+module Net
+
+###
+#
+# This class represents a logical physical interface
+# on the remote machine.
+#
+###
+class Interface
+
+	##
+	#
+	# Constructor
+	#
+	##
+
+	#
+	# Returns a logical interface and initializes it to the supplied
+	# parameters.
+	#
+	def initialize(ip, netmask, mac_addr, mac_name)
+		self.ip       = IPAddr.ntop(ip)
+		self.netmask  = IPAddr.ntop(netmask)
+		self.mac_addr = mac_addr
+		self.mac_name = mac_name
+	end
+
+	#
+	# Returns a pretty string representation of the interface's properties.
+	#
+	def pretty
+		macocts = []
+		mac_addr.each_byte { |o| macocts << o }
+		macocts += [0] * (6 - macocts.size) if macocts.size < 6
+		return sprintf(
+				"#{mac_name}\n" +
+				"Hardware MAC: %02x:%02x:%02x:%02x:%02x:%02x\n" +
+				"IP Address  : %s\n" +
+				"Netmask     : %s\n" +
+				"\n", 
+				macocts[0], macocts[1], macocts[2], macocts[3], 
+				macocts[4], macocts[5], ip, netmask)
+	end
+
+	#
+	# The IP address bound to the interface.
+	#
+	attr_accessor :ip
+	#
+	# The subnet mask associated with the interface.
+	#
+	attr_accessor :netmask
+	#
+	# The physical (MAC) address of the NIC.
+	#
+	attr_accessor :mac_addr
+	#
+	# The name of the interface.
+	#
+	attr_accessor :mac_name
+
+end
+
+end; end; end; end; end; end

data/lib/rex/post/meterpreter/extensions/stdapi/net/route.rb

@@ -0,0 +1,56 @@
+#!/usr/bin/env ruby
+
+require 'ipaddr'
+
+module Rex
+module Post
+module Meterpreter
+module Extensions
+module Stdapi
+module Net
+
+###
+#
+# Represents a logical network route.
+#
+###
+class Route
+
+	##
+	#
+	# Constructor
+	#
+	##
+
+	#
+	# Initializes a route instance.
+	#
+	def initialize(subnet, netmask, gateway)
+		self.subnet  = IPAddr.ntop(subnet)
+		self.netmask = IPAddr.ntop(netmask)
+		self.gateway = IPAddr.ntop(gateway)
+	end
+
+	#
+	# Provides a pretty version of the route.
+	#
+	def pretty
+		return sprintf("%16s %16s %16s", subnet, netmask, gateway)
+	end
+
+	#
+	# The subnet mask associated with the route.
+	#
+	attr_accessor :subnet
+	#
+	# The netmask of the subnet route.
+	#
+	attr_accessor :netmask
+	#
+	# The gateway to take for the subnet route.
+	#
+	attr_accessor :gateway
+
+end
+
+end; end; end; end; end; end

data/lib/rex/post/meterpreter/extensions/stdapi/net/socket.rb

@@ -0,0 +1,137 @@
+#!/usr/bin/env ruby
+
+require 'thread'
+require 'rex/socket'
+require 'rex/post/meterpreter/extensions/stdapi/tlv'
+require 'rex/post/meterpreter/extensions/stdapi/net/socket_subsystem/tcp_client_channel'
+require 'rex/post/meterpreter/extensions/stdapi/net/socket_subsystem/tcp_server_channel'
+require 'rex/post/meterpreter/extensions/stdapi/net/socket_subsystem/udp_channel'
+require 'rex/logging'
+
+module Rex
+module Post
+module Meterpreter
+module Extensions
+module Stdapi
+module Net
+
+###
+#
+# This class provides an interface to interacting with sockets
+# on the remote machine.  It allows callers to open TCP, UDP,
+# and other arbitrary socket-based connections as channels that
+# can then be interacted with through the established
+# meterpreter connection.
+#
+###
+class Socket
+
+	##
+	#
+	# Constructor
+	#
+	##
+
+	#
+	# Initialize the socket subsystem and start monitoring sockets as they come in.
+	#
+	def initialize(client)
+		self.client = client
+		
+		# register the inbound handler for the tcp server channel (allowing us to receive new client connections to a tcp server channel)
+		client.register_inbound_handler( Rex::Post::Meterpreter::Extensions::Stdapi::Net::SocketSubsystem::TcpServerChannel )
+
+	end
+
+	#
+	# Deregister the inbound handler for the tcp server channel 
+	#
+	def shutdown
+		client.deregister_inbound_handler(  Rex::Post::Meterpreter::Extensions::Stdapi::Net::SocketSubsystem::TcpServerChannel )
+	end
+
+	##
+	#
+	# Factory
+	#
+	##
+
+	#
+	# Creates an arbitrary client socket channel using the information
+	# supplied in the socket parameters instance.  The 'params' argument
+	# is expected to be of type Rex::Socket::Parameters.
+	#
+	def create( params )
+		res = nil
+		
+		if( params.tcp? )
+			if( params.server? )
+				res = create_tcp_server_channel( params )
+			else
+				res = create_tcp_client_channel( params )
+			end
+		elsif( params.udp? )
+		  res = create_udp_channel( params )
+		end
+		
+		return res
+	end
+
+	#
+	# Create a TCP server channel.
+	#
+	def create_tcp_server_channel(params)
+		begin
+			return SocketSubsystem::TcpServerChannel.open(client, params)
+		rescue ::Rex::Post::Meterpreter::RequestError => e
+			case e.result
+			when 10000 .. 10100
+				raise ::Rex::ConnectionError.new
+			end
+			raise e
+		end 
+	end
+
+	#
+	# Creates a TCP client channel.
+	#
+	def create_tcp_client_channel(params)
+		begin
+			channel = SocketSubsystem::TcpClientChannel.open(client, params)
+			if( channel != nil )
+				return channel.lsock
+			end 
+			return nil
+		rescue ::Rex::Post::Meterpreter::RequestError => e
+			case e.result
+			when 10000 .. 10100
+				raise ::Rex::ConnectionError.new
+			end
+			raise e
+		end
+	end
+
+	#
+	# Creates a UDP channel.
+	#
+	def create_udp_channel(params)
+		begin
+			return SocketSubsystem::UdpChannel.open(client, params)
+		rescue ::Rex::Post::Meterpreter::RequestError => e
+			case e.result
+				when 10000 .. 10100
+				raise ::Rex::ConnectionError.new
+			end
+			raise e
+		end 
+	end
+
+
+protected
+
+	attr_accessor :client # :nodoc:
+
+end
+
+end; end; end; end; end; end
+