librex 0.0.68 → 0.0.70

data/lib/rex/nop/opty2.rb.ut.rb

@@ -1,24 +0,0 @@
-#!/usr/bin/env ruby
-# -*- coding: binary -*-
-
-$:.unshift(File.join(File.dirname(__FILE__), '..', '..'))
-
-require 'test/unit'
-require 'rex/nop/opty2'
-
-class Rex::Nop::Opty2::UnitTest < Test::Unit::TestCase
-
-	Klass = Rex::Nop::Opty2
-
-	# TODO: machine test
-	def test_opty2
-		o = Klass.new
-
-		100.times {
-			s = o.generate_sled(100)
-
-			assert_equal(s.length, 100)
-		}
-	end
-
-end

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

@@ -1,68 +0,0 @@
-#!/usr/bin/env ruby
-# -*- coding: binary -*-
-
-$:.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.ut.rb

@@ -1,30 +0,0 @@
-#!/usr/bin/env ruby
-# -*- coding: binary -*-
-
-$:.unshift(File.join(File.dirname(__FILE__), '..', '..'))
-
-require 'test/unit'
-require 'rex/parser/ini'
-
-class Rex::Parser::Ini::UnitTest < Test::Unit::TestCase
-
-	Klass   = Rex::Parser::Ini
-	TestIni = <<END
-[group1]
-cat=dog
-bird=frog
-
-[group2]
-salad=cake
-END
-
-	def test_parse
-		ini = Klass.from_s(TestIni)
-
-		assert_equal('dog', ini['group1']['cat'])
-		assert_equal('frog', ini['group1']['bird'])
-		assert_equal('cake', ini['group2']['salad'])
-		assert_equal(TestIni + "\n", ini.to_s)
-	end
-	
-end

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

@@ -1,18 +0,0 @@
-# -*- coding: binary -*-
-$:.unshift(File.join(File.dirname(__FILE__)))
-$:.unshift(File.join(File.dirname(__FILE__), '..', '..','..','..','..','..', 'lib'))
-
-require 'test/unit'
-require 'rex'
-
-require 'railgun/api_constants.rb.ut'
-require 'railgun/type/pointer_util.rb.ut'
-require 'railgun/platform_util.rb.ut'
-require 'railgun/buffer_item.rb.ut'
-require 'railgun/dll_function.rb.ut'
-require 'railgun/dll_helper.rb.ut'
-require 'railgun/win_const_manager.rb.ut'
-require 'railgun/dll.rb.ut.rb'
-require 'railgun/dll_wrapper.rb.ut.rb'
-require 'railgun/railgun.rb.ut.rb'
-require 'railgun/win_const_manager.rb.ut.rb'

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

@@ -1,39 +0,0 @@
-#!/usr/bin/env ruby
-# -*- coding: binary -*-
-
-$:.unshift(File.join(File.dirname(__FILE__), '..', '..', '..','..','..','..'))
-
-require 'rex/post/meterpreter/extensions/stdapi/railgun/api_constants'
-require 'rex/post/meterpreter/extensions/stdapi/railgun/win_const_manager'
-require 'rex/text'
-require 'test/unit'
-
-module Rex
-module Post
-module Meterpreter
-module Extensions
-module Stdapi
-module Railgun
-class ApiConstants::UnitTest < Test::Unit::TestCase
-	def test_manager
-		const_manager = ApiConstants.manager
-
-		assert_equal(0, const_manager.parse('SUCCESS'),
-			"ApiConstants.manager should return a functional constant manager for WinAPI constants")
-	end
-
-	def test_add_constants
-		const_manager = WinConstManager.new
-
-		ApiConstants.add_constants(const_manager)
-
-		assert_equal(0, const_manager.parse('SUCCESS'),
-			"ApiConstants.add_constants should have added WinAPI constants to given constant manager")
-	end
-end
-end
-end
-end
-end
-end
-end

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

@@ -1,37 +0,0 @@
-#!/usr/bin/env ruby
-# -*- coding: binary -*-
-
-$:.unshift(File.join(File.dirname(__FILE__), '..', '..', '..','..','..','..','..', 'lib'))
-
-require 'rex/post/meterpreter/extensions/stdapi/railgun/buffer_item'
-require 'test/unit'
-
-module Rex
-module Post
-module Meterpreter
-module Extensions
-module Stdapi
-module Railgun
-class BufferItem::UnitTest < Test::Unit::TestCase
-
-	def test_initialization
-		target_belongs_to_param_n = 1
-		target_addr = 232323
-		target_length_in_bytes = 4
-		target_datatype = "DWORD"
-
-		item = BufferItem.new(target_belongs_to_param_n, target_addr,
-					target_length_in_bytes, target_datatype)
-
-		assert_equal(target_belongs_to_param_n, item.belongs_to_param_n)
-		assert_equal(target_addr, item.addr)
-		assert_equal(target_length_in_bytes, item.length_in_bytes)
-		assert_equal(target_datatype, item.datatype)
-	end
-end
-end
-end
-end
-end
-end
-end

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

@@ -1,52 +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/mock_magic'
-require 'test/unit'
-
-module Rex
-module Post
-module Meterpreter
-module Extensions
-module Stdapi
-module Railgun
-class DLL::UnitTest < Test::Unit::TestCase
-
-	include MockMagic
-
-	def test_add_function
-		mock_function_descriptions.each do |func|
-			dll = DLL.new(func[:dll_name], nil)
-			dll.add_function(func[:name], func[:return_type], func[:params])
-
-			assert(dll.functions.has_key?(func[:name]),
-				"add_function should expand the list of available functions")
-		end
-	end
-
-	def test_call_function
-		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], nil)
-
-			dll.add_function(func[:name], func[:return_type], func[:params])
-
-			actual_returned_hash = dll.call_function(func[:name].to_sym, func[:ruby_args], client)
-
-			assert(func[:returned_hash].has_key?('GetLastError'),
-				"process_function_call should add the result of GetLastError to the key GetLastError")
-
-			assert_equal(func[:returned_hash], actual_returned_hash,
-				"process_function_call convert function result to a ruby hash")
-		end
-	end
-end
-end
-end
-end
-end
-end
-end

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

@@ -1,43 +0,0 @@
-#!/usr/bin/env ruby
-# -*- coding: binary -*-
-
-$:.unshift(File.join(File.dirname(__FILE__), '..', '..', '..','..','..','..','..', 'lib'))
-
-require 'rex/post/meterpreter/extensions/stdapi/railgun/dll_function'
-require 'test/unit'
-
-module Rex
-module Post
-module Meterpreter
-module Extensions
-module Stdapi
-module Railgun
-class DLLFunction::UnitTest < Test::Unit::TestCase
-
-	VALID_RETURN_TYPE = 'DWORD'
-	NON_RETURN_DATATYPE = 'INVALID_RETURN_TYPE'
-
-	VALID_DIRECTION = 'out'
-	UNKNOWN_DIRECTION = 'unknown'
-
-	VALID_DATATYPE = 'PBLOB'
-	UNKNOWN_DATATYPE = 'UNKNOWN_DATATYPE'
-
-	def test_initialize
-		# TODO: haven't gotten around to writing this yet. Feel free to
-#		skip("incomplete test coverage")
-#
-#		assert_nothing_raised("valid initialization should not raise") do
-#		end
-#
-#		assert_raised(ArgumentError, "check_type_exists should raise ArgumentError on unknown datatypes") do
-#		end
-
-	end
-end
-end
-end
-end
-end
-end
-end

data/lib/rex/post/meterpreter/extensions/stdapi/railgun/dll_helper.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/dll_helper'
-require 'rex/post/meterpreter/extensions/stdapi/railgun/win_const_manager'
-require 'rex/text'
-require 'test/unit'
-
-module Rex
-module Post
-module Meterpreter
-module Extensions
-module Stdapi
-module Railgun
-class DLLHelper::UnitTest < Test::Unit::TestCase
-
-	###
-	# We will test against this instance of DLLHelper (a module)
-	#
-	# We freeze the instance and make the reference constant to ensure consistency
-	##
-	TEST_DLL_HELPER = Object.new.extend(DLLHelper).freeze
-
-	def test_str_to_ascii_z
-		original_string = '23 Skidoo!'
-
-		# converts ruby string to zero-terminated ASCII string
-		zero_terminated_ascii_attempt = TEST_DLL_HELPER.str_to_ascii_z(original_string)
-
-		assert(zero_terminated_ascii_attempt  =~ /\x00$/,
-			"str_to_ascii_z should result in a 0 terminated string")
-
-		assert(zero_terminated_ascii_attempt =~ /^#{original_string}/,
-			"str_to_ascii_z should still start with original string")
-
-		assert_equal(original_string.length + 1, zero_terminated_ascii_attempt.length,
-			"str_to_ascii_z should have length of original pluss room for a terminal 0")
-	end
-
-	def test_asciiz_to_str
-		target_string = '23 Skidoo!'
-		post_zero_noise = 'Loud noises!'
-		zero_terminated_string = target_string + "\x00" + post_zero_noise
-
-		actual_string =  TEST_DLL_HELPER.asciiz_to_str(zero_terminated_string)
-
-		assert(actual_string =~ /^#{target_string}/,
-			"asciiz_to_str should preserve string before zero")
-
-		assert(actual_string !~ /#{post_zero_noise}$/,
-			"asciiz_to_str should ignore characters after zero")
-
-		assert_equal(target_string, actual_string,
-			"asciiz_to_str should only return the contents of the string before (exclusive) the zero")
-
-		assert_equal(target_string, TEST_DLL_HELPER.asciiz_to_str(target_string),
-			"asciiz_to_str should return input verbatim should that input not be zero-terminated")
-
-	end
-
-	def test_str_to_uni_z
-		ruby_string = "If I were a rich man..."
-
-		target_zero_terminated_unicode = Rex::Text.to_unicode(ruby_string) + "\x00\x00"
-		actual_zero_terminated_unicode = TEST_DLL_HELPER.str_to_uni_z(ruby_string)
-
-		assert(actual_zero_terminated_unicode =~ /\x00\x00$/,
-			"str_to_uni_z should result in a double-zero terminated string")
-
-		assert_equal(target_zero_terminated_unicode, actual_zero_terminated_unicode,
-			"str_to_uni_z should convert ruby string to zero-terminated WCHAR string")
-	end
-
-	def test_uniz_to_str
-		target_string = 'Foo bar baz'
-
-		zero_terminated_unicode = Rex::Text.to_unicode(target_string) + "\x00\x00"
-
-		assert_equal(target_string, TEST_DLL_HELPER.uniz_to_str(zero_terminated_unicode),
-			'uniz_to_str should convert 0-terminated UTF16 to ruby string')
-
-	end
-
-	def test_assemble_buffer
-		# TODO: provide test coverage
-		#skip("Currently DLLHelper.assemble_buffer does not have coverage")
-	end
-
-	def test_param_to_number
-		consts_manager = WinConstManager.new
-
-		x_key = 'X'
-		x_value = 23
-
-		y_key = 'Y'
-		y_value = 5
-
-		logical_or = x_key +  '|' +  y_key
-		target_result_of_logical_or = x_value | y_value
-
-		consts_manager.add_const(y_key, y_value)
-		consts_manager.add_const(x_key, x_value)
-
-		assert_equal(x_value, TEST_DLL_HELPER.param_to_number(x_key, consts_manager),
-			"param_to_number should return the appropriate value for a given constant")
-
-		assert_equal(y_value, TEST_DLL_HELPER.param_to_number(y_key, consts_manager),
-			"param_to_number should return the appropriate value for a given constant")
-
-		assert_equal(0, TEST_DLL_HELPER.param_to_number(nil, consts_manager),
-			"param_to_number should return zero when given nil")
-
-		assert_equal(target_result_of_logical_or, TEST_DLL_HELPER.param_to_number(logical_or, consts_manager),
-			"param_to_number should perform an OR should the input be in the form '#{logical_or}'")
-
-		assert_raise(ArgumentError, 'param_to_number should raise an error when a given key does not exist') do
-			TEST_DLL_HELPER.param_to_number('DOESNT_EXIST', consts_manager)
-		end
-	end
-end
-end
-end
-end
-end
-end
-end