librex 0.0.68 → 0.0.70

data/lib/rex/post/meterpreter/extensions/stdapi/railgun/dll_wrapper.rb.ut.rb

@@ -1,64 +0,0 @@
-#!/usr/bin/env ruby
-# -*- coding: binary -*-
-
-$:.unshift(File.join(File.dirname(__FILE__), '..', '..', '..','..','..','..','..', 'lib'))
-
-require 'rex/post/meterpreter/extensions/stdapi/railgun/dll'
-require 'rex/post/meterpreter/extensions/stdapi/railgun/dll_wrapper'
-require 'rex/post/meterpreter/extensions/stdapi/railgun/mock_magic'
-require 'test/unit'
-
-module Rex
-module Post
-module Meterpreter
-module Extensions
-module Stdapi
-module Railgun
-class DLLWrapper::UnitTest < Test::Unit::TestCase
-
-	include MockMagic
-
-	def test_functions
-		mock_function_descriptions.each do |func|
-			client = make_mock_client(func[:platform], func[:request_to_client], func[:response_from_client])
-			dll = DLL.new(func[:dll_name], client)
-
-			dll_wrapper = DLLWrapper.new(dll, client)
-
-			# This represents how people check if a function doesn't exist
-			assert(!dll_wrapper.functions[func[:name]], 'Function non-existence can be chucked via .functions')
-
-			dll.add_function(func[:name], func[:return_type], func[:params])
-
-			# This represents how people check if a function exist
-			assert(dll_wrapper.functions[func[:name]], 'Function existence can be chucked via .functions')
-
-			actual_returned_hash = dll_wrapper.send(:method_missing, func[:name].to_sym, *func[:ruby_args])
-
-			assert_equal(func[:returned_hash], actual_returned_hash,
-				"method_missing should result in a successful call to specified function")
-		end
-	end
-
-	def test_method_missing
-		mock_function_descriptions.each do |func|
-			client = make_mock_client(func[:platform], func[:request_to_client], func[:response_from_client])
-			dll = DLL.new(func[:dll_name], client)
-
-			dll.add_function(func[:name], func[:return_type], func[:params])
-
-			dll_wrapper = DLLWrapper.new(dll, client)
-
-			actual_returned_hash = dll_wrapper.send(:method_missing, func[:name].to_sym, *func[:ruby_args])
-
-			assert_equal(func[:returned_hash], actual_returned_hash,
-				"method_missing should result in a successful call to specified function")
-		end
-	end
-end
-end
-end
-end
-end
-end
-end

data/lib/rex/post/meterpreter/extensions/stdapi/railgun/platform_util.rb.ut.rb

@@ -1,29 +0,0 @@
-#!/usr/bin/env ruby
-# -*- coding: binary -*-
-
-$:.unshift(File.join(File.dirname(__FILE__), '..','..','..','..','..', '..', '..', 'lib'))
-
-require 'rex/post/meterpreter/extensions/stdapi/railgun/platform_util'
-require 'rex/post/meterpreter/extensions/stdapi/railgun/mock_magic'
-require 'test/unit'
-
-module Rex
-module Post
-module Meterpreter
-module Extensions
-module Stdapi
-module Railgun
-class PlatformUtil::UnitTest < Test::Unit::TestCase
-	def test_parse_client_platform
-		assert_equal(PlatformUtil.parse_client_platform('x86/win32'), PlatformUtil::X86_32,
-			'parse_client_platform should translate Win32 client platforms')
-		assert_equal(PlatformUtil.parse_client_platform('x86/win64'), PlatformUtil::X86_64,
-			'parse_client_platform should translate Win64 client platforms')
-	end
-end
-end
-end
-end
-end
-end
-end

data/lib/rex/post/meterpreter/extensions/stdapi/railgun/railgun.rb.ut.rb

@@ -1,155 +0,0 @@
-#!/usr/bin/env ruby
-# -*- coding: binary -*-
-
-$:.unshift(File.join(File.dirname(__FILE__), '..', '..', '..','..','..','..','..', 'lib'))
-
-require 'rex/post/meterpreter/extensions/stdapi/railgun/railgun'
-require 'rex/post/meterpreter/extensions/stdapi/railgun/mock_magic'
-require 'test/unit'
-require 'benchmark'
-
-module Rex
-module Post
-module Meterpreter
-module Extensions
-module Stdapi
-module Railgun
-class Railgun::UnitTest < Test::Unit::TestCase
-
-	# DLLs we know should be available at the time of this writing,
-	# and DLLs that because of changes since then should be available
-	STOCK_DLLS = [
-		'kernel32',
-		'ntdll',
-		'user32',
-		'ws2_32',
-		'iphlpapi',
-		'advapi32',
-		'shell32',
-		'netapi32',
-		'crypt32',
-	] | Railgun::BUILTIN_DLLS
-
-	include MockMagic
-
-	def test_known_dll_names
-		railgun = Railgun.new(make_mock_client())
-
-		dll_names = railgun.known_dll_names
-
-		assert_equal(dll_names.length, dll_names.uniq.length,
-			"known_dll_names should not have duplicates")
-
-		STOCK_DLLS.each do |name|
-			assert(dll_names.include?(name),
-				"known_dll_names should include #{name}")
-		end
-	end
-#
-# TODO:
-#	def test_multi
-#		mock_function_descriptions.each do |func|
-#			railgun = Railgun.new(make_mock_client(func[:platform]))
-#
-#			functions = [
-#				[func[:dll_name], func[:name], func[:ruby_args]]
-#			]
-#
-#			results = railgun.multi(functions)
-#		end
-#	end
-#
-	def test_const
-		railgun = Railgun.new(make_mock_client())
-
-		assert_equal(0, railgun.const('SUCCESS'),
-			"const should look up constants like SUCCESS")
-	end
-
-	def test_add_dll
-		railgun = Railgun.new(make_mock_client())
-
-		target_dll_name = 'discordia'
-		target_windows_name = 'C:\look\behind\you'
-
-		railgun.add_dll(target_dll_name, target_windows_name)
-
-		actual_dll = railgun.get_dll(target_dll_name);
-
-		assert_not_nil(actual_dll,
-			"add_dll should make a DLL accessible via get_dll")
-
-		assert_equal(actual_dll.dll_path, target_windows_name,
-			"add_dll should set a dll path when specified")
-
-		wrapper = railgun.send(target_dll_name.to_sym)
-
-		assert_same(wrapper._dll, actual_dll,
-			"railgun instance responds with dll wrapper of requested dll")
-	end
-
-	def test_method_missing
-		railgun = Railgun.new(make_mock_client())
-
-		STOCK_DLLS.each do |dll_name|
-			assert_nothing_raised do
-				railgun.send(dll_name.to_sym)
-			end
-		end
-	end
-
-	def test_get_dll
-		railgun = Railgun.new(make_mock_client())
-
-		STOCK_DLLS.each do |dll_name|
-			dll = railgun.get_dll(dll_name)
-
-			# We want to ensure autoloading is working
-			assert(dll.instance_of?(DLL),
-				"get_dll should be able to return a value for dll #{dll_name}")
-
-			assert(dll.frozen?,
-				"Stock DLLs loaded lazily in get_dll should be frozen")
-
-			# adding a function should create a local unfrozen instance
-			railgun.add_function(dll_name, '__lolz', 'VOID', [])
-
-			unfrozen_dll = railgun.get_dll(dll_name)
-
-			assert_not_same(dll, unfrozen_dll,
-				"add_function should create a local unfrozen instance that get_dll can then access")
-
-			assert(!unfrozen_dll.frozen?,
-				"add_function should create a local unfrozen instance that get_dll can then access")
-
-			railgun2 = Railgun.new(make_mock_client())
-
-			assert(!railgun2.get_dll(dll_name).functions.has_key?('__lolz'),
-				"functions added to one instance of railgun should not be accessible to others")
-
-			assert_not_same(!railgun2.get_dll(dll_name).functions, unfrozen_dll.functions,
-				"function hash should have been duplicated during unfreeze")
-		end
-	end
-
-	def test_add_function
-		mock_function_descriptions.each do |func|
-			railgun = Railgun.new(make_mock_client(func[:platform]))
-
-			dll_name = func[:dll_name]
-			function_name = func[:name]
-
-			railgun.add_dll(dll_name)
-			railgun.add_function(dll_name, function_name, func[:return_type], func[:params])
-
-			assert(railgun.get_dll(dll_name).functions.has_key?(function_name),
-				"add_function should add a function to the DLL specified")
-		end
-	end
-end
-end
-end
-end
-end
-end
-end

data/lib/rex/post/meterpreter/extensions/stdapi/railgun/type/pointer_util.rb.ut.rb

@@ -1,128 +0,0 @@
-#!/usr/bin/env ruby
-# -*- coding: binary -*-
-
-$:.unshift(File.join(File.dirname(__FILE__), '..', '..','..','..','..','..', '..', '..', 'lib'))
-
-require 'rex/post/meterpreter/extensions/stdapi/railgun/type/pointer_util'
-require 'rex/post/meterpreter/extensions/stdapi/railgun/platform_util'
-require 'rex/post/meterpreter/extensions/stdapi/railgun/mock_magic'
-require 'test/unit'
-
-module Rex
-module Post
-module Meterpreter
-module Extensions
-module Stdapi
-module Railgun
-module Type
-class PlatformUtil::UnitTest < Test::Unit::TestCase
-
-	include Rex::Post::Meterpreter::Extensions::Stdapi::Railgun::MockMagic
-
-	# memread value of win x86 pointer mapped to target unpack value
-	X86_32_POINTERS = {
-		"8D\x15\x00"       => 1393720,
-		"\x1C\x84\x15\x00" => 1410076,
-		"\x0E\x84\x15\x00" => 1410062,
-		"\x02\x84\x15\x00" => 1410050,
-		"\xE6\x83\x15\x00" => 1410022,
-		"\xC4\x83\x15\x00" => 1409988,
-		"\x00\x00\x00\x00" => 0,
-	}
-	X86_64_POINTERS = {
-		"\x10^ \x00\x00\x00\x00\x00"       => 2121232,
-		"\xCA\x9D \x00\x00\x00\x00\x00"    => 2137546,
-		"\xC8\x9D \x00\x00\x00\x00\x00"    => 2137544,
-		"Z\x9D \x00\x00\x00\x00\x00"       => 2137434,
-		"X\x9D \x00\x00\x00\x00\x00"       => 2137432,
-		"\x00\x00\x00\x00\x00\x00\x00\x00" => 0,
-	}
-
-	X86_64_NULL_POINTER = "\x00\x00\x00\x00\x00\x00\x00\x00"
-	X86_32_NULL_POINTER = "\x00\x00\x00\x00"
-
-	X86_64 = PlatformUtil::X86_64
-	X86_32 = PlatformUtil::X86_32
-
-	def test_pack_pointer
-		X86_64_POINTERS.invert.each_pair do |unpacked, packed|
-			assert_equal(packed, PointerUtil.pack_pointer(unpacked.to_i, X86_64),
-				"pack_pointer should pack 64-bit numberic pointers")
-		end
-
-		X86_32_POINTERS.invert.each_pair do |unpacked, packed|
-			assert_equal(packed, PointerUtil.pack_pointer(unpacked.to_i, X86_32),
-				"pack_pointer should pack 32-bit numberic pointers")
-		end
-
-		assert_equal(X86_64_NULL_POINTER, PointerUtil.pack_pointer(nil, X86_64),
-			'pack_pointer should pack "nil" as a null pointer for x86_64')
-
-		assert_equal(X86_32_NULL_POINTER, PointerUtil.pack_pointer(nil, X86_32),
-			'pack_pointer should pack "nil" as a null pointer for x86_32')
-
-		assert_equal(X86_64_NULL_POINTER, PointerUtil.pack_pointer(0, X86_64),
-			'pack_pointer should pack numeric 0 as a null pointer for x86_64')
-
-		assert_equal(X86_32_NULL_POINTER, PointerUtil.pack_pointer(0, X86_32),
-			'pack_pointer should pack numeric 9 as a null pointer for x86_32')
-	end
-
-	def test_unpack_pointer
-		X86_64_POINTERS.each_pair do |packed, unpacked|
-			assert_equal(unpacked, PointerUtil.unpack_pointer(packed, X86_64),
-				"unpack_pointer should unpack 64-bit pointers")
-		end
-
-		X86_32_POINTERS.each_pair do |packed, unpacked|
-			assert_equal(unpacked, PointerUtil.unpack_pointer(packed, X86_32),
-				"unpack_pointer should unpack 32-bit pointers")
-		end
-
-
-	end
-
-	def test_is_null_pointer
-		[X86_32, X86_64].each do |platform|
-			assert(PointerUtil.is_null_pointer?(nil, platform), 'nil should be a null pointer')
-			assert(PointerUtil.is_null_pointer?(0, platform), 'numeric 0 should be a null pointer')
-		end
-
-		assert_equal(true, PointerUtil.is_null_pointer?(X86_32_NULL_POINTER, X86_32),
-			'is_null_pointer? should return true for packed 32-bit null pointers')
-
-		assert_equal(true, PointerUtil.is_null_pointer?(X86_64_NULL_POINTER, X86_64),
-			'is_null_pointer? should return true for packed 64-bit null pointers')
-
-	end
-
-	def test_pointer_size
-		assert_equal(8, PointerUtil.pointer_size(X86_64),
-			'pointer_size should report X86_64 arch as 8 (bytes)')
-
-		assert_equal(4, PointerUtil.pointer_size(X86_32),
-			'pointer_size should report X86_32 arch as 4 (bytes)')
-	end
-
-	def test_is_pointer_type
-		assert_equal(true, PointerUtil.is_pointer_type?(:pointer),
-			'pointer_type should return true for the symbol :pointer')
-
-		assert_equal(true, PointerUtil.is_pointer_type?('LPVOID'),
-			'pointer_type should return true if string begins with LP')
-
-		assert_equal(true, PointerUtil.is_pointer_type?('PDWORD'),
-			'pointer_type should return true if string begins with P')
-
-		assert_equal(false, PointerUtil.is_pointer_type?('LOLZ'),
-			'pointer_type should return false if not a pointer type')
-
-	end
-end
-end
-end
-end
-end
-end
-end
-end

data/lib/rex/post/meterpreter/extensions/stdapi/railgun/win_const_manager.rb.ut.rb

@@ -1,124 +0,0 @@
-#!/usr/bin/env ruby
-# -*- coding: binary -*-
-
-$:.unshift(File.join(File.dirname(__FILE__), '..', '..', '..','..','..','..','..', 'lib'))
-
-require 'rex/post/meterpreter/extensions/stdapi/railgun/win_const_manager'
-require 'test/unit'
-
-module Rex
-module Post
-module Meterpreter
-module Extensions
-module Stdapi
-module Railgun
-class WinConstManager::UnitTest < Test::Unit::TestCase
-
-	def test_select_const_names
-		const_manager = WinConstManager.new
-
-		names = %w(W WW WWW)
-
-		names.each do |name|
-			const_manager.add_const(name, 23)
-		end
-
-		assert(const_manager.select_const_names(23).sort == names,
-			'select_const_names should return all names for given value')
-
-		const_manager.add_const('Skidoo!', 23)
-
-		assert(const_manager.select_const_names(23, /^\w{1,3}$/).sort == names,
-			'select_const_names should filter names with provided regex')
-		
-	end
-
-	def test_is_parseable
-		const_manager = WinConstManager.new
-
-		first_key = 'SOME_NUMBER'
-		second_key = 'SOME_OTHER_NUMBER'
-		boolean_logic = first_key + ' | ' + second_key
-
-		# XXX: Should check (un)parseability before adding constants too?
-
-		const_manager.add_const(first_key, 43123)
-		const_manager.add_const(second_key, 234)
-
-		assert(const_manager.is_parseable(boolean_logic),
-			"is_parseable should consider boolean logic statements parseable")
-
-		assert(const_manager.is_parseable(first_key),
-			"is_parseable should consider constants parseable")
-
-		assert(! const_manager.is_parseable(5),
-			"is_parseable should not consider non-string keys as parseable")
-
-		assert(! const_manager.is_parseable('| FOO |'),
-			"is_parseable should not consider malformed boolean expressions parseable")
-	end
-
-	def test_add_const
-		target_key = 'VALID_KEY'
-		target_value = 23
-
-		const_manager = WinConstManager.new
-
-		const_manager.add_const(target_key, target_value)
-
-		assert_equal(target_value, const_manager.parse(target_key),
-			"add_const should add a constant/value pair that can be trieved with parse")
-
-	end
-
-	def test_initialization
-		target_key = 'VALID_KEY'
-		target_value = 23
-
-		const_manager = WinConstManager.new(target_key => target_value)
-
-		assert_equal(target_value, const_manager.parse(target_key),
-			"upon initialization, should add any provided constants.")
-	end
-
-	def test_parse
-		target_key = 'VALID_KEY'
-		target_value = 23
-		invalid_key = 8
-
-		const_manager = WinConstManager.new
-
-		const_manager.add_const(target_key, target_value)
-
-		assert_equal(target_value, const_manager.parse(target_key),
-			"parse should retrieve the corresponding value when a key is provided")
-
-		# From API: "should not throw an exception given an invalid key"
-		assert_nothing_thrown do
-			const_manager.parse(invalid_key)
-		end
-
-		assert_equal(nil, const_manager.parse(invalid_key),
-			"parse should return nil when an invalid key is provided")
-
-		x_key = 'X'
-		x_value = 228
-		y_key = 'Y'
-		y_value = 15
-
-		boolean_logic = x_key + ' | ' + y_key
-		target_boolean_logic_result = x_value | y_value
-
-		const_manager.add_const(x_key, x_value)
-		const_manager.add_const(y_key, y_value)
-
-		assert_equal(target_boolean_logic_result, const_manager.parse(boolean_logic),
-			"parse should evaluate boolean expressions consisting of OR")
-	end
-end
-end
-end
-end
-end
-end
-end