librex 0.0.13 → 0.0.15

data/lib/rex/ole/stream.rb

@@ -1,53 +0,0 @@
-##
-# $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

@@ -1,49 +0,0 @@
-##
-# $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

@@ -1,157 +0,0 @@
-##
-# $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

@@ -1,97 +0,0 @@
-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

@@ -1,67 +0,0 @@
-#!/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

@@ -1,185 +0,0 @@
-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