librex 0.0.16 → 0.0.17

data/lib/rex/ole/stream.rb

@@ -0,0 +1,53 @@
+##
+# $Id: stream.rb 8457 2010-02-11 18:36:38Z jduck $
+# Version: $Revision: 8457 $
+##
+
+##
+# Rex::OLE - an OLE implementation
+# written in 2010 by Joshua J. Drake <jduck [at] metasploit.com>
+##
+
+module Rex
+module OLE
+
+class Stream < DirEntry
+
+	def initialize(stg)
+		super
+
+		# for reading/writing from this
+		@offset = 0
+		@_mse = STGTY_STREAM
+	end
+
+	def close
+		@mode = nil
+		@offset = nil
+	end
+
+	def seek(offset)
+		@offset = offset
+	end
+
+	def read(len)
+		return nil if (not @data)
+
+		ret = @data[@offset, len]
+		@offset += len
+		ret
+	end
+
+	def <<(expr)
+		if (not @data)
+			@data = expr.dup
+		else
+			@data << expr
+		end
+		@_ulSize = @data.length
+	end
+
+end
+
+end
+end

data/lib/rex/ole/substorage.rb

@@ -0,0 +1,49 @@
+##
+# $Id: substorage.rb 8457 2010-02-11 18:36:38Z jduck $
+# Version: $Revision: 8457 $
+##
+
+##
+# Rex::OLE - an OLE implementation
+# written in 2010 by Joshua J. Drake <jduck [at] metasploit.com>
+##
+
+module Rex
+module OLE
+
+class SubStorage < DirEntry
+
+	def initialize(stg)
+		super
+
+		@_mse = STGTY_STORAGE
+	end
+
+
+	def close
+	end
+
+
+	# stream handling stuff
+	def create_stream(name, mode=STGM_WRITE)
+		@stg.create_stream(name, mode, self)
+	end
+
+	def open_stream(name, mode=STGM_READ)
+		@stg.open_stream(name, mode, self)
+	end
+
+
+	# storage handling stuff
+	def create_storage(name, mode=STGM_WRITE)
+		@stg.create_storage(name, mode, self)
+	end
+
+	def open_storage(name, mode=STGM_WRITE)
+		@stg.open_storage(name, mode, self)
+	end
+
+end
+
+end
+end

data/lib/rex/ole/util.rb

@@ -0,0 +1,157 @@
+##
+# $Id: util.rb 8457 2010-02-11 18:36:38Z jduck $
+# Version: $Revision: 8457 $
+##
+
+##
+# Rex::OLE - an OLE implementation
+# written in 2010 by Joshua J. Drake <jduck [at] metasploit.com>
+##
+
+module Rex
+module OLE
+
+class Util
+
+	def self.Hexify32array(arr)
+		ret = ""
+		arr.each { |dw|
+			ret << " " if ret.length > 0
+			ret << "0x%08x" % dw
+		}
+		ret
+	end
+
+	def self.Printable(buf)
+		ret = ""
+		buf.unpack('C*').each { |byte|
+			ch = byte.chr
+			if (byte < 0x20 || byte > 0x7e)
+				ret << "\\x" + ch.unpack('H*')[0]
+			else
+				ret << ch
+			end
+		}
+		ret
+	end
+
+
+	def self.set_endian(endian)
+		@endian = endian
+	end
+
+	def self.get64(buf, offset)
+		@endian = LITTLE_ENDIAN if not @endian
+		if (@endian == LITTLE_ENDIAN)
+			arr = buf[offset,8].unpack('VV')
+			return (arr[0] + (arr[1] << 32))
+		else
+			arr = buf[offset,8].unpack('NN')
+			return ((arr[0] << 32) + arr[1])
+		end
+	end
+
+	def self.pack64(value)
+		@endian = LITTLE_ENDIAN if not @endian
+		arr = []
+		arr << (value & 0xffffffff)
+		arr << (value >> 32)
+		if (@endian == LITTLE_ENDIAN)
+			arr.pack('VV')
+		else
+			arr.reverse.pack('NN')
+		end
+	end
+
+	def self.get32(buf, offset)
+		@endian = LITTLE_ENDIAN if not @endian
+		if (@endian == LITTLE_ENDIAN)
+			buf[offset,4].unpack('V')[0]
+		else
+			buf[offset,4].unpack('N')[0]
+		end
+	end
+
+	def self.pack32(value)
+		@endian = LITTLE_ENDIAN if not @endian
+		if (@endian == LITTLE_ENDIAN)
+			[value].pack('V')
+		else
+			[value].pack('N')
+		end
+	end
+
+	def self.get32array(buf)
+		@endian = LITTLE_ENDIAN if not @endian
+		if (@endian == LITTLE_ENDIAN)
+			buf.unpack('V*')
+		else
+			buf.unpack('N*')
+		end
+	end
+
+	def self.pack32array(arr)
+		@endian = LITTLE_ENDIAN if not @endian
+		if (@endian == LITTLE_ENDIAN)
+			arr.pack('V*')
+		else
+			arr.pack('N*')
+		end
+	end
+
+	def self.get16(buf, offset)
+		@endian = LITTLE_ENDIAN if not @endian
+		if (@endian == LITTLE_ENDIAN)
+			buf[offset,2].unpack('v')[0]
+		else
+			buf[offset,2].unpack('n')[0]
+		end
+	end
+
+	def self.pack16(value)
+		@endian = LITTLE_ENDIAN if not @endian
+		if (@endian == LITTLE_ENDIAN)
+			[value].pack('v')
+		else
+			[value].pack('n')
+		end
+	end
+
+	def self.get8(buf, offset)
+		buf[offset,1].unpack('C')[0]
+	end
+
+	def self.pack8(value)
+		[value].pack('C')
+	end
+
+
+	def self.getUnicodeString(buf)
+		buf = buf.unpack('S*').pack('C*')
+		if (idx = buf.index(0x00.chr))
+			buf.slice!(idx, buf.length)
+		end
+		buf
+	end
+
+	def self.putUnicodeString(buf)
+		buf = buf.unpack('C*').pack('S*')
+		if (buf.length < 0x40)
+			buf << "\x00" * (0x40 - buf.length)
+		end
+		buf
+	end
+
+
+	def self.name_is_valid(name)
+		return nil if (name.length > 31)
+		(0..0x1f).to_a.each { |x|
+			return nil if (name.include?(x.chr))
+		}
+		return true
+	end
+
+end
+
+end
+end

data/lib/rex/parser/arguments.rb

@@ -0,0 +1,97 @@
+require 'shellwords'
+
+module Rex
+module Parser
+
+###
+#
+# This class parses arguments in a getopt style format, kind of.
+# Unfortunately, the default ruby getopt implementation will only
+# work on ARGV, so we can't use it.
+#
+###
+class Arguments
+
+	#
+	# Specifies that an option is expected to have an argument
+	#
+	HasArgument = (1 << 0)
+
+	#
+	# Initializes the format list with an array of formats like:
+	#
+	# Arguments.new(
+	#    '-b' => [ false, "some text" ]
+	# )
+	#
+	def initialize(fmt)
+		self.fmt = fmt
+	end
+
+	#
+	# Takes a string and converts it into an array of arguments.
+	#
+	def self.from_s(str)
+		Shellwords.shellwords(str)
+	end
+
+	#
+	# Parses the supplied arguments into a set of options.
+	#
+	def parse(args, &block)
+		skip_next = false
+
+		args.each_with_index { |arg, idx|
+			if (skip_next == true)
+				skip_next = false
+				next
+			end
+
+			if (arg.match(/^-/))
+				cfs = arg[0..2]
+
+				fmt.each_pair { |fmtspec, val|
+					next if (fmtspec != cfs)
+
+					param = nil
+
+					if (val[0])
+						param = args[idx+1]
+						skip_next = true
+					end
+
+					yield fmtspec, idx, param
+				}
+			else
+				yield nil, idx, arg
+			end
+		}
+	end
+
+	#
+	# Returns usage information for this parsing context.
+	#
+	def usage
+		txt = "\nOPTIONS:\n\n"
+
+		fmt.sort.each { |entry|
+			fmtspec, val = entry
+
+			txt << "    #{fmtspec}" + ((val[0] == true) ? " <opt>  " : "        ")
+			txt << val[1] + "\n"
+		}
+
+		txt << "\n"
+
+		return txt
+	end
+	def include?(search)
+		return fmt.include?(search)
+	end
+
+	attr_accessor :fmt # :nodoc:
+
+end
+
+end
+end

data/lib/rex/parser/arguments.rb.ut.rb

@@ -0,0 +1,67 @@
+#!/usr/bin/env ruby
+
+$:.unshift(File.join(File.dirname(__FILE__), '..', '..'))
+
+require 'test/unit'
+require 'rex/parser/arguments'
+
+class Rex::Parser::Arguments::UnitTest < Test::Unit::TestCase
+
+	def test_parse
+		args =
+			[
+				"-b",
+				"foo",
+				"-c",
+				"-f",
+				"-g",
+				"arg",
+				"none"
+			]
+
+		b = nil
+		c = false
+		f = false
+		g = nil
+		none = nil
+
+		Rex::Parser::Arguments.new(
+			'-b' => [ true,  "bee" ],
+			'-c' => [ false, "cee" ],
+			'-f' => [ false, "eff" ],
+			'-g' => [ true,  "gee" ]).parse(args) { |opt, idx, val|
+			case opt
+				when nil
+					none = val
+				when '-b'
+					b = val
+				when '-c'
+					c = true
+				when '-f'
+					f = true
+				when '-g'
+					g = val
+			end
+		}
+
+		assert_equal(b, "foo")
+		assert_equal(c, true)
+		assert_equal(f, true)
+		assert_equal(g, "arg")
+		assert_equal(none, "none")
+	end
+
+	def test_from_s
+		args = Rex::Parser::Arguments.from_s(
+			"this is a test \"of the emergency pimping\" system \\\"buh lee dat\\\" yup")
+
+		assert_equal(args[0], "this")
+		assert_equal(args[3], "test")
+		assert_equal(args[4], "of the emergency pimping")
+		assert_equal(args[5], "system")
+		assert_equal(args[6], "\"buh")
+		assert_equal(args[8], "dat\"")
+		assert_equal(args[9], "yup")
+	end
+
+end

data/lib/rex/parser/ini.rb

@@ -0,0 +1,185 @@
+module Rex
+module Parser
+
+###
+#
+# This class parses the contents of an INI file.
+#
+###
+class Ini < Hash
+
+	##
+	#
+	# Factories
+	#
+	##
+	
+	#
+	# Creates a new class instance and reads in the contents of the supplied
+	# file path.
+	#
+	def self.from_file(path)
+		ini = Ini.new(path)
+		ini.from_file
+		return ini
+	end
+
+	#
+	# Creates a new class instance from the supplied string.
+	#
+	def self.from_s(str)
+		ini = Ini.new
+		ini.from_s(str)
+		return ini
+	end
+
+	#
+	# Initializes an ini instance and tries to read in the groups from the
+	# file if it exists.
+	#
+	def initialize(path = nil)
+		self.path = path
+
+		# Try to synchronize ourself with the file if we
+		# have one
+		begin
+			self.from_file if (self.path)
+		rescue
+		end
+	end
+
+	#
+	# Enumerates the groups hash keys.
+	#
+	def each_group(&block) 
+		self.keys.each { |k|
+			yield
+		}
+	end
+
+	#
+	# Adds a group of the supplied name if it doesn't already exist.
+	#
+	def add_group(name = 'global', reset = true)
+		self[name] = {} if (reset == true)
+		self[name] = {} if (!self[name])
+
+		return self[name]
+	end
+
+	#
+	# Checks to see if name is a valid group.
+	#
+	def group?(name)
+		return (self[name] != nil)
+	end
+
+	##
+	#
+	# Serializers
+	#
+	##
+
+	#
+	# Reads in the groups from the supplied file path or the instance's file
+	# path.
+	#
+	def from_file(fpath = nil)
+		fpath = path if (!fpath)
+	
+		read_groups(fpath)
+	end
+
+	#
+	# Reads in the groups from the supplied string.
+	#
+	def from_s(str)
+		read_groups_string(str.split("\n"))
+	end
+
+	#
+	# Writes the group settings to a file.
+	#
+	def to_file(tpath = nil)
+		tpath = path if (!tpath)
+
+		f = File.new(tpath, "w")
+		f.write(to_s)
+		f.close
+	end
+
+	#
+	# Converts the groups to a string.
+	#
+	def to_s
+		str = ''
+		keys.sort.each { |k|
+			str << "[#{k}]\n"
+
+			self[k].each_pair { |var, val|
+				str << "#{var}=#{val}\n"
+			}
+
+			str << "\n";
+		}
+
+		return str
+	end
+
+	attr_reader :path
+
+protected
+
+	#
+	# Reads in the groups and their attributes from the supplied file
+	# path or from the instance's file path if one was set.
+	#
+	def read_groups(fpath) # :nodoc:
+		if (!fpath)
+			raise ArgumentError, "No file path specified.",
+				caller
+		end
+
+		# Read in the contents of the file
+		lines = ::IO.readlines(fpath)
+
+		# Now read the contents from the supplied string
+		read_groups_string(lines)
+	end
+
+	#
+	# Reads groups from the supplied string
+	#
+	def read_groups_string(str) # :nodoc:
+		# Reset the groups hash
+		self.clear
+
+		# The active group
+		active_group = nil
+
+		# Walk each line initializing the groups
+		str.each { |line|
+			next if (line.match(/^;/))
+
+			# Eliminate cr/lf
+			line.gsub!(/(\n|\r)/, '')
+
+			# Is it a group [bob]?
+			if (md = line.match(/^\[(.+?)\]/))
+				active_group = md[1]	
+				self[md[1]]  = {}
+			# Is it a VAR=VAL?
+			elsif (md = line.match(/^(.+?)=(.*)$/))
+				if (active_group)
+					self[active_group][md[1]] = md[2]
+				end
+			end
+		}
+	end
+
+	attr_writer :path # :nodoc:
+
+end
+
+end
+end