librex 0.0.1

data/lib/rex/logging.rb

@@ -0,0 +1,4 @@
+#!/usr/bin/env ruby
+
+require 'rex/constants' # for LEV_'s
+require 'rex/logging/log_dispatcher'

data/lib/rex/logging/log_dispatcher.rb

@@ -0,0 +1,179 @@
+require 'rex/sync'
+require 'rex/logging/log_sink'
+
+module Rex
+module Logging
+
+###
+#
+# The log dispatcher associates log sources with log sinks.  A log source
+# is a unique identity that is associated with one and only one log sink.
+# For instance, the framework-core registers the 'core' 
+#
+###
+class LogDispatcher
+
+	#
+	# Creates the global log dispatcher instance and initializes it for use.
+	#
+	def initialize()
+		self.log_sinks      = {}
+		self.log_levels     = {}
+		self.log_sinks_lock = Mutex.new
+	end
+
+	#
+	# Returns the sink that is associated with the supplied source.
+	#
+	def [](src)
+		sink = nil
+
+		log_sinks_lock.synchronize {
+			sink = log_sinks[src]
+		}
+
+		return sink
+	end
+
+	#
+	# Calls the source association routie.
+	#
+	def []=(src, sink)
+		store(src, sink)
+	end
+
+	#
+	# Associates the supplied source with the supplied sink.  If a log level
+	# has already been defined for the source, the level argument is ignored.
+	# Use set_log_level to alter it.
+	#
+	def store(src, sink, level = 0)
+		log_sinks_lock.synchronize {
+			if (log_sinks[src] == nil)
+				log_sinks[src] = sink
+
+				set_log_level(src, level) if (log_levels[src] == nil)
+			else
+				raise(
+					RuntimeError, 
+					"The supplied log source #{src} is already registered.",
+					caller)
+			end
+		}
+	end
+
+	#
+	# Removes a source association if one exists.
+	#
+	def delete(src)
+		sink = nil
+
+		log_sinks_lock.synchronize {
+			sink = log_sinks[src]
+			
+			log_sinks.delete(src)
+		}
+
+		if (sink)
+			sink.cleanup
+
+			return true
+		end
+
+		return false
+	end
+
+	#
+	# Performs the actual log operation against the supplied source
+	#
+	def log(sev, src, level, msg, from)
+		log_sinks_lock.synchronize {
+			if ((sink = log_sinks[src]))
+				next if (log_levels[src] and level > log_levels[src])
+
+				sink.log(sev, src, level, msg, from)
+			end
+		}
+	end
+
+	#
+	# This method sets the log level threshold for a given source.
+	#
+	def set_level(src, level)
+		log_levels[src] = level.to_i
+	end
+
+	#
+	# This method returns the log level threshold of a given source.
+	#
+	def get_level(src)
+		log_levels[src]
+	end
+
+	attr_accessor :log_sinks, :log_sinks_lock # :nodoc:
+	attr_accessor :log_levels # :nodoc:
+end
+
+end
+end
+
+###
+#
+# An instance of the log dispatcher exists in the global namespace, along
+# with stubs for many of the common logging methods.  Various sources can
+# register themselves as a log sink such that logs can be directed at
+# various targets depending on where they're sourced from.  By doing it
+# this way, things like sessions can use the global logging stubs and
+# still be directed at the correct log file.
+#
+###
+ExceptionCallStack = "__EXCEPTCALLSTACK__"
+
+def dlog(msg, src = 'core', level = 0, from = caller)
+	$dispatcher.log(LOG_DEBUG, src, level, msg, from)
+end
+
+def elog(msg, src = 'core', level = 0, from = caller)
+	$dispatcher.log(LOG_ERROR, src, level, msg, from)
+end
+
+def wlog(msg, src = 'core', level = 0, from = caller)
+	$dispatcher.log(LOG_WARN, src, level, msg, from)
+end
+
+def ilog(msg, src = 'core', level = 0, from = caller)
+	$dispatcher.log(LOG_INFO, src, level, msg, from)
+end
+
+def rlog(msg, src = 'core', level = 0, from = caller)
+	if (msg == ExceptionCallStack)
+		msg = "\nCall stack:\n" + $@.join("\n") + "\n"
+	end
+
+	$dispatcher.log(LOG_RAW, src, level, msg, from)
+end
+
+def log_source_registered?(src)
+	($dispatcher[src] != nil)
+end
+
+def register_log_source(src, sink, level = nil)
+	$dispatcher[src] = sink
+
+	set_log_level(src, level) if (level)
+end
+
+def deregister_log_source(src)
+	$dispatcher.delete(src)
+end
+
+def set_log_level(src, level)
+	$dispatcher.set_level(src, level)
+end
+
+def get_log_level(src)
+	$dispatcher.get_level(src)
+end
+
+# Creates the global log dispatcher
+$dispatcher = Rex::Logging::LogDispatcher.new

data/lib/rex/logging/log_sink.rb

@@ -0,0 +1,42 @@
+require 'rex/constants'
+
+module Rex
+module Logging
+
+###
+#
+# This abstract interface is what must be implemented by any class
+# that would like to register as a log sink on a given LogDispatcher
+# instance, such as the Framework object.
+#
+###
+module LogSink
+
+	def cleanup
+	end
+
+	#
+	# This method must be implemented by any derived log sink classes and is
+	# intended to take the supplied parameters and persist them to an arbitrary
+	# medium.
+	#
+	def log(sev, src, level, msg, from)
+		raise NotImplementedError
+	end
+
+protected
+
+	#
+	# This method returns the current timestamp in MM/DD/YYYY HH:Mi:SS format.
+	#
+	def get_current_timestamp
+		return Time.now.strftime("%m/%d/%Y %H:%M:%S")
+	end
+
+end
+
+end
+end
+
+require 'rex/logging/sinks/flatfile'
+require 'rex/logging/sinks/stderr'

data/lib/rex/logging/sinks/flatfile.rb

@@ -0,0 +1,55 @@
+module Rex
+module Logging
+module Sinks
+
+###
+#
+# This class implements the LogSink interface and backs it against a 
+# file on disk.
+#
+###
+class Flatfile
+
+	include Rex::Logging::LogSink
+
+	#
+	# Creates a flatfile log sink instance that will be configured to log to
+	# the supplied file path.
+	#
+	def initialize(file)
+		self.fd = File.new(file, "a")
+	end
+
+	def cleanup # :nodoc:
+		fd.close
+	end
+
+	def log(sev, src, level, msg, from) # :nodoc:
+		if (sev == LOG_RAW)
+			fd.write(msg)
+		else
+			code = 'i'
+
+			case sev
+				when LOG_DEBUG
+					code = 'd'
+				when LOG_ERROR
+					code = 'e'
+				when LOG_INFO
+					code = 'i'
+				when LOG_WARN
+					code = 'w'
+			end
+			fd.write("[#{get_current_timestamp}] [#{code}(#{level})] #{src}: #{msg}\n")
+		end
+			
+		fd.flush
+	end
+
+protected
+
+	attr_accessor :fd # :nodoc:
+
+end
+
+end end end

data/lib/rex/logging/sinks/stderr.rb

@@ -0,0 +1,43 @@
+module Rex
+module Logging
+module Sinks
+
+###
+#
+# This class implements the LogSink interface and backs it against stderr
+###
+class Stderr
+
+	include Rex::Logging::LogSink
+
+	#
+	# Writes log data to stderr
+	#
+
+	def log(sev, src, level, msg, from) # :nodoc:
+		if (sev == LOG_RAW)
+			$stderr.write(msg)
+		else
+			code = 'i'
+
+			case sev
+				when LOG_DEBUG
+					code = 'd'
+				when LOG_ERROR
+					code = 'e'
+				when LOG_INFO
+					code = 'i'
+				when LOG_WARN
+					code = 'w'
+			end
+			$stderr.write("[#{get_current_timestamp}] [#{code}(#{level})] #{src}: #{msg}\n")
+		end
+			
+		$stderr.flush
+	end
+
+protected
+
+end
+
+end end end

data/lib/rex/machparsey.rb

@@ -0,0 +1,9 @@
+#!/usr/bin/env ruby
+
+module Rex
+module MachParsey
+
+end
+end
+
+require 'rex/machparsey/mach'

data/lib/rex/machparsey/exceptions.rb

@@ -0,0 +1,34 @@
+#!/usr/bin/env ruby
+
+module Rex
+module MachParsey
+
+class MachError < ::RuntimeError
+end
+
+class MachParseError < MachError
+end
+
+class MachHeaderError < MachParseError
+end
+
+class ProgramHeaderError < MachParseError
+end
+
+class BoundsError < MachError
+end
+
+#class WtfError < MachError
+#end
+
+class FatError < ::RuntimeError
+end
+
+class FatParseError < FatError
+end
+
+class FatHeaderError < FatParseError
+end
+
+end
+end

data/lib/rex/machparsey/mach.rb

@@ -0,0 +1,209 @@
+#!/usr/bin/env ruby
+
+require 'rex/machparsey/machbase'
+require 'rex/machparsey/exceptions'
+require 'rex/image_source'
+
+module Rex
+module MachParsey
+
+
+class Mach < MachBase
+	attr_accessor :mach_header, :segments, :isource, :bits, :endian, :arch, :fat_offset
+
+	def initialize(isource, offset = 0, fat = false)
+		_parse_mach_header(isource, offset)
+		if fat == true
+			self.fat_offset = offset
+		else
+			self.fat_offset = 0
+		end
+
+		self.isource = isource
+	end
+
+	def _parse_mach_header(isource, offset)
+		self.mach_header = MachHeader.new(isource.read(offset, MACH_HEADER_SIZE_64))
+		bits = mach_header.bits
+		endian = mach_header.endian
+		ncmds = mach_header.ncmds
+
+		if bits == BITS_32
+			offset += MACH_HEADER_SIZE
+		else
+			offset += MACH_HEADER_SIZE_64
+		end
+
+
+		segments = []
+		ncmds.times do
+			load_command = LoadCommand.new(isource.read(offset, LOAD_COMMAND_SIZE), endian)
+
+			case load_command.cmd
+				when LC_SEGMENT
+					segments << Segment.new(isource.read(offset, SEGMENT_COMMAND_SIZE), bits, endian)
+				when LC_SEGMENT_64
+					segments << Segment.new(isource.read(offset, SEGMENT_COMMAND_SIZE_64), bits, endian)
+			end
+
+			offset += load_command.cmdsize
+		end
+
+		self.mach_header = mach_header
+		self.segments = segments	
+		self.isource = isource
+		self.bits = bits
+		self.endian = endian
+
+		return segments
+	end
+
+	def self.new_from_file(filename, disk_backed = false)
+
+		file = ::File.open(filename, "rb")
+
+		if disk_backed
+			return self.new(ImageSource::Disk.new(file))
+		else
+			obj = new_from_string(file.read)
+			file.close
+			return obj
+		end
+	end
+
+	def self.new_from_string(data)
+		return self.new(ImageSource::Memory.new(data))
+	end
+
+	def ptr_64?
+		mach_header.bits == BITS_64		
+	end
+
+	def ptr_32?
+		ptr_64? == false
+	end
+
+	def ptr_s(vaddr)
+		(ptr_32?) ? ("0x%.8x" % vaddr) : ("0x%.16x" % vaddr)
+	end
+
+	def read(offset, len)
+		isource.read(offset, len)
+	end
+
+	def index(*args)
+		isource.index(*args)
+	end
+
+	def close
+		isource.close
+	end
+
+end
+
+class Fat < FatBase
+	attr_accessor :fat_header, :fat_archs, :machos, :isource
+	
+	def initialize(isource, offset = 0)
+		self.fat_archs = []
+		self.machos = []
+		self.isource = isource
+		self.fat_header = FatHeader.new(isource.read(offset, FAT_HEADER_SIZE))
+			
+		if !self.fat_header
+			raise FatHeaderError, "Could not parse FAT header"
+		end
+		
+		print "Detected " +  self.fat_header.nfat_arch.to_s +  " archs in binary.\n"
+
+		offset += FAT_HEADER_SIZE
+		
+		self.fat_header.nfat_arch.times do
+			fat_arch = FatArch.new(isource.read(offset, FAT_ARCH_SIZE), self.fat_header.endian)
+			self.fat_archs << fat_arch
+			self.machos << Mach.new(isource, fat_arch.offset, true) 
+			offset += FAT_ARCH_SIZE
+		end
+		
+		
+	end
+	
+	#this is useful for debugging but we don't use it for anything.
+	def _parse_fat_header(isource, offset)
+		archs = []
+		nfat_arch = self.fat_header.nfat_arch
+
+		print "Number of archs in binary: " + nfat_arch.to_s + "\n"
+
+		nfat_arch.times do
+			arch = FatArch.new(isource.read(offset, FAT_ARCH_SIZE), self.endian)
+		
+			case arch.cpu_type
+
+			when CPU_TYPE_I386
+				print "i386\n"
+			
+			when CPU_TYPE_X86_64
+				print "x86_64\n"
+			
+			when CPU_TYPE_ARM
+				print "Arm\n"
+			
+			when CPU_TYPE_POWERPC
+				print "Power PC\n"
+			
+			when CPU_TYPE_POWERPC64
+				print "Power PC 64\n"
+			end
+		
+			offset += FAT_ARCH_SIZE
+		end
+	end
+
+	def self.new_from_file(filename, disk_backed = false)
+
+		file = ::File.open(filename, "rb")
+
+		if disk_backed
+			return self.new(ImageSource::Disk.new(file))
+		else
+			obj = new_from_string(file.read)
+			file.close
+			return obj
+		end
+	end
+	
+
+	def self.new_from_string(data)
+		return self.new(ImageSource::Memory.new(data))
+	end
+
+	def ptr_64?
+		mach_header.bits == BITS_64		
+	end
+
+	def ptr_32?
+		ptr_64? == false
+	end
+
+	def ptr_s(vaddr)
+		(ptr_32?) ? ("0x%.8x" % vaddr) : ("0x%.16x" % vaddr)
+	end
+
+	def read(offset, len)
+		isource.read(offset, len)
+	end
+
+	def index(*args)
+		isource.index(*args)
+	end
+
+	def close
+		isource.close
+	end
+
+end
+
+
+end
+end