librex 0.0.16 → 0.0.17

data/lib/rex/proto/dcerpc/exceptions.rb

@@ -0,0 +1,150 @@
+module Rex
+module Proto
+module DCERPC
+module Exceptions
+
+class Error < ::RuntimeError
+	
+	@@errors = {
+		0x00000000 => "stub-defined",
+		0x00000001 => "nca_s_fault_other",
+		0x00000005 => "nca_s_fault_access_denied",
+		0x000006d8 => "nca_s_fault_cant_perform",
+		0x000006f7 => "nca_s_fault_ndr",
+		0x16c9a001 => "rpc_s_op_rng_error",
+		0x16c9a006 => "rpc_s_wrong_boot_time",
+		0x16c9a012 => "rpc_s_no_memory",
+		0x16c9a016 => "rpc_s_comm_failure",
+		0x16c9a01b => "rpc_s_fault_object_not_found",
+		0x16c9a02c => "rpc_s_unknown_if",
+		0x16c9a02d => "rpc_s_unsupported_type",
+		0x16c9a030 => "rpc_s_cancel_timeout",
+		0x16c9a031 => "rpc_s_call_cancelled",
+		0x16c9a036 => "rpc_s_connection_closed",
+		0x16c9a041 => "rpc_s_connect_timed_out",
+		0x16c9a042 => "rpc_s_connect_rejected",
+		0x16c9a043 => "rpc_s_network_unreachable",
+		0x16c9a044 => "rpc_s_connect_no_resources",
+		0x16c9a045 => "rpc_s_rem_network_shutdown",
+		0x16c9a046 => "rpc_s_too_many_rem_connects",
+		0x16c9a047 => "rpc_s_no_rem_endpoint",
+		0x16c9a048 => "rpc_s_rem_host_down",
+		0x16c9a049 => "rpc_s_host_unreachable",
+		0x16c9a04a => "rpc_s_access_control_info_inv",
+		0x16c9a04b => "rpc_s_loc_connect_aborted",
+		0x16c9a04c => "rpc_s_connect_closed_by_rem",
+		0x16c9a04d => "rpc_s_rem_host_crashed",
+		0x16c9a074 => "rpc_s_fault_addr_error",
+		0x16c9a075 => "rpc_s_fault_context_mismatch",
+		0x16c9a076 => "rpc_s_fault_fp_div_by_zero",
+		0x16c9a077 => "rpc_s_fault_fp_error",
+		0x16c9a078 => "rpc_s_fault_fp_overflow",
+		0x16c9a079 => "rpc_s_fault_fp_underflow",
+		0x16c9a07a => "rpc_s_fault_ill_inst",
+		0x16c9a07b => "rpc_s_fault_int_div_by_zero",
+		0x16c9a07c => "rpc_s_fault_int_overflow",
+		0x16c9a07d => "rpc_s_fault_invalid_bound",
+		0x16c9a07e => "rpc_s_fault_invalid_tag",
+		0x16c9a07f => "rpc_s_fault_pipe_closed",
+		0x16c9a080 => "rpc_s_fault_pipe_comm_error",
+		0x16c9a081 => "rpc_s_fault_pipe_discipline",
+		0x16c9a082 => "rpc_s_fault_pipe_empty",
+		0x16c9a083 => "rpc_s_fault_pipe_memory",
+		0x16c9a084 => "rpc_s_fault_pipe_order",
+		0x16c9a085 => "rpc_s_fault_remote_comm_failure",
+		0x16c9a086 => "rpc_s_fault_remote_no_memory",
+		0x16c9a087 => "rpc_s_fault_unspec",
+		0x16c9a0a8 => "rpc_s_no_ns_permission",
+		0x16c9a0b5 => "rpc_s_no_more_bindings",
+		0x16c9a113 => "rpc_s_fault_user_defined",
+		0x16c9a116 => "rpc_s_fault_tx_open_failed",
+		0x16c9a16e => "rpc_s_fault_codeset_conv_error",
+		0x16c9a170 => "rpc_s_fault_no_client_stub",
+		0x1c000001 => "nca_s_fault_int_div_by_zero",
+		0x1c000002 => "nca_s_fault_addr_error",
+		0x1c000003 => "nca_s_fault_fp_div_zero",
+		0x1c000004 => "nca_s_fault_fp_underflow",
+		0x1c000005 => "nca_s_fault_fp_overflow",
+		0x1c000006 => "nca_s_fault_invalid_tag",
+		0x1c000007 => "nca_s_fault_invalid_bound",
+		0x1c000008 => "nca_rpc_version_mismatch",
+		0x1c000009 => "nca_unspec_reject",
+		0x1c00000a => "nca_s_bad_actid",
+		0x1c00000b => "nca_who_are_you_failed",
+		0x1c00000c => "nca_manager_not_entered",
+		0x1c00000d => "nca_s_fault_cancel",
+		0x1c00000e => "nca_s_fault_ill_inst",
+		0x1c00000f => "nca_s_fault_fp_error",
+		0x1c000010 => "nca_s_fault_int_overflow",
+		0x1c000014 => "nca_s_fault_pipe_empty",
+		0x1c000015 => "nca_s_fault_pipe_closed",
+		0x1c000016 => "nca_s_fault_pipe_order",
+		0x1c000017 => "nca_s_fault_pipe_discipline",
+		0x1c000018 => "nca_s_fault_pipe_comm_error",
+		0x1c000019 => "nca_s_fault_pipe_memory",
+		0x1c00001a => "nca_s_fault_context_mismatch",
+		0x1c00001b => "nca_s_fault_remote_no_memory",
+		0x1c00001c => "nca_invalid_pres_context_id",
+		0x1c00001d => "nca_unsupported_authn_level",
+		0x1c00001f => "nca_invalid_checksum",
+		0x1c000020 => "nca_invalid_crc",
+		0x1c000021 => "ncs_s_fault_user_defined",
+		0x1c000022 => "nca_s_fault_tx_open_failed",
+		0x1c000023 => "nca_s_fault_codeset_conv_error",
+		0x1c000024 => "nca_s_fault_object_not_found",
+		0x1c000025 => "nca_s_fault_no_client_stub",
+		0x1c010002 => "nca_op_rng_error",
+		0x1c010003 => "nca_unk_if",
+		0x1c010006 => "nca_wrong_boot_time",
+		0x1c010009 => "nca_s_you_crashed",
+		0x1c01000b => "nca_proto_error",
+		0x1c010013 => "nca_out_args_too_big",
+		0x1c010014 => "nca_server_too_busy",
+		0x1c010017 => "nca_unsupported_type"
+	}
+	
+	def initialize(*args)
+		super(*args)
+	end
+
+	# returns an error string if it exists, otherwise just the error code
+	def get_error(error)
+		string = ''
+		if @@errors[error]
+			string = @@errors[error]
+		else
+			string = sprintf('0x%.8x',error)
+		end
+	end
+end
+
+class Fault < Error
+	attr_accessor :fault
+	def to_s
+		'DCERPC FAULT => ' + get_error(self.fault)
+	end
+end
+
+class NoResponse < Error
+	def to_s
+		'no response from dcerpc service'
+	end
+end
+
+class InvalidPacket < Error
+	def initialize(message = nil)
+		@message = message
+	end
+	
+	def to_s
+		str = 'Invalid packet.'
+		if (@message)
+			str += " #{@message}"
+		end
+	end
+end
+
+end
+end
+end
+end

data/lib/rex/proto/dcerpc/handle.rb

@@ -0,0 +1,47 @@
+module Rex
+module Proto
+module DCERPC
+class Handle
+
+	require 'rex/proto/dcerpc/uuid'
+
+	@@protocols = ['ncacn_ip_tcp', 'ncacn_ip_udp', 'ncacn_np', 'ncacn_http']
+	attr_accessor :uuid, :protocol, :address, :options
+
+	# instantiate a handle object, akin to Microsoft's string binding handle by values
+	def initialize(uuid, protocol, address, options)
+		raise ArgumentError if !Rex::Proto
+		raise ArgumentError if !Rex::Proto::DCERPC::UUID.is?(uuid[0])
+		raise ArgumentError if !@@protocols.include?(protocol)
+		self.uuid = uuid
+		self.protocol = protocol
+		self.address = address
+		self.options = options
+	end
+
+	# instantiate a handle object, by parsing a string binding handle
+	def self.parse (handle)
+		uuid_re = '[a-fA-F0-9]{8}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{12}'
+		rev_re = '\d+.\d+'
+		proto_re = '(?:' + @@protocols.join('|') + ')'
+		re = Regexp.new("(#{uuid_re}):(#{rev_re})\@(#{proto_re}):(.*?)\\[(.*)\\]$", true, 'n')
+		match = re.match(handle)
+		raise ArgumentError if !match
+
+		uuid = [match[1], match[2]]
+		protocol = match[3]
+		address = match[4]
+		options = match[5].split(',')
+		i = Rex::Proto::DCERPC::Handle.new(uuid, protocol, address, options)
+		return i
+	end
+
+	# stringify a handle
+	def to_s
+		self.uuid.join(':') + '@' + self.protocol + ':' + self.address + '[' + self.options.join(', ') + ']'
+	end
+
+end
+end
+end
+end

data/lib/rex/proto/dcerpc/handle.rb.ut.rb

@@ -0,0 +1,85 @@
+#!/usr/bin/env ruby
+
+$:.unshift(File.join(File.dirname(__FILE__), '..', '..', '..'))
+
+require 'rex/test'
+require 'rex/exceptions'
+require 'rex/proto/dcerpc/handle'
+
+class Rex::Proto::DCERPC::Handle::UnitTest < Test::Unit::TestCase
+	Klass = Rex::Proto::DCERPC::Handle
+
+	def test_ncacn_np
+		uuid = ['6bffd098-a112-3610-9833-46c3f87e345a', '1.0']
+		protocol = 'ncacn_np'
+		host  = '1.2.3.4'
+		options = ['\wkssvc']
+		i = Klass.new(uuid, protocol, host, options)
+		assert(i, 'new')
+		assert_equal('6bffd098-a112-3610-9833-46c3f87e345a:1.0@ncacn_np:1.2.3.4[\wkssvc]', i.to_s, 'as string')
+		assert_equal(uuid, i.uuid, 'uuid')
+		assert_equal(protocol, i.protocol, 'protocol')
+		assert_equal(options, i.options, 'options')
+	end
+	
+	def test_ncacn_ip_tcp
+		uuid = ['6bffd098-a112-3610-9833-46c3f87e345a', '1.0']
+		protocol = 'ncacn_ip_tcp'
+		host  = '1.2.3.4'
+		options = [80]
+		i = Klass.new(uuid, protocol, host, options)
+		assert(i, 'new')
+		assert_equal('6bffd098-a112-3610-9833-46c3f87e345a:1.0@ncacn_ip_tcp:1.2.3.4[80]', i.to_s, 'as string')
+		assert_equal(uuid, i.uuid, 'uuid')
+		assert_equal(protocol, i.protocol, 'protocol')
+		assert_equal(options, i.options, 'options')
+	end
+	
+	def test_ncacn_ip_udp
+		uuid = ['6bffd098-a112-3610-9833-46c3f87e345a', '1.0']
+		protocol = 'ncacn_ip_udp'
+		host  = '1.2.3.4'
+		options = [80]
+		i = Klass.new(uuid, protocol, host, options)
+		assert(i, 'new')
+		assert_equal('6bffd098-a112-3610-9833-46c3f87e345a:1.0@ncacn_ip_udp:1.2.3.4[80]', i.to_s, 'as string')
+		assert_equal(uuid, i.uuid, 'uuid')
+		assert_equal(protocol, i.protocol, 'protocol')
+		assert_equal(options, i.options, 'options')
+	end
+	
+	def test_ncacn_http
+		uuid = ['6bffd098-a112-3610-9833-46c3f87e345a', '1.0']
+		protocol = 'ncacn_http'
+		host  = '1.2.3.4'
+		options = [80]
+		i = Klass.new(uuid, protocol, host, options)
+		assert(i, 'new')
+		assert_equal(i.to_s, '6bffd098-a112-3610-9833-46c3f87e345a:1.0@ncacn_http:1.2.3.4[80]', 'as string')
+		assert_equal(uuid, i.uuid, 'uuid')
+		assert_equal(protocol, i.protocol, 'protocol')
+		assert_equal(options, i.options, 'options')
+	end
+	
+	def test_invalid
+		assert_raise(Rex::ArgumentError, 'invalid uuid') { Klass.new(['a', '1.0'], 'ncacn_ip_tcp', '1.2.3.4', [80]) }
+		assert_raise(Rex::ArgumentError, 'invalid uuid version') { Klass.new(['6bffnd098-a112-3610-9833-46c3f87e345a', 'b'], 'ncacn_ip_tcp', '1.2.3.4', [80]) }
+		assert_raise(Rex::ArgumentError, 'invalid proto') { Klass.new(['6bffnd098-a112-3610-9833-46c3f87e345a', '1.0'], 'ncacn_ip_bmc', '1.2.3.4', [80]) }
+		assert_raise(Rex::ArgumentError, 'invalid empty uuid') { Klass.new([nil, '1.0'], 'ncacn_ip_tcp', '1.2.3.4', [80]) }
+	end
+
+	def test_parser
+		handle = '6bffd098-a112-3610-9833-46c3f87e345a:1.0@ncacn_ip_tcp:10.4.10.10[80]'
+		i = Klass.parse( handle )
+		assert(i)
+		assert_equal(['6bffd098-a112-3610-9833-46c3f87e345a', '1.0'], i.uuid, 'uuid')
+		assert_equal('ncacn_ip_tcp', i.protocol, 'protocol')
+		assert_equal('10.4.10.10', i.address, 'address')
+		assert_equal(['80'], i.options, 'options')
+	end
+
+	def test_parser_invalid
+		handle = '6bffd098-a112-3610-9833-46c3f87e345a:1.0@ncacn_ip_tcp:10.4.10.10[80'
+		assert_raise(Rex::ArgumentError, 'invalid handle (parser)') { Klass.parse(handle) }
+	end
+end

data/lib/rex/proto/dcerpc/ndr.rb

@@ -0,0 +1,72 @@
+require "rex/text"
+
+module Rex
+module Proto
+module DCERPC
+class NDR
+
+
+	# Provide padding to align the string to the 32bit boundary
+	def self.align(string)
+		warn 'should be using Rex::Encoder::NDR'
+		return "\x00" * ((4 - (string.length & 3)) & 3)
+	end
+
+	# Encode a 4 byte long
+	# use to encode:
+	#       long element_1;
+	def self.long(string)
+		warn 'should be using Rex::Encoder::NDR'
+		return [string].pack('V')
+	end
+	
+	# Encode a 2 byte short
+	# use to encode:
+	#       short element_1;
+	def self.short(string)
+		warn 'should be using Rex::Encoder::NDR'
+		return [string].pack('v')
+	end
+	
+	# Encode a single byte
+	# use to encode:
+	#       byte element_1;
+	def self.byte(string)
+		warn 'should be using Rex::Encoder::NDR'
+		return [string].pack('c')
+	end
+
+	# Encode a byte array
+	# use to encode:
+	#       char  element_1
+	def self.UniConformantArray(string)
+		warn 'should be using Rex::Encoder::NDR'
+		return long(string.length) + string + align(string)
+	end
+
+	# Encode a string
+	# use to encode:
+	#       w_char *element_1;
+	def self.UnicodeConformantVaryingString(string)
+		warn 'should be using Rex::Encoder::NDR'
+		string += "\x00" # null pad
+		return long(string.length) + long(0) + long(string.length) + Rex::Text.to_unicode(string) + align(Rex::Text.to_unicode(string))
+	end
+	
+	# Encode a string that is already unicode encoded
+	# use to encode:
+	#       w_char *element_1;
+	def self.UnicodeConformantVaryingStringPreBuilt(string)
+		warn 'should be using Rex::Encoder::NDR'
+		# if the string len is odd, thats bad!
+		if string.length % 2 > 0
+			string += "\x00"
+		end
+		len = string.length / 2;
+		return long(len) + long(0) + long(len) + string + align(string)
+	end
+
+end
+end
+end
+end

data/lib/rex/proto/dcerpc/ndr.rb.ut.rb

@@ -0,0 +1,41 @@
+#!/usr/bin/env ruby
+
+$:.unshift(File.join(File.dirname(__FILE__), '..', '..', '..'))
+
+require 'rex/test'
+require 'rex/exceptions'
+require 'rex/proto/dcerpc/ndr'
+
+class Rex::Proto::DCERPC::NDR::UnitTest < Test::Unit::TestCase
+
+	Klass = Rex::Proto::DCERPC::NDR
+
+	def test_align
+		assert_equal(0, Klass.align('').length, 'align 0')
+		assert_equal(3, Klass.align('f').length, 'align 1')
+		assert_equal(2, Klass.align('fo').length, 'align 2')
+		assert_equal(1, Klass.align('foo').length, 'align 3')
+		assert_equal(0, Klass.align('fooo').length, 'align 4')
+		assert_equal(3, Klass.align('foooo').length, 'align 5')
+	end
+
+	def test_numbers
+		assert_equal("\x0a\x00\x00\x00", Klass.long(10), 'long')
+		assert_equal("\x0a\x00", Klass.short(10), 'short')
+		assert_equal("\x0a", Klass.byte(10), 'byte')
+	end
+
+	def test_conformant_array
+		assert_equal("\x05\x00\x00\x00aaaaa", Klass.UniConformantArray('aaaaa').slice(0,9), 'UniConformantArray')
+		assert_equal(12, Klass.UniConformantArray('aaaaa').length, 'UniConformantArray length')
+	end
+	
+	def test_conformant_string
+		assert_equal("\x06\x00\x00\x00" + "\x00\x00\x00\x00" + "\x06\x00\x00\x00" "a\x00a\x00a\x00a\x00a\x00\x00\x00", Klass.UnicodeConformantVaryingString('aaaaa').slice(0,4+4+4+12), 'UniConformantVaryingString')
+		assert_equal(24, Klass.UnicodeConformantVaryingString('aaaaa').length, 'UniConformantVaryingString length')
+	
+		assert_equal("\x02\x00\x00\x00" + "\x00\x00\x00\x00" + "\x02\x00\x00\x00" "aa\x00\x00", Klass.UnicodeConformantVaryingStringPreBuilt('aa' + "\x00\x00"), 'UniConformantVaryingStringPreBuilt')
+		assert_equal(16, Klass.UnicodeConformantVaryingStringPreBuilt('aa' + "\x00\x00").length, 'UniConformantVaryingStringPreBuilt length')
+	end
+
+end

data/lib/rex/proto/dcerpc/packet.rb

@@ -0,0 +1,253 @@
+module Rex
+module Proto
+module DCERPC
+class Packet
+
+require 'rex/proto/dcerpc/uuid'
+require 'rex/proto/dcerpc/response'
+require 'rex/text'
+		
+	UUID = Rex::Proto::DCERPC::UUID
+
+	# Create a standard DCERPC BIND request packet
+	def self.make_bind(uuid, vers)	
+		
+		# Process the version strings ("1.0", 1.0, "1", 1)
+		bind_vers_maj, bind_vers_min = UUID.vers_to_nums(vers)
+		xfer_vers_maj, xfer_vers_min = UUID.vers_to_nums(UUID.xfer_syntax_vers)
+
+		# Create the bind request packet
+		buff = 
+		[
+			5,      # major version 5
+			0,      # minor version 0
+			11,     # bind type
+			3,      # flags
+			0x10000000,  # data representation
+			72,     # frag length
+			0,      # auth length
+			0,      # call id
+			5840,   # max xmit frag
+			5840,   # max recv frag
+			0,      # assoc group
+			1,      # num ctx items
+			0,      # context id
+			1,      # num trans items
+			UUID.uuid_pack(uuid),   # interface uuid
+			bind_vers_maj,       # interface major version
+			bind_vers_min,       # interface minor version
+			UUID.xfer_syntax_uuid,  # transfer syntax
+			xfer_vers_maj,       # syntax major version
+			xfer_vers_min,       # syntax minor version 
+		].pack('CCCCNvvVvvVVvvA16vvA16vv')
+		
+		return buff, 0
+	end
+
+	# Create an obfuscated DCERPC BIND request packet
+	def self.make_bind_fake_multi(uuid, vers, bind_head=0, bind_tail=0)
+
+		bind_head = rand(6)+10 if bind_head == 0
+		bind_tail = rand(4)+1 if bind_head == 0
+
+		u = Rex::Proto::DCERPC::UUID
+		
+		# Process the version strings ("1.0", 1.0, "1", 1)
+		bind_vers_maj, bind_vers_min = UUID.vers_to_nums(vers)
+		xfer_vers_maj, xfer_vers_min = UUID.vers_to_nums(UUID.xfer_syntax_vers)
+		
+		bind_total = bind_head + bind_tail + 1
+		bind_size  = (bind_total * 44) + 28
+		real_ctx, ctx = 0, 0
+
+		# Create the header of the bind request
+		data = 
+		[
+			5,      # major version 5
+			0,      # minor version 0
+			11,     # bind type
+			3,      # flags
+			0x10000000,  # data representation
+			bind_size,   # frag length
+			0,      # auth length
+			0,      # call id
+			5840,   # max xmit frag
+			5840,   # max recv frag
+			0,      # assoc group
+			bind_total,  # num ctx items
+		].pack('CCCCNvvVvvVV')
+		
+		# Generate the fake UUIDs prior to the real one
+		1.upto(bind_head) do ||
+			# Generate some random UUID and versions
+			rand_uuid = Rex::Text.rand_text(16)
+			rand_imaj = rand(6)			
+			rand_imin = rand(4)
+			
+			data += 
+			[
+				ctx,        # context id
+				1,          # num trans items		
+				rand_uuid,  # interface uuid
+				rand_imaj,  # interface major version
+				rand_imin,  # interface minor version
+				UUID.xfer_syntax_uuid,  # transfer syntax
+				xfer_vers_maj,       # syntax major version
+				xfer_vers_min,       # syntax minor version 
+			].pack('vvA16vvA16vv')
+			ctx += 1
+		end
+		
+		# Stuff the real UUID onto the end of the buffer
+		real_ctx = ctx;
+		data += 
+		[
+			ctx,      # context id
+			1,        # num trans items		
+			UUID.uuid_pack(uuid),   # interface uuid
+			bind_vers_maj,       # interface major version
+			bind_vers_min,       # interface minor version
+			UUID.xfer_syntax_uuid,  # transfer syntax
+			xfer_vers_maj,       # syntax major version
+			xfer_vers_min,       # syntax minor version 
+		].pack('vvA16vvA16vv')
+		ctx += 1
+		
+	
+		# Generate the fake UUIDs after the real one
+		1.upto(bind_tail) do ||
+			# Generate some random UUID and versions
+			rand_uuid = Rex::Text.rand_text(16)
+			rand_imaj = rand(6)			
+			rand_imin = rand(4)
+			
+			data += 
+			[
+				ctx,        # context id
+				1,          # num trans items		
+				rand_uuid,  # interface uuid
+				rand_imaj,  # interface major version
+				rand_imin,  # interface minor version
+				UUID.xfer_syntax_uuid,  # transfer syntax
+				xfer_vers_maj,       # syntax major version
+				xfer_vers_min,       # syntax minor version 
+			].pack('vvA16vvA16vv')
+			ctx += 1
+		end
+
+		# Return both the bind packet and the real context_id
+		return data, real_ctx
+	end
+	
+	# Create a standard DCERPC ALTER_CONTEXT request packet
+	def self.make_alter_context(uuid, vers)	
+		u = Rex::Proto::DCERPC::UUID
+		
+		# Process the version strings ("1.0", 1.0, "1", 1)
+		bind_vers_maj, bind_vers_min = UUID.vers_to_nums(vers)
+		xfer_vers_maj, xfer_vers_min = UUID.vers_to_nums(UUID.xfer_syntax_vers)
+
+		buff = 
+		[
+			5,      # major version 5
+			0,      # minor version 0
+			14,     # alter context
+			3,      # flags
+			0x10000000,     # data representation
+			72,     # frag length
+			0,      # auth length
+			0,      # call id
+			5840,   # max xmit frag
+			5840,   # max recv frag
+			0,      # assoc group
+			1,      # num ctx items
+			0,      # context id
+			1,      # num trans items
+			UUID.uuid_pack(uuid),   # interface uuid
+			bind_vers_maj,       # interface major version
+			bind_vers_min,       # interface minor version
+			UUID.xfer_syntax_uuid,  # transfer syntax
+			xfer_vers_maj,       # syntax major version
+			xfer_vers_min,       # syntax minor version 
+		].pack('CCCCNvvVvvVVvvA16vvA16vv')
+	end
+	
+
+	# Used to create a piece of a DCERPC REQUEST packet
+	def self.make_request_chunk(flags=3, opnum=0, data="", ctx=0, object_id = '')
+
+		dlen = data.length
+		flen = dlen + 24
+
+		use_object = 0
+
+		object_str = ''
+
+		if object_id.size > 0
+			flags |= 0x80
+			flen = flen + 16
+			object_str = UUID.uuid_pack(object_id)
+		end
+
+		buff = 
+		[
+			5,      # major version 5
+			0,      # minor version 0
+			0,      # request type
+			flags,  # flags
+			0x10000000,     # data representation
+			flen,   # frag length
+			0,      # auth length
+			0,      # call id
+			dlen,   # alloc hint
+			ctx,    # context id
+			opnum,  # operation number
+		].pack('CCCCNvvVVvv') + object_str + data
+	end	
+
+	# Used to create standard DCERPC REQUEST packet(s)
+	def self.make_request(opnum=0, data="", size=data.length, ctx=0, object_id = '')
+
+		if size > 4000
+			size = 4000
+		end
+
+		chunks, frags = [], []
+		ptr = 0
+		
+		# Break the request into fragments of 'size' bytes
+		while ptr < data.length
+			chunks.push( data[ ptr, size ] )
+			ptr += size
+		end
+		
+		# Process requests with no stub data
+		if chunks.length == 0
+			frags.push( make_request_chunk(3, opnum, '', ctx, object_id) )
+			return frags
+		end
+		
+		# Process requests with only one fragment
+		if chunks.length == 1
+			frags.push( make_request_chunk(3, opnum, chunks[0], ctx, object_id) )
+			return frags
+		end
+
+		# Create the first fragment of the request
+		frags.push( make_request_chunk(1, opnum, chunks.shift, ctx, object_id) )
+		
+		# Create all of the middle fragments
+		while chunks.length != 1
+			frags.push( make_request_chunk(0, opnum, chunks.shift, ctx, object_id) )
+		end
+		
+		# Create the last fragment of the request
+		frags.push( make_request_chunk(2, opnum, chunks.shift, ctx, object_id) )
+
+		return frags
+	end		
+	
+end
+end
+end
+end