librex 0.0.16 → 0.0.17

data/lib/rex/poly/register.rb

@@ -0,0 +1,100 @@
+module Rex
+module Poly
+
+###
+#
+# This class represents a register that is used in the context of one or more
+# logical blocks.  The register number is assigned on demand or is statically
+# specified if passed in to the constructor.
+#
+###
+class LogicalRegister
+
+	require 'rex/poly/register/x86'
+
+	#
+	# This class method is meant to return an array of register numbers that
+	# can be used to pool from.  Architecture specific classes must implement
+	# this method on their own.
+	#
+	def self.regnum_set
+		nil
+	end
+
+	#
+	# Initializes the register's name and number, if assigned.  If a register
+	# number is specified, the instance will be assumed to have a statically
+	# assigned register number.  The name is meant to be used as a symbolic
+	# variable name, such as 'counter' or 'key'.
+	#
+	def initialize(name, regnum = nil)
+		@name   = name
+		@regnum = regnum
+		@static = (regnum) ? true : false
+	end
+
+	#
+	# Returns true if the register number should be assumed static.
+	#
+	def static?
+		@static
+	end
+
+	#
+	# Sets the register number to the value specified.  If the register number
+	# is declared static, a RuntimeError exception is raised.
+	#
+	def regnum=(val)
+		raise RuntimeError, "Attempted to assign regnum to static register" if (static?)
+
+		@regnum = val
+	end
+
+	#
+	# Returns the register number that has currently been assigned.  If no
+	# register number is assigned, an InvalidRegisterError exception is raised.
+	# This exception can be used to assign the LogicalRegister instance a
+	# register number on demand.
+	#
+	def regnum
+		raise InvalidRegisterError.new(self), "Register has not been assigned" if (@regnum == nil)
+
+		@regnum
+	end
+
+	#
+	# Returns the variable (friendly) name for the register that was passed to
+	# the constructor.
+	#
+	attr_reader :name
+
+protected
+
+end
+
+###
+#
+# An exception that is raised when the regnum method is accessed on a
+# LogicalRegister that does not currently have a regnum assigned to it.
+#
+###
+class InvalidRegisterError < RuntimeError
+
+	#
+	# Initializes the exception with the instance that lead to the generation
+	# of the exception such that it can be assigned a register number as
+	# needed.
+	#
+	def initialize(reg)
+		@reg = reg
+	end
+
+	#
+	# The LogicalRegister instance that generated the exception.
+	#
+	attr_reader :reg
+
+end
+
+end
+end

data/lib/rex/poly/register/x86.rb

@@ -0,0 +1,40 @@
+require 'rex/arch/x86'
+
+module Rex
+module Poly
+
+###
+#
+# This class encapsulates logical registers for the X86 architecture.
+#
+###
+class LogicalRegister::X86 < LogicalRegister
+
+	#
+	# The default set of register numbers that can be used on x86.
+	#
+	def self.regnum_set
+		[
+			Rex::Arch::X86::EAX,
+			Rex::Arch::X86::EBX,
+			Rex::Arch::X86::ECX,
+			Rex::Arch::X86::EDX,
+			Rex::Arch::X86::ESI,
+			Rex::Arch::X86::EDI,
+			Rex::Arch::X86::EBP,
+			Rex::Arch::X86::ESP
+		]
+	end
+
+	#
+	# Calls the base class constructor after translating the register name to
+	# number.
+	#
+	def initialize(name, register = nil)
+		super(name, register ? Rex::Arch::X86.reg_number(register) : nil)
+	end
+
+end
+
+end
+end

data/lib/rex/post.rb

@@ -0,0 +1,8 @@
+#!/usr/bin/env ruby
+
+# General independent containers
+require 'rex/post/permission'
+
+# Post-exploitation clients
+require 'rex/post/dispatch_ninja'
+require 'rex/post/meterpreter'

data/lib/rex/post/dir.rb

@@ -0,0 +1,51 @@
+#!/usr/bin/env ruby
+
+module Rex
+module Post
+
+###
+#
+# This class wraps the behavior of the Ruby Dir class against a remote entity.
+# Refer to the Ruby documentation for expected behavior.
+#
+###
+class Dir
+
+	def Dir.entries(name)
+		raise NotImplementedError
+	end
+
+	def Dir.foreach(name, &block)
+		entries(name).each(&block)
+	end
+	
+	def Dir.chdir(path)
+		raise NotImplementedError
+	end
+	
+	def Dir.mkdir(path)
+		raise NotImplementedError
+	end
+	
+	def Dir.pwd
+		raise NotImplementedError
+	end
+	
+	def Dir.getwd
+		raise NotImplementedError
+	end
+	
+	def Dir.delete(path)
+		raise NotImplementedError
+	end
+	
+	def Dir.rmdir(path)
+		raise NotImplementedError
+	end
+	
+	def Dir.unlink(path)
+		raise NotImplementedError
+	end
+end
+
+end; end # Post/Rex

data/lib/rex/post/file.rb

@@ -0,0 +1,172 @@
+#!/usr/bin/env ruby
+
+require 'rex/post/io'
+
+module Rex
+module Post
+
+# make this a module so we can mix it in, and have inheritence like..
+# => [Rex::Post::DispatchNinja::File, Rex::Post::File,
+# Rex::Post::DispatchNinja::IO, Rex::Post::IO, Object, Kernel]
+
+###
+#
+# This module simulates the behavior that one would expect from the Ruby File
+# class against a remote entity.  Refer to the ruby documentation for expected
+# behavior.
+#
+###
+module File
+
+	protected
+		# inherits fd and mode from IO
+		attr_accessor :filename
+	public
+
+	# f = File.new("testfile", "r")
+	# f = File.new("newfile",  "w+")
+	# f = File.new("newfile", File::CREAT|File::TRUNC|File::RDWR, 0644)
+	# !!! I suppose I should figure out the correct default for perm..
+	def initialize(name, mode='r', perm=0)
+	end
+
+	def path
+		filename
+	end
+
+	# ctime/atime blah need fstat..
+	# need lchown/chown/fchown, etc, etc
+
+	# proxy these methods
+	def File.basename(*a)
+		::File.basename(*a)
+	end
+	def File.dirname(*a)
+		::File.dirname(*a)
+	end
+	def File.extname(*a)
+		::File.extname(*a)
+	end
+	# !!! we might actually want to handle this File::SEPERATOR stuff
+	# for win32 support, etc.
+	def File.join(*a)
+		::File.join(*a)
+	end
+
+	def File.chmod
+		raise NotImplementedError
+	end
+	def File.chown
+		raise NotImplementedError
+	end
+	def File.delete(*a)
+		unlink(*a)
+	end
+	def File.unlink
+		raise NotImplementedError
+	end
+	def File.lchmod
+		raise NotImplementedError
+	end
+	def File.lchown
+		raise NotImplementedError
+	end
+	def File.link
+		raise NotImplementedError
+	end
+	def File.lstat
+		raise NotImplementedError
+	end
+
+	# this, along with all the other globbing/search stuff, probably
+	# won't get implemented, atleast for a bit...
+	def File.expand_path
+		raise NotImplementedError
+	end
+	def File.fnmatch(*a)
+		fnmatch?(*a)
+	end
+	def File.fnmatch?
+		raise NotImplementedError
+	end
+
+	#
+	# autogen'd stat passthroughs
+	#
+	def File.atime(name)
+		stat(name).atime
+	end
+	def File.blockdev?(name)
+		stat(name).blockdev?
+	end
+	def File.chardev?(name)
+		stat(name).chardev?
+	end
+	def File.ctime(name)
+		stat(name).ctime
+	end
+	def File.directory?(name)
+		stat(name).directory?
+	end
+	def File.executable?(name)
+		stat(name).executable?
+	end
+	def File.executable_real?(name)
+		stat(name).executable_real?
+	end
+	def File.file?(name)
+		stat(name).file?
+	end
+	def File.ftype(name)
+		stat(name).ftype
+	end
+	def File.grpowned?(name)
+		stat(name).grpowned?
+	end
+	def File.mtime(name)
+		stat(name).mtime
+	end
+	def File.owned?(name)
+		stat(name).owned?
+	end
+	def File.pipe?(name)
+		stat(name).pipe?
+	end
+	def File.readable?(name)
+		stat(name).readable?
+	end
+	def File.readable_real?(name)
+		stat(name).readable_real?
+	end
+	def File.setuid?(name)
+		stat(name).setuid?
+	end
+	def File.setgid?(name)
+		stat(name).setgid?
+	end
+	def File.size(name)
+		stat(name).size
+	end
+	def File.socket?(name)
+		stat(name).socket?
+	end
+	def File.sticky?(name)
+		stat(name).sticky?
+	end
+	def File.symlink?(name)
+		stat(name).symlink?
+	end
+	def File.writeable?(name)
+		stat(name).writeable?
+	end
+	def File.writeable_real?(name)
+		stat(name).writeable_real?
+	end
+	def File.zero?(name)
+		stat(name).zero?
+	end
+
+end
+
+end; end # Post/Rex
+

data/lib/rex/post/file_stat.rb

@@ -0,0 +1,220 @@
+#!/usr/bin/env ruby
+
+#
+# This is just a container class basically, that acts like File::Struct
+#
+# You must supply an initialize method that somehow populates the stathash..
+#
+
+module Rex
+module Post
+
+###
+#
+# This class emulates the ruby FileStat class against a remote entity in a
+# generic fashion.  Refer to the ruby documentation for expected behavior.
+#
+###
+class FileStat
+
+	#
+	# Basic file types.
+	#
+	@@ftypes = [
+		'fifo', 'characterSpecial', 'directory',
+		'blockSpecial', 'file', 'link', 'socket'
+	]
+
+	attr_accessor :stathash
+
+	def initialize(buf='')
+		self.stathash = {}
+		update(buf) if (buf and not buf.empty?)
+	end
+	
+	def dev
+		self.stathash['st_dev']
+	end
+	def ino
+		self.stathash['st_ino']
+	end
+	def mode
+		self.stathash['st_mode']
+	end
+	def nlink
+		self.stathash['st_nlink']
+	end
+	def uid
+		self.stathash['st_uid']
+	end
+	def gid
+		self.stathash['st_gid']
+	end
+	def rdev
+		self.stathash['st_rdev']
+	end
+	def size
+		self.stathash['st_size']
+	end
+	def blksize
+		self.stathash['st_blksize']
+	end
+	def blocks
+		self.stathash['st_blocks']
+	end
+	def atime
+		Time.at(self.stathash['st_atime'])
+	end
+	def mtime
+		Time.at(self.stathash['st_mtime'])
+	end
+	def ctime
+		Time.at(self.stathash['st_ctime'])
+	end
+
+	def update(buf)
+
+		# XXX: This needs to understand more than just 'stat' structures
+		# Windows can also return _stat32, _stat32i64, _stat64i32, and _stat64 structures
+		
+		skeys = %W{st_dev st_ino st_mode st_wtf st_nlink st_uid st_gid st_rdev st_size st_ctime st_atime st_mtime}
+		svals = buf.unpack("VvvvvvvVVVVV")
+		skeys.each_index do |i|
+			self.stathash[ skeys[i] ] = svals[i]
+		end
+	end
+
+	#
+	# S_IFMT     0170000   bitmask for the file type bitfields
+	# S_IFSOCK   0140000   socket
+	# S_IFLNK    0120000   symbolic link
+	# S_IFREG    0100000   regular file
+	# S_IFBLK    0060000   block device
+	# S_IFDIR    0040000   directory
+	# S_IFCHR    0020000   character device
+	# S_IFIFO    0010000   fifo
+	#
+
+	# this is my own, just a helper...
+	def filetype?(mask)
+		return true if mode & 0170000 == mask
+		return false
+	end
+
+	def blockdev?
+		filetype?(060000)
+	end
+	def chardev?
+		filetype?(020000)
+	end
+	def directory?
+		filetype?(040000)
+	end
+	def file?
+		filetype?(0100000)
+	end
+	def pipe?
+		filetype?(010000) # ??? fifo?
+	end
+	def socket?
+		filetype(0140000)
+	end
+	def symlink?
+		filetype(0120000)
+	end
+
+	def ftype
+		return @@ftypes[(mode & 0170000) >> 13].dup
+	end
+
+	#
+	# S_ISUID    0004000   set UID bit
+	# S_ISGID    0002000   set GID bit (see below)
+	# S_ISVTX    0001000   sticky bit (see below)
+	# S_IRWXU    00700     mask for file owner permissions
+	# S_IRUSR    00400     owner has read permission
+	# S_IWUSR    00200     owner has write permission
+	# S_IXUSR    00100     owner has execute permission
+	# S_IRWXG    00070     mask for group permissions
+	# S_IRGRP    00040     group has read permission
+	# S_IWGRP    00020     group has write permission
+	# S_IXGRP    00010     group has execute permission
+	# S_IRWXO    00007     mask for permissions for others (not in group)
+	# S_IROTH    00004     others have read permission
+	# S_IWOTH    00002     others have write permisson
+	# S_IXOTH    00001     others have execute permission
+	#
+
+	def perm?(mask)
+		return true if mode & mask == mask
+		return false
+	end
+
+	def setgid?
+		perm?(02000)
+	end
+	def setuid?
+		perm?(04000)
+	end
+	def sticky?
+		perm?(01000)
+	end
+
+	def executable?
+		raise NotImplementedError
+	end
+	def executable_real?
+		raise NotImplementedError
+	end
+	def grpowned?
+		raise NotImplementedError
+	end
+	def owned?
+		raise NotImplementedError
+	end
+	def readable?
+		raise NotImplementedError
+	end
+	def readable_real?
+		raise NotImplementedError
+	end
+	def writeable?
+		raise NotImplementedError
+	end
+	def writeable_real?
+		raise NotImplementedError
+	end
+
+	#
+	# Return pretty information about a file's permissions.
+	#
+	def prettymode
+		m  = mode
+		om = '%04o' % m
+		perms = ''
+
+		3.times {
+			perms = ((m & 01) == 01 ? 'x' : '-') + perms
+			perms = ((m & 02) == 02 ? 'w' : '-') + perms
+			perms = ((m & 04) == 04 ? 'r' : '-') + perms
+			m >>= 3
+		}
+
+		return "#{om}/#{perms}"
+	end
+
+	#
+	# Return pretty information about a file.
+	#
+	def pretty
+		"  Size: #{size}   Blocks: #{blocks}   IO Block: #{blksize}   Type: #{rdev}\n"\
+		"Device: #{dev}  Inode: #{ino}  Links: #{nlink}\n"\
+		"  Mode: #{prettymode}\n"\
+		"   Uid: #{uid}  Gid: #{gid}\n"\
+		"Access: #{atime}\n"\
+		"Modify: #{mtime}\n"\
+		"Change: #{ctime}\n"
+	end
+
+end
+end; end # Post/Rex