librex 0.0.32 → 0.0.33

data/README.markdown

@@ -3,7 +3,7 @@
 A non-official re-packaging of the Rex library as a gem for easy of usage of the Metasploit REX framework in a non Metasploit application. I received permission from HDM to create this package.
 
 Currently based on:
-SVN Revision: 12612
+SVN Revision: 12724
 
 # Credits
 The Metasploit development team <http://www.metasploit.com>

data/lib/rex/exploitation/egghunter.rb

@@ -20,6 +20,7 @@ module Exploitation
 # Checksum code merged to Egghunter by jduck
 # Conversion to use Metasm by jduck
 # Startreg code added by corelanc0d3r
+# Added routine to disable DEP for discovered egg (for win, added by corelanc0d3r)
 #
 ###
 class Egghunter
@@ -57,7 +58,95 @@ class Egghunter
 				end
 				startstub << "\n\t" if startstub.length > 0
 
+				getpointer = ''
+				getsize = ''
+				getpc = ''
+				jmppayload = "jmp edi"
+
+				apireg = (opts[:depreg] || 'esi').downcase
+				apidest = opts[:depdest]
+				depsize = opts[:depsize]
+
+				freeregs = [ "esi", "ebp", "ecx", "ebx" ]
+
+				if opts[:depmethod]
+
+					if freeregs.index(apireg) == nil
+						getpointer << "mov #{freeregs[0]},#{apireg}\n\t"
+						apireg = freeregs[0]
+					end
+					freeregs.delete(apireg)
+
+					if opts[:depmethod].downcase == "copy" || opts[:depmethod].downcase == "copy_size"
+						if apidest
+							if freeregs.index(apidest) == nil
+								getpointer << "mov #{freeregs[0]},#{apidest}\n\t"
+								apidest = freeregs[0]
+							end
+						else
+							getpc = "fldpi\n\tfstenv [esp-0xc]\n\tpop #{freeregs[0]}\n\t"
+							apidest = freeregs[0]
+						end
+						freeregs.delete(apidest)
+					end
+
+
+					sizereg = freeregs[0]
+
+					if not depsize
+						depsize = payload.length * 2
+						if opts[:depmethod]
+							if opts[:depmethod].downcase == "copy_size" 
+								depsize = payload.length
+							end
+						end
+					end
+
+
+					blockcnt = 0
+					vpsize = 0
+					blocksize = depsize
+					while blocksize >= 127
+						blocksize = blocksize / 2
+						blockcnt += 1
+					end
+					if blockcnt > 0
+						getsize << "xor #{sizereg},#{sizereg}\n\tadd #{sizereg},0x%02x\n\t" % blocksize
+						vpsize = blocksize
+						depblockcnt = 0
+						while depblockcnt < blockcnt
+							getsize << "add #{sizereg},#{sizereg}\n\t"	
+							vpsize += vpsize						
+							depblockcnt += 1
+						end
+						delta = depsize - vpsize
+						if delta > 0
+							getsize << "add #{sizereg},0x%02x\n\t" % delta
+						end
+					else
+						getsize << "xor #{sizereg},#{sizereg}\n\tadd #{sizereg},0x%02x\n\t" % depsize	
+					end
+				
+
+					case opts[:depmethod].downcase
+						when "virtualprotect"
+							jmppayload = "push esp\n\tpush 0x40\n\t"
+							jmppayload << getsize
+							jmppayload << "push #{sizereg}\n\tpush edi\n\tpush edi\n\tpush #{apireg}\n\tret"
+						when "copy"
+							jmppayload = getpc
+							jmppayload << "push edi\n\tpush #{apidest}\n\tpush #{apidest}\n\tpush #{apireg}\n\tmov edi,#{apidest}\n\tret"
+						when "copy_size"
+							jmppayload = getpc
+							jmppayload << getsize
+							jmppayload << "push #{sizereg}\n\tpush edi\n\tpush #{apidest}\n\tpush #{apidest}\n\tpush #{apireg}\n\tmov edi,#{apidest}\n\tret"
+					end
+				end
+
+				jmppayload << "\n" if jmppayload.length > 0
+
 				assembly = <<EOS
+#{getpointer}				
 #{startstub}
 check_readable:
 	or dx,0xfff
@@ -84,7 +173,7 @@ check_for_tag:
 #{checksum}
 
 	; jump to the payload
-	jmp edi
+	#{jmppayload}
 EOS
 
 				assembled_code = Metasm::Shellcode.assemble(Metasm::Ia32.new, assembly).encode_string

data/lib/rex/exploitation/javascriptosdetect.rb

@@ -636,6 +636,12 @@ function getVersion(){
 				os_flavor = "XP";
 				os_sp = "SP3";
 				break;
+			case "576000":
+				// IE 7.0.6000.16386, Vista Ultimate SP0 English
+				ua_version = "7.0";
+				os_flavor = "Vista";
+				os_sp = "SP0";
+				break;
 			case "5822960":
 				// IE 8.0.6001.18702, XP Professional SP3 Greek
 			case "5818702":
@@ -650,6 +656,8 @@ function getVersion(){
 			case "5816385":
 				// IE 8.0.7600.16385, Windows 7 English
 			case "5816475":
+			case "5816762":
+				// IE 8.0.7600.16385, Windows 7 English
 				ua_version = "8.0";
 				os_flavor = "7";
 				os_sp = "SP0";
@@ -816,7 +824,7 @@ function ua_ver_cmp(ver_a, ver_b) {
 
 	a = ver_a.split(".");
 	b = ver_b.split(".");
-	for (i = 0; i < Math.max(a.length, b.length); i++) {
+	for (var i = 0; i < Math.max(a.length, b.length); i++) {
 		// 3.0 == 3
 		if (!b[i]) { b[i] = "0"; }
 		if (!a[i]) { a[i] = "0"; }

data/lib/rex/io/ring_buffer.rb.ut.rb

@@ -0,0 +1,134 @@
+
+$:.unshift(File.join(File.dirname(__FILE__), '..', '..'))
+
+require 'test/unit'
+require 'rex/socket'
+require 'rex/io/ring_buffer'
+
+#
+# TODO: Mock up the socket so this test doesn't take so long
+#
+class Rex::IO::RingBuffer::UnitTest < Test::Unit::TestCase
+
+	def setup
+		server = Rex::Socket.create_tcp_server('LocalPort' => 0)
+		lport  = server.getsockname[2]
+		@client = Rex::Socket.create_tcp('PeerHost' => '127.0.0.1', 'PeerPort' => lport)
+		conn   = server.accept
+		#server.close		
+
+		@r = Rex::IO::RingBuffer.new(conn, {:size => 64})
+		@r.start_monitor
+	end
+
+	def teardown
+		begin
+			@client.close		
+			@r.stop_monitor
+		rescue ::Exception
+		end
+	end
+
+	def test_single_read_data
+		@client.put("123")
+		@r.wait(0)
+		s,d = @r.read_data
+
+		assert_equal("123", d)
+	end
+
+	def test_sequential_read_data
+		@r.clear_data
+
+		s = nil
+		0.upto(10) do |num|
+			@client.put(num.to_s)
+			@r.wait(s)
+			s,d = @r.read_data(s)
+			assert_equal(num.to_s, d)
+		end
+	end
+
+	def test_wrap
+		@r.clear_data
+		0.upto(@r.size - 1) {
+			@client.put("a")
+			# Need to sleep so the socket doesn't get all the data in one read()
+			sleep 0.05
+		}
+		s,d = @r.read_data
+
+		@client.put("b")
+		sleep 0.01
+		s,d = @r.read_data(s)
+
+		assert_equal("b", d)
+
+	end
+
+end
+=begin
+client.put("4")
+client.put("5")
+client.put("6")
+s,d = r.read_data(s)
+
+client.put("7")
+client.put("8")
+client.put("9")
+s,d = r.read_data(s)
+
+client.put("0")
+s,d = r.read_data(s)
+
+test_counter = 11
+1.upto(100) do
+	client.put( "X" )			
+	test_counter += 1
+end
+
+sleep(1)
+
+s,d = r.read_data
+p s
+p d
+
+fdata = ''
+File.open("/bin/ls", "rb") do |fd|
+	fdata = fd.read(fd.stat.size)
+	fdata = fdata * 10
+	client.put(fdata)
+end
+
+sleep(1)
+
+s,vdata = r.read_data(s)
+
+if vdata != fdata
+	puts "DATA FAILED"
+else
+	puts "DATA VERIFIED"
+end
+
+r.clear_data
+
+a = r.create_stream
+b = r.create_stream
+
+client.put("ABC123")
+sleep(1)
+
+p a.read
+p b.read
+
+client.put("$$$$$$")
+sleep(1)
+
+p a.read
+p b.read
+
+c = r.create_stream
+p c.read
+
+end
+=end

data/lib/rex/io/stream_server.rb

@@ -1,3 +1,5 @@
+require 'thread'
+
 module Rex
 module IO
 
@@ -61,6 +63,7 @@ module StreamServer
 	#
 	def start
 		self.clients = []
+		self.client_waiter = ::Queue.new
 
 		self.listener_thread = Rex::ThreadFactory.spawn("StreamServerListener", false) {
 			monitor_listener
@@ -128,6 +131,7 @@ module StreamServer
 
 	attr_accessor :clients # :nodoc:
 	attr_accessor :listener_thread, :clients_thread # :nodoc:
+	attr_accessor :client_waiter
 
 protected
 
@@ -151,6 +155,9 @@ protected
 
 				# Initialize the connection processing
 				on_client_connect(cli)
+				
+				# Notify the client monitor
+				self.client_waiter.push(cli)
 
 			# Skip exceptions caused by accept() [ SSL ]
 			rescue ::EOFError, ::Errno::ECONNRESET, ::Errno::ENOTCONN, ::Errno::ECONNABORTED
@@ -170,12 +177,14 @@ protected
 	#
 	def monitor_clients
 		begin
+		
+			# Wait for a notify if our client list is empty
 			if (clients.length == 0)
-				Rex::ThreadSafe::sleep(0.25)
+				self.client_waiter.pop
 				next
 			end
 
-			sd = Rex::ThreadSafe.select(clients)
+			sd = Rex::ThreadSafe.select(clients, nil, nil, nil)
 
 			sd[0].each { |cfd|
 				begin

data/lib/rex/parser/nessus_xml.rb

@@ -17,7 +17,8 @@ class NessusXMLStreamParser
 	def reset_state
 		@host = {'hname' => nil, 'addr' => nil, 'mac' => nil, 'os' => nil, 'ports' => [
 			'port' => {'port' => nil, 'svc_name'  => nil, 'proto' => nil, 'severity' => nil,
-			'nasl' => nil, 'description' => nil, 'cve' => [], 'bid' => [], 'xref' => [], 'msf' => nil } ] }
+			'nasl' => nil, 'nasl_name' => nil, 'description' => nil, 
+			'cve' => [], 'bid' => [], 'xref' => [], 'msf' => nil } ] }
 		@state = :generic_state
 	end
 
@@ -46,7 +47,8 @@ class NessusXMLStreamParser
 			@bid = Array.new
 			@xref = Array.new
 			@x = Hash.new
-			@x['nasl'] = [attributes['pluginID'],attributes['pluginName']].join(" ")
+			@x['nasl'] = attributes['pluginID']
+			@x['nasl_name'] = attributes['pluginName']
 			@x['port'] = attributes['port']
 			@x['proto'] = attributes['protocol']
 			@x['svc_name'] = attributes['svc_name']

data/lib/rex/parser/nexpose_xml.rb

@@ -13,8 +13,16 @@ class NexposeXMLStreamParser
 
 	def reset_state
 		@state = :generic_state
-		@host = { "status" => nil, "endpoints" => [], "names" => [], "vulns" => {} }
-		@vuln = { "refs" => [] }
+		@only_vuln_states_needed = true
+		@current_vuln_id = nil
+		@vulnerable_markers = ['vulnerable-exploited', 'vulnerable-version', 'potential']
+		@host = {"status" => nil, "endpoints" => [], "names" => [], "vulns" => {}}
+		@vuln = {"refs" => [], "description" => [], "solution" => []}
+	end
+
+	# If all vuln states are required set this to false
+	def parse_vulnerable_states_only only_vuln_states_needed
+		@only_vuln_states_needed = only_vuln_states_needed
 	end
 
 	def tag_start(name, attributes)
@@ -48,19 +56,31 @@ class NexposeXMLStreamParser
 			if @state == :in_service
 				@host["endpoints"].last.merge!(attributes)
 			end
-		when "test"
-			if attributes["status"] == "vulnerable-exploited" or attributes["status"] == "vulnerable-version"
-				@host["vulns"][attributes["id"]] = attributes.dup
-				if attributes["key"]
-					@host["notes"] ||= []
-					@host["notes"] << [attributes["id"], attributes["key"]]
+			when "test"
+				if (not @only_vuln_states_needed) or (@vulnerable_markers.include? attributes["status"].to_s.chomp and @only_vuln_states_needed)
+					@state = :in_test
+					@current_vuln_id = attributes["id"]
+					@host["vulns"][@current_vuln_id] = attributes.dup
+					# Append the endpoint info for how the vuln was discovered
+					unless @host["endpoints"].empty?
+						@host["vulns"][@current_vuln_id].merge!("endpoint_data" => @host["endpoints"].last)
+					end
+					if attributes["key"]
+						@host["notes"] ||= []
+						@host["notes"] << [@current_vuln_id, attributes["key"]]
+					end
 				end
-			end
-		when "vulnerability"
-			@vuln.merge! attributes
-		when "reference"
-			@state = :in_reference
-			@vuln["refs"].push attributes
+			when "vulnerability"
+				@vuln.merge! attributes
+			when "reference"
+				@state = :in_reference
+				@vuln["refs"].push attributes
+			when "solution"
+				@state = :in_solution
+			when "description"
+				@state = :in_description
+			when "URLLink"
+				@vuln["solution"] << attributes
 		end
 	end
 
@@ -70,7 +90,17 @@ class NexposeXMLStreamParser
 			@host["names"].push str
 		when :in_reference
 			@vuln["refs"].last["value"] = str
-		end
+    when :in_solution
+      @vuln["solution"] << str
+    when :in_description
+      @vuln["description"] << str
+    when :in_test
+      if @host["vulns"][@current_vuln_id]
+         proof = @host["vulns"][@current_vuln_id]["proof"] || []
+         proof << str
+         @host["vulns"][@current_vuln_id]["proof"] = proof
+      end
+    end
 	end
 
 	def tag_end(name)

data/lib/rex/parser/nmap_nokogiri.rb

@@ -0,0 +1,385 @@
+require File.join(File.expand_path(File.dirname(__FILE__)),"nokogiri_doc_mixin")
+
+module Rex
+	module Parser
+
+		# If Nokogiri is available, define Nmap document class. 
+		load_nokogiri && class NmapDocument < Nokogiri::XML::SAX::Document
+
+		include NokogiriDocMixin
+
+		def determine_port_state(v)
+			case v
+			when "open"
+				Msf::ServiceState::Open
+			when "closed"
+				Msf::ServiceState::Closed
+			when "filtered"
+				Msf::ServiceState::Filtered
+			when "unknown"
+				Msf::ServiceState::Unknown
+			end
+		end
+
+		# Compare OS fingerprinting data
+		def better_os_match(orig_hash,new_hash)
+			return false unless new_hash.has_key? "accuracy"
+			return true unless orig_hash.has_key? "accuracy"
+			new_hash["accuracy"].to_i > orig_hash["accuracy"].to_i
+		end
+
+		# Triggered every time a new element is encountered. We keep state
+		# ourselves with the @state variable, turning things on when we
+		# get here (and turning things off when we exit in end_element()).
+		def start_element(name=nil,attrs=[])
+			attrs = normalize_attrs(attrs)
+			block = @block
+			@state[:current_tag][name] = true
+			case name
+			when "host"
+				@state[:in_host] = true
+			when "os"
+				if @state[:in_host]
+					@state[:in_os] = true
+				end
+			when "status"
+				record_host_status(attrs)
+			when "address"
+				record_address(attrs)
+			when "osclass"
+				record_host_osclass(attrs)
+			when "osmatch"
+				record_host_osmatch(attrs)
+			when "uptime"
+				record_host_uptime(attrs)
+			when "hostname"
+				record_hostname(attrs)
+			when "port"
+				record_port(attrs) 
+			when "state"
+				record_port_state(attrs)
+			when "service"
+				record_port_service(attrs)
+			when "script" # Not actually used in import?
+				record_port_script(attrs)
+				record_host_script(attrs)
+				# Ignoring post scripts completely
+			when "trace"
+				record_host_trace(attrs)
+			when "hop"
+				record_host_hop(attrs)
+			end
+		end
+
+		# We can certainly get fancier with self.send() magic, but
+		# leaving this pretty simple for now.
+
+		def record_host_hop(attrs)
+			return unless @state[:in_host]
+			return unless @state[:in_trace]
+			hops = attr_hash(attrs)
+			hops["name"] = hops.delete "host"
+			@state[:trace][:hops] << hops
+		end
+
+		def record_host_trace(attrs)
+			return unless @state[:in_host]
+			@state[:in_trace] = true
+			@state[:trace] = attr_hash(attrs)
+			@state[:trace][:hops] = []
+		end
+
+		def record_host_uptime(attrs)
+			return unless @state[:in_host]
+			@state[:uptime] = attr_hash(attrs)
+		end
+
+		def record_host_osmatch(attrs)
+			return unless @state[:in_host]
+			return unless @state[:in_os]
+			temp_hash = attr_hash(attrs)
+			if temp_hash["accuracy"].to_i == 100
+				@state[:os]["osmatch"] = temp_hash["name"]
+			end
+		end
+
+		def record_host_osclass(attrs)
+			return unless @state[:in_host]
+			return unless @state[:in_os]
+			@state[:os] ||= {}
+			temp_hash = attr_hash(attrs)
+			if better_os_match(@state[:os],temp_hash)
+				@state[:os] = temp_hash
+			end
+		end
+
+		def record_hostname(attrs)
+			return unless @state[:in_host]
+			if attr_hash(attrs)["type"] == "PTR"
+				@state[:hostname] = attr_hash(attrs)["name"]
+			end
+		end
+
+		def record_host_script(attrs)
+			return unless @state[:in_host]
+			return if @state[:in_port]
+			temp_hash = attr_hash(attrs)
+			@state[:hostscripts] ||= {}
+			@state[:hostscripts].merge! temp_hash
+			temp_hash[:addresses] = @state[:addresses]
+			db.emit(:host_script,temp_hash,&block) if block
+		end
+
+		def record_port_script(attrs)
+			return unless @state[:in_host]
+			return unless @state[:in_port]
+			temp_hash = attr_hash(attrs)
+			@state[:portscripts] ||= {}
+			@state[:portscripts].merge! temp_hash
+			temp_hash[:addresses] = @state[:addresses]
+			temp_hash[:port] = @state[:port]
+			db.emit(:port_script,temp_hash,&block) if block
+		end
+
+		def record_port_service(attrs)
+			return unless @state[:in_host]
+			return unless @state[:in_port]
+			svc = attr_hash(attrs)
+			if svc["name"] && @args[:fix_services]
+				svc["name"] = db.nmap_msf_service_map(svc["name"])
+			end
+			@state[:port] = @state[:port].merge(svc)
+		end
+
+		def record_port_state(attrs)
+			return unless @state[:in_host]
+			return unless @state[:in_port]
+			temp_hash = attr_hash(attrs)
+			@state[:port] = @state[:port].merge(temp_hash)
+		end
+
+		def record_port(attrs)
+			return unless @state[:in_host]
+			@state[:in_port] = true
+			@state[:port] ||= {}
+			svc = attr_hash(attrs)
+			@state[:port] = @state[:port].merge(svc)
+		end
+
+		def record_host_status(attrs)
+			return unless @state[:in_host]
+			attrs.each do |k,v|
+				next unless k == "state"
+				@state[:host_alive] = (v == "up") 
+			end
+		end
+
+		def record_address(attrs)
+			return unless @state[:in_host]
+			@state[:addresses] ||= {}
+			address = nil
+			type = nil
+			attrs.each do |k,v|
+				if k == "addr"
+					address = v
+				elsif k == "addrtype"
+					type = v
+				end
+			end
+			@state[:addresses][type] = address
+		end
+
+		# When we exit a tag, this is triggered.
+		def end_element(name=nil)
+			block = @block
+			@state[:current_tag].delete name
+			case name
+			when "os"
+				collect_os_data
+				@state[:in_os] = false
+				@state[:os] = {}
+			when "port"
+				collect_port_data 
+				@state[:in_port] = false
+				@state[:port] = {}
+			when "script"
+				if @state[:in_host]
+					if @state[:in_port]
+						@state[:portscripts] = {}
+					else
+						@state[:hostscripts] = {}
+					end
+				end
+			when "trace"
+				@state[:in_trace] = false
+			when "host" # Roll everything up now
+				collect_host_data
+				host_object = report_host &block
+				if host_object
+					db.report_import_note(@args[:wspace],host_object)
+					report_services(host_object,&block)
+					report_fingerprint(host_object)
+					report_uptime(host_object)
+					report_traceroute(host_object)
+				end
+				@state.delete_if {|k| k != :current_tag}
+			end
+		end
+
+		def end_document
+			block = @block
+			unless @state[:current_tag].empty?
+				missing_ends = @state[:current_tag].keys.map {|x| "'#{x}'"}.join(", ")
+				msg = "Warning, the provided file is incomplete, and there may be missing\n"
+				msg << "data. The following tags were not closed: #{missing_ends}."
+				db.emit(:warning,msg,&block)
+			end
+		end
+
+		def collect_os_data
+			return unless @state[:in_host]
+			if @state[:os]
+				@report_data[:os_fingerprint] = {
+					:type => "host.os.nmap_fingerprint",
+					:data => {
+						:os_vendor => @state[:os]["vendor"],
+						:os_family => @state[:os]["osfamily"],
+						:os_version => @state[:os]["osgen"],
+						:os_accuracy => @state[:os]["accuracy"].to_i
+					}
+				}
+				if @state[:os].has_key? "osmatch"
+					@report_data[:os_fingerprint][:data][:os_match] = @state[:os]["osmatch"]
+				end
+			end
+		end
+
+		def collect_host_data
+			if @state[:host_alive] 
+				@report_data[:state] = Msf::HostState::Alive
+			else
+				@report_data[:state] = Msf::HostState::Dead
+			end
+			if @state[:addresses] 
+				if @state[:addresses].has_key? "ipv4"
+					@report_data[:host] = @state[:addresses]["ipv4"]
+				elsif @state[:addresses].has_key? "ipv6"
+					@report_data[:host] = @state[:addresses]["ipv6"]
+				end
+			end
+			if @state[:addresses] and @state[:addresses].has_key?("mac")
+				@report_data[:mac] = @state[:addresses]["mac"]
+			end
+			if @state[:hostname]
+				@report_data[:name] = @state[:hostname]
+			end
+			if @state[:uptime]
+				@report_data[:last_boot] = @state[:uptime]["lastboot"]
+			end
+			if @state[:trace] and @state[:trace].has_key?(:hops)
+				@report_data[:traceroute] = @state[:trace]
+			end
+		end
+
+		def collect_port_data(&block)
+			return unless @state[:in_host]
+			if @args[:fix_services]
+				if @state[:port]["state"] == "filtered"
+					return
+				end
+			end
+			@report_data[:ports] ||= []
+			port_hash = {}
+			extra = []
+			@state[:port].each do |k,v|
+				case k
+				when "protocol"
+					port_hash[:protocol] = v
+				when "portid"
+					port_hash[:port] = v
+				when "state"
+					port_hash[:state] = determine_port_state(v)
+				when "name"
+					port_hash[:name] = v
+				when "reason"
+					port_hash[:reason] = v
+				when "product"
+					extra[0] = v
+				when "version"
+					extra[1] = v
+				when "extrainfo"
+					extra[2] = v
+				end
+			end
+			port_hash[:info] = extra.compact.join(" ") unless extra.empty?
+			# Skip localhost port results when they're unknown
+			if( port_hash[:reason] == "localhost-response" &&
+				  port_hash[:state] == Msf::ServiceState::Unknown )
+				@report_data[:ports]
+			else
+				@report_data[:ports] << port_hash
+			end
+		end
+
+		def report_traceroute(host_object)
+			return unless host_object.kind_of? ::Msf::DBManager::Host
+			return unless @report_data[:traceroute]
+			db.report_note(
+				:workspace => host_object.workspace,
+				:host => host_object,
+				:type => "host.nmap.traceroute",
+				:data => {
+					'port' => @report_data[:traceroute]["port"].to_i,
+					'proto' => @report_data[:traceroute]["proto"].to_s,
+					'hops' => @report_data[:traceroute][:hops]
+				}
+			)
+		end
+
+		def report_uptime(host_object)
+			return unless host_object.kind_of? ::Msf::DBManager::Host
+			return unless @report_data[:last_boot]
+			db.report_note(
+				:workspace => host_object.workspace,
+				:host => host_object,
+				:type => "host.last_boot",
+				:data => { :time => @report_data[:last_boot] }
+			)
+		end
+
+		def report_fingerprint(host_object)
+			return unless host_object.kind_of? ::Msf::DBManager::Host
+			return unless @report_data[:os_fingerprint]
+			db.report_note(
+				@report_data[:os_fingerprint].merge(
+					:workspace => host_object.workspace,
+					:host => host_object
+				)
+			)
+		end
+
+		def report_host(&block)
+			if host_is_okay
+				host_object = db.report_host( @report_data.merge(
+					:workspace => @args[:wspace] ) )
+				db.emit(:address,@report_data[:host],&block) if block
+				host_object
+			end
+		end
+
+		def report_services(host_object,&block)
+			return unless host_object.kind_of? ::Msf::DBManager::Host
+			return unless @report_data[:ports]
+			return if @report_data[:ports].empty?
+			reported = []
+			@report_data[:ports].each do |svc|
+				reported << db.report_service(svc.merge(:host => host_object))
+			end
+			reported
+		end
+
+	end
+
+end
+end
+